consensus

type Backoff struct {
	InitialInterval time.Duration
	MaxInterval     time.Duration
	Multiplier      float64
	Jitter          float64
	// contains filtered or unexported fields
}

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

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

type CircuitState int

type Config struct {
	// NodeID is the unique identifier for this node in the cluster.
	// Must be non-zero.
	NodeID uint64

	// Peers is the initial list of peers in the cluster.
	// For bootstrapping a new cluster, include all initial members.
	// For joining an existing cluster, this can be a subset.
	Peers []Peer

	// DataDir is the directory where Raft state is persisted.
	DataDir string

	// TickInterval is the time between Raft ticks.
	// The Raft paper recommends 100-500ms for typical deployments.
	// Default: 100ms
	TickInterval time.Duration

	// ElectionTick is the number of ticks before starting an election.
	// A higher value can reduce election frequency in stable networks.
	// Must be greater than HeartbeatTick.
	// Default: 10 (1 second with 100ms tick interval)
	ElectionTick int

	// HeartbeatTick is the number of ticks between heartbeats.
	// Leaders send heartbeats to maintain their leadership.
	// Default: 1 (100ms with 100ms tick interval)
	HeartbeatTick int

	// MaxSizePerMsg is the maximum size of each Raft message.
	// Default: 1MB
	MaxSizePerMsg uint64

	// MaxInflightMsgs is the maximum number of in-flight append messages.
	// This limits the number of messages being sent to followers at once.
	// Default: 256
	MaxInflightMsgs int

	// SnapshotInterval is the number of log entries between snapshots.
	// A snapshot compacts the Raft log to prevent unbounded growth.
	// Default: 10000
	SnapshotInterval uint64

	// SnapshotCatchUpEntries is the number of entries a follower can lag
	// before the leader sends a snapshot instead of log entries.
	// Default: 5000
	SnapshotCatchUpEntries uint64

	// PreVote enables the pre-vote algorithm to reduce disruptions.
	// When enabled, candidates first check if they would win an election
	// before actually starting one.
	// Default: true
	PreVote bool

	// CheckQuorum enables leader health checking by followers.
	// If the leader doesn't receive a quorum of heartbeat responses,
	// it steps down to follower.
	// Default: true
	CheckQuorum bool

	// DisableProposalForwarding disables proposal forwarding to the leader.
	// When disabled, proposals on non-leaders will be rejected immediately.
	// Default: false
	DisableProposalForwarding bool
}

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

type MessageHandler func(msg raftpb.Message)

type Node interface {
	// Propose proposes data to be appended to the Raft log.
	// This is used for any state changes that need to be replicated.
	Propose(ctx context.Context, data []byte) error

	// Start starts the Raft node and begins participating in the cluster.
	Start() error

	// Stop gracefully stops the Raft node.
	Stop() error

	// IsLeader returns true if this node is currently the Raft leader.
	IsLeader() bool

	// Leader returns the ID of the current leader, or 0 if unknown.
	Leader() uint64

	// AddNode adds a new node to the Raft cluster.
	AddNode(ctx context.Context, nodeID uint64, addr string) error

	// RemoveNode removes a node from the Raft cluster.
	RemoveNode(ctx context.Context, nodeID uint64) error

	// Campaign causes the node to transition to candidate state and attempt to become leader.
	Campaign(ctx context.Context) error

	// Ready returns a channel that receives Ready structs when the Raft state changes.
	Ready() <-chan Ready

	// Advance notifies the Raft node that the application has applied the committed entries.
	Advance()
}

type Peer struct {
	ID   uint64 // Raft node ID
	Addr string // Network address (host:port)
}

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

type Ready struct {
	// SoftState provides state that is useful for logging and debugging.
	// It does not need to be persisted.
	SoftState *SoftState

	// HardState contains the durable state that must be persisted to stable storage.
	HardState raftpb.HardState

	// Entries specifies entries to be saved to stable storage.
	Entries []raftpb.Entry

	// Snapshot specifies the snapshot to be saved to stable storage.
	Snapshot raftpb.Snapshot

	// CommittedEntries specifies entries to be committed to the state machine.
	CommittedEntries []raftpb.Entry

	// Messages specifies outgoing messages to be sent to other nodes.
	Messages []raftpb.Message

	// MustSync indicates whether the HardState and Entries must be synchronously
	// written to disk before proceeding.
	MustSync bool
}

type SoftState struct {
	Lead      uint64 // Lead is the ID of the current leader
	RaftState StateType
}

type StateMachine interface {
	// Apply applies a committed log entry to the state machine.
	Apply(entry []byte) error

	// Snapshot returns the current state of the state machine as a snapshot.
	Snapshot() ([]byte, error)

	// Restore restores the state machine from a snapshot.
	Restore(snapshot []byte) error
}

type StateType uint64

type Storage interface {
	// InitialState returns the saved HardState and ConfState.
	InitialState() (raftpb.HardState, raftpb.ConfState, error)

	// SaveState saves the current HardState.
	SaveState(st raftpb.HardState) error

	// Entries returns a slice of log entries in the range [lo, hi).
	Entries(lo, hi uint64) ([]raftpb.Entry, error)

	// Term returns the term of entry i.
	Term(i uint64) (uint64, error)

	// LastIndex returns the index of the last entry in the log.
	LastIndex() (uint64, error)

	// FirstIndex returns the index of the first log entry that is available.
	FirstIndex() (uint64, error)

	// Snapshot returns the most recent snapshot.
	Snapshot() (raftpb.Snapshot, error)

	// SaveEntries saves entries to stable storage.
	SaveEntries(entries []raftpb.Entry) error

	// SaveSnapshot saves the snapshot to stable storage.
	SaveSnapshot(snap raftpb.Snapshot) error

	// Compact compacts the log up to compactIndex.
	Compact(compactIndex uint64) error

	// Close closes the storage.
	Close() error
}

type Transport interface {
	// Send sends a message to the specified node.
	Send(msg raftpb.Message) error

	// Start starts the transport layer.
	Start() error

	// Stop stops the transport layer.
	Stop() error

	// AddPeer adds a peer to the transport.
	AddPeer(nodeID uint64, addr string) error

	// RemovePeer removes a peer from the transport.
	RemovePeer(nodeID uint64) error
}