cluster基本结构

clusterNode

clusternode定义如下

typedef struct clusterNode {
    mstime_t ctime;  // 该node创建时间
    char name[CLUSTER_NAMELEN]; // 40位的node名字
     // node 状态标识通过投CLUSTER_NODE 定义。
     // 包括  maser slave self pfail fail handshake noaddr meet migrate_to null_name 这些状态
    int flags;     
    // 本节点最新epoch
    uint64_t configEpoch; 
    // 当前node负责的slot 通过bit表示
    unsigned char slots[CLUSTER_SLOTS/8]; 
    int numslots;   
    int numslaves; 
    struct clusterNode **slaves; 
    // 如果该node为从 则指向master节点
    struct clusterNode *slaveof; 
    mstime_t ping_sent;      /* Unix time we sent latest ping */
    mstime_t pong_received;  /* Unix time we received the pong */
    mstime_t fail_time;      /* Unix time when FAIL flag was set */
    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;      /* Last known repl offset for this node. */
    char ip[NET_IP_STR_LEN];  /* Latest known IP address of this node */
    int port;                   /* Latest known port of this node */
    
    clusterLink *link;          
    // 将该节点标记为失败的node list
    // 节点收到gossip消息后，如果gossip里标记该节点为pfail则加入改list
    // 比如：节点a向b发送gossip，消息包含了 c 节点且出于pfail，则a将被加入c的link。
    list *fail_reports;         
} clusterNode;

clusterMsgData 节点间消息协议

clusterMsgData定义了节点间通讯的数据结构
包含了 ping fail publish update四种类型
ping消息定义为

 struct {
       /* Array of N clusterMsgDataGossip structures */
       clusterMsgDataGossip gossip[1];
   } ping;

节点间通过ping保持心跳以及进行gossip集群状态同步，每次心跳时，节点会带上多个clusterMsgDataGossip消息体，经过多次心跳，该节点包含的其他节点信息将
同步到其他节点。

clusterState集群状态

定义了完整的集群信息

struct clusterState{
   // 集群最新的epoch，为64位的自增序列 
   uint64_t currentEpoch;
   // 包含的所有节点信息
   dict *nodes; 
   // 每个slot所属于的节点，包括处于migrating和importinng状态的slot
   clusterNode *migrating_slots_to[CLUSTER_SLOTS];
   clusterNode *importing_slots_from[CLUSTER_SLOTS];
   clusterNode *slots[CLUSTER_SLOTS]; 
   // 当前节点所包含的key 用于在getkeysinslot的时候返回key信息
   zskiplist *slots_to_keys;
   ...   
}

redis启动，判断是否允许cluster模式，如果允许，则调用clusterInit进行cluster信息的初始化。clusterState被初始化为初始值。
在后续节点meet及ping过程逐步更新clusterState信息。

Gossip实现

Send Ping

节点创建成功后，节点会向已知的其他节点发送ping消息保持心跳，ping消息体同时会携带已知节点的信息，
并通过gossip同步到集群的其他节点。

Ping节点选择

• ping周期

node的ping由clusterCron负责调用，服务启动时，在serverCron内部会注册
clusterCron，该函数没秒执行10次，在clusterCron内部，维护着static变量iteration记录该函数被执行的次数
通过if (!(iteration % 10)){}的判断，使得node每秒发送一次心跳。

• ping节点选择
  ping节点选择的代码逻辑如下

void clusterCron(void)
{
    // ...
    // 如果没有设置handshake超时，则默认超时未1s
    handshake_timeout = server.cluster_node_timeout;
    if (handshake_timeout < 1000)
        handshake_timeout = 1000;

    // 遍历nodes列表
    while ((de = dictNext(di)) != NULL)
    {
        //  删除handshake超时的节点
        if (nodeInHandshake(node) && now - node->ctime > handshake_timeout)
        {
            clusterDelNode(node);
            continue;
        }
        // 如果该节点的link为空，则为该节点新建连接，并且初始化ping初始时间
        if (node->link == NULL)
        {
        // 如果该节点处于meet状态，则直接发送meet让节点加入集群
        // 否则发送向该节点发送ping
        clusterSendPing(link, node->flags & CLUSTER_NODE_MEET ? CLUSTERMSG_TYPE_MEET : CLUSTERMSG_TYPE_PING);
        }
        // 函数每被调动10次，则发送一次ping，因此ping间隔为1s
        if (!(iteration % 10))
        {
        int j;
        for (j = 0; j < 5; j++)
        {
            // 随机选取节点并过滤link为空的以及self
            de = dictGetRandomKey(server.cluster->nodes);
            clusterNode *this = dictGetVal(de);
            if (this->link == NULL || this->ping_sent != 0)
                continue;
            if (this->flags & (CLUSTER_NODE_MYSELF | CLUSTER_NODE_HANDSHAKE))
                continue;
            
            // 挑选距离上次pong间隔最久的节点
            // redis会尽量选择距离上次ping间隔最久的节点，
            // 以此防止随机不均匀导致某些节点一直收不到ping
            if (min_pong_node == NULL || min_pong > this->pong_received)
            {
                min_pong_node = this;
                min_pong = this->pong_received;
            }
        }
    }
}

redis挑选node发送ping的时候，会优先给新加入的节点发送ping，其实再选择最久没被更新的节点，
通过对旧节点选择的加权，尽可能地保证了集群最新状态的一致。

Gossip携带节点选择

每次ping请求，node会从已知的nodes里面随机选取n个节点（n=1/10*len(nodes)&& n>=3）,一段时间后，该节点已知的nodes将被同步到集群的其他节点，
集群状态信息达成最终一致。具体实现代码如下（只列出部分代码，完整代码见cluster.c/clusterSendPing）

void clusterSendPing(clusterLink *link, int type)
{
   // 选取1/10 的节点数并且要求大于3.
   // 1/10是个魔数，为啥是1/10在源码里有解释
   int freshnodes = dictSize(server.cluster->nodes) - 2;   
    wanted = floor(dictSize(server.cluster->nodes) / 10);
   if (wanted < 3)
       wanted = 3;
   if (wanted > freshnodes)
       wanted = freshnodes;
   while (freshnodes > 0 && gossipcount < wanted && maxiterations--)
   {
   // 通过随机函数随机选择一个节点，保证所有节点尽可能被同步到整个集群
   dictEntry *de = dictGetRandomKey(server.cluster->nodes);
   clusterNode *this = dictGetVal(de);
   // 为了保证失败的节点尽可能快地同步到集群其他节点，
   // 优先选取处于pfail以及fail状态的节点
   if (maxiterations > wanted * 2 &&
   !(this->flags & (CLUSTER_NODE_PFAIL | CLUSTER_NODE_FAIL)))
   continue;
   }
   // 如果被选中的节点处于
   // 1.handshake 并且noaddr状态
   // 2.其他节点没有包含该节点的信息，并且该节点没有拥有slot
   // 则跳过该节点并且将可用的节点数减1，以较少gossip数据同步的开销
   if (this->flags & (CLUSTER_NODE_HANDSHAKE | CLUSTER_NODE_NOADDR) ||
   (this->link == NULL && this->numslots == 0))
   {
   freshnodes--; /* Tecnically not correct, but saves CPU. */
   continue;
   }
}

通过随机选取合适数量的节点，以及对节点状态的过滤，保证了尽可能快的达成最终一致性的
同时，减少gossip的网络开销。

Receive Ping

cluster监听cluster 端口，并通过clusterAcceptHandler接受集群节点发起的连接请求，
通过aeCreateFileEvent将clusterReadHandler注册进事件回调里面，读取node发送的数据包。
clusterReadHandler读取到完整的数据包后，调用clusterProcessPacket处理包请求。
clusterProcessPacket包含收到数据包后完整的处理逻辑。

int clusterProcessPacket(clusterLink *link)
{
   // 判断是否为ping请求并校验数据包长度
   if (type == CLUSTERMSG_TYPE_PING || type == CLUSTERMSG_TYPE_PONG ||
       type == CLUSTERMSG_TYPE_MEET)
   {
       uint16_t count = ntohs(hdr->count);
       uint32_t explen; /* expected length of this packet */

       explen = sizeof(clusterMsg) - sizeof(union clusterMsgData);
       explen += (sizeof(clusterMsgDataGossip) * count);
       if (totlen != explen)
           return 1;
   }   
   // ...
   
   // 是否为已知节点
   sender = clusterLookupNode(hdr->sender);
   if (sender && !nodeInHandshake(sender))
   {
       //  比较epoch并更新为最大的epoch
       if (senderCurrentEpoch > server.cluster->currentEpoch)
           server.cluster->currentEpoch = senderCurrentEpoch;
       /* Update the sender configEpoch if it is publishing a newer one. */
       if (senderConfigEpoch > sender->configEpoch)
       {
           sender->configEpoch = senderConfigEpoch;
           clusterDoBeforeSleep(CLUSTER_TODO_SAVE_CONFIG |
                                CLUSTER_TODO_FSYNC_CONFIG);
       }
   }
   // 回复pong数据包
   clusterSendPing(link, CLUSTERMSG_TYPE_PONG);

   // 获取gossip消息并处理gossip请求
   if (sender)
   clusterProcessGossipSection(hdr, link);
}

clusterProcessGossipSection 读取携带的gossip node内容，并判断这些node是否failover

void clusterProcessGossipSection(clusterMsg *hdr, clusterLink *link)
{
    // ...


    if (flags & (CLUSTER_NODE_FAIL | CLUSTER_NODE_PFAIL))
{
    if (clusterNodeAddFailureReport(node, sender))
    {
        serverLog(LL_VERBOSE,
                  "Node %.40s reported node %.40s as not reachable.",
                  sender->name, node->name);
    }
    markNodeAsFailingIfNeeded(node);
}
else
{
    // 如果该node并非出于fail状态，则从fail link里删除该node
    if (clusterNodeDelFailureReport(node, sender))
    {
        serverLog(LL_VERBOSE,
                  "Node %.40s reported node %.40s is back online.",
                  sender->name, node->name);
    }
}
}

int clusterNodeDelFailureReport(clusterNode *node, clusterNode *sender)
{
    while ((ln = listNext(&li)) != NULL)
    {
        fr = ln->value;
        if (fr->node == sender)
            break;
    }
    if (!ln)
    return 0;
    // 如果之前被标记为失败，则从失败list里删除
    listDelNode(l, ln);
}

cluster会根据收到的gossip包里的msgdata来更新集群的状态信息，包括epoch，以及其余节点的状态。
如果node被标记为pfail或fail，则被加入fail_reports，当fail_reports长度超过半数节点数量时，该节点及被标记为failover。