sentinel(哨兵)是redis的高可用解决方案。由一个或多个sentinel实例组成的分布式系统，可以监控任意多个主节点，以及它们属下的所有从节点。当某个主节点下线时，sentinel可以将下线主节点属下的某个从节点升级为新的主节点。
一：哨兵进程
哨兵，本质上是redis服务器的一种运行模式。也就是说它们共用大部分的代码，只是哨兵模式中有部分代码是自己特有的。
在Makefile中，哨兵的编译和安装，实际上跟redis服务器是一模一样的：
REDIS_SERVER_NAME=redis-server
REDIS_SENTINEL_NAME=redis-sentinel
...
$(REDIS_SENTINEL_NAME): $(REDIS_SERVER_NAME)
...
install: all
...
@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_SENTINEL_NAME)
因此，哨兵实际上就是redis服务器的软连接而已：
# ll /usr/local/bin/redis-sentinel lrwxrwxrwx 1 root root 12 May 21 10:50 /usr/local/bin/redis-sentinel -> redis-server
在代码中，使用全局变量server.sentinel_mode，来决定当前的进程是哨兵模式，还是redis服务器进程：
int main(int argc, char **argv) {
...
server.sentinel_mode = checkForSentinelMode(argc,argv);
initServerConfig();
/* We need to init sentinel right now as parsing the configuration file
* in sentinel mode will have the effect of populating the sentinel
* data structures with master nodes to monitor. */
if (server.sentinel_mode) {
initSentinelConfig();
initSentinel();
}
...
}
checkForSentinelMode的代码非常简单质朴，就是扫描命令行参数中是否包含"--sentinel"，或者程序名是否为"redis-sentinel"，来决定当前进程是否为哨兵模式的：
/* Returns 1 if there is --sentinel among the arguments or if
* argv[0] is exactly "redis-sentinel". */
int checkForSentinelMode(int argc, char **argv) {
int j;
if (strstr(argv[0],"redis-sentinel") != NULL) return 1;
for (j = 1; j < argc; j++)
if (!strcmp(argv[j],"--sentinel")) return 1;
return 0;
}
因此，哨兵的下面两种启动方法，本质上是一样的：
redis-sentinel /path/to/your/sentinel.conf redis-server /path/to/your/sentinel.conf --sentinel
在main函数中，得到server.sentinel_mode的值之后，接下来就是调用initServerConfig初始化全局服务器结构：structredisServer server。
哨兵模式下也会使用该结构，但是在哨兵模式中，接下来就会调用initSentinelConfig和initSentinel来初始化哨兵自己的结构和属性。还会覆盖掉server中某些属性：
/* This function overwrites a few normal Redis config default with Sentinel
* specific defaults. */
void initSentinelConfig(void) {
server.port = REDIS_SENTINEL_PORT;
}
/* Perform the Sentinel mode initialization. */
void initSentinel(void) {
unsigned int j;
/* Remove usual Redis commands from the command table, then just add
* the SENTINEL command. */
dictEmpty(server.commands,NULL);
for (j = 0; j < sizeof(sentinelcmds)/sizeof(sentinelcmds[0]); j++) {
int retval;
struct redisCommand *cmd = sentinelcmds+j;
retval = dictAdd(server.commands, sdsnew(cmd->name), cmd);
redisAssert(retval == DICT_OK);
}
/* Initialize various data structures. */
sentinel.current_epoch = 0;
sentinel.masters = dictCreate(&instancesDictType,NULL);
sentinel.tilt = 0;
sentinel.tilt_start_time = 0;
sentinel.previous_time = mstime();
sentinel.running_scripts = 0;
sentinel.scripts_queue = listCreate();
sentinel.announce_ip = NULL;
sentinel.announce_port = 0;
}
在initSentinelConfig函数中，使用REDIS_SENTINEL_PORT(26379)覆盖掉server.port属性。也就是说，哨兵进程默认的监听端口是26379。
在initSentinel函数中，除了初始化全局哨兵结构struct sentinelState sentinel之外，还会使用sentinelcmds，重新初始化server.commands，该结构中记录了redis支持的命令以及命令处理函数等内容。sentinelcmds的内容如下：
struct redisCommand sentinelcmds[] = {
{"ping",pingCommand,1,"",0,NULL,0,0,0,0,0},
{"sentinel",sentinelCommand,-2,"",0,NULL,0,0,0,0,0},
{"subscribe",subscribeCommand,-2,"",0,NULL,0,0,0,0,0},
{"unsubscribe",unsubscribeCommand,-1,"",0,NULL,0,0,0,0,0},
{"psubscribe",psubscribeCommand,-2,"",0,NULL,0,0,0,0,0},
{"punsubscribe",punsubscribeCommand,-1,"",0,NULL,0,0,0,0,0},
{"publish",sentinelPublishCommand,3,"",0,NULL,0,0,0,0,0},
{"info",sentinelInfoCommand,-1,"",0,NULL,0,0,0,0,0},
{"role",sentinelRoleCommand,1,"l",0,NULL,0,0,0,0,0},
{"client",clientCommand,-2,"rs",0,NULL,0,0,0,0,0},
{"shutdown",shutdownCommand,-1,"",0,NULL,0,0,0,0,0}
};
也就是说，在哨兵模式下，支持的命令要比redis服务器要少很多，而且大部分命令的处理函数也不同于redis服务器中的命令处理函数。
二：数据结构
在哨兵模式中，最主要的数据结构就是sentinelState。该结构中保存维护了哨兵模式下的所有状态和属性。它的定义如下：
/* Main state. */
struct sentinelState {
uint64_t current_epoch; /* Current epoch. */
dict *masters; /* Dictionary of master sentinelRedisInstances.
Key is the instance name, value is the
sentinelRedisInstance structure pointer. */
int tilt; /* Are we in TILT mode? */
int running_scripts; /* Number of scripts in execution right now. */
mstime_t tilt_start_time; /* When TITL started. */
mstime_t previous_time; /* Last time we ran the time handler. */
list *scripts_queue; /* Queue of user scripts to execute. */
char *announce_ip; /* IP addr that is gossiped to other sentinels if
not NULL. */
int announce_port; /* Port that is gossiped to other sentinels if
non zero. */
} sentinel;
在sentinelState结构中，最主要的成员就是字典masters。该字典中记录当前哨兵所要监控和交互的所有实例。这些实例包括主节点、从节点和其他哨兵。
masters字典以主节点的名字为key，以主节点实例结构sentinelRedisInstance为value。主节点的名字通过解析配置文件得到。而sentinelRedisInstance结构的定义如下：
typedef struct sentinelRedisInstance {
int flags; /* See SRI_... defines */
char *name; /* Master name from the point of view of this sentinel. */
char *runid; /* run ID of this instance. */
uint64_t config_epoch; /* Configuration epoch. */
sentinelAddr *addr; /* Master host. */
redisAsyncContext *cc; /* Hiredis context for commands. */
redisAsyncContext *pc; /* Hiredis context for Pub / Sub. */
int pending_commands; /* Number of commands sent waiting for a reply. */
mstime_t cc_conn_time; /* cc connection time. */
mstime_t pc_conn_time; /* pc connection time. */
...
/* Master specific. */
dict *sentinels; /* Other sentinels monitoring the same master. */
dict *slaves; /* Slaves for this master instance. */
...
/* Slave specific. */
...
struct sentinelRedisInstance *master; /* Master instance if it's slave. */
...
/* Failover */
...
struct sentinelRedisInstance *promoted_slave;
...
} sentinelRedisInstance;
在哨兵模式中，所有的主节点、从节点以及哨兵实例，都是由sentinelRedisInstance结构表示的。
在该结构中，首先是公共部分，也就是所有实例都会用到的属性，比如：
flags是实例标志位，该标志位中的标记，表示实例的类型或者所处的状态等；
name是实例的名字：每个实例都有一个名字，相当于实例的索引，不同实例具有不同的名字。主节点实例的名字从配置文件中得到，从节点和哨兵实例的名字是由ip和port组成的；
runid记录实例的运行ID；
addr记录实例的地址，其中包含了ip地址和port端口号；
哨兵会与其监控的所有主节点、该主节点下属的所有从节点，以及与之监控相同主节点的其他哨兵之间建立TCP连接。哨兵与主节点和从节点之间会建立两个TCP连接，分别用于发送命令和订阅HELLO频道；哨兵与其他哨兵之间只建立一个发送命令的TCP连接（因为哨兵本身不支持订阅模式）；
哨兵与其他节点进行通信，使用的是Hiredis中的异步方式。因此，sentinelRedisInstance结构中的cc，就是用于命令连接的异步上下文；而其中的pc，就是用于订阅连接的异步上下文；
除了公共部分，不同类型的实例还会有自己特有的属性。比如对于主节点实例而言，它的特有属性有：
sentinels字典：用于记录监控相同主节点其他哨兵实例。该字典以哨兵名字为key，以哨兵实例sentinelRedisInstance结构为key；
slaves字典：用于记录该主节点实例的所有从节点实例。该字典以从节点名字为key，以从节点实例sentinelRedisInstance结构为key；
因此总结而言就是：sentinelState结构中的字典masters中，记录了本哨兵要监控的所有主节点实例，而在表示每个主节点实例的sentinelRedisInstance结构中，字典sentinels中记录了监控该主节点的其他哨兵实例，字典slaves记录了该主节点的所有下属从节点。
这种设计方式非常巧妙，以主节点为核心，将当前哨兵所监控的实例进行分组，每个主节点及其属下的从节点和哨兵，组成一个监控单位，不同监控单位之间的流程是相互隔离的。
对于从节点实例而言，sentinelRedisInstance结构中也有一些它所各有的属性，比如master指针，就指向了它的主节点的sentinelRedisInstance结构；
sentinelRedisInstance结构中还包含与故障转移相关的属性，这在分析哨兵的故障转移流程的代码时会介绍。
三：初始化
在哨兵模式下，启动时必须指定一个配置文件，这也是哨兵模式和redis服务器不同的地方，哨兵模式不支持命令行方式的参数配置。
除了redis服务器的配置选项之外，哨兵还需要自己特有的一些配置选项。比如最基本的，就是在配置文件中，需要制定哨兵要监控的主节点：
sentinel monitor <mastername> <masterip> <masterport> <quorum>
该配置选项中，制定了要监控的主节点的名字、ip、port和quorum值。只有主节点的名字是需要在配置文件中指定，后续所有该主节点的配置选项都以该名字为索引，比如下面就是一个实际的配置内容：
sentinel monitor mymaster 127.0.0.1 6379 2 sentinel down-after-milliseconds mymaster 60000 sentinel failover-timeout mymaster 180000 sentinel parallel-syncs mymaster 1 sentinel monitor resque 192.168.1.3 6380 4 sentinel down-after-milliseconds resque 10000 sentinel failover-timeout resque 180000 sentinel parallel-syncs resque 5
与哨兵相关的配置选项，第一个单词必须是”sentinel”。上面的配置文件，监控的主节点名字分别是mymaster和resque。
在配置文件中，只需要指定主节点的名字、ip和port信息，而从节点和其他哨兵的信息，都是在信息交互的过程中自动发现的。
在源代码sentinel.c中，函数sentinelHandleConfiguration就是用于解析哨兵配置选项的函数。比如用于解析”sentinel monitor”选项的部分代码如下：
char *sentinelHandleConfiguration(char **argv, int argc) {
sentinelRedisInstance *ri;
if (!strcasecmp(argv[0],"monitor") && argc == 5) {
/* monitor <name> <host> <port> <quorum> */
int quorum = atoi(argv[4]);
if (quorum <= 0) return "Quorum must be 1 or greater.";
if (createSentinelRedisInstance(argv[1],SRI_MASTER,argv[2],
atoi(argv[3]),quorum,NULL) == NULL)
{
switch(errno) {
case EBUSY: return "Duplicated master name.";
case ENOENT: return "Can't resolve master instance hostname.";
case EINVAL: return "Invalid port number";
}
}
}
...
}
”sentinelmonitor”选项中，参数个数必须为5个：以”monitor”为第一个参数，剩下的分别是主节点名字、主节点ip，主节点端口，以及quorum值。
上面的代码，就是根据参数值，直接调用createSentinelRedisInstance函数，创建一个SRI_MASTER标记的主节点实例。
createSentinelRedisInstance函数的代码如下：
sentinelRedisInstance *createSentinelRedisInstance(char *name, int flags, char *hostname, int port, int quorum, sentinelRedisInstance *master) {
sentinelRedisInstance *ri;
sentinelAddr *addr;
dict *table = NULL;
char slavename[128], *sdsname;
redisAssert(flags & (SRI_MASTER|SRI_SLAVE|SRI_SENTINEL));
redisAssert((flags & SRI_MASTER) || master != NULL);
/* Check address validity. */
addr = createSentinelAddr(hostname,port);
if (addr == NULL) return NULL;
/* For slaves and sentinel we use ip:port as name. */
if (flags & (SRI_SLAVE|SRI_SENTINEL)) {
snprintf(slavename,sizeof(slavename),
strchr(hostname,':') ? "[%s]:%d" : "%s:%d",
hostname,port);
name = slavename;
}
/* Make sure the entry is not duplicated. This may happen when the same
* name for a master is used multiple times inside the configuration or
* if we try to add multiple times a slave or sentinel with same ip/port
* to a master. */
if (flags & SRI_MASTER) table = sentinel.masters;
else if (flags & SRI_SLAVE) table = master->slaves;
else if (flags & SRI_SENTINEL) table = master->sentinels;
sdsname = sdsnew(name);
if (dictFind(table,sdsname)) {
releaseSentinelAddr(addr);
sdsfree(sdsname);
errno = EBUSY;
return NULL;
}
/* Create the instance object. */
ri = zmalloc(sizeof(*ri));
/* Note that all the instances are started in the disconnected state,
* the event loop will take care of connecting them. */
ri->flags = flags | SRI_DISCONNECTED;
ri->name = sdsname;
ri->runid = NULL;
ri->config_epoch = 0;
ri->addr = addr;
ri->cc = NULL;
ri->pc = NULL;
...
dictAdd(table, ri->name, ri);
return ri;
}
参数hostname可以是实例的IP地址，也可以是实例的域名；参数flags表示该实例的类型，共有三种类型：SRI_MASTER，表示要创建的实例是主节点；SRI_SLAVE，表示要创建的实例是从节点；SRI_SENTINEL，表示要创建的实例是哨兵；
首先调用函数createSentinelAddr，根据参数hostname和port，创建地址结构addr；hostname有可能是域名，因此createSentinelAddr中，会首先对域名进行解析，如果能解析出IP地址，并且port在范围(0, 65535]中，则将ip和port记录到addr中；如果解析不了hostname，则createSentinelAddr中，会设置errno为ENOENT，并返回NULL；如果port超出了合法范围，则设置errno为EINVAL，并返回NULL；如果createSentinelAddr返回NULL，则createSentinelRedisInstance也直接返回NULL，表示创建实例失败；
参数name表示该实例的名字，主节点的名字在配置文件中配置的；从节点和哨兵的名字由hostname和port组成；
如果该实例为主节点，则参数master为NULL，最终会将该实例存放到字典sentinel.masters中；如果该实例为从节点或哨兵，则参数master不能为NULL，将该实例存放到字典master->slaves或master->sentinels中；如果字典中已经存在同名实例，则设置errno为EBUSY，并且返回NULL，表示创建实例失败；
新创建的实例中，标志位中设置SRI_DISCONNECTED标记，表示尚未与实例建链；剩下的代码，就是初始化实例的一系列属性，不再赘述；
最后，将该实例插入到相应的字典中；
因此，解析完哨兵的配置文件之后，就已经把所有要监控的主节点实例插入到字典sentinel.masters中了。下一步，就是开始向主节点进行TCP建链了。
四：哨兵进程的“主函数”
在介绍哨兵进程的各种流程之前，需要先了解一下哨兵进程的“主函数”。
在redis服务器中的定时器函数serverCron中，每隔100ms就会调用一次sentinelTimer函数。该函数就是哨兵进程的主要处理函数，哨兵中的所有流程都是在该函数中处理的。
void sentinelTimer(void) {
sentinelCheckTiltCondition();
sentinelHandleDictOfRedisInstances(sentinel.masters);
sentinelRunPendingScripts();
sentinelCollectTerminatedScripts();
sentinelKillTimedoutScripts();
/* We continuously change the frequency of the Redis "timer interrupt"
* in order to desynchronize every Sentinel from every other.
* This non-determinism avoids that Sentinels started at the same time
* exactly continue to stay synchronized asking to be voted at the
* same time again and again (resulting in nobody likely winning the
* election because of split brain voting). */
server.hz = REDIS_DEFAULT_HZ + rand() % REDIS_DEFAULT_HZ;
}
哨兵中记录的所有实例，随着时间的流逝，在各种状态间进行转换，不同的状态下就有不同的处理方式。
该函数中，首先调用sentinelCheckTiltCondition判断当前是否处于TILT模式下，有关TILT模式后续会介绍；
然后调用函数sentinelHandleDictOfRedisInstances处理哨兵中的所有实例；
剩下的就是跟执行脚本相关：sentinelRunPendingScripts用于执行列表sentinel.scripts_queue中的任务；sentinelCollectTerminatedScripts用于得到执行任务的子进程的退出状态；sentinelKillTimedoutScripts用于杀死执行时间过程的任务；
最后，修改server.hz，增加其随机性，以避免投票选举时发生冲突；
sentinelHandleDictOfRedisInstances函数，是处理该哨兵中保存的所有实例的函数。它的代码如下：
void sentinelHandleDictOfRedisInstances(dict *instances) {
dictIterator *di;
dictEntry *de;
sentinelRedisInstance *switch_to_promoted = NULL;
/* There are a number of things we need to perform against every master. */
di = dictGetIterator(instances);
while((de = dictNext(di)) != NULL) {
sentinelRedisInstance *ri = dictGetVal(de);
sentinelHandleRedisInstance(ri);
if (ri->flags & SRI_MASTER) {
sentinelHandleDictOfRedisInstances(ri->slaves);
sentinelHandleDictOfRedisInstances(ri->sentinels);
if (ri->failover_state == SENTINEL_FAILOVER_STATE_UPDATE_CONFIG) {
switch_to_promoted = ri;
}
}
}
if (switch_to_promoted)
sentinelFailoverSwitchToPromotedSlave(switch_to_promoted);
dictReleaseIterator(di);
}
sentinelHandleDictOfRedisInstances函数会扫描字典instances，针对其中的每一个实例，都调用函数sentinelHandleRedisInstance进行处理。而且如果实例是主节点的话，还会递归调用本函数，接着处理字典ri->slaves中的所有从节点实例，以及字典ri->sentinels中的所有哨兵实例。
函数的最后，如果针对某个主节点，发起了故障转移流程，并且流程已经到了最后一步，则会调用函数sentinelFailoverSwitchToPromotedSlave进行处理；
sentinelHandleRedisInstance函数，就是相当于哨兵进程的“主函数”。有关实例的几乎所有动作，都在该函数中进行的。该函数的代码如下：
void sentinelHandleRedisInstance(sentinelRedisInstance *ri) {
/* ========== MONITORING HALF ============ */
/* Every kind of instance */
sentinelReconnectInstance(ri);
sentinelSendPeriodicCommands(ri);
/* ============== ACTING HALF ============= */
/* We don't proceed with the acting half if we are in TILT mode.
* TILT happens when we find something odd with the time, like a
* sudden change in the clock. */
if (sentinel.tilt) {
if (mstime()-sentinel.tilt_start_time < SENTINEL_TILT_PERIOD) return;
sentinel.tilt = 0;
sentinelEvent(REDIS_WARNING,"-tilt",NULL,"#tilt mode exited");
}
/* Every kind of instance */
sentinelCheckSubjectivelyDown(ri);
/* Masters and slaves */
if (ri->flags & (SRI_MASTER|SRI_SLAVE)) {
/* Nothing so far. */
}
/* Only masters */
if (ri->flags & SRI_MASTER) {
sentinelCheckObjectivelyDown(ri);
if (sentinelStartFailoverIfNeeded(ri))
sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_ASK_FORCED);
sentinelFailoverStateMachine(ri);
sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_NO_FLAGS);
}
}
本函数用于处理实例的所有状态。在哨兵中，每个实例在某一时刻都处于某种状态，随着时间的流逝，实例在不同的状态之间转换，本函数就是在实例处于不同状态下，进行不同的处理；
首先调用sentinelReconnectInstance函数，如果实例处于断链状态，则调用该函数进行TCP建链；
然后调用sentinelSendPeriodicCommands函数，向实例发送"PING"，"INFO"或"PUBLISH"消息。
接下来，如果哨兵当前处于TILT模式下，并且处于该模式下的时间还不到SENTINEL_TILT_PERIOD毫秒，则直接返回，而不在进行后续的处理；如果处于TILT模式下已经超过了SENTINEL_TILT_PERIOD毫秒，则退出TILT模式；
然后，调用函数sentinelCheckSubjectivelyDown检查实例是否主观下线；
最后，如果当前实例为主节点，则检查该实例是否客观下线，并在必要的情况下，发起故障转移流程；
五：建链
哨兵对于其所监控的所有主节点，及其属下的所有从节点，都会建立两个TCP连接。一个用于发送命令，一个用于订阅其HELLO频道。而哨兵对于监控同一主节点的其他哨兵实例，只建立一个命令连接。
哨兵向其他实例建立的命令连接，主要用于发送”PING”、”INFO”或”PUBLISH”命令。哨兵会根据实例对于这些命令的回复时间和回复内容，修改该实例的状态；
哨兵向主节点和从节点建立的订阅连接，主要是为了监控同一主节点的所有哨兵之间，能够相互发现，以及交换信息。
哨兵与其他实例之间的交互，主要是通过Hiredis的异步方式进行的。关于Hiredis的异步方式，可以参考之前的文章。
TCP连接的建立，就是通过函数sentinelReconnectInstance实现的。该函数的代码如下：
void sentinelReconnectInstance(sentinelRedisInstance *ri) {
if (!(ri->flags & SRI_DISCONNECTED)) return;
/* Commands connection. */
if (ri->cc == NULL) {
ri->cc = redisAsyncConnectBind(ri->addr->ip,ri->addr->port,REDIS_BIND_ADDR);
if (ri->cc->err) {
sentinelEvent(REDIS_DEBUG,"-cmd-link-reconnection",ri,"%@ #%s",
ri->cc->errstr);
sentinelKillLink(ri,ri->cc);
} else {
ri->cc_conn_time = mstime();
ri->cc->data = ri;
redisAeAttach(server.el,ri->cc);
redisAsyncSetConnectCallback(ri->cc,
sentinelLinkEstablishedCallback);
redisAsyncSetDisconnectCallback(ri->cc,
sentinelDisconnectCallback);
sentinelSendAuthIfNeeded(ri,ri->cc);
sentinelSetClientName(ri,ri->cc,"cmd");
/* Send a PING ASAP when reconnecting. */
sentinelSendPing(ri);
}
}
/* Pub / Sub */
if ((ri->flags & (SRI_MASTER|SRI_SLAVE)) && ri->pc == NULL) {
ri->pc = redisAsyncConnectBind(ri->addr->ip,ri->addr->port,REDIS_BIND_ADDR);
if (ri->pc->err) {
sentinelEvent(REDIS_DEBUG,"-pubsub-link-reconnection",ri,"%@ #%s",
ri->pc->errstr);
sentinelKillLink(ri,ri->pc);
} else {
int retval;
ri->pc_conn_time = mstime();
ri->pc->data = ri;
redisAeAttach(server.el,ri->pc);
redisAsyncSetConnectCallback(ri->pc,
sentinelLinkEstablishedCallback);
redisAsyncSetDisconnectCallback(ri->pc,
sentinelDisconnectCallback);
sentinelSendAuthIfNeeded(ri,ri->pc);
sentinelSetClientName(ri,ri->pc,"pubsub");
/* Now we subscribe to the Sentinels "Hello" channel. */
retval = redisAsyncCommand(ri->pc,
sentinelReceiveHelloMessages, NULL, "SUBSCRIBE %s",
SENTINEL_HELLO_CHANNEL);
if (retval != REDIS_OK) {
/* If we can't subscribe, the Pub/Sub connection is useless
* and we can simply disconnect it and try again. */
sentinelKillLink(ri,ri->pc);
return;
}
}
}
/* Clear the DISCONNECTED flags only if we have both the connections
* (or just the commands connection if this is a sentinel instance). */
if (ri->cc && (ri->flags & SRI_SENTINEL || ri->pc))
ri->flags &= ~SRI_DISCONNECTED;
}
如果实例标志位中没有SRI_DISCONNECTED标记，则表示该实例已经建链，直接返回；
实例中的异步上下文cc，用于向该实例发送命令。如果cc为NULL，则首先调用函数redisAsyncConnectBind创建异步上下文，并发起非阻塞的TCP建链；
创建异步上下文cc成功之后，调用redisAeAttach将该上下文与AE事件loop结合；然后调用redisAsyncSetConnectCallback，设置建链回调函数sentinelLinkEstablishedCallback，并注册可写事件；然后调用redisAsyncSetDisconnectCallback，设置断链回调函数sentinelDisconnectCallback；然后调用sentinelSendAuthIfNeeded，向该实例异步发送"AUTHXXX"命令，进行密码认证；然后调用sentinelSetClientName，向该实例异步发送命令"CLIENT SETNAME sentinel-<runid>-cmd"，设置该客户端连接的名字；最后调用函数sentinelSendPing，向实例异步发送"PING"命令；
实例中的异步上下文pc，用于订阅实例的HELLO频道。如果pc为NULL，并且实例ri不是哨兵的话，则首先调用redisAsyncConnectBind创建异步上下文，并发起非阻塞的TCP建链；
创建异步上下文pc成功之后，调用redisAeAttach将该上下文与AE事件loop结合；然后调用redisAsyncSetConnectCallback，设置建链回调函数sentinelLinkEstablishedCallback，并注册可写事件；然后调用redisAsyncSetDisconnectCallback，设置断链回调函数sentinelDisconnectCallback；然后调用sentinelSendAuthIfNeeded，向该实例异步发送"AUTHXXX"命令，进行密码认证；然后调用sentinelSetClientName，向该实例异步发送命令"CLIENT SETNAME sentinel-<runid>-pubsub"，设置该客户端连接的名字；最后向实例异步发送"SUBSCRIBE __sentinel__:hello"命令，订阅实例的HELLO频道，回调函数为sentinelReceiveHelloMessages，当收到该频道发布的消息时，就会调用该函数；
如果异步上下文cc和pc都创建好了，则可以从实例标志位中去除SRI_DISCONNECTED
标记。如果实例为哨兵，则无需创建异步上下文pc。
注意：以上两个连接的建连回调函数，只是会在TCP连接建立成功或失败时被调用，用于打印一些信息；而断连回调函数，是在TCP断连时被调用，用于将断连的异步上下文置为NULL，并且将标记SRI_DISCONNECTED增加到实例标志位中，这样，下次调用sentinelReconnectInstance函数时，就会重新建连了。