【Redis】客观下线
在sentinelHandleRedisInstance函数中，如果是主节点，需要做如下处理：
void sentinelHandleRedisInstance(sentinelRedisInstance *ri) {
// 省略...
// 如果是主节点
if (ri->flags & SRI_MASTER) {
// 检查是否主观下线
sentinelCheckObjectivelyDown(ri);
// 是否需要开始故障切换
if (sentinelStartFailoverIfNeeded(ri))
// 获取其他哨兵实例对节点状态的判断
sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_ASK_FORCED);
// 故障切换状态机
sentinelFailoverStateMachine(ri);
// 获取其他哨兵实例对节点状态的判断
sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_NO_FLAGS);
}
}
节点的状态定义
#define SRI_MASTER (1<<0) /* master主节点 */
#define SRI_SLAVE (1<<1) /* slave从节点 */
#define SRI_SENTINEL (1<<2) /* 哨兵节点 */
#define SRI_S_DOWN (1<<3) /* 主观下线 */
#define SRI_O_DOWN (1<<4) /* 客观下线 */
#define SRI_MASTER_DOWN (1<<5) /* 节点下线 */
#define SRI_FAILOVER_IN_PROGRESS (1<<6) /* 正在执行master节点的故障切换
换 */
客观下线
sentinelCheckObjectivelyDown
sentinelCheckObjectivelyDown函数用于判断master节点是否客观下线：
- 首先确认主节点是否已经被哨兵标记为主观下线，如果已经主观下线，quorum的值置为1，表示当前已经有1个哨兵认为master主观下线，进行第2步
- master->sentinels存储了监控当前master的其他哨兵节点，遍历其他哨兵节点，通过flag标识中是否有SRI_MASTER_DOWN状态判断其他哨兵对MASTER节点下线的判断，如果有则认为MASTER下线，对quorum数量加1
- 遍历结束后判断quorum的数量是否大于master->quorum设置的数量，也就是是否有过半的哨兵认为主节点下线，如果是将odown置为1，认为主节点客观下线
- 根据odown的值判断主节点是否客观下线
- 如果客观下线，确认master->flags是否有SRI_O_DOWN状态，如果没有，发布+odown客观下线事件并将master->flags置为SRI_O_DOWN状态
- 如果没有客观下线，校验master->flags是否有SRI_O_DOWN状态，如果有，需要发布-odown事件，取消master的客观下线标记（master->flags的SRI_O_DOWN状态取消）
可以看到，master节点客观下线需要根据其他哨兵实例对主节点的判断来共同决定，具体是通过其他哨兵实例的flag中是否有SRI_MASTER_DOWN状态来判断的，如果认为master下线的哨兵个数超过了master节点中的quorum设置，master节点将被认定为客观下线，发布+odown客观下线事件，关于SRI_MASTER_DOWN状态是在哪里设置的在后面会讲到。
void sentinelCheckObjectivelyDown(sentinelRedisInstance *master) {
dictIterator *di;
dictEntry *de;
unsigned int quorum = 0, odown = 0;
// 判断主节点是否被标记为主观下线SRI_S_DOWN
if (master->flags & SRI_S_DOWN) {
/* quorum初始化为1 */
quorum = 1;
/* 遍历监听主节点的其他哨兵实例. */
di = dictGetIterator(master->sentinels);
while((de = dictNext(di)) != NULL) {
// 获取哨兵实例
sentinelRedisInstance *ri = dictGetVal(de);
// 判断其他哨兵实例是否把master节点标记为下线
if (ri->flags & SRI_MASTER_DOWN) quorum++;
}
dictReleaseIterator(di);
// 如果大于master->quorum，也就是过半的哨兵认为主节点已经下线，标记客观下线
if (quorum >= master->quorum) odown = 1;
}
// 如果客观下线
if (odown) {
if ((master->flags & SRI_O_DOWN) == 0) {
// 发布+odown客观下线事件
sentinelEvent(LL_WARNING,"+odown",master,"%@ #quorum %d/%d",
quorum, master->quorum);
// 将MASTER节点标记为SRI_O_DOWN
master->flags |= SRI_O_DOWN;
// 标记客观下线的时间
master->o_down_since_time = mstime();
}
} else {
// 非客观下线，判断master是否有客观下线标识
if (master->flags & SRI_O_DOWN) {
// 发布-odown事件
sentinelEvent(LL_WARNING,"-odown",master,"%@");
// 取消master的客观下线标识
master->flags &= ~SRI_O_DOWN;
}
}
}
是否需要执行故障切换
sentinelStartFailoverIfNeeded
sentinelStartFailoverIfNeeded用于判断是否需要执行故障切换，可以开始故障切换的条件有三个：
- master节点被认为客观下线（SRI_O_DOWN）
- 当前没有在进行故障切换（状态不是SRI_FAILOVER_IN_PROGRESS）
- 距离上次执行故障切换的时间，超过了故障切换超时时间设置的2倍，意味着上一次执行故障切换的时间已超时，可以重新进行故障切换
同时满足以上三个条件，达到执行故障切换的标准，调用sentinelStartFailover函数，将故障切换的状态改为待执行。
int sentinelStartFailoverIfNeeded(sentinelRedisInstance *master) {
/* 如果MASTER不是客观下线，直接返回 */
if (!(master->flags & SRI_O_DOWN)) return 0;
/* 如果当前已经在执行故障切换直接返回 */
if (master->flags & SRI_FAILOVER_IN_PROGRESS) return 0;
/* 判断距离上次执行故障切换的时间，如果小于failover_timeout配置项的2倍，表示上次故障切换还未达到超时设置，所以本次不能执行*/
if (mstime() - master->failover_start_time <
master->failover_timeout*2)
{
if (master->failover_delay_logged != master->failover_start_time) {
time_t clock = (master->failover_start_time +
master->failover_timeout*2) / 1000;
char ctimebuf[26];
ctime_r(&clock,ctimebuf);
ctimebuf[24] = '\0'; /* Remove newline. */
master->failover_delay_logged = master->failover_start_time;
serverLog(LL_WARNING,
"Next failover delay: I will not start a failover before %s",
ctimebuf);
}
return 0;
}
// 开始故障切换（只更改了故障切换状态）
sentinelStartFailover(master);
return 1;
}
sentinelStartFailover
可以看到sentinelStartFailover函数并没有直接进行故障切换，而是更改了一些状态：
- 将failover_state置为了SENTINEL_FAILOVER_STATE_WAIT_START等待开始执行状态
- 将master节点的flags设置为SRI_FAILOVER_IN_PROGRESS故障切换执行中状态
- **将master的failover_epoch设置为当前哨兵的投票轮次current_epoch + 1 **，在选举leader时会用到
void sentinelStartFailover(sentinelRedisInstance *master) {
serverAssert(master->flags & SRI_MASTER);
// 将状态更改为等待开始执行故障切换
master->failover_state = SENTINEL_FAILOVER_STATE_WAIT_START;
// 设置为故障切换执行中状态
master->flags |= SRI_FAILOVER_IN_PROGRESS;
// 设置failover_epoch故障切换轮次
master->failover_epoch = ++sentinel.current_epoch;
sentinelEvent(LL_WARNING,"+new-epoch",master,"%llu",
(unsigned long long) sentinel.current_epoch);
// 发布事件
sentinelEvent(LL_WARNING,"+try-failover",master,"%@");
master->failover_start_time = mstime()+rand()%SENTINEL_MAX_DESYNC;
master->failover_state_change_time = mstime();
}
获取哨兵实例对主节点状态判断
在sentinelHandleRedisInstance函数中，可以看到sentinelStartFailoverIfNeeded条件成立时以及函数的最后都调用了sentinelAskMasterStateToOtherSentinels，接下来就去看看sentinelAskMasterStateToOtherSentinels里面都做了什么：
if (ri->flags & SRI_MASTER) {
sentinelCheckObjectivelyDown(ri);
if (sentinelStartFailoverIfNeeded(ri))
// 获取其他哨兵实例对主节点的状态判断，这里传入的参数是SENTINEL_ASK_FORCED
sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_ASK_FORCED);
sentinelFailoverStateMachine(ri);
// 获取其他哨兵实例对主节点的状态判断，这里传入的参数是SENTINEL_NO_FLAGS
sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_NO_FLAGS);
}
is-master-down-by-addr命令发送
sentinelAskMasterStateToOtherSentinels
sentinelAskMasterStateToOtherSentinels函数用于向其他哨兵实例发送is-master-down-by-addr命令获取其他哨兵实例对主节点状态的判断，它会遍历监听同一主节点的其他哨兵实例进行处理:
- 获取每一个哨兵实例
- 计算距离每个哨兵实例上一次收到IS-MASTER-DOWN-BY-ADDR命令回复时间的间隔
- 如果距离上次收到回复的时间已经超过了SENTINEL_ASK_PERIOD周期的5倍，清空哨兵节点flag中的SRI_MASTER_DOWN状态和leader
- 如果master节点已经是下线状态SRI_S_DOWN，不需要进行处理，回到第一步处理下一个哨兵
- 如果哨兵节点用于发送命令的link连接处于未连接状态，不处理，回到第一步处理下一个哨兵
- 如果不是强制发送命令（入参的flag是SENTINEL_ASK_FORCED时），并且距离上次收到回复命令的时间还在SENTINEL_ASK_PERIOD周期内，不处理，回到第一步处理下一个哨兵
- 通过redisAsyncCommand函数发送发送is-master-down-by-addr命令，sentinelReceiveIsMasterDownReply为处理函数，redisAsyncCommand函数有如下参数：
- 用于发送请求的连接：ri->link->cc
- 收到命令返回结果时对应的处理函数：sentinelReceiveIsMasterDownReply
- master节点的ip：announceSentinelAddr(master->addr)
- master节点端口：port
- 当前哨兵的投票轮次：sentinel.current_epoch
- 实例ID：master->failover_state > SENTINEL_FAILOVER_STATE_NONE时表示要执行故障切换，此时传入当前哨兵的myid，否则传入*
void sentinelAskMasterStateToOtherSentinels(sentinelRedisInstance *master, int flags) {
dictIterator *di;
dictEntry *de;
// 遍历监听主节点的其他哨兵实例
di = dictGetIterator(master->sentinels);
while((de = dictNext(di)) != NULL) {
// 获取每一个哨兵实例
sentinelRedisInstance *ri = dictGetVal(de);
// 计算距离上一次收到IS-MASTER-DOWN-BY-ADDR命令回复时间的间隔
mstime_t elapsed = mstime() - ri->last_master_down_reply_time;
char port[32];
int retval;
/* 如果距离上次收到回复的时间已经超过了SENTINEL_ASK_PERIOD周期的5倍，清空相关设置 */
if (elapsed > SENTINEL_ASK_PERIOD*5) {
// 取消SRI_MASTER_DOWN状态
ri->flags &= ~SRI_MASTER_DOWN;
sdsfree(ri->leader);
// leader置为null
ri->leader = NULL;
}
// 如果master已经是下线状态
if ((master->flags & SRI_S_DOWN) == 0) continue;
// 如果已经连接中断
if (ri->link->disconnected) continue;
// 如果不是强制发送命令状态SENTINEL_ASK_FORCED，并且距离上次收到回复命令的时间还在SENTINEL_ASK_PERIOD周期内，不处理，回到第一步处理下一个哨兵
if (!(flags & SENTINEL_ASK_FORCED) &&
mstime() - ri->last_master_down_reply_time < SENTINEL_ASK_PERIOD)
continue;
ll2string(port,sizeof(port),master->addr->port);
// 发送is-master-down-by-addr命令，sentinelReceiveIsMasterDownReply为处理函数
retval = redisAsyncCommand(ri->link->cc,
sentinelReceiveIsMasterDownReply, ri,
"%s is-master-down-by-addr %s %s %llu %s",
sentinelInstanceMapCommand(ri,"SENTINEL"),
announceSentinelAddr(master->addr), port,
sentinel.current_epoch,
(master->failover_state > SENTINEL_FAILOVER_STATE_NONE) ?
sentinel.myid : "*");
if (retval == C_OK) ri->link->pending_commands++;
}
dictReleaseIterator(di);
}
is-master-down-by-addr命令处理
sentinelCommand
其他哨兵实例收到is-master-down-by-addr命令之后的处理逻辑在sentinelCommand函数中可以找到：
- 根据请求传入的ip和端口信息获取主节点的sentinelRedisInstance实例对象（在发送is-master-down-by-addr命令的redisAsyncCommand函数中传入了主节点的ip和端口）
- 如果不是TILT模式，校验sentinelRedisInstance对象是否是主节点并且主节点被标记为主观下线，如果条件都成立表示主节点已经主观下线，将isdown置为1
- 判断请求参数中的runid是否不为*，如果不为*表示当前需要进行leader选举，调用sentinelVoteLeader选举哨兵Leader
- 发送is-master-down-by-addr命令的回复，将对主节点主观下线的判断、选出的leader节点的runid、投票轮次leader_epoch返回给发送命令哨兵
void sentinelCommand(client *c) {
if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
}
// 省略其他else if...
// 如果是is-master-down-by-addr命令
else if (!strcasecmp(c->argv[1]->ptr,"is-master-down-by-addr")) {
/* SENTINEL IS-MASTER-DOWN-BY-ADDR <ip> <port> <current-epoch> <runid>
*
* 参数说明:
* ip和端口：哨兵检测的主节点的ip和端口
* current-epoch：是故障切换中当前投票的轮次，每一个哨兵在一轮投票中只能投一次
* runid：如果需要执行故障切换，传入的是哨兵的myid，否则传入的是 *
*/
sentinelRedisInstance *ri;
long long req_epoch;
uint64_t leader_epoch = 0; // 默认为0
char *leader = NULL;
long port;
int isdown = 0;
if (c->argc != 6) goto numargserr;
if (getLongFromObjectOrReply(c,c->argv[3],&port,NULL) != C_OK ||
getLongLongFromObjectOrReply(c,c->argv[4],&req_epoch,NULL)
!= C_OK)
return;
// 根据请求传入的ip和端口信息获取对应的哨兵实例，也就是监控的master节点
ri = getSentinelRedisInstanceByAddrAndRunID(sentinel.masters,
c->argv[2]->ptr,port,NULL);
/* 如果不是TILT模式，校验是否是主节点并且主节点被标记为主观下线 */
if (!sentinel.tilt && ri && (ri->flags & SRI_S_DOWN) &&
(ri->flags & SRI_MASTER))
isdown = 1;// 确定主观下线
/* 如果是主节点并且传入的runid不为*，调用sentinelVoteLeader选举Leader执行故障切换 */
if (ri && ri->flags & SRI_MASTER && strcasecmp(c->argv[5]->ptr,"*")) {
// 选举leader
leader = sentinelVoteLeader(ri,(uint64_t)req_epoch,
c->argv[5]->ptr,
&leader_epoch);
}
/* 发送回复包含三部分:
* 下线状态, 选出的leader, leader的投票轮次leader_epoch */
addReplyArrayLen(c,3);
// 下线状态
addReply(c, isdown ? shared.cone : shared.czero);
// leader不为空传入leader否则传入*
addReplyBulkCString(c, leader ? leader : "*");
// 投票轮次
addReplyLongLong(c, (long long)leader_epoch);
if (leader) sdsfree(leader);
}
// 省略其他else if...
else {
addReplySubcommandSyntaxError(c);
}
return;
}
is-master-down-by-addr回复处理
sentinelReceiveIsMasterDownReply
在sentinelCommand中对命令处理之后发送了返回数据，数据里面包含主观下线的判断、leader的runid以及投票轮次leader_epoch，对返回数据的处理在sentinelReceiveIsMasterDownReply函数中：
- 如果回复者也标记了节点主观下线，将哨兵实例的flags状态置为SRI_MASTER_DOWN下线状态，SRI_MASTER_DOWN状态就是在这里设置的
- 如果返回的leader runid不是*，意味着哨兵实例对leader进行了投票，需要更新哨兵实例中的leader和leader_epoch
// 这里的privdata指向回复is-master-down-by-addr命令的那个哨兵实例
void sentinelReceiveIsMasterDownReply(redisAsyncContext *c, void *reply, void *privdata) {
// 每个哨兵实例监控的master节点中，保存了其他监控该主节点的哨兵实例，这里的privdata就指向master节点存储的其他哨兵实例中回复了is-master-down-by-addr命令的那个哨兵实例
sentinelRedisInstance *ri = privdata;
instanceLink *link = c->data;
redisReply *r;
if (!reply || !link) return;
link->pending_commands--;
r = reply;
if (r->type == REDIS_REPLY_ARRAY && r->elements == 3 &&
r->element[0]->type == REDIS_REPLY_INTEGER &&
r->element[1]->type == REDIS_REPLY_STRING &&
r->element[2]->type == REDIS_REPLY_INTEGER)
{
ri->last_master_down_reply_time = mstime();
// 如果回复主观下线
if (r->element[0]->integer == 1) {
// 将回复命令的哨兵节点的flags状态改为SRI_MASTER_DOWN
ri->flags |= SRI_MASTER_DOWN;
} else {
ri->flags &= ~SRI_MASTER_DOWN;
}
// 如果runid不是*
if (strcmp(r->element[1]->str,"*")) {
sdsfree(ri->leader);
if ((long long)ri->leader_epoch != r->element[2]->integer)
serverLog(LL_WARNING,
"%s voted for %s %llu", ri->name,
r->element[1]->str,
(unsigned long long) r->element[2]->integer);
// 更新回复命令的哨兵存储的leader
ri->leader = sdsnew(r->element[1]->str);
// 更新投票轮次
ri->leader_epoch = r->element[2]->integer;
}
}
}
故障切换状态机
在sentinelHandleRedisInstance函数中，判断是否需要执行故障切换之后，就会调用sentinelFailoverStateMachine函数进入故障切换状态机，根据failover_state故障切换状态调用不同的方法，我们先关注以下两种状态：
-
SENTINEL_FAILOVER_STATE_WAIT_START：等待执行状态，表示需要执行故障切换但还未开始，在sentinelStartFailoverIfNeeded函数中可以看到如果需要执行故障切换，会调用sentinelStartFailover函数将状态置为SENTINEL_FAILOVER_STATE_WAIT_START，对应的处理函数为sentinelFailoverWaitStart，sentinelFailoverWaitStart中会判断是当前哨兵节点是否是执行故障切换的leader，如果是将状态改为SENTINEL_FAILOVER_STATE_SELECT_SLAVE。
-
SENTINEL_FAILOVER_STATE_SELECT_SLAVE：从SLAVE节点中选举Master节点的状态，处于这个状态意味着需要从Master的从节点中选举出可以替代Master节点的从节点，进行故障切换，对应的处理函数为sentinelFailoverSelectSlave。
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: // 选举master节点
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;
}
}
sentinelFailoverWaitStart
sentinelFailoverWaitStart函数的处理逻辑如下：
- 调用sentinelGetLeader获取执行故障切换的leader
- 对比当前哨兵是与获取到执行故障切换leader的myid是否一致，判断当前哨兵是否是执行故障切换的leader
- 如果当前哨兵不是故障切换leader, 并且不是强制执行状态SRI_FORCE_FAILOVER，当前哨兵不能执行故障切换
- 如果当前哨兵是故障切换的leader节点，将故障切换状态改为SENTINEL_FAILOVER_STATE_SELECT_SLAVE状态，在下一次执行故障切换状态机时会从slave节点选出master节点进行故障切换
void sentinelFailoverWaitStart(sentinelRedisInstance *ri) {
char *leader;
int isleader;
/* 获取执行故障切换的leader */
leader = sentinelGetLeader(ri, ri->failover_epoch);
// leader不为空并且与当前哨兵的myid一致
isleader = leader && strcasecmp(leader,sentinel.myid) == 0;
sdsfree(leader);
/* 如果当前哨兵不是leader, 并且不是强制执行状态SRI_FORCE_FAILOVER，当前哨兵不能执行故障切换 */
if (!isleader && !(ri->flags & SRI_FORCE_FAILOVER)) {
int election_timeout = SENTINEL_ELECTION_TIMEOUT;
if (election_timeout > ri->failover_timeout)
election_timeout = ri->failover_timeout;
/* 在超时时终止故障切换 */
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();
// 更改为SENTINEL_FAILOVER_STATE_SELECT_SLAVE状态，在下一次执行故障切换状态机时会从slave节点选出master节点
ri->failover_state = SENTINEL_FAILOVER_STATE_SELECT_SLAVE;
ri->failover_state_change_time = mstime();
sentinelEvent(LL_WARNING,"+failover-state-select-slave",ri,"%@");
}
Leader选举
sentinelGetLeader
sentinelGetLeader函数用于从指定的投票轮次epoch中获取Leader节点，成为一个Leader节点需要获取大多数的投票，处理逻辑如下：
- 创建了一个counters字典，里面记录了每个哨兵得到的投票数，其中key为哨兵实例的id
- counters的数据来源：遍历master->sentinels获取其他哨兵实例，判断哨兵实例记录的leader是否为空并且投票轮次与当前指定的epoch一致，如果一致加入counters中并将投票数增加一票
- 从counters中获取投票数最多的哨兵实例记为winner，最大投票数记为max_votes
- 判断winner是否为空
- 如果不为空，在master节点中记录的leader节点和winner节点中，选出纪元（投票轮次）最新的节点记为myvote
- 如果为空，在master节点中记录的leader节点和当前哨兵实例中，选出纪元（投票轮次）最新的节点记为myvote
- 经过上一步之后，如果myvote不为空并且leader_epoch与调用sentinelGetLeader函数时指定的epoch一致，当前哨兵给myvote增加一票，然后判断myvote得到的投票数是否大于max_votes，如果是将winner获胜者更新为myvote
- 到这里，winner中记录了本轮投票的获胜者，也就是得到票数最多的那个，max_votes记录了获得投票数，能否成为leader还需满足以下两个条件，，保证选举出的leader得到了过半哨兵的投票：
- 条件一：得到的投票数max_votes大于voters_quorum，voters_quorum为哨兵实例个数的一半+1，也就是需要有过半的哨兵实例
- 条件二：得到的投票数max_votes大于master->quorum，这个值是在 sentinel.conf 配置文件中设置的，一般设置为哨兵总数的一半+1
- 选举结束，返回winner中记录的实例id作为leader
char *sentinelGetLeader(sentinelRedisInstance *master, uint64_t epoch) {
dict *counters;
dictIterator *di;
dictEntry *de;
unsigned int voters = 0, voters_quorum;
char *myvote;
char *winner = NULL;
uint64_t leader_epoch;
uint64_t max_votes = 0;
serverAssert(master->flags & (SRI_O_DOWN|SRI_FAILOVER_IN_PROGRESS));
// 创建字典
counters = dictCreate(&leaderVotesDictType,NULL);
// 获取所有的哨兵实例个数包含当前哨兵
voters = dictSize(master->sentinels)+1;
/* 遍历哨兵实例 */
di = dictGetIterator(master->sentinels);
while((de = dictNext(di)) != NULL) {
// 获取每一个哨兵节点
sentinelRedisInstance *ri = dictGetVal(de);
// 如果某个哨兵实例的leader不为空并且leader的轮次等于指定的轮次
if (ri->leader != NULL && ri->leader_epoch == sentinel.current_epoch)
sentinelLeaderIncr(counters,ri->leader); // ri->leader的投票数加1
}
dictReleaseIterator(di);
di = dictGetIterator(counters);
while((de = dictNext(di)) != NULL) {
// 获取投票数
uint64_t votes = dictGetUnsignedIntegerVal(de);
// 获取投票数最多的节点的runid，记录在winner中
if (votes > max_votes) {
max_votes = votes;
winner = dictGetKey(de);
}
}
dictReleaseIterator(di);
/* 如果winner不为空，在master节点和winner节点中获取epoch投票轮次最新的当做当前节点的投票者*/
/* 如果winner为空，在master节点和当前哨兵节点中选取epoch投票轮次最新的节点*/
if (winner)
myvote = sentinelVoteLeader(master,epoch,winner,&leader_epoch);
else
myvote = sentinelVoteLeader(master,epoch,sentinel.myid,&leader_epoch);
//
if (myvote && leader_epoch == epoch) {
// 为myvote增加一票
uint64_t votes = sentinelLeaderIncr(counters,myvote);
// 如果超过了max_votes
if (votes > max_votes) {
max_votes = votes; // 更新max_votes
winner = myvote; // 更新winner
}
}
// voters_quorum，为哨兵实例个数的一半+1
voters_quorum = voters/2+1;
// 如果投票数量max_votes小于quorum，说明未达到过半的投票数
if (winner && (max_votes < voters_quorum || max_votes < master->quorum))
winner = NULL;
winner = winner ? sdsnew(winner) : NULL;
sdsfree(myvote);
dictRelease(counters);
// 返回获胜的节点，也就是leader节点
return winner;
}
投票
sentinelVoteLeader
sentinelVoteLeader函数入参中可以看到传入了master节点，和候选节点的IDreq_runid以及候选节点的投票纪元（轮次）req_epoch。master节点中记录了当前哨兵节点选举的执行故障切换的leader节点，在master->leader中保存。sentinelVoteLeader就用于在这两个节点中选出获胜的那个节点：
- 如果候选节点的req_epoch大于当前sentinel实例的epoch，将当前哨兵实例的current_epoch置为请求轮次req_epoch
- 如果master节点记录的leader_epoch小于候选节点的req_epoch，并且当前实例的轮次小于等于候选节点轮次，将master节点中的leader改为候选节点
- 返回master节点中记录的leader
char *sentinelVoteLeader(sentinelRedisInstance *master, uint64_t req_epoch, char *req_runid, uint64_t *leader_epoch) {
// 如果请求的轮次req_epoch大于当前sentinel实例的轮次
if (req_epoch > sentinel.current_epoch) {
// 将哨兵实例的current_epoch置为请求轮次
sentinel.current_epoch = req_epoch;
sentinelFlushConfig();
sentinelEvent(LL_WARNING,"+new-epoch",master,"%llu",
(unsigned long long) sentinel.current_epoch);
}
// 如果master节点记录的轮次leader_epoch小于请求轮次，并且当前实例的轮次小于等于请求轮次
if (master->leader_epoch < req_epoch && sentinel.current_epoch <= req_epoch)
{
sdsfree(master->leader);
// 将leader置为传入的runid
master->leader = sdsnew(req_runid);
// 更改master的leader_epoch
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 (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;
}
总结
参考
Redis版本：redis-6.2.5
