rafty

type BoltOptions struct {
	// DataDir is the default data directory that will be used to store all data on the disk. It's required
	DataDir string

	// Options holds all bolt options
	Options *bolt.Options
}

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

type ClusterStore interface {
	// Close permits to close the store
	Close() error

	// GetMetadata will fetch rafty metadata from the k/v store
	GetMetadata() ([]byte, error)

	// StoreMetadata will store rafty metadata into the k/v bucket.
	// This won't be replicated
	StoreMetadata([]byte) error

	// Set will add key/value to the k/v store
	Set(key, value []byte) error

	// Get will fetch provided key from the k/v store
	Get(key []byte) ([]byte, error)

	// SetUint64 will add key/value to the k/v store
	SetUint64(key, value []byte) error

	// GetUint64 will fetch provided key from the k/v store
	GetUint64(key []byte) uint64
}

type Configuration struct {
	// ServerMembers holds all current members of the cluster
	ServerMembers []Peer `json:"serverMembers"`
}

type GetLogsByRangeResponse struct {
	Logs                             []*LogEntry
	Total, LastLogIndex, LastLogTerm uint64
	SendSnapshot                     bool
	Err                              error
}

type InitialPeer struct {
	// Address is the address of a peer node, must be just the ip or ip:port
	Address string
	// contains filtered or unexported fields
}

type LogEntry struct {
	FileFormat uint32
	Tombstone  uint32
	LogType    uint32
	Timestamp  uint32
	Term       uint64
	Index      uint64
	Command    []byte
}

type LogKind uint8

type LogStore interface {
	// Close permits to close the store
	Close() error

	// StoreLogs stores multiple log entries
	StoreLogs(logs []*LogEntry) error

	// StoreLog stores a single log entry
	StoreLog(log *LogEntry) error

	// GetLogByIndex permits to retrieve log from specified index
	GetLogByIndex(index uint64) (*LogEntry, error)

	// GetLogsByRange will return a slice of logs
	// with min and max index capped by options.MaxAppendEntries
	GetLogsByRange(minLogIndex, maxLogIndex, maxAppendEntries uint64) GetLogsByRangeResponse

	// DiscardLogs permits to wipe entries with the provided range indexes
	DiscardLogs(from, to uint64) error

	// CompactLogs permits to wipe all entries lower than the provided index
	CompactLogs(index uint64) error

	// FistIndex will return the first index from the raft log
	FirstIndex() (uint64, error)

	// LastIndex will return the last index from the raft log
	LastIndex() (uint64, error)

	// GetLastConfiguration returns the last configuration found
	// in logs
	GetLastConfiguration() (*LogEntry, error)
}

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

type LogsCacheOptions struct {
	// LogStore holds the long term storage data related to raft logs
	LogStore LogStore

	// CacheOnWrite when set to true will put every write
	// request in cache before writting to the long term storage
	CacheOnWrite bool

	// TTL is the maximum amount of time to keep the entry in cache.
	// Default to 30 seconds if ttl == 0
	TTL time.Duration
}

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

type MembershipChange uint32

type Options struct {

	// Logger expose zerolog so it can be override
	Logger *zerolog.Logger

	// ElectionTimeout is used to start new election campaign.
	// Its value will be divided by 2 in order to randomize election timing process.
	// It must be greater or equal to HeartbeatTimeout.
	// Unit is in milliseconds
	ElectionTimeout int

	// HeartbeatTimeout is used by follower without contact from the leader
	// before starting new election campaign.
	// Unit is in milliseconds
	HeartbeatTimeout int

	// TimeMultiplier is a scaling factor that will be used during election timeout
	// by electionTimeoutMin/electionTimeoutMax/leaderHeartBeatTimeout in order to avoid cluster instability
	// The default value is 1 and the maximum is 10
	TimeMultiplier uint

	// ForceStopTimeout is the timeout after which grpc server will forced to stop.
	// Default to 60s
	ForceStopTimeout time.Duration

	// MinimumClusterSize is the size minimum to have before starting prevote or election campaign
	// default is 3
	// all members of the cluster will be contacted before any other tasks
	MinimumClusterSize uint64

	// MaxAppendEntries will holds how much append entries the leader will send to the follower at once
	MaxAppendEntries uint64

	// DataDir is the default data directory that will be used to store all data on the disk. It's required
	DataDir string

	// IsVoter statuates if this peer is a voting member node.
	// When set to false, this node won't participate into any election campaign
	IsVoter bool

	// Peers holds the list of the peers
	InitialPeers []InitialPeer

	// PrevoteDisabled is a boolean the allows us to directly start
	// vote election without pre vote step
	PrevoteDisabled bool

	// ShutdownOnRemove is a boolean that allow the current node to shut down
	// when Remove command as been sent during membership change request
	ShutdownOnRemove bool

	// LeaveOnTerminate is a boolean that allow the current node to completely remove itself
	// from the cluster before shutting down by sending a LeaveOnTerminate command to the leader.
	// It's usually used by read replicas nodes.
	LeaveOnTerminate bool

	// IsSingleServerCluster indicate that it's a single server cluster.
	// This is useful for development for example
	IsSingleServerCluster bool

	// BootstrapCluster indicate if the cluster must be bootstrapped before
	// proceeding to normal cluster operations
	BootstrapCluster bool

	// SnapshotInterval is the interval at which a snapshot will be taken.
	// It will be randomize with this minimum value in order to prevent
	// all nodes to take a snapshot at the same time
	// Default to 1h
	SnapshotInterval time.Duration

	// SnapshotThreshold is the threshold that must be reached between LastIncluedIndex and new logs before taking a snapshot.
	// It prevent to take snapshots to frequently.
	// Default to 64
	SnapshotThreshold uint64

	// MetricsNamespacePrefix is the namespace to use for all rafty metrics.
	// When set, the full metric name will be `<MetricsNamespacePrefix>_rafty_<metric_name>`.
	// Otherwise it will be `rafty_<metric_name>`.
	MetricsNamespacePrefix string
	// contains filtered or unexported fields
}

type Peer struct {
	// Address is the address of a peer node, must be just the ip or ip:port
	Address string `json:"address"`

	// ID of the current peer
	ID string `json:"id"`

	// IsVoter statuates if this peer is a voting member node.
	// When set to false, this node won't participate into any election campaign
	IsVoter bool `json:"isVoter"`

	// WaitToBePromoted is a boolean when set to true make sure the node
	// can fully participate in raft operations.
	// It's used when using AddVoter or AddNonVoter
	WaitToBePromoted bool `json:"waitToBePromoted"`

	// Decommissioning is a boolean when set to true will allow devops
	// to put this node on maintenance or to lately send a membership
	// removal command to be safely be removed from the cluster.
	// DON'T confuse it with WaitToBePromoted flag
	Decommissioning bool `json:"decommissioning"`
	// contains filtered or unexported fields
}

type RPCAskNodeIDRequest struct {
	Id, Address string
	IsVoter     bool
}

type RPCAskNodeIDResponse struct {
	LeaderID, LeaderAddress, PeerID string
	IsVoter, AskForMembership       bool
}

type RPCGetLeaderRequest struct {
	PeerID, PeerAddress string
	TotalPeers          int
}

type RPCGetLeaderResponse struct {
	LeaderID, LeaderAddress, PeerID string
	TotalPeers                      int
	AskForMembership                bool
}

type RPCPreVoteRequest struct {
	Id          string
	CurrentTerm uint64
}

type RPCPreVoteResponse struct {
	PeerID                     string
	RequesterTerm, CurrentTerm uint64
	Granted                    bool
}

type RPCRequest struct {
	RPCType      RPCType
	Request      any
	Timeout      time.Duration
	ResponseChan chan<- RPCResponse
}

type RPCResponse struct {
	TargetPeer Peer
	Response   any
	Error      error
}

type RPCTimeoutNowRequest struct{}

type RPCTimeoutNowResponse struct {
	Success bool
}

type RPCType uint8

type RPCVoteRequest struct {
	CandidateId, CandidateAddress          string
	CurrentTerm, LastLogIndex, LastLogTerm uint64
	CandidateForLeadershipTransfer         bool
}

type RPCVoteResponse struct {
	PeerID                     string
	RequesterTerm, CurrentTerm uint64
	Granted                    bool
}

type Rafty struct {

	// Logger expose zerolog so it can be override
	Logger *zerolog.Logger

	// Address is the current address of the raft server
	Address net.TCPAddr

	// State of the current raft server state
	// Can only be Leader, Candidate, Follower, Down
	State
	// contains filtered or unexported fields
}

type Snapshot interface {
	io.ReadWriteSeeker
	io.Closer

	// Name return the snapshot name
	Name() string

	// Metadata will return snapshot metadata
	Metadata() SnapshotMetadata

	// Discard will remove the snapshot actually in progress
	Discard() error
}

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

type SnapshotManager struct {
	io.ReadWriteSeeker
	// contains filtered or unexported fields
}

type SnapshotMetadata struct {
	// LastIncludedIndex is the last index included in the snapshot
	LastIncludedIndex uint64 `json:"lastIncludedIndex"`

	// LastIncludedTerm is the term of LastIncludedIndex
	LastIncludedTerm uint64 `json:"lastIncludedTerm"`

	// Configuration holds server members
	Configuration Configuration `json:"configuration"`

	// LastAppliedConfig is the index of the highest log entry configuration applied to the current raft server
	LastAppliedConfigIndex uint64 `json:"lastAppliedConfigIndex"`

	// LastAppliedConfigTerm is the term of the highest log entry configuration applied to the current raft server
	LastAppliedConfigTerm uint64 `json:"lastAppliedConfigTerm"`

	// SnapshotName is the snapshot name
	SnapshotName string `json:"snapshotName"`

	// Size is the snapshot size
	Size int64
	// contains filtered or unexported fields
}

type SnapshotStore interface {
	// PrepareSnapshotWriter will prepare the requirements with the provided parameters to write a snapshot
	PrepareSnapshotWriter(lastIncludedIndex, lastIncludedTerm, lastAppliedConfigIndex, lastAppliedConfigTerm uint64, currentConfig Configuration) (Snapshot, error)

	// PrepareSnapshotReader will return the appropriate config to read
	// the snapshot name
	PrepareSnapshotReader(name string) (Snapshot, io.ReadCloser, error)

	// List will return the list of snapshots
	List() []*SnapshotMetadata
}

type State uint32

type StateMachine interface {
	// Snapshot allow the client to take snapshots
	Snapshot(snapshotWriter io.Writer) error

	// Restore allow the client to restore a snapshot
	Restore(snapshotReader io.Reader) error

	// ApplyCommand allow the client to apply a log to the state machine
	ApplyCommand(log *LogEntry) ([]byte, error)
}

type Status struct {
	// State is the current state of the node
	State State

	// Leader is the current leader of the cluster, if any
	Leader leaderMap

	// currentTerm is the current term of the node
	CurrentTerm uint64

	// CommittedIndex is the last committed index of the node
	CommitIndex uint64

	// LastApplied is the last applied index of the node
	LastApplied uint64

	// LastLogIndex is the last log index of the node
	LastLogIndex uint64

	// LastLogTerm is the last log term of the node
	LastLogTerm uint64

	// LastAppliedConfigIndex is the index of the last applied configuration
	LastAppliedConfigIndex uint64

	// LastAppliedConfigTerm is the term of the last applied configuration
	LastAppliedConfigTerm uint64

	// Configuration is the current configuration of the cluster
	Configuration Configuration
}