void sentinelHandleRedisInstance(sentinelRedisInstance *ri) {

    ...

    // 判断 master 是否进入SDOWN 状态

    sentinelCheckSubjectivelyDown(ri);

    /* Masters and slaves */

    if (ri->flags & (SRI_MASTER|SRI_SLAVE)) {

        /* Nothing so far. */

    }        

    if (ri->flags & SRI_MASTER) {

        // 判断 master 是否进入 ODOWN 状态

        sentinelCheckObjectivelyDown(ri);

        // 查看是否需要开始故障转移

        if (sentinelStartFailoverIfNeeded(ri))

            // 向其他 Sentinel 发送 SENTINEL is-master-down-by-addr 命令

            // 刷新其他 Sentinel 关于主服务器的状态

            sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_ASK_FORCED);

        // 执行故障转移

        sentinelFailoverStateMachine(ri);

        //此处调用sentinelAskMasterStateToOtherSentinels，只是为了获取其他Sentinel对于master是否存活的判断，

        //用来下一次判断master是否进入ODOWN状态

        sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_NO_FLAGS);

    }

}

#define SENTINEL_ASK_FORCED (1<<0)

void sentinelAskMasterStateToOtherSentinels(sentinelRedisInstance *master, int flags) {

    dictIterator *di;

    dictEntry *de;

    // 遍历正在监视相同 master 的所有 sentinel

    // 向它们发送 SENTINEL is-master-down-by-addr 命令

    di = dictGetIterator(master->sentinels);

    while((de = dictNext(di)) != NULL) {

        sentinelRedisInstance *ri = dictGetVal(de);

        // 距离该 sentinel 最后一次回复 SENTINEL master-down-by-addr 命令已经过了多久

        mstime_t elapsed = mstime() - ri->last_master_down_reply_time;

        char port[32];

        int retval;

        /* If the master state from other sentinel is too old, we clear it. */

        // 如果目标 Sentinel 关于主服务器的信息已经太久没更新，那么我们清除它

        if (elapsed > SENTINEL_ASK_PERIOD*5) {

            ri->flags &= ~SRI_MASTER_DOWN;

            sdsfree(ri->leader);

            ri->leader = NULL;

        }

        /* Only ask if master is down to other sentinels if:

         *

         * 只在以下情况满足时，才向其他 sentinel 询问主服务器是否已下线

         *

         * 1) We believe it is down, or there is a failover in progress.

         *    本 sentinel 相信服务器已经下线，或者针对该主服务器的故障转移操作正在执行

         * 2) Sentinel is connected.

         *    目标 Sentinel 与本 Sentinel 已连接

         * 3) We did not received the info within SENTINEL_ASK_PERIOD ms.

         *    当前 Sentinel 在 SENTINEL_ASK_PERIOD 毫秒内没有获得过目标 Sentinel 发来的信息

         * 4) 条件 1 和条件 2 满足而条件 3 不满足，但是 flags 参数给定了 SENTINEL_ASK_FORCED 标识

         */

        if ((master->flags & SRI_S_DOWN) == 0) continue;

        if (ri->flags & SRI_DISCONNECTED) continue;

        if (!(flags & SENTINEL_ASK_FORCED) &&

            mstime() - ri->last_master_down_reply_time < SENTINEL_ASK_PERIOD)

            continue;

        /* Ask */

        // 发送 SENTINEL is-master-down-by-addr 命令

        ll2string(port,sizeof(port),master->addr->port);

        retval = redisAsyncCommand(ri->cc,

                    sentinelReceiveIsMasterDownReply, NULL,

                    "SENTINEL is-master-down-by-addr %s %s %llu %s",

                    master->addr->ip, port,

                    sentinel.current_epoch,

                    // 如果本 Sentinel 已经检测到 master 进入 ODOWN

                    // 并且要开始一次故障转移，那么向其他 Sentinel 发送自己的运行 ID

                    // 让对方将给自己投一票（如果对方在这个纪元内还没有投票的话）

                    (master->failover_state > SENTINEL_FAILOVER_STATE_NONE) ?

                    server.runid : "*");

        if (retval == REDIS_OK) ri->pending_commands++;

    }

    dictReleaseIterator(di);

}

/* This function checks if there are the conditions to start the failover,

 * that is:

 *

 * 这个函数检查是否需要开始一次故障转移操作：

 *

 * 1) Master must be in ODOWN condition.

 *    主服务器已经计入 ODOWN 状态。

 * 2) No failover already in progress.

 *    当前没有针对同一主服务器的故障转移操作在执行。

 * 3) No failover already attempted recently.

 *    最近时间内，这个主服务器没有尝试过执行故障转移

 *    （应该是为了防止频繁执行）。

 *

 * We still don't know if we'll win the election so it is possible that we

 * start the failover but that we'll not be able to act.

 *

 * 虽然 Sentinel 可以发起一次故障转移，但因为故障转移操作是由领头 Sentinel 执行的，

 * 所以发起故障转移的 Sentinel 不一定就是执行故障转移的 Sentinel 。

 *

 * Return non-zero if a failover was started.

 *

 * 如果故障转移操作成功开始，那么函数返回非 0 值。

 */

int sentinelStartFailoverIfNeeded(sentinelRedisInstance *master) {

    /* We can't failover if the master is not in O_DOWN state. */

    if (!(master->flags & SRI_O_DOWN)) return ;

    /* Failover already in progress? */

    if (master->flags & SRI_FAILOVER_IN_PROGRESS) return ;

    /* Last failover attempt started too little time ago? */

    if (mstime() - master->failover_start_time <

        master->failover_timeout*)

    {

        if (master->failover_delay_logged != master->failover_start_time) {

            time_t clock = (master->failover_start_time +

                            master->failover_timeout*) / ;

            char ctimebuf[];

            ctime_r(&clock,ctimebuf);

            ctimebuf[] = '\0'; /* Remove newline. */

            master->failover_delay_logged = master->failover_start_time;

            redisLog(REDIS_WARNING,

                "Next failover delay: I will not start a failover before %s",

                ctimebuf);

        }

        return ;

    }

    sentinelStartFailover(master);

    return ;

}     

/* Setup the master state to start a failover. */

// 设置主服务器的状态，开始一次故障转移

void sentinelStartFailover(sentinelRedisInstance *master) {

    redisAssert(master->flags & SRI_MASTER);

    // 更新故障转移状态

    master->failover_state = SENTINEL_FAILOVER_STATE_WAIT_START;

    // 更新主服务器状态

    master->flags |= SRI_FAILOVER_IN_PROGRESS;

    // 更新纪元

    master->failover_epoch = ++sentinel.current_epoch;

    sentinelEvent(REDIS_WARNING,"+new-epoch",master,"%llu",

        (unsigned long long) sentinel.current_epoch);

    sentinelEvent(REDIS_WARNING,"+try-failover",master,"%@");

    // 记录故障转移状态的变更时间

    master->failover_start_time = mstime()+rand()%SENTINEL_MAX_DESYNC;

    master->failover_state_change_time = mstime();

}

/* Vote for the sentinel with 'req_runid' or return the old vote if already

 * voted for the specifed 'req_epoch' or one greater.

 *

 * 为运行 ID 为 req_runid 的 Sentinel 投上一票，有两种额外情况可能出现：

 * 1) 如果 Sentinel 在 req_epoch 纪元已经投过票了，那么返回之前投的票。

 * 2) 如果 Sentinel 已经为大于 req_epoch 的纪元投过票了，那么返回更*的投票。

 *

 * If a vote is not available returns NULL, otherwise return the Sentinel

 * runid and populate the leader_epoch with the epoch of the vote.

 *

 * 如果投票暂时不可用，那么返回 NULL 。

 * 否则返回 Sentinel 的运行 ID ，并将被投票的纪元保存到 leader_epoch 指针的值里面。

 */

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(REDIS_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(REDIS_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,server.runid))

            master->failover_start_time = mstime()+rand()%SENTINEL_MAX_DESYNC;

    }

    *leader_epoch = master->leader_epoch;

    return master->leader ? sdsnew(master->leader) : NULL;

}

void sentinelFailoverStateMachine(sentinelRedisInstance *ri) {

    redisAssert(ri->flags & SRI_MASTER);

    if (!(ri->flags & SRI_FAILOVER_IN_PROGRESS)) return;

    switch(ri->failover_state) {

        case SENTINEL_FAILOVER_STATE_WAIT_START:

            // 统计选票，查看是否成为leader

            sentinelFailoverWaitStart(ri);

            break;

        case SENTINEL_FAILOVER_STATE_SELECT_SLAVE:

            // 从slave列表中选出最佳slave

            sentinelFailoverSelectSlave(ri);

            break;

        case SENTINEL_FAILOVER_STATE_SEND_SLAVEOF_NOONE:

            // 把选出的slave设置为master

            sentinelFailoverSendSlaveOfNoOne(ri);

            break;

        case SENTINEL_FAILOVER_STATE_WAIT_PROMOTION:

            // 等待升级生效，如果升级超时，那么重新选择新主服务器

            sentinelFailoverWaitPromotion(ri);

            break;

        case SENTINEL_FAILOVER_STATE_RECONF_SLAVES:

            // 向从服务器发送 SLAVEOF 命令，让它们同步新主服务器

            sentinelFailoverReconfNextSlave(ri);

            break;

    }

}

void sentinelFailoverWaitStart(sentinelRedisInstance *ri) {

    char *leader;

    int isleader;

    /* Check if we are the leader for the failover epoch. */

    // 获取给定纪元的领头 Sentinel

    leader = sentinelGetLeader(ri, ri->failover_epoch);

    // 本 Sentinel 是否为领头 Sentinel ？

    isleader = leader && strcasecmp(leader,server.runid) == ;

    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. */

    // 如果本 Sentinel 不是领头，并且这次故障迁移不是一次强制故障迁移操作

    // 那么本 Sentinel 不做动作

    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. */

        // 当选的时长（类似于任期）是 SENTINEL_ELECTION_TIMEOUT

        // 和 Sentinel 设置的故障迁移时长之间的较小那个值

        if (election_timeout > ri->failover_timeout)

            election_timeout = ri->failover_timeout;

        /* Abort the failover if I'm not the leader after some time. */

        // Sentinel 的当选时间已过，取消故障转移计划

        if (mstime() - ri->failover_start_time > election_timeout) {

            sentinelEvent(REDIS_WARNING,"-failover-abort-not-elected",ri,"%@");

            // 取消故障转移

            sentinelAbortFailover(ri);

        }

        return;

    }

    // 本 Sentinel 作为领头，开始执行故障迁移操作...

    sentinelEvent(REDIS_WARNING,"+elected-leader",ri,"%@");

    // 进入选择从服务器状态

    ri->failover_state = SENTINEL_FAILOVER_STATE_SELECT_SLAVE;

    ri->failover_state_change_time = mstime();

    sentinelEvent(REDIS_WARNING,"+failover-state-select-slave",ri,"%@");

}

/* Scan all the Sentinels attached to this master to check if there

 * is a leader for the specified epoch.

 *

 * 扫描所有监视 master 的 Sentinels ，查看是否有 Sentinels 是这个纪元的领头。

 *

 * To be a leader for a given epoch, we should have the majorify of

 * the Sentinels we know that reported the same instance as

 * leader for the same epoch.

 *

 * 要让一个 Sentinel 成为本纪元的领头，

 * 这个 Sentinel 必须让大多数其他 Sentinel 承认它是该纪元的领头才行。

 */

// 选举出 master 在指定 epoch 上的领头

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;

    redisAssert(master->flags & (SRI_O_DOWN|SRI_FAILOVER_IN_PROGRESS));

    // 统计器

    counters = dictCreate(&leaderVotesDictType,NULL);

    /* Count other sentinels votes */

    // 统计其他 sentinel 的主观 leader 投票

    di = dictGetIterator(master->sentinels);

    while((de = dictNext(di)) != NULL) {

        sentinelRedisInstance *ri = dictGetVal(de);

        // 为目标 Sentinel 选出的领头 Sentinel 增加一票

        if (ri->leader != NULL && ri->leader_epoch == sentinel.current_epoch)

            sentinelLeaderIncr(counters,ri->leader);

        // 统计投票数量

        voters++;

    }

    dictReleaseIterator(di);

    /* Check what's the winner. For the winner to win, it needs two conditions:

     *

     * 选出领头 leader ，它必须满足以下两个条件：

     *

     * 1) Absolute majority between voters (50% + 1).

     *    有多于一般的 Sentinel 支持

     * 2) And anyway at least master->quorum votes.

     *    投票数至少要有 master->quorum 那么多

     */

    di = dictGetIterator(counters);

    while((de = dictNext(di)) != NULL) {

        // 取出票数

        uint64_t votes = dictGetUnsignedIntegerVal(de);

        // 选出票数最大的人

        if (votes > max_votes) {

            max_votes = votes;

            winner = dictGetKey(de);

        }

    }

    dictReleaseIterator(di);

    /* Count this Sentinel vote:

     * if this Sentinel did not voted yet, either vote for the most

     * common voted sentinel, or for itself if no vote exists at all. */

    // 本 Sentinel 进行投票

    // 如果 Sentinel 之前还没有进行投票，那么有两种选择：

    // 1）如果选出了 winner （最多票数支持的 Sentinel ），那么这个 Sentinel 也投 winner 一票

    // 2）如果没有选出 winner ，那么 Sentinel 投自己一票

    if (winner)

        myvote = sentinelVoteLeader(master,epoch,winner,&leader_epoch);

    else

        myvote = sentinelVoteLeader(master,epoch,server.runid,&leader_epoch);

    // 领头 Sentinel 已选出，并且领头的纪元和给定的纪元一样

    if (myvote && leader_epoch == epoch) {

        // 为领头 Sentinel 增加一票（这一票来自本 Sentinel ）

        uint64_t votes = sentinelLeaderIncr(counters,myvote);

        // 如果投票之后的票数比最大票数要大，那么更换领头 Sentinel

        if (votes > max_votes) {

            max_votes = votes;

            winner = myvote;

        }

    }

    voters++; /* Anyway, count me as one of the voters. */

    // 如果支持领头的投票数量不超过半数

    // 并且支持票数不超过 master 配置指定的投票数量

    // 那么这次领头选举无效

    voters_quorum = voters/2+1;

    if (winner && (max_votes < voters_quorum || max_votes < master->quorum))

        winner = NULL;

    // 返回领头 Sentinel ，或者 NULL

    winner = winner ? sdsnew(winner) : NULL;

    sdsfree(myvote);

    dictRelease(counters);

    return winner;

}

/* Process the INFO output from masters. */

void sentinelRefreshInstanceInfo(sentinelRedisInstance *ri, const char *info) {

    ...

    /* Handle slave -> master role switch. */

    // 处理从服务器转变为主服务器的情况

    if ((ri->flags & SRI_SLAVE) && role == SRI_MASTER) {

        /* If this is a promoted slave we can change state to the

         * failover state machine. */

        if ((ri->master->flags & SRI_FAILOVER_IN_PROGRESS) &&

            (ri->master->failover_state ==

                SENTINEL_FAILOVER_STATE_WAIT_PROMOTION))

        {

            /* Now that we are sure the slave was reconfigured as a master

             * set the master configuration epoch to the epoch we won the

             * election to perform this failover. This will force the other

             * Sentinels to update their config (assuming there is not

             * a newer one already available). */

            ri->master->config_epoch = ri->master->failover_epoch;

            ri->master->failover_state = SENTINEL_FAILOVER_STATE_RECONF_SLAVES;

            ri->master->failover_state_change_time = mstime();

            sentinelFlushConfig();

            sentinelEvent(REDIS_WARNING,"+promoted-slave",ri,"%@");

            sentinelEvent(REDIS_WARNING,"+failover-state-reconf-slaves",

                ri->master,"%@");

            sentinelCallClientReconfScript(ri->master,SENTINEL_LEADER,

                "start",ri->master->addr,ri->addr);

            sentinelForceHelloUpdateForMaster(ri->master);

        }

        ...

    }

    ...

}

/* Process an hello message received via Pub/Sub in master or slave instance,

 * or sent directly to this sentinel via the (fake) PUBLISH command of Sentinel.

 *

 * If the master name specified in the message is not known, the message is

 * discarded. */

void sentinelProcessHelloMessage(char *hello, int hello_len) {

    ...

        /* Update master info if received configuration is newer. */

        if (master->config_epoch < master_config_epoch) {

            master->config_epoch = master_config_epoch;

            if (master_port != master->addr->port ||

                strcmp(master->addr->ip, token[5]))

            {

                sentinelAddr *old_addr;

                sentinelEvent(REDIS_WARNING,"+config-update-from",si,"%@");

                sentinelEvent(REDIS_WARNING,"+switch-master",

                    master,"%s %s %d %s %d",

                    master->name,

                    master->addr->ip, master->addr->port,

                    token[5], master_port);

                old_addr = dupSentinelAddr(master->addr);

                sentinelResetMasterAndChangeAddress(master, token[5], master_port);

                sentinelCallClientReconfScript(master,

                    SENTINEL_OBSERVER,"start",

                    old_addr,master->addr);

                releaseSentinelAddr(old_addr);

            }

        }

    ...

}