raft

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

type AddressResolver interface {

	// Resolve returns an address of TCP end point.
	//
	// If the host in the address parameter is not a literal IP address or
	// the port is not a literal port number, ResolveTCPAddr resolves the
	// address to an address of TCP end point.
	// Otherwise, it parses the address as a pair of literal IP address
	// and port number.
	// The address parameter can use a host name, but this is not
	// recommended, because it will return at most one of the host name's
	// IP addresses.
	Resolve(string) (net.Addr, error)
}

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

type DialerProvider interface {
	// Dial creates a rafthttp.Dial function that connects over TLS using the given
	// cluster (and optionally CA) certificate both as client and remote
	// certificate.
	Dial(certInfo *cert.Info) (rafthttp.Dial, error)
}

type HTTPHandler interface {
	// Requests returns a channel of inbound Raft membership change requests
	// received over HTTP. Consumer code is supposed to process this channel by
	// invoking raftmembership.HandleChangeRequests.
	Requests() <-chan *raftmembership.ChangeRequest

	// ServerHTTP upgrades the given HTTP connection to a raw TCP one for
	// use by raft.
	ServeHTTP(w http.ResponseWriter, r *http.Request)
}

type HTTPProvider interface {
	// Handler implements an HTTP handler that will look for an Upgrade
	// header in the request to switch the HTTP connection to raw TCP
	// mode, so it can be used as raft.NetworkTransport stream.
	Handler(*stdlog.Logger) *rafthttp.Handler

	// NewLayer returns a new raft stream layer that initiates connections
	// with HTTP and then uses Upgrade to switch them into raw TCP.
	Layer(string, net.Addr, *rafthttp.Handler, rafthttp.Dial, *stdlog.Logger) *rafthttp.Layer
}

type LogStore interface {
	// FirstIndex returns the first index written. 0 for no entries.
	FirstIndex() (uint64, error)

	// LastIndex returns the last index written. 0 for no entries.
	LastIndex() (uint64, error)

	// GetLog gets a log entry at a given index.
	GetLog(uint64, *raft.Log) error

	// StoreLog stores a log entry.
	StoreLog(*raft.Log) error

	// StoreLogs stores multiple log entries.
	StoreLogs([]*raft.Log) error

	// DeleteRange deletes a range of log entries. The range is inclusive.
	DeleteRange(uint64, uint64) error

	// Set stores the key and value
	Set([]byte, []byte) error

	// Get returns the value for key, or an empty byte slice if key was not
	// found.
	Get([]byte) ([]byte, error)

	// SetUint64 sets a key and a uint64 value
	SetUint64([]byte, uint64) error

	// GetUint64 returns the uint64 value for key, or 0 if key was not found.
	GetUint64([]byte) (uint64, error)

	// Close the log store
	Close() error
}

type LogsProvider interface {

	// Logs returns a LogStore
	Logs(string, time.Duration) (LogStore, error)
}

type MembershipChangerFunc func(*raft.Raft)

type NetworkProvider interface {

	// Network creates a new network transport with the given config struct
	Network(*raft.NetworkTransportConfig) raft.Transport
}

type Node interface {
	db.NodeTransactioner

	// Dir returns the directory of the underlying database file.
	Dir() string
}

type Option func(*options)

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

type RaftNodeMediator interface {
	// DetermineRaftNode figures out what raft node ID and address we have, if any.
	//
	// This decision is based on the values of the core.https_address config key
	// and on the rows in the raft_nodes table, both stored in the node-level
	// SQLite database.
	DetermineRaftNode(node.Tx, config.Schema) (*db.RaftNode, error)
}

type RaftProvider interface {
	Raft(*raft.Config, raft.FSM, LogStore, raft.SnapshotStore, raft.Transport) (*raft.Raft, error)
}

type RegistryProvider interface {

	// Registry tracks internal data shared by the dqlite Driver and FSM.
	// The parameter is a string identifying the local node.
	Registry(string) *dqlite.Registry

	// FSM creates a new dqlite FSM, suitable to be passed to raft.NewRaft.
	// It will handle replication of the SQLite write-ahead log.
	FSM(*dqlite.Registry) raft.FSM
}

type SnapshotStoreProvider interface {

	// Store returns a new shapshot store for a given path
	Store(string) (raft.SnapshotStore, error)
}