raft

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

type ApplierMetrics interface {
	// Record times how long a apply operation took, along with if it failed or
	// not. This can be used to understand if we're hitting issues with the
	// underlying raft instance.
	Record(start time.Time, result string)
	// RecordLeaderError calls out that there was a leader error, so didn't
	// follow the usual flow.
	RecordLeaderError(start time.Time)
}

type BootstrapFSM struct{}

type BootstrapLeaseApplier struct{}

type BootstrapNotifyTarget struct{}

type Config struct {
	// FSM is the raft.FSM to use for this raft worker. This
	// must be non-nil for NewWorker, and nil for Bootstrap.
	FSM raft.FSM

	// Logger is the logger for this worker.
	Logger Logger

	// StorageDir is the directory in which to store raft
	// artifacts: logs, snapshots, etc. It is expected that
	// this directory is under the full control of the raft
	// worker.
	StorageDir string

	// NonSyncedWritesToRaftLog allows the operator to disable fsync calls
	// after each write to the raft log. This option trades performance for
	// data safety and should be used with caution.
	NonSyncedWritesToRaftLog bool

	// LocalID is the raft.ServerID of this worker.
	LocalID raft.ServerID

	// Transport is the raft.Transport to use for communication
	// between raft servers. This must be non-nil for NewWorker,
	// and nil for Bootstrap.
	//
	// The raft worker expects the server address to exactly
	// match the server ID, which is the stringified agent tag.
	// The transport internally maps the server address to one
	// or more network addresses, i.e. by looking up the API
	// connection information in the state database.
	Transport raft.Transport

	// Clock is used for timeouts in the worker (although not inside
	// raft).
	Clock clock.Clock

	// NoLeaderTimeout, if non-zero, will override the default
	// timeout for leader contact before restarting.
	NoLeaderTimeout time.Duration

	// ElectionTimeout, if non-zero, will override the default
	// raft election timeout.
	ElectionTimeout time.Duration

	// HeartbeatTimeout, if non-zero, will override the default
	// raft heartbeat timeout.
	HeartbeatTimeout time.Duration

	// LeaderLeaseTimeout, if non-zero, will override the default
	// raft leader lease timeout.
	LeaderLeaseTimeout time.Duration

	// SnapshotRetention is the non-negative number of snapshots
	// to retain on disk. If zero, defaults to 2.
	SnapshotRetention int

	// PrometheusRegisterer is used to register the raft metrics.
	PrometheusRegisterer prometheus.Registerer

	// Queue is a blocking queue to apply raft operations.
	Queue Queue

	// NotifyTarget is used to notify the changes from the raft operation
	// applications.
	NotifyTarget raftlease.NotifyTarget

	// NewApplier is used to apply the raft operations on to the raft
	// instance, before notifying a target of the changes.
	NewApplier func(Raft, raftlease.NotifyTarget, ApplierMetrics, clock.Clock, Logger) LeaseApplier
}

type LeaseApplier interface {
	// ApplyOperation applies a lease opeartion against the raft instance. If
	// the raft instance isn't the leader, then an error is returned with the
	// leader information if available.
	// This Raft spec outlines this "The first option, which we recommend ...,
	// is for the server to reject the request and return to the client the
	// address of the leader, if known." (see 6.2.1).
	// If the leader is the current raft instance, then attempt to apply it to
	// the fsm.
	// The time duration is the applying of a command in an operation, not for
	// the whole operation.
	ApplyOperation([]queue.Operation, time.Duration)
}

type Logger interface {
	Criticalf(message string, args ...interface{})
	Warningf(message string, args ...interface{})
	Errorf(message string, args ...interface{})
	Infof(message string, args ...interface{})
	Debugf(message string, args ...interface{})
	Tracef(message string, args ...interface{})
	Logf(level loggo.Level, message string, args ...interface{})
	IsTraceEnabled() bool
}

type ManifoldConfig struct {
	ClockName     string
	AgentName     string
	TransportName string
	StateName     string

	FSM                  raft.FSM
	Logger               Logger
	PrometheusRegisterer prometheus.Registerer
	NewWorker            func(Config) (worker.Worker, error)
	NewTarget            func(*state.State, raftleasestore.Logger) raftlease.NotifyTarget
	NewApplier           func(Raft, raftlease.NotifyTarget, ApplierMetrics, clock.Clock, Logger) LeaseApplier

	Queue Queue
}

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

type Queue interface {
	// Queue returns the queue of operations. Removing an item from the channel
	// will unblock to allow another to take its place.
	Queue() <-chan []queue.Operation
}

type Raft interface {
	// State is used to return the current raft state.
	State() raft.RaftState

	// Leader is used to return the current leader of the cluster.
	// It may return empty string if there is no current leader
	// or the leader is unknown.
	Leader() raft.ServerAddress

	// GetConfiguration returns the latest configuration. This may not yet be
	// committed. The main loop can access this directly.
	GetConfiguration() raft.ConfigurationFuture

	// Apply is used to apply a command to the FSM in a highly consistent
	// manner. This returns a future that can be used to wait on the application.
	// An optional timeout can be provided to limit the amount of time we wait
	// for the command to be started. This must be run on the leader or it
	// will fail.
	Apply([]byte, time.Duration) raft.ApplyFuture
}

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

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

type SyncMode bool

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