ston1th/vipman
0
0
Fork 0
Code Issues 2 Releases Activity

added etcd support

Browse source
This commit is contained in:
ston1th 2020-11-15 18:39:16 +01:00
commit 85a8ba23bd
21 changed files with 767 additions and 247 deletions
Download patch file Download diff file Expand all files Collapse all files

54
pkg/raft/cluster.go
View file

@ -4,33 +4,53 @@ import (
"errors"
"git.giftfish.de/ston1th/vipman/pkg/cluster"
"github.com/go-logr/logr"
"github.com/hashicorp/raft"
)
type Cluster struct {
kv *KV
r *raft.Raft
logr.Logger
cluster.KV
r *raft.Raft
kvm *kv
stepdown chan struct{}
stop chan struct{}
done chan struct{}
Callbacks cluster.Callbacks
callbacks cluster.Callbacks
id string
}
func NewCluster(callbacks cluster.Callbacks) (cluster.Cluster, error) {
if callbacks.Leader == nil {
return nil, errors.New("Leader is nil")
}
if callbacks.Follower == nil {
return nil, errors.New("Follower is nil")
func NewCluster(log logr.Logger) cluster.Cluster {
kvm := &kv{
m: make(map[string][]byte),
}
return &Cluster{
kv: &KV{
m: make(map[string][]byte),
},
stepdown: make(chan struct{}, 1),
stop: make(chan struct{}, 1),
done: make(chan struct{}, 1),
Callbacks: callbacks,
}, nil
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
}

8
pkg/raft/fsm.go
View file

@ -27,7 +27,7 @@ type raftCmd struct {
V []byte
}
type fsm KV
type fsm kv
func (f *fsm) Apply(l *raft.Log) interface{} {
var c raftCmd
@ -49,7 +49,7 @@ func (f *fsm) Apply(l *raft.Log) interface{} {
func (f *fsm) Snapshot() (raft.FSMSnapshot, error) {
f.mu.Lock()
defer f.mu.Unlock()
m := make(kv)
m := make(kvm)
for k, v := range f.m {
m[k] = v
}
@ -57,7 +57,7 @@ func (f *fsm) Snapshot() (raft.FSMSnapshot, error) {
}
func (f *fsm) Restore(rc io.ReadCloser) error {
o := make(kv)
o := make(kvm)
if err := msgpack.NewDecoder(rc).Decode(&o); err != nil {
return err
}
@ -78,7 +78,7 @@ func (f *fsm) applyDelete(k string) {
}
type fsmSnapshot struct {
m kv
m kvm
}
func (f *fsmSnapshot) Persist(sink raft.SnapshotSink) error {

12
pkg/raft/kv.go
View file

@ -10,21 +10,21 @@ import (
var ErrNotLeader = errors.New("not leader")
type kv map[string][]byte
type kvm map[string][]byte
type KV struct {
type kv struct {
mu sync.Mutex
m kv
m kvm
r *raft.Raft
}
func (kv *KV) Get(k string) []byte {
func (kv *kv) Get(k string) []byte {
kv.mu.Lock()
defer kv.mu.Unlock()
return kv.m[k]
}
func (kv *KV) Set(k string, v []byte) error {
func (kv *kv) Set(k string, v []byte) error {
if kv.r.State() != raft.Leader {
return ErrNotLeader
}
@ -40,7 +40,7 @@ func (kv *KV) Set(k string, v []byte) error {
}
// Delete deletes the given key.
func (kv *KV) Delete(k string) error {
func (kv *kv) Delete(k string) error {
if kv.r.State() != raft.Leader {
return ErrNotLeader
}

74
pkg/raft/raft.go
View file

@ -4,32 +4,27 @@ import (
"context"
"fmt"
"net"
"net/http"
"os"
"path/filepath"
"runtime"
"time"
"git.giftfish.de/ston1th/raftbbolt"
"git.giftfish.de/ston1th/vipman/pkg/config"
"git.giftfish.de/ston1th/vipman/pkg/raft/tls"
"github.com/go-logr/logr"
"git.giftfish.de/ston1th/vipman/pkg/util"
hclog "github.com/hashicorp/go-hclog"
"github.com/hashicorp/raft"
"k8s.io/klog/v2"
)
type raftLog string
func (r *raftLog) Write(p []byte) (n int, err error) {
return os.Stdout.Write(append([]byte(*r), p...))
}
func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
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.Level),
Level: hclog.LevelFromString(cfg.LogLevel),
Output: hclog.DefaultOutput,
TimeFormat: "I0102 15:04:05.000000",
})
@ -38,19 +33,20 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
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 {
log.Info("transport: tls")
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 {
log.Info("transport: tcp")
c.V(1).Info("setup", "transport", "tcp")
address, err := net.ResolveTCPAddr("tcp", cfg.Address)
if err != nil {
return err
@ -104,16 +100,13 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
}
}
// Create RAFT instance
c.r, err = raft.NewRaft(rc, (*fsm)(c.kv), logStore, stableStore, snapshots, transport)
c.r, err = raft.NewRaft(rc, (*fsm)(c.kvm), logStore, stableStore, snapshots, transport)
if err != nil {
return err
}
c.kv.r = c.r
c.kvm.r = c.r
t := time.NewTicker(time.Second)
time.Sleep(time.Second * 3)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
leading := false
@ -128,6 +121,7 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
}
select {
case <-t.C:
case leader := <-c.r.LeaderCh():
if leader {
if following {
@ -163,7 +157,6 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
}
close(c.done)
return nil
case <-t.C:
}
}
return nil
@ -171,49 +164,16 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
func (c *Cluster) leader(ctx context.Context) {
defer func() {
handleCrash()
util.HandleCrash()
}()
c.Callbacks.Leader(ctx, c.kv)
c.callbacks.Leader(ctx, c)
}
func (c *Cluster) follower(ctx context.Context) {
defer func() {
handleCrash()
util.HandleCrash()
}()
c.Callbacks.Follower(ctx, c.kv)
}
var reallyCrash = false
func handleCrash() {
if r := recover(); r != nil {
logPanic(r)
if reallyCrash {
panic(r)
}
}
}
// logPanic logs the caller tree when a panic occurs (except in the special case of http.ErrAbortHandler).
func logPanic(r interface{}) {
if r == http.ErrAbortHandler {
// honor the http.ErrAbortHandler sentinel panic value:
// ErrAbortHandler is a sentinel panic value to abort a handler.
// While any panic from ServeHTTP aborts the response to the client,
// panicking with ErrAbortHandler also suppresses logging of a stack trace to the server's error log.
return
}
// Same as stdlib http server code. Manually allocate stack trace buffer size
// to prevent excessively large logs
const size = 64 << 10
stacktrace := make([]byte, size)
stacktrace = stacktrace[:runtime.Stack(stacktrace, false)]
if _, ok := r.(string); ok {
klog.Errorf("Observed a panic: %s\n%s", r, stacktrace)
} else {
klog.Errorf("Observed a panic: %#v (%v)\n%s", r, r, stacktrace)
}
c.callbacks.Follower(ctx, c)
}
func (c *Cluster) Stepdown() {

16
pkg/raft/tls/stream.go
View file

@ -3,7 +3,6 @@ package tls
import (
"crypto/tls"
"crypto/x509"
"io/ioutil"
"net"
"time"
@ -20,19 +19,6 @@ var (
}
)
func loadCertPool(file string) (p *x509.CertPool, err error) {
if file == "" {
return
}
buf, err := ioutil.ReadFile(file)
if err != nil {
return
}
p = x509.NewCertPool()
p.AppendCertsFromPEM(buf)
return
}
type stream struct {
net.Listener
insecure bool
@ -44,7 +30,7 @@ func NewStream(cfg *config.Raft) (s *stream, err error) {
if err != nil {
return
}
ca, err := loadCertPool(cfg.TLS.CA)
ca, err := config.LoadCertPool(cfg.TLS.CA)
if err != nil {
return
}