Etcd database source code analysis -- starting from the start function of raftnode

As shown in the figure above ,raftNode It's real manipulation ETCD RAFT API Module , act as etcd-raft The bridge between modules and upper modules , It defines the following members . among msgSnapC Channels are used to receive and send snapshots 、applyc The channel is used to send... To be applied Entry Record 、readStateC It is used to send ReadState、ticker Used to direct to raft The module sends timing pulses tick、td It is used to detect whether two heartbeat messages sent to the same node timeout .raftNodeConfig Let's talk about it later , This article mainly explains ticker modular .

type raftNode struct {
    
	lg *zap.Logger
	tickMu *sync.Mutex
	raftNodeConfig	
	msgSnapC chan raftpb.Message // a chan to send/receive snapshot 
	applyc chan toApply // a chan to send out apply 
	readStateC chan raft.ReadState // a chan to send out readState 
	ticker *time.Ticker // utility 
	td *contention.TimeoutDetector // contention detectors for raft heartbeat message
	stopped chan struct{
    }
	done    chan struct{
    }
}

initialization raftNode The function of the structure is newRaftNode,raftNodeConfig Contains the initialized network transport、 Prewrite log Storage、raftStorage And most importantly raft modular , These modules provide corresponding interfaces to raftnode Use to help complete raft log send out 、 Persistence 、 Most functions such as replication .

func newRaftNode(cfg raftNodeConfig) *raftNode {
        
	raft.SetLogger(lg) //  initialization logger( A little )
	r := &raftNode{
     lg: cfg.lg, tickMu: new(sync.Mutex),
		raftNodeConfig: cfg, td: contention.NewTimeoutDetector(2 * cfg.heartbeat), // set up contention detectors for raft heartbeat message. expect to send a heartbeat within 2 heartbeat intervals.
		readStateC: make(chan raft.ReadState, 1),
		msgSnapC:   make(chan raftpb.Message, maxInFlightMsgSnap),
		applyc:     make(chan toApply),
		stopped:    make(chan struct{
    }), done:       make(chan struct{
    }),
	}
	//  Here's the point 
	if r.heartbeat == 0 {
     r.ticker = &time.Ticker{
    }  //  If heartbeat zero , Use default &time.Ticker{}
	} else {
     r.ticker = time.NewTicker(r.heartbeat) } //  otherwise , You need to set the time interval as r.heartbeat
	return r
}

start Function will start a coroutine to run the main business logic , Here we will see if the timer expires ,select This channel will be detected , call raftNode Interface tick function . The tick Function gets tickMu lock , And then call Node Interface provided Tick function , That's what this is raft.Node Provided Tick function .

func (r *raftNode) start(rh *raftReadyHandler) {
    
	internalTimeout := time.Second
	go func() {
    
		defer r.onStop()
		islead := false
		for {
    
			select {
    
			case <-r.ticker.C:
				r.tick()
				
// raft.Node does not have locks in Raft package
func (r *raftNode) tick() {
    
	r.tickMu.Lock()
	r.Tick()
	r.tickMu.Unlock()
}				

raft.Node Provided Tick The function will be directed to n.tickc Write struct{}{}, And in the raft.Node There will be coordination execution run function , As shown in figure, raft.Node Of run As shown in the process , It will perform monitoring n.tickc Channel code , And then execute n.rn.Tick(). And here n.rn.Tick() Execution is rawnode Included members raft Structure of the Tick Member functions , This function will be based on raft Roles perform different tick function ：tickElection or tickHeartbeat.

// Tick advances the internal logical clock by a single tick.
func (rn *RawNode) Tick() {
    
	rn.raft.tick()
}