一万字详解 Redis Cluster Gossip 协议

// 注意，PING 、 PONG 和 MEET 实际上是同一种消息。 
// PONG 是对 PING 的回复，它的实际格式也为 PING 消息， 
// 而 MEET 则是一种特殊的 PING 消息，用于强制消息的接收者将消息的发送者添加到集群中（如果节点尚未在节点列表中的话） 
#define CLUSTERMSG_TYPE_PING 0          /* Ping 消息 */ 
#define CLUSTERMSG_TYPE_PONG 1          /* Pong 用于回复Ping */ 
#define CLUSTERMSG_TYPE_MEET 2          /* Meet 请求将某个节点添加到集群中 */ 
#define CLUSTERMSG_TYPE_FAIL 3          /* Fail 将某个节点标记为 FAIL */ 
#define CLUSTERMSG_TYPE_PUBLISH 4       /* 通过发布与订阅功能广播消息 */ 
#define CLUSTERMSG_TYPE_FAILOVER_AUTH_REQUEST 5 /* 请求进行故障转移操作，要求消息的接收者通过投票来支持消息的发送者 */ 
#define CLUSTERMSG_TYPE_FAILOVER_AUTH_ACK 6     /* 消息的接收者同意向消息的发送者投票 */ 
#define CLUSTERMSG_TYPE_UPDATE 7        /* slots 已经发生变化，消息发送者要求消息接收者进行相应的更新 */ 
#define CLUSTERMSG_TYPE_MFSTART 8       /* 为了进行手动故障转移，暂停各个客户端 */ 
#define CLUSTERMSG_TYPE_COUNT 9         /* 消息总数 */ 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

typedef struct clusterState { 
   clusterNode *myself;  /* 当前节点的clusterNode信息 */ 
   .... 
   dict *nodes;          /* name到clusterNode的字典 */ 
   .... 
   clusterNode *slots[CLUSTER_SLOTS]; /* slot 和节点的对应关系*/ 
   .... 
} clusterState; 
1.
2.
3.
4.
5.
6.
7.
8.

typedef struct clusterNode { 
    mstime_t ctime; /* 创建节点的时间 */ 
    char name[CLUSTER_NAMELEN]; /* 节点的名字 */ 
    int flags;      /* 节点标识，标记节点角色或者状态，比如主节点从节点或者在线和下线 */ 
    uint64_t configEpoch; /* 当前节点已知的集群统一epoch */ 
    unsigned char slots[CLUSTER_SLOTS/8]; /* slots handled by this node */ 
    int numslots;   /* Number of slots handled by this node */ 
    int numslaves;  /* Number of slave nodes, if this is a master */ 
    struct clusterNode **slaves; /* pointers to slave nodes */ 
    struct clusterNode *slaveof; /* pointer to the master node. Note that it 
                                    may be NULL even if the node is a slave 
                                    if we don't have the master node in our 
                                    tables. */ 
    mstime_t ping_sent;      /* 当前节点最后一次向该节点发送 PING 消息的时间 */ 
    mstime_t pong_received;  /* 当前节点最后一次收到该节点 PONG 消息的时间 */ 
    mstime_t fail_time;      /* FAIL 标志位被设置的时间 */ 
    mstime_t voted_time;     /* Last time we voted for a slave of this master */ 
    mstime_t repl_offset_time;  /* Unix time we received offset for this node */ 
    mstime_t orphaned_time;     /* Starting time of orphaned master condition */ 
    long long repl_offset;      /* 当前节点的repl便宜 */ 
    char ip[NET_IP_STR_LEN];  /* 节点的IP 地址 */ 
    int port;                   /* 端口 */ 
    int cport;                  /* 通信端口，一般是端口+1000 */ 
    clusterLink *link;          /* 和该节点的 tcp 连接 */ 
    list *fail_reports;         /* 下线记录列表 */ 
} clusterNode; 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

typedef struct clusterNodeFailReport { 
    struct clusterNode *node;  /* 报告当前节点已经下线的节点 */ 
    mstime_t time;             /* 报告时间 */ 
} clusterNodeFailReport; 
1.
2.
3.
4.

typedef struct { 
    char sig[4];        /* 标志位，"RCmb" (Redis Cluster message bus). */ 
    uint32_t totlen;    /* 消息总长度 */ 
    uint16_t ver;       /* 消息协议版本 */ 
    uint16_t port;      /* 端口 */ 
    uint16_t type;      /* 消息类型 */ 
    uint16_t count;     /*  */ 
    uint64_t currentEpoch;  /* 表示本节点当前记录的整个集群的统一的epoch，用来决策选举投票等，与configEpoch不同的是：configEpoch表示的是master节点的唯一标志，currentEpoch是集群的唯一标志。 */ 
    uint64_t configEpoch;   /* 每个master节点都有一个唯一的configEpoch做标志，如果和其他master节点冲突，会强制自增使本节点在集群中唯一 */ 
    uint64_t offset;    /* 主从复制偏移相关信息，主节点和从节点含义不同 */ 
    char sender[CLUSTER_NAMELEN]; /* 发送节点的名称 */ 
    unsigned char myslots[CLUSTER_SLOTS/8]; /* 本节点负责的slots信息,16384/8个char数组，一共为16384bit */ 
    char slaveof[CLUSTER_NAMELEN]; /* master信息，假如本节点是slave节点的话，协议带有master信息 */ 
    char myip[NET_IP_STR_LEN];    /* IP */ 
    char notused1[34];  /* 保留字段 */ 
    uint16_t cport;      /* 集群的通信端口 */ 
    uint16_t flags;      /* 本节点当前的状态，比如 CLUSTER_NODE_HANDSHAKE、CLUSTER_NODE_MEET */ 
    unsigned char state; /* Cluster state from the POV of the sender */ 
    unsigned char mflags[3]; /* 本条消息的类型，目前只有两类：CLUSTERMSG_FLAG0_PAUSED、CLUSTERMSG_FLAG0_FORCEACK */ 
    union clusterMsgData data; 
} clusterMsg; 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

// 注意这是 union 关键字 
union clusterMsgData { 
    /* PING, MEET 或者 PONG 消息时，ping 字段被赋值 */ 
    struct { 
        /* Array of N clusterMsgDataGossip structures */ 
        clusterMsgDataGossip gossip[1]; 
    } ping; 
    /*  FAIL 消息时，fail 被赋值 */ 
    struct { 
        clusterMsgDataFail about; 
    } fail; 
    // .... 省略 publish 和 update 消息的字段 
}; 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

typedef struct { 
 /* 节点的名字，默认是随机的，MEET消息发送并得到回复后，集群会为该节点设置正式的名称*/ 
    char nodename[CLUSTER_NAMELEN];  
    uint32_t ping_sent; /* 发送节点最后一次给接收节点发送 PING 消息的时间戳，收到对应 PONG 回复后会被赋值为0 */ 
    uint32_t pong_received; /* 发送节点最后一次收到接收节点发送 PONG 消息的时间戳 */ 
    char ip[NET_IP_STR_LEN];  /* IP address last time it was seen */ 
    uint16_t port;       /* IP*/        
    uint16_t cport;      /* 端口*/   
    uint16_t flags;      /* 标识*/  
    uint32_t notused1;   /* 对齐字符*/ 
} clusterMsgDataGossip; 
 
typedef struct { 
    char nodename[CLUSTER_NAMELEN]; /* 下线节点的名字 */ 
} clusterMsgDataFail; 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

// cluster.c 文件  
// clusterCron() 每执行 10 次（至少间隔一秒钟），就向一个随机节点发送 gossip 信息 
if (!(iteration % 10)) { 
    int j; 
 
    /* 随机 5 个节点，选出其中一个 */ 
    for (j = 0; j < 5; j++) { 
        de = dictGetRandomKey(server.cluster->nodes); 
        clusterNode *this = dictGetVal(de); 
 
        /* 不要 PING 连接断开的节点，也不要 PING 最近已经 PING 过的节点 */ 
        if (this->link == NULL || this->ping_sent != 0) continue; 
        if (this->flags & (CLUSTER_NODE_MYSELF|CLUSTER_NODE_HANDSHAKE)) 
            continue; 
        /* 对比 pong_received 字段，选出更长时间未收到其 PONG 消息的节点(表示好久没有接受到该节点的PONG消息了) */ 
        if (min_pong_node == NULL || min_pong > this->pong_received) { 
            min_pong_node = this; 
            min_pong = this->pong_received; 
        } 
    } 
    /* 向最久没有收到 PONG 回复的节点发送 PING 命令 */ 
    if (min_pong_node) { 
        serverLog(LL_DEBUG,"Pinging node %.40s", min_pong_node->name); 
        clusterSendPing(min_pong_node->link, CLUSTERMSG_TYPE_PING); 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

/* cluster.c clusterCron 函数部分,为未创建连接的节点创建连接 */ 
if (node->link == NULL) { 
    int fd; 
    mstime_t old_ping_sent; 
    clusterLink *link; 
    /* 和该节点建立连接 */ 
    fd = anetTcpNonBlockBindConnect(server.neterr, node->ip, 
        node->cport, NET_FIRST_BIND_ADDR); 
    /* .... fd 为-1时的异常处理 */ 
    /* 建立 link */ 
    link = createClusterLink(node); 
    link->fd = fd; 
    node->link = link; 
    aeCreateFileEvent(server.el,link->fd,AE_READABLE, 
            clusterReadHandler,link); 
    /* 向新连接的节点发送 PING 命令，防止节点被识进入下线 */ 
    /* 如果节点被标记为 MEET ，那么发送 MEET 命令，否则发送 PING 命令 */ 
    old_ping_sent = node->ping_sent; 
    clusterSendPing(link, node->flags & CLUSTER_NODE_MEET ? 
            CLUSTERMSG_TYPE_MEET : CLUSTERMSG_TYPE_PING); 
    /* .... */ 
    /* 如果当前节点（发送者）没能收到 MEET 信息的回复，那么它将不再向目标节点发送命令。*/ 
    /* 如果接收到回复的话，那么节点将不再处于 HANDSHAKE 状态，并继续向目标节点发送普通 PING 命令*/ 
    node->flags &= ~CLUSTER_NODE_MEET; 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

/* cluster.c clusterCron 函数部分，遍历节点来检查 fail 的节点*/ 
while((de = dictNext(di)) != NULL) { 
    clusterNode *node = dictGetVal(de); 
    now = mstime(); /* Use an updated time at every iteration. */ 
    mstime_t delay; 
 
    /* 如果等到 PONG 到达的时间超过了 node timeout 一半的连接 */ 
    /* 因为尽管节点依然正常，但连接可能已经出问题了 */ 
    if (node->link && /* is connected */ 
        now - node->link->ctime > 
        server.cluster_node_timeout && /* 还未重连 */ 
        node->ping_sent && /* 已经发过ping消息 */ 
        node->pong_received < node->ping_sent && /* 还在等待pong消息 */ 
        /* 等待pong消息超过了 timeout/2 */ 
        now - node->ping_sent > server.cluster_node_timeout/2) 
    { 
        /* 释放连接，下次 clusterCron() 会自动重连 */ 
        freeClusterLink(node->link); 
    } 
 
    /* 如果目前没有在 PING 节点*/ 
    /* 并且已经有 node timeout 一半的时间没有从节点那里收到 PONG 回复 */ 
    /* 那么向节点发送一个 PING ，确保节点的信息不会太旧，有可能一直没有随机中 */ 
    if (node->link && 
        node->ping_sent == 0 && 
        (now - node->pong_received) > server.cluster_node_timeout/2) 
    { 
        clusterSendPing(node->link, CLUSTERMSG_TYPE_PING); 
        continue; 
    } 
    /* .... 处理failover和标记遗失下线 */ 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.

/* 如果这是一个主节点，并且有一个从服务器请求进行手动故障转移,那么向从服务器发送 PING*/ 
if (server.cluster->mf_end && 
    nodeIsMaster(myself) && 
    server.cluster->mf_slave == node && 
    node->link) 
{ 
    clusterSendPing(node->link, CLUSTERMSG_TYPE_PING); 
    continue; 
} 
 
/* 后续代码只在节点发送了 PING 命令的情况下执行*/ 
if (node->ping_sent == 0) continue; 
 
/* 计算等待 PONG 回复的时长 */  
delay = now - node->ping_sent; 
/* 等待 PONG 回复的时长超过了限制值，将目标节点标记为 PFAIL （疑似下线)*/ 
if (delay > server.cluster_node_timeout) { 
    /* 超时了，标记为疑似下线 */ 
    if (!(node->flags & (REDIS_NODE_PFAIL|REDIS_NODE_FAIL))) { 
        redisLog(REDIS_DEBUG,"*** NODE %.40s possibly failing", 
            node->name); 
        // 打开疑似下线标记 
        node->flags |= REDIS_NODE_PFAIL; 
        update_state = 1; 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

/* 向指定节点发送一条 MEET 、 PING 或者 PONG 消息 */ 
void clusterSendPing(clusterLink *link, int type) { 
    unsigned char *buf; 
    clusterMsg *hdr; 
    int gossipcount = 0; /* Number of gossip sections added so far. */ 
    int wanted; /* Number of gossip sections we want to append if possible. */ 
    int totlen; /* Total packet length. */ 
    // freshnodes 是用于发送 gossip 信息的计数器 
    // 每次发送一条信息时，程序将 freshnodes 的值减一 
    // 当 freshnodes 的数值小于等于 0 时，程序停止发送 gossip 信息 
    // freshnodes 的数量是节点目前的 nodes 表中的节点数量减去 2  
    // 这里的 2 指两个节点，一个是 myself 节点（也即是发送信息的这个节点） 
    // 另一个是接受 gossip 信息的节点 
    int freshnodes = dictSize(server.cluster->nodes)-2; 
 
     
    /* 计算要携带多少节点的信息，最少3个，最多 1/10 集群总节点数量*/ 
    wanted = floor(dictSize(server.cluster->nodes)/10); 
    if (wanted < 3) wanted = 3; 
    if (wanted > freshnodes) wanted = freshnodes; 
 
    /* .... 省略 totlen 的计算等*/ 
 
    /* 如果发送的信息是 PING ，那么更新最后一次发送 PING 命令的时间戳 */ 
    if (link->node && type == CLUSTERMSG_TYPE_PING) 
        link->node->ping_sent = mstime(); 
    /* 将当前节点的信息（比如名字、地址、端口号、负责处理的槽）记录到消息里面 */ 
    clusterBuildMessageHdr(hdr,type); 
 
    /* Populate the gossip fields */ 
    int maxiterations = wanted*3; 
    /* 每个节点有 freshnodes 次发送 gossip 信息的机会 
       每次向目标节点发送 2 个被选中节点的 gossip 信息（gossipcount 计数） */ 
    while(freshnodes > 0 && gossipcount < wanted && maxiterations--) { 
        /* 从 nodes 字典中随机选出一个节点（被选中节点） */ 
        dictEntry *de = dictGetRandomKey(server.cluster->nodes); 
        clusterNode *this = dictGetVal(de); 
 
        /* 以下节点不能作为被选中节点： 
         * Myself:节点本身。 
         * PFAIL状态的节点 
         * 处于 HANDSHAKE 状态的节点。 
         * 带有 NOADDR 标识的节点 
         * 因为不处理任何 Slot 而被断开连接的节点  
         */ 
        if (this == myself) continue; 
        if (this->flags & CLUSTER_NODE_PFAIL) continue; 
        if (this->flags & (CLUSTER_NODE_HANDSHAKE|CLUSTER_NODE_NOADDR) || 
            (this->link == NULL && this->numslots == 0)) 
        { 
            freshnodes--; /* Tecnically not correct, but saves CPU. */ 
            continue; 
        } 
 
        // 检查被选中节点是否已经在 hdr->data.ping.gossip 数组里面 
        // 如果是的话说明这个节点之前已经被选中了 
        // 不要再选中它（否则就会出现重复） 
        if (clusterNodeIsInGossipSection(hdr,gossipcount,this)) continue; 
 
        /* 这个被选中节点有效，计数器减一 */ 
        clusterSetGossipEntry(hdr,gossipcount,this); 
        freshnodes--; 
        gossipcount++; 
    } 
 
    /* .... 如果有 PFAIL 节点，最后添加 */ 
 
 
    /* 计算信息长度 */ 
    totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData); 
    totlen += (sizeof(clusterMsgDataGossip)*gossipcount); 
    /* 将被选中节点的数量（gossip 信息中包含了多少个节点的信息）记录在 count 属性里面*/ 
    hdr->count = htons(gossipcount); 
    /* 将信息的长度记录到信息里面 */ 
    hdr->totlen = htonl(totlen); 
    /* 发送网络请求 */ 
    clusterSendMessage(link,buf,totlen); 
    zfree(buf); 
} 
 
 
void clusterSetGossipEntry(clusterMsg *hdr, int i, clusterNode *n) { 
    clusterMsgDataGossip *gossip; 
    /* 指向 gossip 信息结构 */ 
    gossip = &(hdr->data.ping.gossip[i]); 
    /* 将被选中节点的名字记录到 gossip 信息 */    
    memcpy(gossip->nodename,n->name,CLUSTER_NAMELEN); 
    /* 将被选中节点的 PING 命令发送时间戳记录到 gossip 信息 */ 
    gossip->ping_sent = htonl(n->ping_sent/1000); 
    /* 将被选中节点的 PONG 命令回复的时间戳记录到 gossip 信息 */ 
    gossip->pong_received = htonl(n->pong_received/1000); 
    /* 将被选中节点的 IP 记录到 gossip 信息 */ 
    memcpy(gossip->ip,n->ip,sizeof(n->ip)); 
    /* 将被选中节点的端口号记录到 gossip 信息 */ 
    gossip->port = htons(n->port); 
    gossip->cport = htons(n->cport); 
    /* 将被选中节点的标识值记录到 gossip 信息 */ 
    gossip->flags = htons(n->flags); 
    gossip->notused1 = 0; 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.

/* 构建消息的 header */ 
void clusterBuildMessageHdr(clusterMsg *hdr, int type) { 
    int totlen = 0; 
    uint64_t offset; 
    clusterNode *master; 
 
    /* 如果当前节点是salve，则master为其主节点，如果当前节点是master节点，则master就是当前节点 */ 
    master = (nodeIsSlave(myself) && myself->slaveof) ? 
              myself->slaveof : myself; 
 
    memset(hdr,0,sizeof(*hdr)); 
    /* 初始化协议版本、标识、及类型， */ 
    hdr->ver = htons(CLUSTER_PROTO_VER); 
    hdr->sig[0] = 'R'; 
    hdr->sig[1] = 'C'; 
    hdr->sig[2] = 'm'; 
    hdr->sig[3] = 'b'; 
    hdr->type = htons(type); 
    /* 消息头设置当前节点id */ 
    memcpy(hdr->sender,myself->name,CLUSTER_NAMELEN); 
 
    /* 消息头设置当前节点ip */ 
    memset(hdr->myip,0,NET_IP_STR_LEN); 
    if (server.cluster_announce_ip) { 
        strncpy(hdr->myip,server.cluster_announce_ip,NET_IP_STR_LEN); 
        hdr->myip[NET_IP_STR_LEN-1] = '\0'; 
    } 
 
    /* 基础端口及集群内节点通信端口 */ 
    int announced_port = server.cluster_announce_port ? 
                         server.cluster_announce_port : server.port; 
    int announced_cport = server.cluster_announce_bus_port ? 
                          server.cluster_announce_bus_port : 
                          (server.port + CLUSTER_PORT_INCR); 
    /* 设置当前节点的槽信息 */ 
    memcpy(hdr->myslots,master->slots,sizeof(hdr->myslots)); 
    memset(hdr->slaveof,0,CLUSTER_NAMELEN); 
    if (myself->slaveof != NULL) 
        memcpy(hdr->slaveof,myself->slaveof->name, CLUSTER_NAMELEN); 
    hdr->port = htons(announced_port); 
    hdr->cport = htons(announced_cport); 
    hdr->flags = htons(myself->flags); 
    hdr->state = server.cluster->state; 
 
    /* 设置 currentEpoch and configEpochs. */ 
    hdr->currentEpoch = htonu64(server.cluster->currentEpoch); 
    hdr->configEpoch = htonu64(master->configEpoch); 
 
    /* 设置复制偏移量 */ 
    if (nodeIsSlave(myself)) 
        offset = replicationGetSlaveOffset(); 
    else 
        offset = server.master_repl_offset; 
    hdr->offset = htonu64(offset); 
 
    /* Set the message flags. */ 
    if (nodeIsMaster(myself) && server.cluster->mf_end) 
        hdr->mflags[0] |= CLUSTERMSG_FLAG0_PAUSED; 
 
    /* 计算并设置消息的总长度 */ 
    if (type == CLUSTERMSG_TYPE_FAIL) { 
        totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData); 
        totlen += sizeof(clusterMsgDataFail); 
    } else if (type == CLUSTERMSG_TYPE_UPDATE) { 
        totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData); 
        totlen += sizeof(clusterMsgDataUpdate); 
    } 
    hdr->totlen = htonl(totlen); 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.