epaxos

type Config struct {
	// ID is the identity of the local epaxos.
	ID pb.ReplicaID
	// Nodes is the set of all nodes in the epaxos network.
	Nodes []pb.ReplicaID
	// Storage is the persistent storage for epaxos. epaxos reads out
	// the previous instance state and configuration from storage when
	// restarting.
	Storage Storage
	// Logger is the logger that the epaxos state machine will use
	// to log events. If not set, a default logger will be used.
	Logger Logger
	// RandSeed allows the seed used by epaxos's rand.Source to be
	// injected, to allow for fully deterministic execution.
	RandSeed int64
}

type DefaultLogger struct {
	*log.Logger
	// contains filtered or unexported fields
}

type Logger interface {
	Debug(v ...interface{})
	Debugf(format string, v ...interface{})

	Error(v ...interface{})
	Errorf(format string, v ...interface{})

	Info(v ...interface{})
	Infof(format string, v ...interface{})

	Warning(v ...interface{})
	Warningf(format string, v ...interface{})

	Fatal(v ...interface{})
	Fatalf(format string, v ...interface{})

	Panic(v ...interface{})
	Panicf(format string, v ...interface{})
}

type MemoryStorage struct {
	// contains filtered or unexported fields
}

type Node interface {
	// Tick increments the internal logical clock for the Node by a single tick.
	// Election timeouts and progress timeouts are in units of ticks.
	Tick()
	// Propose proposes that data be ordered by paxos.
	Propose(ctx context.Context, command pb.Command) error
	// Step advances the state machine using the given message. ctx.Err() will be
	// returned, if any.
	Step(ctx context.Context, msg pb.Message) error
	// Ready returns a channel that returns the current point-in-time state.
	// Users of the Node must call Advance after retrieving the state returned by
	// Ready.
	//
	// NOTE: No committed entries from the next Ready may be applied until all
	// committed entries and snapshots from the previous one have finished.
	Ready() <-chan Ready
	// Stop performs any necessary termination of the Node.
	Stop()
}

type Ready struct {
	// Messages specifies outbound messages to be sent AFTER Entries are
	// committed to stable storage.
	Messages []pb.Message

	// ExecutedCommands specifies commands to be executed by a state-machine.
	// These have previously been committed to stable store.
	ExecutedCommands []pb.Command
}

type Storage interface {
	HardState() (pb.HardState, bool)
	PersistHardState(hs pb.HardState)

	Instances() []*pb.InstanceState
	PersistInstance(is *pb.InstanceState)
}