Redis Sentinel原理与实现 (下)

void sentinelFailoverStateMachine(sentinelRedisInstance *ri) {
    serverAssert(ri->flags & SRI_MASTER);
 if (!(ri->flags & SRI_FAILOVER_IN_PROGRESS)) return;
 switch(ri->failover_state) {
 case SENTINEL_FAILOVER_STATE_WAIT_START:
            sentinelFailoverWaitStart(ri);
 break;
 case SENTINEL_FAILOVER_STATE_SELECT_SLAVE:
            sentinelFailoverSelectSlave(ri);
 break;
 case SENTINEL_FAILOVER_STATE_SEND_SLAVEOF_NOONE:
            sentinelFailoverSendSlaveOfNoOne(ri);
 break;
 case SENTINEL_FAILOVER_STATE_WAIT_PROMOTION:
            sentinelFailoverWaitPromotion(ri);
 break;
 case SENTINEL_FAILOVER_STATE_RECONF_SLAVES:
            sentinelFailoverReconfNextSlave(ri);
 break;
    }
}

void sentinelFailoverWaitStart(sentinelRedisInstance *ri) {
 char *leader;
 int isleader;
 /* Check if we are the leader for the failover epoch. */
    leader = sentinelGetLeader(ri, ri->failover_epoch);
    isleader = leader && strcasecmp(leader,sentinel.myid) == 0;
    sdsfree(leader);
 /* If I'm not the leader, and it is not a forced failover via
     * SENTINEL FAILOVER, then I can't continue with the failover. */
 if (!isleader && !(ri->flags & SRI_FORCE_FAILOVER)) {
 int election_timeout = SENTINEL_ELECTION_TIMEOUT;
 /* The election timeout is the MIN between SENTINEL_ELECTION_TIMEOUT
         * and the configured failover timeout. */
 if (election_timeout > ri->failover_timeout)
            election_timeout = ri->failover_timeout;
 /* Abort the failover if I'm not the leader after some time. */
 if (mstime() - ri->failover_start_time > election_timeout) {
            sentinelEvent(LL_WARNING,"-failover-abort-not-elected",ri,"%@");
            sentinelAbortFailover(ri);
        }
 return;
    }
    sentinelEvent(LL_WARNING,"+elected-leader",ri,"%@");
 if (sentinel.simfailure_flags & SENTINEL_SIMFAILURE_CRASH_AFTER_ELECTION)
        sentinelSimFailureCrash();
    ri->failover_state = SENTINEL_FAILOVER_STATE_SELECT_SLAVE;
    ri->failover_state_change_time = mstime();
    sentinelEvent(LL_WARNING,"+failover-state-select-slave",ri,"%@");
}

void sentinelAskMasterStateToOtherSentinels(sentinelRedisInstance *master, int flags) {
 ...
    di = dictGetIterator(master->sentinels);
 while((de = dictNext(di)) != NULL) {
 ...
        ll2string(port,sizeof(port),master->addr->port);
 retval = redisAsyncCommand(ri->link->cc,
 sentinelReceiveIsMasterDownReply, ri,
 "SENTINEL is-master-down-by-addr %s %s %llu %s",
                    master->addr->ip, port,
 sentinel.current_epoch,
                    (master->failover_state > SENTINEL_FAILOVER_STATE_NONE) ?
 sentinel.myid : "*");
 if (retval == C_OK) ri->link->pending_commands++;
    }
    dictReleaseIterator(di);
}
    这个投票过程跟Raft协议是一致的，当其他Sentinel接收到此请求后会调用sentinelVoteLeader()函数进行投票。sentinelVoteLeader()代码如下：
char *sentinelVoteLeader(sentinelRedisInstance *master, uint64_t req_epoch, char *req_runid, uint64_t *leader_epoch) {
 if (req_epoch > sentinel.current_epoch) {
 sentinel.current_epoch = req_epoch;
        sentinelFlushConfig();
        sentinelEvent(LL_WARNING,"+new-epoch",master,"%llu",
            (unsigned long long) sentinel.current_epoch);
    }
 if (master->leader_epoch < req_epoch && sentinel.current_epoch <= req_epoch)
    {
        sdsfree(master->leader);
        master->leader = sdsnew(req_runid);
        master->leader_epoch = sentinel.current_epoch;
        sentinelFlushConfig();
        sentinelEvent(LL_WARNING,"+vote-for-leader",master,"%s %llu",
            master->leader, (unsigned long long) master->leader_epoch);
 /* If we did not voted for ourselves, set the master failover start
         * time to now, in order to force a delay before we can start a
         * failover for the same master. */
 if (strcasecmp(master->leader,sentinel.myid))
            master->failover_start_time = mstime()+rand()%SENTINEL_MAX_DESYNC;
    }
    *leader_epoch = master->leader_epoch;
 return master->leader ? sdsnew(master->leader) : NULL;
}

char *sentinelGetLeader(sentinelRedisInstance *master, uint64_t epoch) {
 ...
    di = dictGetIterator(master->sentinels);
 while((de = dictNext(di)) != NULL) {
 sentinelRedisInstance *ri = dictGetVal(de);
 if (ri->leader != NULL && ri->leader_epoch == sentinel.current_epoch)
            sentinelLeaderIncr(counters,ri->leader);
    }
    dictReleaseIterator(di);
 di = dictGetIterator(counters);
 while((de = dictNext(di)) != NULL) {
 uint64_t votes = dictGetUnsignedIntegerVal(de);
 if (votes > max_votes) {
 max_votes = votes;
 winner = dictGetKey(de); // 选择一个票数最高的sentinel
        }
    }
    dictReleaseIterator(di);
 if (winner)
 myvote = sentinelVoteLeader(master,epoch,winner,&leader_epoch);
 else
 myvote = sentinelVoteLeader(master,epoch,sentinel.myid,&leader_epoch);
 if (myvote && leader_epoch == epoch) {
 uint64_t votes = sentinelLeaderIncr(counters,myvote);
 if (votes > max_votes) {
 max_votes = votes;
 winner = myvote;
        }
    }
 voters_quorum = voters/2+1;
 if (winner && (max_votes < voters_quorum || max_votes < master->quorum))
 winner = NULL;
 winner = winner ? sdsnew(winner) : NULL;
 ...
 return winner;
}