package fsm import ( "fmt" "io" "sync" "time" "github.com/hashicorp/consul/agent/consul/state" "github.com/hashicorp/consul/agent/structs" "github.com/hashicorp/consul/logging" "github.com/hashicorp/go-hclog" "github.com/hashicorp/go-msgpack/codec" "github.com/hashicorp/go-raftchunking" "github.com/hashicorp/raft" ) // command is a command method on the FSM. type command func(buf []byte, index uint64) interface{} // unboundCommand is a command method on the FSM, not yet bound to an FSM // instance. type unboundCommand func(c *FSM, buf []byte, index uint64) interface{} // commands is a map from message type to unbound command. var commands map[structs.MessageType]unboundCommand // registerCommand registers a new command with the FSM, which should be done // at package init() time. func registerCommand(msg structs.MessageType, fn unboundCommand) { if commands == nil { commands = make(map[structs.MessageType]unboundCommand) } if commands[msg] != nil { panic(fmt.Errorf("Message %d is already registered", msg)) } commands[msg] = fn } // FSM implements a finite state machine that is used // along with Raft to provide strong consistency. We implement // this outside the Server to avoid exposing this outside the package. type FSM struct { logger hclog.Logger path string // apply is built off the commands global and is used to route apply // operations to their appropriate handlers. apply map[structs.MessageType]command // stateLock is only used to protect outside callers to State() from // racing with Restore(), which is called by Raft (it puts in a totally // new state store). Everything internal here is synchronized by the // Raft side, so doesn't need to lock this. stateLock sync.RWMutex state *state.Store gc *state.TombstoneGC chunker *raftchunking.ChunkingFSM } // New is used to construct a new FSM with a blank state. func New(gc *state.TombstoneGC, logger hclog.Logger) (*FSM, error) { if logger == nil { logger = hclog.New(&hclog.LoggerOptions{}) } stateNew, err := state.NewStateStore(gc) if err != nil { return nil, err } fsm := &FSM{ logger: logger.Named(logging.FSM), apply: make(map[structs.MessageType]command), state: stateNew, gc: gc, } // Build out the apply dispatch table based on the registered commands. for msg, fn := range commands { thisFn := fn fsm.apply[msg] = func(buf []byte, index uint64) interface{} { return thisFn(fsm, buf, index) } } fsm.chunker = raftchunking.NewChunkingFSM(fsm, nil) return fsm, nil } func (c *FSM) ChunkingFSM() *raftchunking.ChunkingFSM { return c.chunker } // State is used to return a handle to the current state func (c *FSM) State() *state.Store { c.stateLock.RLock() defer c.stateLock.RUnlock() return c.state } func (c *FSM) Apply(log *raft.Log) interface{} { buf := log.Data msgType := structs.MessageType(buf[0]) // Check if this message type should be ignored when unknown. This is // used so that new commands can be added with developer control if older // versions can safely ignore the command, or if they should crash. ignoreUnknown := false if msgType&structs.IgnoreUnknownTypeFlag == structs.IgnoreUnknownTypeFlag { msgType &= ^structs.IgnoreUnknownTypeFlag ignoreUnknown = true } // Apply based on the dispatch table, if possible. if fn := c.apply[msgType]; fn != nil { return fn(buf[1:], log.Index) } // Otherwise, see if it's safe to ignore. If not, we have to panic so // that we crash and our state doesn't diverge. if ignoreUnknown { c.logger.Warn("ignoring unknown message type, upgrade to newer version", "type", msgType) return nil } panic(fmt.Errorf("failed to apply request: %#v", buf)) } func (c *FSM) Snapshot() (raft.FSMSnapshot, error) { defer func(start time.Time) { c.logger.Info("snapshot created", "duration", time.Since(start).String()) }(time.Now()) chunkState, err := c.chunker.CurrentState() if err != nil { return nil, err } return &snapshot{ state: c.state.Snapshot(), chunkState: chunkState, }, nil } // Restore streams in the snapshot and replaces the current state store with a // new one based on the snapshot if all goes OK during the restore. func (c *FSM) Restore(old io.ReadCloser) error { defer old.Close() // Create a new state store. stateNew, err := state.NewStateStore(c.gc) if err != nil { return err } // Set up a new restore transaction restore := stateNew.Restore() defer restore.Abort() // Create a decoder dec := codec.NewDecoder(old, structs.MsgpackHandle) // Read in the header var header snapshotHeader if err := dec.Decode(&header); err != nil { return err } // Populate the new state msgType := make([]byte, 1) for { // Read the message type _, err := old.Read(msgType) if err == io.EOF { break } else if err != nil { return err } // Decode msg := structs.MessageType(msgType[0]) switch { case msg == structs.ChunkingStateType: chunkState := &raftchunking.State{ ChunkMap: make(raftchunking.ChunkMap), } if err := dec.Decode(chunkState); err != nil { return err } if err := c.chunker.RestoreState(chunkState); err != nil { return err } case restorers[msg] != nil: fn := restorers[msg] if err := fn(&header, restore, dec); err != nil { return err } default: return fmt.Errorf("Unrecognized msg type %d", msg) } } if err := restore.Commit(); err != nil { return err } // External code might be calling State(), so we need to synchronize // here to make sure we swap in the new state store atomically. c.stateLock.Lock() stateOld := c.state c.state = stateNew c.stateLock.Unlock() // Signal that the old state store has been abandoned. This is required // because we don't operate on it any more, we just throw it away, so // blocking queries won't see any changes and need to be woken up. stateOld.Abandon() return nil }