void slaveofCommand(redisClient *c) { //想让一个节点A通过slaveof成为另一个节点B的slave，则必须是B在单机模式下

    // .......

        /* Check if we are already attached to the specified slave */

        // 检查输入的 host 和 port 是否服务器目前的主服务器

        // 如果是的话，向客户端返回 +OK ，不做其他动作

        //说明之前已经slaveof ip port过，这次又执行该命令，说明之前已经连接建立成功过了

        if (server.masterhost && !strcasecmp(server.masterhost,c->argv[]->ptr)

            && server.masterport == port) {

            redisLog(REDIS_NOTICE,"SLAVE OF would result into synchronization with the master we are already connected with. No operation performed.");

            addReplySds(c,sdsnew("+OK Already connected to specified master\r\n"));//向从服务器的redis-cli客户端发送该命令

            return;

        }

        //第一次执行slaveof ip port,新的ip或者port

        /* There was no previous master or the user specified a different one,

         * we can continue. */

        // 没有前任主服务器，或者客户端指定了新的主服务器

        // 开始执行复制操作

        replicationSetMaster(c->argv[]->ptr, port);

        redisLog(REDIS_NOTICE,"SLAVE OF %s:%d enabled (user request)",

            server.masterhost, server.masterport);

    }

    addReply(c,shared.ok);

}

// 以非阻塞方式连接主服务器

int connectWithMaster(void) {

    int fd;

    // 连接主服务器

    fd = anetTcpNonBlockConnect(NULL,server.masterhost,server.masterport);

    if (fd == -) {

        redisLog(REDIS_WARNING,"Unable to connect to MASTER: %s",  strerror(errno));

        return REDIS_ERR;

    }

    // 监听主服务器 fd 的读和写事件，并绑定文件事件处理器

    if (aeCreateFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE,syncWithMaster,NULL) ==

            AE_ERR)

    {

        close(fd);

        redisLog(REDIS_WARNING,"Can't create readable event for SYNC");

        return REDIS_ERR;

    }

    // 初始化统计变量

    server.repl_transfer_lastio = server.unixtime;

    server.repl_transfer_s = fd;

    // 将状态改为已连接

    server.repl_state = REDIS_REPL_CONNECTING;

    return REDIS_OK;

}

int slaveTryPartialResynchronization(int fd) {

    char *psync_runid;

    char psync_offset[];

    sds reply;

    server.repl_master_initial_offset = -;

//例如从服务器之前和主服务器连接上，并同步了数据，中途端了，则连接断了后会在replicationCacheMaster把server.cached_master = server.master;

//表示之前有连接到过服务器

    if (server.cached_master) {

        // 缓存存在，尝试部分重同步

        // 命令为 "PSYNC <master_run_id> <repl_offset>"

        psync_runid = server.cached_master->replrunid;

        snprintf(psync_offset,sizeof(psync_offset),"%lld", server.cached_master->reploff+);

        redisLog(REDIS_NOTICE,"Trying a partial resynchronization (request %s:%s).", psync_runid, psync_offset);

    } else {

        // 缓存不存在

        // 发送 "PSYNC ? -1" ，要求完整重同步

        redisLog(REDIS_NOTICE,"Partial resynchronization not possible (no cached master)");

        psync_runid = "?";

        memcpy(psync_offset,"-1",); //

    }

    /* Issue the PSYNC command */

    // 向主服务器发送 PSYNC 命令

    reply = sendSynchronousCommand(fd,"PSYNC",psync_runid,psync_offset,NULL);

    // 接收到 FULLRESYNC ，进行 full-resync

    if (!strncmp(reply,"+FULLRESYNC",)) {

        char *runid = NULL, *offset = NULL;

        /* FULL RESYNC, parse the reply in order to extract the run id

         * and the replication offset. */

        // 分析并记录主服务器的 run id

        runid = strchr(reply,' ');

        if (runid) {

            runid++;

            offset = strchr(runid,' ');

            if (offset) offset++;

        }

        // 检查 run id 的合法性

        if (!runid || !offset || (offset-runid-) != REDIS_RUN_ID_SIZE) {

            redisLog(REDIS_WARNING, "Master replied with wrong +FULLRESYNC syntax.");

            // 主服务器支持 PSYNC ，但是却发来了异常的 run id

            // 只好将 run id 设为 0 ，让下次 PSYNC 时失败

            memset(server.repl_master_runid,,REDIS_RUN_ID_SIZE+);

        } else {

            // 保存 run id

            memcpy(server.repl_master_runid, runid, offset-runid-);

            server.repl_master_runid[REDIS_RUN_ID_SIZE] = '\0';

            // 以及 initial offset

            server.repl_master_initial_offset = strtoll(offset,NULL,);

            // 打印日志，这是一个 FULL resync

            redisLog(REDIS_NOTICE,"Full resync from master: %s:%lld",

                server.repl_master_runid,

                server.repl_master_initial_offset);

        }

       /* We are going to full resync, discard the cached master structure. */

        // 要开始完整重同步，缓存中的 master 已经没用了，清除它

        replicationDiscardCachedMaster();

        sdsfree(reply);

        // 返回状态

        return PSYNC_FULLRESYNC;

    }

    // 接收到 CONTINUE ，进行 partial resync

    if (!strncmp(reply,"+CONTINUE",)) {

        /* Partial resync was accepted, set the replication state accordingly */

        redisLog(REDIS_NOTICE, "Successful partial resynchronization with master.");

        sdsfree(reply);

        // 将缓存中的 master 设为当前 master

        replicationResurrectCachedMaster(fd);

        // 返回状态

        return PSYNC_CONTINUE;

    }

    // 接收到错误？

    if (strncmp(reply,"-ERR",)) {

        /* If it's not an error, log the unexpected event. */

        redisLog(REDIS_WARNING,

            "Unexpected reply to PSYNC from master: %s", reply);

    } else {

        redisLog(REDIS_NOTICE,

            "Master does not support PSYNC or is in "

            "error state (reply: %s)", reply);

    }

    //如果从服务器发送PSYNC上去后或者其他原因返回错误，然后在serverCron中重新建立连接再次从新走一次PSYNC或者SYNC流程

    sdsfree(reply);

    replicationDiscardCachedMaster();

    // 主服务器不支持 PSYNC

    return PSYNC_NOT_SUPPORTED;

}

REPLCONF ACK <replication_offset>