initial commit
This commit is contained in:
commit
7715fcf373
37 changed files with 2957 additions and 0 deletions
56
pkg/raft/cluster.go
Normal file
56
pkg/raft/cluster.go
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
package raft
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"git.giftfish.de/ston1th/vipman/pkg/cluster"
|
||||
"github.com/go-logr/logr"
|
||||
"github.com/hashicorp/raft"
|
||||
)
|
||||
|
||||
type Cluster struct {
|
||||
logr.Logger
|
||||
cluster.KV
|
||||
r *raft.Raft
|
||||
|
||||
kvm *kv
|
||||
stepdown chan struct{}
|
||||
stop chan struct{}
|
||||
done chan struct{}
|
||||
callbacks cluster.Callbacks
|
||||
|
||||
id string
|
||||
}
|
||||
|
||||
func NewCluster(log logr.Logger) cluster.Cluster {
|
||||
kvm := &kv{
|
||||
m: make(map[string][]byte),
|
||||
}
|
||||
return &Cluster{
|
||||
Logger: log,
|
||||
KV: kvm,
|
||||
kvm: kvm,
|
||||
stepdown: make(chan struct{}, 1),
|
||||
stop: make(chan struct{}, 1),
|
||||
done: make(chan struct{}, 1),
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Cluster) ID() string {
|
||||
return c.id
|
||||
}
|
||||
|
||||
func (c *Cluster) SetCallbacks(callbacks cluster.Callbacks) error {
|
||||
c.callbacks = callbacks
|
||||
return c.checkConfig()
|
||||
}
|
||||
|
||||
func (c *Cluster) checkConfig() error {
|
||||
if c.callbacks.Leader == nil {
|
||||
return errors.New("Leader callback is nil")
|
||||
}
|
||||
if c.callbacks.Follower == nil {
|
||||
return errors.New("Follower callback is nil")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
99
pkg/raft/fsm.go
Normal file
99
pkg/raft/fsm.go
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
package raft
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"time"
|
||||
|
||||
"git.giftfish.de/ston1th/raftbbolt/msgpack"
|
||||
"github.com/hashicorp/raft"
|
||||
)
|
||||
|
||||
const (
|
||||
retainSnapshotCount = 2
|
||||
raftTimeout = 10 * time.Second
|
||||
)
|
||||
|
||||
type Op uint8
|
||||
|
||||
const (
|
||||
SET Op = iota
|
||||
DELETE
|
||||
)
|
||||
|
||||
type raftCmd struct {
|
||||
Op Op
|
||||
K string
|
||||
V []byte
|
||||
}
|
||||
|
||||
type fsm kv
|
||||
|
||||
func (f *fsm) Apply(l *raft.Log) interface{} {
|
||||
var c raftCmd
|
||||
if err := msgpack.Unmarshal(l.Data, &c); err != nil {
|
||||
panic(fmt.Sprintf("failed to unmarshal command: %s", err.Error()))
|
||||
}
|
||||
|
||||
switch c.Op {
|
||||
case SET:
|
||||
f.applySet(c.K, c.V)
|
||||
case DELETE:
|
||||
f.applyDelete(c.K)
|
||||
default:
|
||||
panic(fmt.Sprintf("unrecognized command op: %d", c.Op))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *fsm) Snapshot() (raft.FSMSnapshot, error) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
m := make(kvm)
|
||||
for k, v := range f.m {
|
||||
m[k] = v
|
||||
}
|
||||
return &fsmSnapshot{m: m}, nil
|
||||
}
|
||||
|
||||
func (f *fsm) Restore(rc io.ReadCloser) error {
|
||||
o := make(kvm)
|
||||
if err := msgpack.NewDecoder(rc).Decode(&o); err != nil {
|
||||
return err
|
||||
}
|
||||
f.m = o
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *fsm) applySet(k string, v []byte) {
|
||||
f.mu.Lock()
|
||||
f.m[k] = v
|
||||
f.mu.Unlock()
|
||||
}
|
||||
|
||||
func (f *fsm) applyDelete(k string) {
|
||||
f.mu.Lock()
|
||||
delete(f.m, k)
|
||||
f.mu.Unlock()
|
||||
}
|
||||
|
||||
type fsmSnapshot struct {
|
||||
m kvm
|
||||
}
|
||||
|
||||
func (f *fsmSnapshot) Persist(sink raft.SnapshotSink) error {
|
||||
err := func() error {
|
||||
err := msgpack.NewEncoder(sink).Encode(f.m)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return sink.Close()
|
||||
}()
|
||||
|
||||
if err != nil {
|
||||
sink.Cancel()
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (f *fsmSnapshot) Release() {}
|
||||
56
pkg/raft/kv.go
Normal file
56
pkg/raft/kv.go
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
package raft
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"sync"
|
||||
|
||||
"git.giftfish.de/ston1th/raftbbolt/msgpack"
|
||||
"github.com/hashicorp/raft"
|
||||
)
|
||||
|
||||
var ErrNotLeader = errors.New("not leader")
|
||||
|
||||
type kvm map[string][]byte
|
||||
|
||||
type kv struct {
|
||||
mu sync.Mutex
|
||||
m kvm
|
||||
r *raft.Raft
|
||||
}
|
||||
|
||||
func (kv *kv) Get(k string) ([]byte, error) {
|
||||
kv.mu.Lock()
|
||||
defer kv.mu.Unlock()
|
||||
return kv.m[k], nil
|
||||
}
|
||||
|
||||
func (kv *kv) Set(k string, v []byte) error {
|
||||
if kv.r.State() != raft.Leader {
|
||||
return ErrNotLeader
|
||||
}
|
||||
|
||||
c := &raftCmd{SET, k, v}
|
||||
b, err := msgpack.Marshal(c)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
f := kv.r.Apply(b, raftTimeout)
|
||||
return f.Error()
|
||||
}
|
||||
|
||||
// Delete deletes the given key.
|
||||
func (kv *kv) Delete(k string) error {
|
||||
if kv.r.State() != raft.Leader {
|
||||
return ErrNotLeader
|
||||
}
|
||||
|
||||
c := &raftCmd{Op: DELETE, K: k}
|
||||
b, err := msgpack.Marshal(c)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
f := kv.r.Apply(b, raftTimeout)
|
||||
return f.Error()
|
||||
}
|
||||
202
pkg/raft/raft.go
Normal file
202
pkg/raft/raft.go
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
package raft
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
||||
"git.giftfish.de/ston1th/raftbbolt"
|
||||
"git.giftfish.de/ston1th/vipman/pkg/config"
|
||||
"git.giftfish.de/ston1th/vipman/pkg/raft/tls"
|
||||
"git.giftfish.de/ston1th/vipman/pkg/util"
|
||||
hclog "github.com/hashicorp/go-hclog"
|
||||
"github.com/hashicorp/raft"
|
||||
)
|
||||
|
||||
func (c *Cluster) Start(raftcfg *config.Config) error {
|
||||
err := c.checkConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cfg := raftcfg.Cluster.Raft
|
||||
hcl := hclog.New(&hclog.LoggerOptions{
|
||||
Name: "raft",
|
||||
Level: hclog.LevelFromString(cfg.LogLevel),
|
||||
Output: hclog.DefaultOutput,
|
||||
TimeFormat: "I0102 15:04:05.000000",
|
||||
})
|
||||
|
||||
rc := raft.DefaultConfig()
|
||||
rc.ProtocolVersion = 3
|
||||
rc.LocalID = raft.ServerID(cfg.ID)
|
||||
rc.Logger = hcl
|
||||
c.id = cfg.ID
|
||||
|
||||
pool := 3
|
||||
timeout := 10 * time.Second
|
||||
var transport *raft.NetworkTransport
|
||||
if cfg.TLS != nil {
|
||||
c.V(1).Info("setup", "transport", "tls")
|
||||
s, err := tls.NewStream(cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
transport = raft.NewNetworkTransportWithLogger(s, pool, timeout, hcl)
|
||||
} else {
|
||||
c.V(1).Info("setup", "transport", "tcp")
|
||||
address, err := net.ResolveTCPAddr("tcp", cfg.Address)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
transport, err = raft.NewTCPTransportWithLogger(cfg.Address, address, pool, timeout, hcl)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// Create Raft structures
|
||||
//snapshots := raft.NewInmemSnapshotStore()
|
||||
snapshots, err := raft.NewFileSnapshotStoreWithLogger(cfg.Dir, retainSnapshotCount, hcl)
|
||||
if err != nil {
|
||||
return fmt.Errorf("file snapshot store: %s", err)
|
||||
}
|
||||
|
||||
store := filepath.Join(cfg.Dir, "store.db")
|
||||
|
||||
//logStore := raft.NewInmemStore()
|
||||
bootstrap := true
|
||||
if _, err := os.Stat(store); err == nil {
|
||||
bootstrap = false
|
||||
}
|
||||
|
||||
stableStore, err := raftbbolt.NewStore(store)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
logStore := stableStore
|
||||
|
||||
// Cluster configuration
|
||||
configuration := raft.Configuration{}
|
||||
|
||||
// Add Local Peer
|
||||
configuration.Servers = append(configuration.Servers, raft.Server{
|
||||
ID: raft.ServerID(cfg.ID),
|
||||
Address: raft.ServerAddress(cfg.Address),
|
||||
})
|
||||
for _, p := range cfg.Peers {
|
||||
if cfg.Address != p.Address {
|
||||
configuration.Servers = append(configuration.Servers, raft.Server{
|
||||
ID: raft.ServerID(p.ID),
|
||||
Address: raft.ServerAddress(p.Address)})
|
||||
}
|
||||
}
|
||||
|
||||
if bootstrap {
|
||||
if err := raft.BootstrapCluster(rc, logStore, stableStore, snapshots, transport, configuration); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
c.r, err = raft.NewRaft(rc, (*fsm)(c.kvm), logStore, stableStore, snapshots, transport)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
c.kvm.r = c.r
|
||||
|
||||
t := time.NewTicker(time.Second)
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
leading := false
|
||||
following := false
|
||||
for {
|
||||
if !leading && cfg.Address == string(c.r.Leader()) {
|
||||
leading = true
|
||||
go c.leader(ctx)
|
||||
} else if !following && !leading {
|
||||
following = true
|
||||
go c.follower(ctx)
|
||||
}
|
||||
|
||||
select {
|
||||
case <-t.C:
|
||||
case leader := <-c.r.LeaderCh():
|
||||
if leader {
|
||||
if following {
|
||||
cancel()
|
||||
following = false
|
||||
ctx, cancel = context.WithCancel(context.Background())
|
||||
}
|
||||
if !leading {
|
||||
leading = true
|
||||
go c.leader(ctx)
|
||||
}
|
||||
} else if c.r.State() == raft.Follower {
|
||||
if leading {
|
||||
cancel()
|
||||
leading = false
|
||||
ctx, cancel = context.WithCancel(context.Background())
|
||||
}
|
||||
if !following {
|
||||
following = true
|
||||
go c.follower(ctx)
|
||||
}
|
||||
}
|
||||
case <-c.stepdown:
|
||||
if leading {
|
||||
cancel()
|
||||
c.r.LeadershipTransfer().Error()
|
||||
}
|
||||
case <-c.stop:
|
||||
t.Stop()
|
||||
cancel()
|
||||
if leading {
|
||||
c.r.LeadershipTransfer().Error()
|
||||
}
|
||||
if c.callbacks.Cleanup != nil {
|
||||
ctx, _ := context.WithTimeout(context.Background(), time.Second*2)
|
||||
c.callbacks.Cleanup(ctx, c)
|
||||
}
|
||||
close(c.done)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Cluster) leader(ctx context.Context) {
|
||||
defer func() {
|
||||
util.HandleCrash()
|
||||
}()
|
||||
c.callbacks.Leader(ctx, c)
|
||||
}
|
||||
|
||||
func (c *Cluster) follower(ctx context.Context) {
|
||||
defer func() {
|
||||
util.HandleCrash()
|
||||
}()
|
||||
c.callbacks.Follower(ctx, c)
|
||||
}
|
||||
|
||||
func (c *Cluster) Stepdown() {
|
||||
select {
|
||||
case c.stepdown <- struct{}{}:
|
||||
case <-time.After(time.Second * 2):
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Cluster) Stop() {
|
||||
close(c.stop)
|
||||
<-c.done
|
||||
s := make(chan struct{})
|
||||
go func() {
|
||||
c.r.Shutdown().Error()
|
||||
close(s)
|
||||
}()
|
||||
select {
|
||||
case <-s:
|
||||
case <-time.After(time.Second * 5):
|
||||
}
|
||||
}
|
||||
63
pkg/raft/tls/stream.go
Normal file
63
pkg/raft/tls/stream.go
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
package tls
|
||||
|
||||
import (
|
||||
"crypto/tls"
|
||||
"crypto/x509"
|
||||
"net"
|
||||
"time"
|
||||
|
||||
"git.giftfish.de/ston1th/vipman/pkg/config"
|
||||
"github.com/hashicorp/raft"
|
||||
)
|
||||
|
||||
var (
|
||||
ciphers = []uint16{
|
||||
tls.TLS_CHACHA20_POLY1305_SHA256,
|
||||
}
|
||||
curves = []tls.CurveID{
|
||||
tls.X25519,
|
||||
}
|
||||
)
|
||||
|
||||
type stream struct {
|
||||
net.Listener
|
||||
insecure bool
|
||||
ca *x509.CertPool
|
||||
}
|
||||
|
||||
func NewStream(cfg *config.Raft) (s *stream, err error) {
|
||||
cert, err := tls.LoadX509KeyPair(cfg.TLS.Cert, cfg.TLS.Key)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
ca, err := config.LoadCertPool(cfg.TLS.CA)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
l, err := tls.Listen("tcp", cfg.Address, &tls.Config{
|
||||
MinVersion: tls.VersionTLS13,
|
||||
CipherSuites: ciphers,
|
||||
CurvePreferences: curves,
|
||||
PreferServerCipherSuites: true,
|
||||
Certificates: []tls.Certificate{cert},
|
||||
})
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s = &stream{l, cfg.TLS.Insecure, ca}
|
||||
return
|
||||
}
|
||||
|
||||
func (s *stream) Dial(address raft.ServerAddress, timeout time.Duration) (net.Conn, error) {
|
||||
return tls.DialWithDialer(
|
||||
&net.Dialer{Timeout: timeout},
|
||||
"tcp", string(address),
|
||||
&tls.Config{
|
||||
MinVersion: tls.VersionTLS13,
|
||||
CipherSuites: ciphers,
|
||||
CurvePreferences: curves,
|
||||
InsecureSkipVerify: s.insecure,
|
||||
RootCAs: s.ca,
|
||||
},
|
||||
)
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue