raft

package module
v0.0.0-...-d6dbd13 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 18, 2024 License: Unlicense Imports: 9 Imported by: 0

Documentation

Overview

Core Raft implementation - Consensus Module.

Eli Bendersky [https://eli.thegreenplace.net] This code is in the public domain.

Server container for a Raft Consensus Module. Exposes Raft to the network and enables RPCs between Raft peers.

Eli Bendersky [https://eli.thegreenplace.net] This code is in the public domain.

Test harness for writing tests for Raft.

Eli Bendersky [https://eli.thegreenplace.net] This code is in the public domain.

Index

Constants

View Source 
const DebugCM = 1

Variables

This section is empty.

Functions

This section is empty.

Types

type AppendEntriesArgs 

type AppendEntriesArgs struct {
	Term     int
	LeaderId int

	PrevLogIndex int
	PrevLogTerm  int
	Entries      []LogEntry
	LeaderCommit int
}

See figure 2 in the paper.

type AppendEntriesReply 

type AppendEntriesReply struct {
	Term    int
	Success bool
}

type CMState 

type CMState int
const (
	Follower CMState = iota
	Candidate
	Leader
	Dead
)

func (CMState) String 

func (s CMState) String() string

type CommitEntry 

type CommitEntry struct {
	// Command is the client command being committed.
	Command interface{}

	// Index is the log index at which the client command is committed.
	Index int

	// Term is the Raft term at which the client command is committed.
	Term int
}

CommitEntry is the data reported by Raft to the commit channel. Each commit entry notifies the client that consensus was reached on a command and it can be applied to the client's state machine.

type ConsensusModule 

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

ConsensusModule (CM) implements a single node of Raft consensus.

func NewConsensusModule 

func NewConsensusModule(id int, peerIds []int, server *Server, ready <-chan interface{}, commitChan chan<- CommitEntry) *ConsensusModule

NewConsensusModule creates a new CM with the given ID, list of peer IDs and server. The ready channel signals the CM that all peers are connected and it's safe to start its state machine. commitChan is going to be used by the CM to send log entries that have been committed by the Raft cluster.

func (*ConsensusModule) AppendEntries 

func (cm *ConsensusModule) AppendEntries(args AppendEntriesArgs, reply *AppendEntriesReply) error

func (*ConsensusModule) Report 

func (cm *ConsensusModule) Report() (id int, term int, isLeader bool)

Report reports the state of this CM.

func (*ConsensusModule) RequestReport 

func (cm *ConsensusModule) RequestReport(args ReportArgs, reply *ReportReply) error

func (*ConsensusModule) RequestVote 

func (cm *ConsensusModule) RequestVote(args RequestVoteArgs, reply *RequestVoteReply) error

RequestVote RPC.

func (*ConsensusModule) Stop 

func (cm *ConsensusModule) Stop()

Stop stops this CM, cleaning up its state. This method returns quickly, but it may take a bit of time (up to ~election timeout) for all goroutines to exit.

func (*ConsensusModule) Submit 

func (cm *ConsensusModule) Submit(command interface{}) bool

Submit submits a new command to the CM. This function doesn't block; clients read the commit channel passed in the constructor to be notified of new committed entries. It returns true iff this CM is the leader - in which case the command is accepted. If false is returned, the client will have to find a different CM to submit this command to.

func (*ConsensusModule) SubmitCommand 

func (cm *ConsensusModule) SubmitCommand(args SubmitArgs, reply *SubmitReply) error

type Harness 

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

func NewHarness 

func NewHarness(t *testing.T, n int) *Harness

NewHarness creates a new test Harness, initialized with n servers connected to each other.

func (*Harness) CheckCommitted 

func (h *Harness) CheckCommitted(cmd int) (nc int, index int)

CheckCommitted verifies that all connected servers have cmd committed with the same index. It also verifies that all commands *before* cmd in the commit sequence match. For this to work properly, all commands submitted to Raft should be unique positive ints. Returns the number of servers that have this command committed, and its log index. TODO: this check may be too strict. Consider that a server can commit something and crash before notifying the channel. It's a valid commit but this checker will fail because it may not match other servers. This scenario is described in the paper...

func (*Harness) CheckCommittedN 

func (h *Harness) CheckCommittedN(cmd int, n int)

CheckCommittedN verifies that cmd was committed by exactly n connected servers.

func (*Harness) CheckNoLeader 

func (h *Harness) CheckNoLeader()

CheckNoLeader checks that no connected server considers itself the leader.

func (*Harness) CheckNotCommitted 

func (h *Harness) CheckNotCommitted(cmd int)

CheckNotCommitted verifies that no command equal to cmd has been committed by any of the active servers yet.

func (*Harness) CheckSingleLeader 

func (h *Harness) CheckSingleLeader() (int, int)

CheckSingleLeader checks that only a single server thinks it's the leader. Returns the leader's id and term. It retries several times if no leader is identified yet.

func (*Harness) DisconnectPeer 

func (h *Harness) DisconnectPeer(id int)

DisconnectPeer disconnects a server from all other servers in the cluster.

func (*Harness) ReconnectPeer 

func (h *Harness) ReconnectPeer(id int)

ReconnectPeer connects a server to all other servers in the cluster.

func (*Harness) Shutdown 

func (h *Harness) Shutdown()

Shutdown shuts down all the servers in the harness and waits for them to stop running.

func (*Harness) SubmitToServer 

func (h *Harness) SubmitToServer(serverId int, cmd interface{}) bool

SubmitToServer submits the command to serverId.

type LogEntry 

type LogEntry struct {
	Command interface{}
	Term    int
}

type RPCProxy 

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

RPCProxy is a trivial pass-thru proxy type for ConsensusModule's RPC methods. It's useful for:

  • Simulating a small delay in RPC transmission.
  • Avoiding running into https://github.com/golang/go/issues/19957
  • Simulating possible unreliable connections by delaying some messages significantly and dropping others when RAFT_UNRELIABLE_RPC is set.

func (*RPCProxy) AppendEntries 

func (rpp *RPCProxy) AppendEntries(args AppendEntriesArgs, reply *AppendEntriesReply) error

func (*RPCProxy) RequestReport 

func (rpp *RPCProxy) RequestReport(args ReportArgs, reply *ReportReply) error

func (*RPCProxy) RequestVote 

func (rpp *RPCProxy) RequestVote(args RequestVoteArgs, reply *RequestVoteReply) error

func (*RPCProxy) SubmitCommand 

func (rpp *RPCProxy) SubmitCommand(args SubmitArgs, reply *SubmitReply) error

type ReportArgs 

type ReportArgs struct {
	Id int
}

type ReportReply 

type ReportReply struct {
	Id       int
	Term     int
	IsLeader bool
}

type RequestVoteArgs 

type RequestVoteArgs struct {
	Term         int
	CandidateId  int
	LastLogIndex int
	LastLogTerm  int
}

See figure 2 in the paper.

type RequestVoteReply 

type RequestVoteReply struct {
	Term        int
	VoteGranted bool
}

type Server 

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

Server wraps a raft.ConsensusModule along with a rpc.Server that exposes its methods as RPC endpoints. It also manages the peers of the Raft server. The main goal of this type is to simplify the code of raft.Server for presentation purposes. raft.ConsensusModule has a *Server to do its peer communication and doesn't have to worry about the specifics of running an RPC server.

func NewServer 

func NewServer(serverId int, peerIds []int, ready <-chan interface{}, commitChan chan<- CommitEntry) *Server

func (*Server) Call 

func (s *Server) Call(id int, serviceMethod string, args interface{}, reply interface{}) error

func (*Server) ConnectToPeer 

func (s *Server) ConnectToPeer(peerId int, addr net.Addr) error

func (*Server) DisconnectAll 

func (s *Server) DisconnectAll()

DisconnectAll closes all the client connections to peers for this server.

func (*Server) DisconnectPeer 

func (s *Server) DisconnectPeer(peerId int) error

DisconnectPeer disconnects this server from the peer identified by peerId.

func (*Server) GetListenAddr 

func (s *Server) GetListenAddr() net.Addr

func (*Server) Serve 

func (s *Server) Serve()

func (*Server) ServeAt 

func (s *Server) ServeAt(addr string)

func (*Server) Shutdown 

func (s *Server) Shutdown()

Shutdown closes the server and waits for it to shut down properly.

type SubmitArgs 

type SubmitArgs struct {
	Command interface{}
}

type SubmitReply 

type SubmitReply struct {
	IsLeader bool
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.