106 lines
1.9 KiB
Go
106 lines
1.9 KiB
Go
package raft
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
|
|
"github.com/hashicorp/raft"
|
|
)
|
|
|
|
type Fsm Store
|
|
|
|
// Apply applies a Raft log entry to the key-value store.
|
|
func (f *Fsm) Apply(l *raft.Log) interface{} {
|
|
/*if f.Raft.State() == raft.Leader {
|
|
println("j'insert dans etcd !")
|
|
}*/
|
|
|
|
var c command
|
|
if err := json.Unmarshal(l.Data, &c); err != nil {
|
|
panic(fmt.Sprintf("failed to unmarshal command: %s", err.Error()))
|
|
}
|
|
|
|
switch c.Op {
|
|
case "set":
|
|
return f.applySet(c.Key, c.Value)
|
|
case "delete":
|
|
return f.applyDelete(c.Key)
|
|
default:
|
|
panic(fmt.Sprintf("unrecognized command op: %s", c.Op))
|
|
}
|
|
}
|
|
|
|
// Snapshot returns a snapshot of the key-value store.
|
|
func (f *Fsm) Snapshot() (raft.FSMSnapshot, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
|
|
// Clone the map.
|
|
o := make(map[string][]byte)
|
|
for k, v := range f.m {
|
|
o[k] = v
|
|
}
|
|
|
|
return &fsmSnapshot{store: o}, nil
|
|
}
|
|
|
|
// Restore stores the key-value store to a previous state.
|
|
func (f *Fsm) Restore(rc io.ReadCloser) error {
|
|
o := make(map[string][]byte)
|
|
|
|
if err := json.NewDecoder(rc).Decode(&o); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Set the state from the snapshot, no lock required according to
|
|
// Hashicorp docs.
|
|
f.m = o
|
|
return nil
|
|
}
|
|
|
|
func (f *Fsm) applySet(key string, value []byte) interface{} {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.m[key] = value
|
|
return nil
|
|
}
|
|
|
|
func (f *Fsm) applyDelete(key string) interface{} {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
delete(f.m, key)
|
|
return nil
|
|
}
|
|
|
|
type fsmSnapshot struct {
|
|
store map[string][]byte
|
|
}
|
|
|
|
func (f *fsmSnapshot) Persist(sink raft.SnapshotSink) error {
|
|
err := func() error {
|
|
// Encode data.
|
|
b, err := json.Marshal(f.store)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Write data to sink.
|
|
if _, err := sink.Write(b); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Close the sink.
|
|
return sink.Close()
|
|
}()
|
|
|
|
if err != nil {
|
|
sink.Cancel()
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func (f *fsmSnapshot) Release() {
|
|
}
|