主从同步
主从同步流程图
主从复制流程图
状态常量
/* 当前服务器作为slave的复制状态，保存在server.repl_state用于记住下一步该干什么 */
#define REPL_STATE_NONE 0 /* 复制能力未激活 */
#define REPL_STATE_CONNECT 1 /* 未连接到master */
#define REPL_STATE_CONNECTING 2 /* 正在发起到master的连接，发送PING命令 */
/* 握手状态，必须有序 */
#define REPL_STATE_RECEIVE_PONG 3 /* 已发送PING，等待PING命令的响应-PONG */
#define REPL_STATE_SEND_AUTH 4 /* 待发送AUTH命令 */
#define REPL_STATE_RECEIVE_AUTH 5 /* 已发送AUTH，等待响应 */
#define REPL_STATE_SEND_PORT 6 /* 待发送REPLCONF-监听端口信息 */
#define REPL_STATE_RECEIVE_PORT 7 /* 已发送REPLCONF-监听端口信息，等待响应 */
#define REPL_STATE_SEND_IP 8 /* 待发送REPLCONF-ip-address信息 */
#define REPL_STATE_RECEIVE_IP 9 /* 已发送REPLCONF-ip-address信息，等待响应 */
#define REPL_STATE_SEND_CAPA 10 /* 待发送REPLCONF capa能力信息*/
#define REPL_STATE_RECEIVE_CAPA 11 /* 待发送REPLCONF capa能力信息，等待响应 */
#define REPL_STATE_SEND_PSYNC 12 /* 待发送PSYNC命令 */
#define REPL_STATE_RECEIVE_PSYNC 13 /* 待发送PSYNC命令，等待响应 */
/* --- 握手完成，握手结束后的状态 --- */
#define REPL_STATE_TRANSFER 14 /* 正在从master接受rdb文件 */
#define REPL_STATE_CONNECTED 15 /* 已经连接上master，正在进行命令传播 */
/* 从master角度看待的slave状态，将会放置在client->replstate中。
* 当是SEND_BULK和ONLINE状态时，说明slave将会接收新的更新到它的output队列。
* 当是WAIT_BGSAVE状态时，说明客户端正在等待RDB文件生成。 */
#define SLAVE_STATE_WAIT_BGSAVE_START 6 /* 需要生产一个RDB文件 */
#define SLAVE_STATE_WAIT_BGSAVE_END 7 /* 正在等待RDB文件生成结束 */
#define SLAVE_STATE_SEND_BULK 8 /* 正在发送RDB到slave */
#define SLAVE_STATE_ONLINE 9 /* RDB传输完成，发送后续的命令传播 */
启动同步
客户端向从服务器发送slavef {ip:port}命令
/* REPLCONF <option> <value> <option> <value> ...
* 这个命令用于在SYNC命令之前配置复制进程。
* 当前这个命令用于和master通信，
* 1) 用来告诉master端口号等相关信息，使得master的info输出中可以正确的输出相关信息。
* 2) 也用来告诉master复制过程中的相关配置信息如CAPA来让master决策。
* */
void replconfCommand(client *c) {
int j;
if ((c->argc % 2) == 0) {
/* Number of arguments must be odd to make sure that every
* option has a corresponding value. */
addReply(c,shared.syntaxerr);
return;
}
/* Process every option-value pair. */
for (j = 1; j < c->argc; j+=2) {
if (!strcasecmp(c->argv[j]->ptr,"listening-port")) {
long port;
if ((getLongFromObjectOrReply(c,c->argv[j+1],
&port,NULL) != C_OK))
return;
c->slave_listening_port = port;
} else if (!strcasecmp(c->argv[j]->ptr,"ip-address")) {
sds ip = c->argv[j+1]->ptr;
if (sdslen(ip) < sizeof(c->slave_ip)) {
memcpy(c->slave_ip,ip,sdslen(ip)+1);
} else {
addReplyErrorFormat(c,"REPLCONF ip-address provided by "
"replica instance is too long: %zd bytes", sdslen(ip));
return;
}
} else if (!strcasecmp(c->argv[j]->ptr,"capa")) {
/* Ignore capabilities not understood by this master. */
if (!strcasecmp(c->argv[j+1]->ptr,"eof"))
c->slave_capa |= SLAVE_CAPA_EOF;
else if (!strcasecmp(c->argv[j+1]->ptr,"psync2"))
c->slave_capa |= SLAVE_CAPA_PSYNC2;
} else if (!strcasecmp(c->argv[j]->ptr,"ack")) {
/* REPLCONF ACK is used by slave to inform the master the amount
* of replication stream that it processed so far. It is an
* internal only command that normal clients should never use. */
long long offset;
if (!(c->flags & CLIENT_SLAVE)) return;
if ((getLongLongFromObject(c->argv[j+1], &offset) != C_OK))
return;
if (offset > c->repl_ack_off)
c->repl_ack_off = offset;
c->repl_ack_time = server.unixtime;
/* If this was a diskless replication, we need to really put
* the slave online when the first ACK is received (which
* confirms slave is online and ready to get more data). */
if (c->repl_put_online_on_ack && c->replstate == SLAVE_STATE_ONLINE)
putSlaveOnline(c);
/* Note: this command does not reply anything! */
return;
} else if (!strcasecmp(c->argv[j]->ptr,"getack")) {
/* REPLCONF GETACK is used in order to request an ACK ASAP
* to the slave. */
if (server.masterhost && server.master) replicationSendAck();
return;
} else {
addReplyErrorFormat(c,"Unrecognized REPLCONF option: %s",
(char*)c->argv[j]->ptr);
return;
}
}
addReply(c,shared.ok);
}
配置同步信息
从服务器在serverCron事件函数中向主服务器发送replconf信息
/* 复制核心函数，每秒执行一次，在serverCron中调用 */
void replicationCron(void) {
static long long replication_cron_loops = 0;
/* 当前实例作为slave，正准备握手或者正在握手：[2,13]，超时，则取消当前握手，重连 */
if (server.masterhost &&
(server.repl_state == REPL_STATE_CONNECTING ||
slaveIsInHandshakeState()) &&
(time(NULL)-server.repl_transfer_lastio) > server.repl_timeout)
{
serverLog(LL_WARNING,"Timeout connecting to the MASTER...");
cancelReplicationHandshake();
}
/* 当前实例作为slave，正在接受RDB: [14]，如果超时，取消当前握手，重连 */
if (server.masterhost && server.repl_state == REPL_STATE_TRANSFER &&
(time(NULL)-server.repl_transfer_lastio) > server.repl_timeout)
{
serverLog(LL_WARNING,"Timeout receiving bulk data from MASTER... If the problem persists try to set the 'repl-timeout' parameter in redis.conf to a larger value.");
cancelReplicationHandshake();
}
/* 当前实例作为slave, 正在进行正常的复制，但是出现了超时，则释放master客户端，重连 */
if (server.masterhost && server.repl_state == REPL_STATE_CONNECTED &&
(time(NULL)-server.master->lastinteraction) > server.repl_timeout)
{
serverLog(LL_WARNING,"MASTER timeout: no data nor PING received...");
freeClient(server.master);
}
/* 当前实例作为slave, 需要连接一个master */
if (server.repl_state == REPL_STATE_CONNECT) {
serverLog(LL_NOTICE,"Connecting to MASTER %s:%d",
server.masterhost, server.masterport);
if (connectWithMaster() == C_OK) {
serverLog(LL_NOTICE,"MASTER <-> REPLICA sync started");
}
}
/* 当前实例作为slave, 并且master可以理解PSYNC，发送REPLCONf ACK给master，每秒1次，作用：
* 1) slave->master的心跳
* 2) 同步给master当前slave的复制偏移量
* 注意：如果master不支持PSYNC和复制偏移量。
* */
if (server.masterhost && server.master &&
!(server.master->flags & CLIENT_PRE_PSYNC))
replicationSendAck();
/* 如果我们有slaves，不断地PING它们。
* 这样slaves可以显式的实现一个到master的超时，并且能在TCP不可用时，监测到断连。 */
listIter li;
listNode *ln;
robj *ping_argv[1];
/* 当时实例作为master向slaves发送PING，每repl_ping_slave_period=10s一次
* 注意：这个功能实际上是通过写入到复制积压缓冲区中实现的，而不是直接发送给slave。
* 这意味着，在复制同步期间，所有的PING将会在slave同步期间不会真正发送给slave，
* 而是在slave的复制状态变更为ONLINE时才发送。
* */
if ((replication_cron_loops % server.repl_ping_slave_period) == 0 &&
listLength(server.slaves))
{
ping_argv[0] = createStringObject("PING",4);
replicationFeedSlaves(server.slaves, server.slaveseldb,
ping_argv, 1);
decrRefCount(ping_argv[0]);
}
/* 对于presync阶段的slaves，它们正在等待RDB文件，发送一个空行。
* 对于presync阶段的slaves，它们正在等待RDB文件，而RDB生成的时间可能很长，我们需要让slave
* 能够知道这段时间内到master的连接正常，这是必要的。
* 注意：在线状态时master->slave的心跳是通过复制流中的PING实现的，而sub-slaves间的复制流是
* 是从顶级master继承的，此时还在presync阶段，没有复制流传输，所以PING心跳无法用于presync阶段。
* 这个presync阶段的newline的心跳机制不会影响复制流偏移量。
* 这个newline将会被slave忽略，但是会刷新slave和master的最后交互时间来防止超时，我们每秒发送一次。
* */
listRewind(server.slaves,&li);
while((ln = listNext(&li))) {
client *slave = ln->value;
int is_presync =
(slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START ||
(slave->replstate == SLAVE_STATE_WAIT_BGSAVE_END &&
server.rdb_child_type != RDB_CHILD_TYPE_SOCKET));
if (is_presync) {
if (write(slave->fd, "\n", 1) == -1) {
/* 不必关心socket errors，这只是用于RDB生成期间的心跳 */
}
}
}
...
}
/* 连接上master
* 1. 创建socket，连接上master
* 2. 注册该socket的读写时间为syncWithMaster函数
* 3. 修改复制相关状态
* */
int connectWithMaster(void) {
int fd;
fd = anetTcpNonBlockBestEffortBindConnect(NULL,
server.masterhost,server.masterport,NET_FIRST_BIND_ADDR);
if (fd == -1) {
serverLog(LL_WARNING,"Unable to connect to MASTER: %s",
strerror(errno));
return C_ERR;
}
if (aeCreateFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE,syncWithMaster,NULL) ==
AE_ERR)
{
close(fd);
serverLog(LL_WARNING,"Can't create readable event for SYNC");
return C_ERR;
}
server.repl_transfer_lastio = server.unixtime;
server.repl_transfer_s = fd;
server.repl_state = REPL_STATE_CONNECTING;
return C_OK;
}
/* 这个函数将会在一个非阻塞的客户端连接到master后触发 */
void syncWithMaster(aeEventLoop *el, int fd, void *privdata, int mask) {
char tmpfile[256], *err = NULL;
int dfd = -1, maxtries = 5;
int sockerr = 0, psync_result;
socklen_t errlen = sizeof(sockerr);
UNUSED(el);
UNUSED(privdata);
UNUSED(mask);
/* 当用户将服务器切换到master后，关闭socket */
if (server.repl_state == REPL_STATE_NONE) {
close(fd);
return;
}
/* 一个非阻塞的连接可能会触发error，如果出现了错误，我们跳转到error */
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &sockerr, &errlen) == -1)
sockerr = errno;
if (sockerr) {
serverLog(LL_WARNING,"Error condition on socket for SYNC: %s",
strerror(sockerr));
goto error;
}
/* 发送一个PING命令检查master是否有能力回复 */
if (server.repl_state == REPL_STATE_CONNECTING) {
serverLog(LL_NOTICE,"Non blocking connect for SYNC fired the event.");
// 删除写事件，我们只关注PONG回复，切换状态
aeDeleteFileEvent(server.el,fd,AE_WRITABLE);
server.repl_state = REPL_STATE_RECEIVE_PONG;
// 发送PING，如果出现了错误，那么就跳转到write_error
err = sendSynchronousCommand(SYNC_CMD_WRITE,fd,"PING",NULL);
if (err) goto write_error;
return;
}
/* Receive the PONG command. */
if (server.repl_state == REPL_STATE_RECEIVE_PONG) {
err = sendSynchronousCommand(SYNC_CMD_READ,fd,NULL);
/* +PONG 正常响应
* --NOAUTH 需要进行验证
* -ERR operation not permitted 老版本，需要进行验证
* */
if (err[0] != '+' &&
strncmp(err,"-NOAUTH",7) != 0 &&
strncmp(err,"-ERR operation not permitted",28) != 0)
{
serverLog(LL_WARNING,"Error reply to PING from master: '%s'",err);
sdsfree(err);
goto error;
} else {
serverLog(LL_NOTICE,
"Master replied to PING, replication can continue...");
}
sdsfree(err);
// 切换到待发送AUTH状态
server.repl_state = REPL_STATE_SEND_AUTH;
}
/* 如果master需要，我们就进行验证，否则我们切换到待发送端口状态 */
if (server.repl_state == REPL_STATE_SEND_AUTH) {
if (server.masterauth) {
err = sendSynchronousCommand(SYNC_CMD_WRITE,fd,"AUTH",server.masterauth,NULL);
if (err) goto write_error;
server.repl_state = REPL_STATE_RECEIVE_AUTH;
return;
} else {
server.repl_state = REPL_STATE_SEND_PORT;
}
}
/* 接收AUTH回复，如果通过，切换到待发送端口状态 */
if (server.repl_state == REPL_STATE_RECEIVE_AUTH) {
err = sendSynchronousCommand(SYNC_CMD_READ,fd,NULL);
if (err[0] == '-') {
serverLog(LL_WARNING,"Unable to AUTH to MASTER: %s",err);
sdsfree(err);
goto error;
}
sdsfree(err);
server.repl_state = REPL_STATE_SEND_PORT;
}
/* 如果配置了server.slave_announce_port，则使用slave_announce_port，否则使用server.port */
if (server.repl_state == REPL_STATE_SEND_PORT) {
sds port = sdsfromlonglong(server.slave_announce_port ?
server.slave_announce_port : server.port);
err = sendSynchronousCommand(SYNC_CMD_WRITE,fd,"REPLCONF",
"listening-port",port, NULL);
sdsfree(port);
if (err) goto write_error;
sdsfree(err);
server.repl_state = REPL_STATE_RECEIVE_PORT;
return;
}
/* 接收 REPLCONF listeniing-port [port] 的响应 */
if (server.repl_state == REPL_STATE_RECEIVE_PORT) {
err = sendSynchronousCommand(SYNC_CMD_READ,fd,NULL);
/*忽略，不是所有redis版本都支持 REPLCONF listening-port. */
if (err[0] == '-') {
serverLog(LL_NOTICE,"(Non critical) Master does not understand "
"REPLCONF listening-port: %s", err);
}
sdsfree(err);
server.repl_state = REPL_STATE_SEND_IP;
}
/* 如果没有配置slave-announce-ip，则跳过，master可以直接从socket中知道ip */
if (server.repl_state == REPL_STATE_SEND_IP &&
server.slave_announce_ip == NULL)
{
server.repl_state = REPL_STATE_SEND_CAPA;
}
/* 发送 REPLCONF ip-address [ip] */
/* 设置slave的ip，这样对于端口转发和NAT的场景，master的INFO命令将能够列出正确的slave的ip */
if (server.repl_state == REPL_STATE_SEND_IP) {
err = sendSynchronousCommand(SYNC_CMD_WRITE,fd,"REPLCONF",
"ip-address",server.slave_announce_ip, NULL);
if (err) goto write_error;
sdsfree(err);
server.repl_state = REPL_STATE_RECEIVE_IP;
return;
}
/* 接收 REPLCONF ip-address [ip] 的响应 */
if (server.repl_state == REPL_STATE_RECEIVE_IP) {
err = sendSynchronousCommand(SYNC_CMD_READ,fd,NULL);
/* 忽略，不是所有redis版本都支持 REPLCONF ip-address */
if (err[0] == '-') {
serverLog(LL_NOTICE,"(Non critical) Master does not understand "
"REPLCONF ip-address: %s", err);
}
sdsfree(err);
server.repl_state = REPL_STATE_SEND_CAPA;
}
/* 宣告我们的slave支持的能力
* EOF：支持EOF格式的RDB无盘复制
* PSYNC2：支持PSYNC v2，所以能够理解 +CONTINUE <new repl ID>
*
* master将会忽略它无法理解的能力
* */
if (server.repl_state == REPL_STATE_SEND_CAPA) {
err = sendSynchronousCommand(SYNC_CMD_WRITE,fd,"REPLCONF",
"capa","eof","capa","psync2",NULL);
if (err) goto write_error;
sdsfree(err);
server.repl_state = REPL_STATE_RECEIVE_CAPA;
return;
}
/* 接收CAPA回复 */
if (server.repl_state == REPL_STATE_RECEIVE_CAPA) {
err = sendSynchronousCommand(SYNC_CMD_READ,fd,NULL);
/* 忽略，不是所有redis版本都支持 REPLCONF capa. */
if (err[0] == '-') {
serverLog(LL_NOTICE,"(Non critical) Master does not understand "
"REPLCONF capa: %s", err);
}
sdsfree(err);
server.repl_state = REPL_STATE_SEND_PSYNC;
}
/* 尝试执行一个部分重同步。
* 如果没有cached master，我们将会使用PSYNC来开启一个完整重同步，这样我们可以
* 获得master runid和全局偏移量，我们将会在下次重连时开启一个部分重同步。 */
if (server.repl_state == REPL_STATE_SEND_PSYNC) {
if (slaveTryPartialResynchronization(fd,0) == PSYNC_WRITE_ERROR) {
err = sdsnew("Write error sending the PSYNC command.");
goto write_error;
}
server.repl_state = REPL_STATE_RECEIVE_PSYNC;
return;
}
/* 如果我们到达了这里，我们应该处于REPL_STATE_RECEIVE_PSYNC状态 */
if (server.repl_state != REPL_STATE_RECEIVE_PSYNC) {
serverLog(LL_WARNING,"syncWithMaster(): state machine error, "
"state should be RECEIVE_PSYNC but is %d",
server.repl_state);
goto error;
}
/* 获取PSYNC的响应 */
psync_result = slaveTryPartialResynchronization(fd,1);
if (psync_result == PSYNC_WAIT_REPLY) return; /* 暂时没有数据，继续获取 */
/* master暂时无法进行复制，我们之后需要从零开始复制，所以我们转到err。
* 当master正在loading或者master未连接到它的master等情况时发生。 */
if (psync_result == PSYNC_TRY_LATER) goto error;
/* 注意：如果PSYNC没有返回WAIT_REPLY，它会自己处理卸载可读事件处理器 */
if (psync_result == PSYNC_CONTINUE) {
serverLog(LL_NOTICE, "MASTER <-> REPLICA sync: Master accepted a Partial Resynchronization.");
return;
}
/* PSYNC失败或者不支持：如果我们有sub-slaves，我们希望它们和我们重新进行同步。
* 因为master可能会传输给我们一个全新的数据集，我们不能增量传播给slaves。 */
disconnectSlaves(); /* 强制我们的slaves重新同步我们 */
freeReplicationBacklog(); /* 不允许我们的slaves进行PSYNC */
/* 不支持PSYNC命令，我们将会在后面用SYNC重试 */
if (psync_result == PSYNC_NOT_SUPPORTED) {
serverLog(LL_NOTICE,"Retrying with SYNC...");
if (syncWrite(fd,"SYNC\r\n",6,server.repl_syncio_timeout*1000) == -1) {
serverLog(LL_WARNING,"I/O error writing to MASTER: %s",
strerror(errno));
goto error;
}
}
/* 准备一个合适的临时文件来接收RDB数据 */
while(maxtries--) {
snprintf(tmpfile,256,
"temp-%d.%ld.rdb",(int)server.unixtime,(long int)getpid());
dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
if (dfd != -1) break;
sleep(1);
}
if (dfd == -1) {
serverLog(LL_WARNING,"Opening the temp file needed for MASTER <-> REPLICA synchronization: %s",strerror(errno));
goto error;
}
/* 设置非阻塞下载RDB文件的可读事件处理器 */
if (aeCreateFileEvent(server.el,fd, AE_READABLE,readSyncBulkPayload,NULL)
== AE_ERR)
{
serverLog(LL_WARNING,
"Can't create readable event for SYNC: %s (fd=%d)",
strerror(errno),fd);
goto error;
}
// 初始化相关状态
server.repl_state = REPL_STATE_TRANSFER;
server.repl_transfer_size = -1;
server.repl_transfer_read = 0;
server.repl_transfer_last_fsync_off = 0;
server.repl_transfer_fd = dfd;
server.repl_transfer_lastio = server.unixtime;
server.repl_transfer_tmpfile = zstrdup(tmpfile);
return;
error: // 如果出现了任何错误，我们将会重置关闭socket，删除ae注册时间，并重置复制状态以重连
aeDeleteFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE);
if (dfd != -1) close(dfd);
close(fd);
server.repl_transfer_s = -1;
server.repl_state = REPL_STATE_CONNECT;
return;
write_error: // 处理同步发送命令的错误
serverLog(LL_WARNING,"Sending command to master in replication handshake: %s", err);
sdsfree(err);
goto error;
}
主服务器处理从服务器发来的replconf命令
/* REPLCONF <option> <value> <option> <value> ...
* 这个命令用于在SYNC命令之前配置复制进程。
* 当前这个命令用于和master通信，
* 1) 用来告诉master端口号等相关信息，使得master的info输出中可以正确的输出相关信息。
* 2) 也用来告诉master复制过程中的相关配置信息如CAPA来让master决策。
* */
void replconfCommand(client *c) {
int j;
if ((c->argc % 2) == 0) {
/* Number of arguments must be odd to make sure that every
* option has a corresponding value. */
addReply(c,shared.syntaxerr);
return;
}
/* Process every option-value pair. */
for (j = 1; j < c->argc; j+=2) {
if (!strcasecmp(c->argv[j]->ptr,"listening-port")) {
long port;
if ((getLongFromObjectOrReply(c,c->argv[j+1],
&port,NULL) != C_OK))
return;
c->slave_listening_port = port;
} else if (!strcasecmp(c->argv[j]->ptr,"ip-address")) {
sds ip = c->argv[j+1]->ptr;
if (sdslen(ip) < sizeof(c->slave_ip)) {
memcpy(c->slave_ip,ip,sdslen(ip)+1);
} else {
addReplyErrorFormat(c,"REPLCONF ip-address provided by "
"replica instance is too long: %zd bytes", sdslen(ip));
return;
}
} else if (!strcasecmp(c->argv[j]->ptr,"capa")) {
/* Ignore capabilities not understood by this master. */
if (!strcasecmp(c->argv[j+1]->ptr,"eof"))
c->slave_capa |= SLAVE_CAPA_EOF;
else if (!strcasecmp(c->argv[j+1]->ptr,"psync2"))
c->slave_capa |= SLAVE_CAPA_PSYNC2;
} else if (!strcasecmp(c->argv[j]->ptr,"ack")) {
/* REPLCONF ACK is used by slave to inform the master the amount
* of replication stream that it processed so far. It is an
* internal only command that normal clients should never use. */
long long offset;
if (!(c->flags & CLIENT_SLAVE)) return;
if ((getLongLongFromObject(c->argv[j+1], &offset) != C_OK))
return;
if (offset > c->repl_ack_off)
c->repl_ack_off = offset;
c->repl_ack_time = server.unixtime;
/* If this was a diskless replication, we need to really put
* the slave online when the first ACK is received (which
* confirms slave is online and ready to get more data). */
if (c->repl_put_online_on_ack && c->replstate == SLAVE_STATE_ONLINE)
putSlaveOnline(c);
/* Note: this command does not reply anything! */
return;
} else if (!strcasecmp(c->argv[j]->ptr,"getack")) {
/* REPLCONF GETACK is used in order to request an ACK ASAP
* to the slave. */
if (server.masterhost && server.master) replicationSendAck();
return;
} else {
addReplyErrorFormat(c,"Unrecognized REPLCONF option: %s",
(char*)c->argv[j]->ptr);
return;
}
}
addReply(c,shared.ok);
}
同步策略协调
从服务器询问同步策略
/* 如果我们正在重连，尝试一个部分重同步。
* 如果没有cached master，我们将会发送'PSYNC ? -1'来触发一个全同步，来获取master的
* runid和复制全局offset。
*
* 这个函数被syncWithMaster调用，所以下面的假设成立：
* 1) 入参fd已经连接上。
* 2) 这个函数不会关闭fd，然而，当部分重同步成功时，server.master的client结构体将会重用fd。
*
* 这个函数有两种行为，通过read_reply控制：
* 如果read_reply为0，我们将会发送PSYNC命令到master，并且调用方需要在之后使用read_reply=1，
* 再次调用该函数来读取master的回复。这是为了支持非阻塞的操作，我们在两次事件循环中分别进行读写
* 来发送命令和获取响应。
*
* 当read_reply=0时，即发送命令时，如果发送出错，将会返回PSYNC_WRITE_ERR，否则将会返回
* PSYNC_WAIT_REPLY，并且调用方需要使用read_reply=1再次调用该函数来读取master的回复。
* 当read_reply=1时，当还没有有效的数据时，将再次返回PSYNC_WAIT_REPLY，
*
* 函数返回值：
* PSYNC_CONTINUE: 可以进行部分重同步。
* PSYNC_FULLRESYNC：master支持PSYNC命令，但是需要进行完整重同步。master runid和offset将会被保存。
* PSYNC_NOT_SUPPORTED： master不理解PSYNC命令，调用方需要使用SYNC命令再次调用。
* PSYNC_WRITE_ERROR：写命令时出现了错误。
* PSYNC_WAIT_REPLY：暂时没有有效的数据，需要后续使用read_reply=1再次调用。
* PSYNC_TRY_LATER： master暂时无法处理，比如正在load数据或者master没联系上自己的master，等等。
*
* 副作用：
* 1) 这个将会移除读事件处理器，除非返回了PSYNC_WAIT_REPLY。
* 2) server.master_initial_offset将会根据master的reply正确的设置，这个值将会被用来
* 填充server.master结构体的复制偏移量。
* */
#define PSYNC_WRITE_ERROR 0
#define PSYNC_WAIT_REPLY 1
#define PSYNC_CONTINUE 2
#define PSYNC_FULLRESYNC 3
#define PSYNC_NOT_SUPPORTED 4
#define PSYNC_TRY_LATER 5
int slaveTryPartialResynchronization(int fd, int read_reply) {
char *psync_replid;
char psync_offset[32];
sds reply;
if (!read_reply) { // read_reply=0，向master发送PSYNC
/* 初始化master_initial_offset=-1来标记不可用。
* 之后我们如果要做完整重同步我们将会设置其为正确的值，然后这个值将会传递到server.master。*/
server.master_initial_offset = -1;
if (server.cached_master) { // 如果我们有一个缓存的master信息，我们将会使用该信息做部分重同步
psync_replid = server.cached_master->replid;
// 注意：PSYNC发送的偏移量是reploff+1，表示slave需要的首个数据
snprintf(psync_offset,sizeof(psync_offset),"%lld", server.cached_master->reploff+1);
serverLog(LL_NOTICE,"Trying a partial resynchronization (request %s:%s).", psync_replid, psync_offset);
} else { // 如果没有，我们只能进行一个完整重同步
serverLog(LL_NOTICE,"Partial resynchronization not possible (no cached master)");
psync_replid = "?";
memcpy(psync_offset,"-1",3);
}
/* 发送PSYNC命令 */
reply = sendSynchronousCommand(SYNC_CMD_WRITE,fd,"PSYNC",psync_replid,psync_offset,NULL);
if (reply != NULL) {
serverLog(LL_WARNING,"Unable to send PSYNC to master: %s",reply);
sdsfree(reply);
// 发送PSYNC出错，删除注册的读事件
aeDeleteFileEvent(server.el,fd,AE_READABLE);
return PSYNC_WRITE_ERROR;
}
return PSYNC_WAIT_REPLY;
}
// read_reply=1, 之后后面的逻辑，读取PSYNC的响应
/* 从响应中读取一行命令回复 */
reply = sendSynchronousCommand(SYNC_CMD_READ,fd,NULL);
if (sdslen(reply) == 0) {
/* 在它接受到PSYNC回复前后，master可能会返回一些空白行用于心跳，我们保持连接即可 */
sdsfree(reply);
return PSYNC_WAIT_REPLY;
}
aeDeleteFileEvent(server.el,fd,AE_READABLE);
// +FULLRESYNC bc1621104063d4f46cff756b644c290e80362d3c 238
if (!strncmp(reply,"+FULLRESYNC",11)) {
char *replid = NULL, *offset = NULL;
/* 如果master要求我们做完整重同步，解析reply来提取runid和复制偏移量 */
replid = strchr(reply,' ');
if (replid) {
replid++;
offset = strchr(replid,' ');
if (offset) offset++;
}
if (!replid || !offset || (offset-replid-1) != CONFIG_RUN_ID_SIZE) {
serverLog(LL_WARNING,
"Master replied with wrong +FULLRESYNC syntax.");
/* 这是一种异常情况，master返回了+FULLRESYNC，说明master支持PSYNC，
* 但是返回的格式看起来有问题。
* 为了保证安全，我们把replid置为空, 防止等会重连master时使用一个错误的replid */
memset(server.master_replid,0,CONFIG_RUN_ID_SIZE+1);
} else {
memcpy(server.master_replid, replid, offset-replid-1);
server.master_replid[CONFIG_RUN_ID_SIZE] = '\0';
server.master_initial_offset = strtoll(offset,NULL,10);
serverLog(LL_NOTICE,"Full resync from master: %s:%lld",
server.master_replid,
server.master_initial_offset);
}
/* 我们要执行完整重同步了，抛弃cached master结构体。 */
replicationDiscardCachedMaster();
sdsfree(reply);
return PSYNC_FULLRESYNC;
}
// +CONTINUE <replid> <offset>
if (!strncmp(reply,"+CONTINUE",9)) {
/* 部分重同步被接受 */
serverLog(LL_NOTICE,
"Successful partial resynchronization with master.");
/* 检查master宣告的复制偏移量。
* 如果它改变，我们需要把新的id作为id，并把之前的id作为次id2，并更新second_replid_offset，
* 这样我们的子slaves可以在断开后使用PSYNC重连我们。 */
char *start = reply+10;
char *end = reply+9;
while(end[0] != '\r' && end[0] != '\n' && end[0] != '\0') end++;
if (end-start == CONFIG_RUN_ID_SIZE) {
char new[CONFIG_RUN_ID_SIZE+1];
memcpy(new,start,CONFIG_RUN_ID_SIZE);
new[CONFIG_RUN_ID_SIZE] = '\0';
if (strcmp(new,server.cached_master->replid)) { // masterID改变
serverLog(LL_WARNING,"Master replication ID changed to %s",new);
/* 设置oldID作为我们的id2，并更新second_replid_offset */
memcpy(server.replid2,server.cached_master->replid,
sizeof(server.replid2));
server.second_replid_offset = server.master_repl_offset+1;
/* 更新ceched->masterID和id */
memcpy(server.replid,new,sizeof(server.replid));
memcpy(server.cached_master->replid,new,sizeof(server.replid));
/* 断开所有的slave，之后它们将会重连，并使用我们新的id */
disconnectSlaves();
}
}
/* 设置继续复制 */
sdsfree(reply);
replicationResurrectCachedMaster(fd);
/* 如果当前的实例是我们重启的，并且PSYNC的元数据是从持久化文件中读取的，
* 我们的复制缓冲区应该还没有初始化，创建它。 */
if (server.repl_backlog == NULL) createReplicationBacklog();
return PSYNC_CONTINUE;
}
/* 如果我们达到了这里说明我们遇到了某些错误。
* 当错误是临时错误时，我们返回PSYNC_TRY_LATER
* 当master不支持PSYNC或者我们不清楚的错误时，我们返回PSYNC_NOT_SUPPORTED */
if (!strncmp(reply,"-NOMASTERLINK",13) ||
!strncmp(reply,"-LOADING",8))
{
serverLog(LL_NOTICE,
"Master is currently unable to PSYNC "
"but should be in the future: %s", reply);
sdsfree(reply);
return PSYNC_TRY_LATER;
}
if (strncmp(reply,"-ERR",4)) {
/* If it's not an error, log the unexpected event. */
serverLog(LL_WARNING,
"Unexpected reply to PSYNC from master: %s", reply);
} else {
serverLog(LL_NOTICE,
"Master does not support PSYNC or is in "
"error state (reply: %s)", reply);
}
sdsfree(reply);
replicationDiscardCachedMaster();
return PSYNC_NOT_SUPPORTED;
}
主服务器响应同步策略
/* SYNC和PSYNC命令的实现 */
void syncCommand(client *c) {
/* 如果客户端已经是一个slave或者monitor，则直接返回 */
if (c->flags & CLIENT_SLAVE) return;
/* 如果我们是一个slave但是还没有跟随成功我们的master，则拒绝 */
if (server.masterhost && server.repl_state != REPL_STATE_CONNECTED) {
addReplySds(c,sdsnew("-NOMASTERLINK Can't SYNC while not connected with my master\r\n"));
return;
}
/* 当执行同步时，client的回复缓冲区必须是空的。我们在执行BGSAVE时，可能复用RDB文件，
* 会在两个slave之间拷贝回复缓冲区 */
if (clientHasPendingReplies(c)) {
addReplyError(c,"SYNC and PSYNC are invalid with pending output");
return;
}
serverLog(LL_NOTICE,"Replica %s asks for synchronization",
replicationGetSlaveName(c));
/* 如果是PSYNC命令，尝试进行部分重同步。
* 如果失败了，我们将会进行一个完整重同步，通过返回：
* +FULLRESYNC <replid> <offset>
* 这样slave可以在断开到master的连接时，知道新的replid和偏移量，来进行一个部分重同步的重连。
* */
if (!strcasecmp(c->argv[0]->ptr,"psync")) {
if (masterTryPartialResynchronization(c) == C_OK) {
server.stat_sync_partial_ok++;
return; /* 不需要完整重同步，直接返回 */
} else {
char *master_replid = c->argv[1]->ptr;
/* 仅当slave被迫执行部分重同步出错时，才更新stat_sync_partial_err */
if (master_replid[0] != '?') server.stat_sync_partial_err++;
}
} else {
/* 如果是SYNC命令，我们将会使用复制协议的一个老的实现。标记客户端，我们不希望接受
* REPLCONF ACK的反馈信息。 */
c->flags |= CLIENT_PRE_PSYNC;
}
/* 下面进行完整重同步 */
server.stat_sync_full++;
/* 设置slave复制状态为SLAVE_STATE_WAIT_BGSAVE_START。下面的代码路径将会根据
* 我们不同的处理来修改状态。 */
c->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
if (server.repl_disable_tcp_nodelay) // 如果禁用TCP NoDelay选项
anetDisableTcpNoDelay(NULL, c->fd); /* 失败了也不要紧 */
c->repldbfd = -1;
c->flags |= CLIENT_SLAVE;
listAddNodeTail(server.slaves,c);
/* 如果需要，我们创建repl_backlog缓冲区 */
if (listLength(server.slaves) == 1 && server.repl_backlog == NULL) {
/* 当我们创建backlog时，我们总是使用新的replid并且清理id2，
* 这样就不会有非法的历史数据了 */
changeReplicationId();
clearReplicationId2();
createReplicationBacklog();
}
/* 第一种情况：BGSAVE正在后台进行，并且target=disk */
if (server.rdb_child_pid != -1 &&
server.rdb_child_type == RDB_CHILD_TYPE_DISK)
{
/* 现在后台有一个BGSAVE在运行。我们检查是否可以用于复制。
* 如果有另外一个slave触发了BGSAVE，我们可以尝试复用RDB文件 */
client *slave;
listNode *ln;
listIter li;
listRewind(server.slaves,&li);
while((ln = listNext(&li))) {
slave = ln->value;
if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_END) break;
}
/* 如果我们的slave的能力兼容这个slave的能力，则可以复用同一个RDB文件 */
if (ln && ((c->slave_capa & slave->slave_capa) == slave->slave_capa)) {
/* 完成，我们和另外一个slave兼容，设置正确的状态，并copy缓冲区 */
copyClientOutputBuffer(c,slave);
replicationSetupSlaveForFullResync(c,slave->psync_initial_offset);
serverLog(LL_NOTICE,"Waiting for end of BGSAVE for SYNC");
} else {
/* 不兼容，我们需要等待下一个BGSAVE */
serverLog(LL_NOTICE,"Can't attach the replica to the current BGSAVE. Waiting for next BGSAVE for SYNC");
}
/* 第二种情况：BGSAVE在后台运行，但是target=socket */
} else if (server.rdb_child_pid != -1 &&
server.rdb_child_type == RDB_CHILD_TYPE_SOCKET)
{
/* 又一个RDB进程正直写入socket。我们需要等待下一次BGSAVE来执行同步。 */
serverLog(LL_NOTICE,"Current BGSAVE has socket target. Waiting for next BGSAVE for SYNC");
/* 没有BGSAVE在后台运行 */
} else {
if (server.repl_diskless_sync && (c->slave_capa & SLAVE_CAPA_EOF)) {
/* diskless复制RDB进程将会在replicationCron()函数中创建，
* 因为我们想延迟它一段时间来等待更多的slaves。 */
if (server.repl_diskless_sync_delay)
serverLog(LL_NOTICE,"Delay next BGSAVE for diskless SYNC");
} else {
/* 如果target=disk，或者slave无法支持diskless复制，并且我们还没有RDB进程，开始一个。 */
if (server.aof_child_pid == -1) { // 如果没有aof重写进程，则开启
startBgsaveForReplication(c->slave_capa);
} else { // 如果有aof重写进程，则延迟复制
serverLog(LL_NOTICE,
"No BGSAVE in progress, but an AOF rewrite is active. "
"BGSAVE for replication delayed");
}
}
}
return;
}
/* 这个函数从master的视角处理PSYNC请求。
* 可以进行部分重同步返回C_OK，需要进行完整重同步返回C_ERR。*/
int masterTryPartialResynchronization(client *c) {
long long psync_offset, psync_len;
char *master_replid = c->argv[1]->ptr;
char buf[128];
int buflen;
/* 解析slave指定的复制偏移量。
* 如果解析错误，则进行完整重同步：这一般不会发生，但是处理这种情况可以提高鲁棒性。 */
if (getLongLongFromObjectOrReply(c,c->argv[2],&psync_offset,NULL) !=
C_OK) goto need_full_resync;
/* server的replid是否和slave宣告的一致。
* 如果replid改变了，这个master将会有一个不同的复制历史，就不能进行完整重同步。
* 注意：那里有两个潜在的合法replid。然而id2是否合法取决于指定的偏移量。
* 如果replid和server.replid2相同，说明master和slave曾经都作为slave同步过，
* 后来进行了故障转移，则仅当slave没有该新的slave复制的多时，才允许部分重同步。
* */
if (strcasecmp(master_replid, server.replid) &&
(strcasecmp(master_replid, server.replid2) ||
psync_offset > server.second_replid_offset))
{
/* replid=?意味这slave要求进行完整重同步 */
if (master_replid[0] != '?') {
if (strcasecmp(master_replid, server.replid) &&
strcasecmp(master_replid, server.replid2))
{
serverLog(LL_NOTICE,"Partial resynchronization not accepted: "
"Replication ID mismatch (Replica asked for '%s', my "
"replication IDs are '%s' and '%s')",
master_replid, server.replid, server.replid2);
} else {
serverLog(LL_NOTICE,"Partial resynchronization not accepted: "
"Requested offset for second ID was %lld, but I can reply "
"up to %lld", psync_offset, server.second_replid_offset);
}
} else {
serverLog(LL_NOTICE,"Full resync requested by replica %s",
replicationGetSlaveName(c));
}
goto need_full_resync;
}
/* 检查我们是否有slave需要的数据 */
if (!server.repl_backlog ||
psync_offset < server.repl_backlog_off ||
psync_offset > (server.repl_backlog_off + server.repl_backlog_histlen))
{
serverLog(LL_NOTICE,
"Unable to partial resync with replica %s for lack of backlog (Replica request was: %lld).", replicationGetSlaveName(c), psync_offset);
if (psync_offset > server.master_repl_offset) {
serverLog(LL_WARNING,
"Warning: replica %s tried to PSYNC with an offset that is greater than the master replication offset.", replicationGetSlaveName(c));
}
goto need_full_resync;
}
/* 如果到达了这里，说明我们可以执行一个部分重同步：
* 1) 设置当前的client为slave。
* 2) 使用+CONTINUE通告客户端我们可以进行部分重同步。
* 3) 发送复制缓冲区中的数据。
* */
c->flags |= CLIENT_SLAVE;
c->replstate = SLAVE_STATE_ONLINE;
c->repl_ack_time = server.unixtime;
c->repl_put_online_on_ack = 0;
listAddNodeTail(server.slaves,c);
/* 在这个阶段，我们不使用client的输出缓冲区时为了加速新的命令。
* 但是，此时我们确定这个socket的发送缓冲区是空的，因此我们的写操作实际上不会错误。 */
if (c->slave_capa & SLAVE_CAPA_PSYNC2) {
buflen = snprintf(buf,sizeof(buf),"+CONTINUE %s\r\n", server.replid);
} else {
buflen = snprintf(buf,sizeof(buf),"+CONTINUE\r\n");
}
if (write(c->fd,buf,buflen) != buflen) { // 出现了短写，断开重来
freeClientAsync(c);
return C_OK;
}
// 发送复制缓冲区中积累的数据
psync_len = addReplyReplicationBacklog(c,psync_offset);
serverLog(LL_NOTICE,
"Partial resynchronization request from %s accepted. Sending %lld bytes of backlog starting from offset %lld.",
replicationGetSlaveName(c),
psync_len, psync_offset);
/* 注意：我们不需要设置server.slaveseldb为-1来强制master发射SELECT，因为这个slave
* 从先前到master的连接中获取了它自己的状态 */
refreshGoodSlavesCount(); // 刷新存活的slave的数量
return C_OK; /* 返回OK，表示进行部分重同步*/
need_full_resync:
/* 我们需要一个完整重同步。
* 注意：我们不能理解回复给slave一个PSYNC。PSYNC的回复里需要包含生成RDB文件时master的offset，
* 因此我们需要延迟回复。*/
return C_ERR;
}
进行部分重同步：
从服务器复活cachedMaster
/* 复活cached master为当前的master，并使用一个新的文件描述符作为socket参数。
* 这个函数在成功设置部分重同步时调用，我们可以继续接受master剩下的数据。
* */
void replicationResurrectCachedMaster(int newfd) {
server.master = server.cached_master;
server.cached_master = NULL;
server.master->fd = newfd;
server.master->flags &= ~(CLIENT_CLOSE_AFTER_REPLY|CLIENT_CLOSE_ASAP);
server.master->authenticated = 1;
server.master->lastinteraction = server.unixtime;
server.repl_state = REPL_STATE_CONNECTED;
server.repl_down_since = 0;
/* 重新增加client到链表中 */
linkClient(server.master);
if (aeCreateFileEvent(server.el, newfd, AE_READABLE,
readQueryFromClient, server.master)) {
serverLog(LL_WARNING,"Error resurrecting the cached master, impossible to add the readable handler: %s", strerror(errno));
freeClientAsync(server.master); /* Close ASAP. */
}
/* 如果有未发送的数据在写缓冲区中，我们需要安装可写事件处理器 */
if (clientHasPendingReplies(server.master)) {
if (aeCreateFileEvent(server.el, newfd, AE_WRITABLE,
sendReplyToClient, server.master)) {
serverLog(LL_WARNING,"Error resurrecting the cached master, impossible to add the writable handler: %s", strerror(errno));
freeClientAsync(server.master); /* Close ASAP. */
}
}
}
主服务器推送数据缓冲区中的数据：见masterTryPartialResynchronization()
进行完整重同步：
主服务器准备RDB文件并传输给从服务器
/* 为了复制开启一个BGSAVE进程，根据配置选择disk或者socket，并且确保在开始前脚本缓存被清理。
* 入参mincapa是一个slave能力的位表示，可以通过SLAVE_CAPA_*相关宏测试。
* 副作用：
* 1) 如果可能开始一个RDB，则处理WAIT_START状态，否则发送一个错误，并从slaves列表中移除。
* 2) 如果BGSAVE开始清空Lua脚本缓存
* 成功返回OK，失败返回ERR。
* */
int startBgsaveForReplication(int mincapa) {
int retval;
int socket_target = server.repl_diskless_sync && (mincapa & SLAVE_CAPA_EOF);
listIter li;
listNode *ln;
serverLog(LL_NOTICE,"Starting BGSAVE for SYNC with target: %s",
socket_target ? "replicas sockets" : "disk");
rdbSaveInfo rsi, *rsiptr;
rsiptr = rdbPopulateSaveInfo(&rsi);
/* 仅当rsipt不为NULL时才做rdbSave，否则slave将会错过这次复制流 */
if (rsiptr) {
if (socket_target)
retval = rdbSaveToSlavesSockets(rsiptr);
else
retval = rdbSaveBackground(server.rdb_filename,rsiptr);
} else {
serverLog(LL_WARNING,"BGSAVE for replication: replication information not available, can't generate the RDB file right now. Try later.");
retval = C_ERR;
}
/* 如果我们BGSAVE失败，需要从slaves中删除等待完整重同步的slave，并提示错误，异步关闭连接 */
if (retval == C_ERR) {
serverLog(LL_WARNING,"BGSAVE for replication failed");
listRewind(server.slaves,&li);
while((ln = listNext(&li))) {
client *slave = ln->value;
if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
slave->flags &= ~CLIENT_SLAVE;
listDelNode(server.slaves,ln);
addReplyError(slave,
"BGSAVE failed, replication can't continue");
slave->flags |= CLIENT_CLOSE_AFTER_REPLY;
}
}
return retval;
}
/* 如果target=socket, rdbSaveToSlavesSockets()将会设置slaves变更为全同步，
* 对于target=disk, 我们将会现在做这些。 */
if (!socket_target) {
listRewind(server.slaves,&li);
while((ln = listNext(&li))) {
client *slave = ln->value;
if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
replicationSetupSlaveForFullResync(slave,
getPsyncInitialOffset());
}
}
}
/* Flush the script cache, since we need that slave differences are
* accumulated without requiring slaves to match our cached scripts. */
if (retval == C_OK) replicationScriptCacheFlush();
return retval;
}
/* 在完整重同步时发送一个FULLRESYNC的回复，根据不同的清空，产生不同的副作用：
* 1) 记住，在client中，我们把offset记录到psync_initial_offset，来保证后面slave可以
* 附加到这个BGSAVE进程，通过获取这个offset和复制client的output。
* 2) 设置WAIT_BGSAVE_END，这样我们可以积累增量数据。
* 3) 强制复制流发射一个SELECT命令到新的slave来选择正确的数据库。
* 正常情况下应该在这两种情况下调用：
* 1) 在成功启动BGSAVE后调用
* 2) 当已经有一个BGSAVE在执行时，另一个slave附加在这个BGSAVE上
* */
int replicationSetupSlaveForFullResync(client *slave, long long offset) {
char buf[128];
int buflen;
slave->psync_initial_offset = offset;
slave->replstate = SLAVE_STATE_WAIT_BGSAVE_END;
/* 我们将会开始记录增量数据，通过设置slaveseldb=-1来强制发射SELECT语句。 */
server.slaveseldb = -1;
/* 如果是SYNV命令，则不发送+FULLRESYNC回复 */
if (!(slave->flags & CLIENT_PRE_PSYNC)) {
buflen = snprintf(buf,sizeof(buf),"+FULLRESYNC %s %lld\r\n",
server.replid,offset);
if (write(slave->fd,buf,buflen) != buflen) {
freeClientAsync(slave);
return C_ERR;
}
}
return C_OK;
}
/* 这个函数在每次BGSAVE操作的末尾被调用，或者RDB传输策略切换时。
* 这个函数的目标是当slaves等待BGSAVE操作完成时，来进行非阻塞的同步操作，
* 并且如果slaves需要的话，调度一个新的BGSAVE操作。
* bgsaveerr如果是OK，表示保存成功，ERR表示失败。
* type则表示BGSAVE的target类型。
* */
void updateSlavesWaitingBgsave(int bgsaveerr, int type) {
listNode *ln;
int startbgsave = 0;
int mincapa = -1;
listIter li;
listRewind(server.slaves,&li);
while((ln = listNext(&li))) {
client *slave = ln->value;
if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
// 计算当前需要进行的BGSAVE的slave的capa的最小交集
startbgsave = 1;
mincapa = (mincapa == -1) ? slave->slave_capa :
(mincapa & slave->slave_capa);
} else if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_END) {
struct redis_stat buf;
/* 如果是一个target=disk的BGSAVE，我们需要将RDB从磁盘发送给slave socket。
* 否则如果是一个diskless，用于无盘复制的，我们的工作量则很少，只需要设置slave在线。 */
if (type == RDB_CHILD_TYPE_SOCKET) {
serverLog(LL_NOTICE,
"Streamed RDB transfer with replica %s succeeded (socket). Waiting for REPLCONF ACK from slave to enable streaming",
replicationGetSlaveName(slave));
/* 注意：我们等待从slave过来的REPLCONF ACK消息才真正使slave在线
* （安装可写事件从而积累的数据可以传输）。然而我们尽快改变复制状态，
* 因为我们的salve现在从技术上来说已经是在线了。 */
slave->replstate = SLAVE_STATE_ONLINE;
slave->repl_put_online_on_ack = 1;
slave->repl_ack_time = server.unixtime; /* Timeout otherwise. */
} else {
if (bgsaveerr != C_OK) {
freeClient(slave);
serverLog(LL_WARNING,"SYNC failed. BGSAVE child returned an error");
continue;
}
if ((slave->repldbfd = open(server.rdb_filename,O_RDONLY)) == -1 ||
redis_fstat(slave->repldbfd,&buf) == -1) {
freeClient(slave);
serverLog(LL_WARNING,"SYNC failed. Can't open/stat DB after BGSAVE: %s", strerror(errno));
continue;
}
// 初始化相关状态
slave->repldboff = 0;
slave->repldbsize = buf.st_size;
slave->replstate = SLAVE_STATE_SEND_BULK;
slave->replpreamble = sdscatprintf(sdsempty(),"$%lld\r\n",
(unsigned long long) slave->repldbsize);
// 设置可写事件为sendBulkToSlave
aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave) == AE_ERR) {
freeClient(slave);
continue;
}
}
}
}
// 开启一个新的BGSAVE
if (startbgsave) startBgsaveForReplication(mincapa);
}
void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
client *slave = privdata;
UNUSED(el);
UNUSED(mask);
char buf[PROTO_IOBUF_LEN];
ssize_t nwritten, buflen;
/* 在发送RDB之前，我们需要先发送复制进程配置的序言。现在序言仅仅只是RDB文件的长度，
* 形式是"$<length>\r\n" */
if (slave->replpreamble) {
nwritten = write(fd,slave->replpreamble,sdslen(slave->replpreamble));
if (nwritten == -1) {
serverLog(LL_VERBOSE,"Write error sending RDB preamble to replica: %s",
strerror(errno));
freeClient(slave);
return;
}
server.stat_net_output_bytes += nwritten;
sdsrange(slave->replpreamble,nwritten,-1);
if (sdslen(slave->replpreamble) == 0) {
sdsfree(slave->replpreamble);
slave->replpreamble = NULL;
/* 接下来发送数据 */
} else {
return;
}
}
/* 如果序言发送完成，我们接下来传输RDB文件 */
lseek(slave->repldbfd,slave->repldboff,SEEK_SET);
buflen = read(slave->repldbfd,buf,PROTO_IOBUF_LEN);
if (buflen <= 0) {
serverLog(LL_WARNING,"Read error sending DB to replica: %s",
(buflen == 0) ? "premature EOF" : strerror(errno));
freeClient(slave);
return;
}
if ((nwritten = write(fd,buf,buflen)) == -1) {
if (errno != EAGAIN) {
serverLog(LL_WARNING,"Write error sending DB to replica: %s",
strerror(errno));
freeClient(slave);
}
return;
}
slave->repldboff += nwritten;
server.stat_net_output_bytes += nwritten;
// 如果发送RDB文件已经传输完成了，则删除可写事件处理器，并设置slave为在线状态
if (slave->repldboff == slave->repldbsize) {
close(slave->repldbfd);
slave->repldbfd = -1;
aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
putSlaveOnline(slave);
}
}
/* 这个函数将会把一个slave变更为state状态，调用的时机应该仅在：
* 一个slave收到了RDB文件后调用，并且已经准备好发送增量数据。
* 它会做以下事情：
* 1) 设置为ONLINE状态(当state=ONLINE但是repl_put_online_on_ack=1时无用)
* 2) 确保可写事件是重新安装的，从而我们可以把output缓冲区发送给slave。
* 3) 更新good slaves数量。
* */
void putSlaveOnline(client *slave) {
slave->replstate = SLAVE_STATE_ONLINE;
slave->repl_put_online_on_ack = 0;
slave->repl_ack_time = server.unixtime; /* Prevent false timeout. */
if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE,
sendReplyToClient, slave) == AE_ERR) {
serverLog(LL_WARNING,"Unable to register writable event for replica bulk transfer: %s", strerror(errno));
freeClient(slave);
return;
}
refreshGoodSlavesCount();
serverLog(LL_NOTICE,"Synchronization with replica %s succeeded",
replicationGetSlaveName(slave));
}
从服务器设置可读事件处理器：readSyncBulkPayload
/* 异步读取从master传递来的RDB文件 */
#define REPL_MAX_WRITTEN_BEFORE_FSYNC (1024*1024*8) /* 8 MB */
void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
char buf[4096];
ssize_t nread, readlen, nwritten;
off_t left;
UNUSED(el);
UNUSED(privdata);
UNUSED(mask);
/* 静态变量用来保持EOF标记和最后接受的字节：当它们匹配时说明到达了文件传输的末尾 */
static char eofmark[CONFIG_RUN_ID_SIZE];
static char lastbytes[CONFIG_RUN_ID_SIZE];
static int usemark = 0;
/* 如果repl_transfer_size == -1说明我们需要读取RDB文件长度 */
if (server.repl_transfer_size == -1) {
if (syncReadLine(fd,buf,1024,server.repl_syncio_timeout*1000) == -1) {
serverLog(LL_WARNING,
"I/O error reading bulk count from MASTER: %s",
strerror(errno));
goto error;
}
if (buf[0] == '-') {
serverLog(LL_WARNING,
"MASTER aborted replication with an error: %s",
buf+1);
goto error;
} else if (buf[0] == '\0') {
/* 这个空行仅仅是保活心跳，我们更新最后交互时间就好 */
server.repl_transfer_lastio = server.unixtime;
return;
} else if (buf[0] != '$') {
serverLog(LL_WARNING,"Bad protocol from MASTER, the first byte is not '$' (we received '%s'), are you sure the host and port are right?", buf);
goto error;
}
/* 有两种传输bulk数据的格式，1用于RDB文件传输，2用于diskless传输
* 1) $381
* 2) $EOF:<40 bytes delimiter>
* diskless传输中无法直接获得文件长度，只能基于分隔符标记传输。这个分隔符足够长且随机，
* 以至于和数据内容产生冲突的可能性很小，可以忽略。
* */
if (strncmp(buf+1,"EOF:",4) == 0 && strlen(buf+5) >= CONFIG_RUN_ID_SIZE) { // rdb传输
usemark = 1;
memcpy(eofmark,buf+5,CONFIG_RUN_ID_SIZE);
memset(lastbytes,0,CONFIG_RUN_ID_SIZE);
/* 设置repl_transfer_size=0，防止重入该条件*/
server.repl_transfer_size = 0;
serverLog(LL_NOTICE,
"MASTER <-> REPLICA sync: receiving streamed RDB from master");
} else { // diskless传输
usemark = 0;
server.repl_transfer_size = strtol(buf+1,NULL,10);
serverLog(LL_NOTICE,
"MASTER <-> REPLICA sync: receiving %lld bytes from master",
(long long) server.repl_transfer_size);
}
return;
}
/* 计算要读取的长度 */
if (usemark) {
readlen = sizeof(buf);
} else {
left = server.repl_transfer_size - server.repl_transfer_read;
readlen = (left < (signed)sizeof(buf)) ? left : (signed)sizeof(buf);
}
nread = read(fd,buf,readlen);
if (nread <= 0) {
serverLog(LL_WARNING,"I/O error trying to sync with MASTER: %s",
(nread == -1) ? strerror(errno) : "connection lost");
cancelReplicationHandshake();
return;
}
server.stat_net_input_bytes += nread;
/* 在diskless传输中，我们需要检查EOF标记，防止把它写到文件中 */
int eof_reached = 0;
if (usemark) {
/* 更新lastbytes，并检查是否匹配EOF标记 */
if (nread >= CONFIG_RUN_ID_SIZE) {
memcpy(lastbytes,buf+nread-CONFIG_RUN_ID_SIZE,CONFIG_RUN_ID_SIZE);
} else {
int rem = CONFIG_RUN_ID_SIZE-nread;
memmove(lastbytes,lastbytes+nread,rem);
memcpy(lastbytes+rem,buf,nread);
}
if (memcmp(lastbytes,eofmark,CONFIG_RUN_ID_SIZE) == 0) eof_reached = 1;
}
server.repl_transfer_lastio = server.unixtime;
if ((nwritten = write(server.repl_transfer_fd,buf,nread)) != nread) {
serverLog(LL_WARNING,"Write error or short write writing to the DB dump file needed for MASTER <-> REPLICA synchronization: %s",
(nwritten == -1) ? strerror(errno) : "short write");
goto error;
}
server.repl_transfer_read += nread;
/* 如果达到了eof，我们需要删除后面的40个字节 */
if (usemark && eof_reached) {
if (ftruncate(server.repl_transfer_fd,
server.repl_transfer_read - CONFIG_RUN_ID_SIZE) == -1)
{
serverLog(LL_WARNING,"Error truncating the RDB file received from the master for SYNC: %s", strerror(errno));
goto error;
}
}
/* 立即把数据sync到磁盘上，如果先保存在内存中最后在落盘，我们会消耗很多内存 */
if (server.repl_transfer_read >=
server.repl_transfer_last_fsync_off + REPL_MAX_WRITTEN_BEFORE_FSYNC)
{
off_t sync_size = server.repl_transfer_read -
server.repl_transfer_last_fsync_off;
rdb_fsync_range(server.repl_transfer_fd,
server.repl_transfer_last_fsync_off, sync_size);
server.repl_transfer_last_fsync_off += sync_size;
}
/* 检查传输是否完成了 */
if (!usemark) {
if (server.repl_transfer_read == server.repl_transfer_size)
eof_reached = 1;
}
if (eof_reached) {
int aof_is_enabled = server.aof_state != AOF_OFF;
if (rename(server.repl_transfer_tmpfile,server.rdb_filename) == -1) {
serverLog(LL_WARNING,"Failed trying to rename the temp DB into dump.rdb in MASTER <-> REPLICA synchronization: %s", strerror(errno));
cancelReplicationHandshake();
return;
}
serverLog(LL_NOTICE, "MASTER <-> REPLICA sync: Flushing old data");
/* 如果开启了AOF，我们需要暂时停止，否则AOF和RDB一起进行，我们会造成写时复制的灾难行为 */
if(aof_is_enabled) stopAppendOnly();
signalFlushedDb(-1);
// 清空数据库
emptyDb(
-1,
server.repl_slave_lazy_flush ? EMPTYDB_ASYNC : EMPTYDB_NO_FLAGS,
replicationEmptyDbCallback);
/* 在把DB异步加载到内存中之前，我们需要删除可读事件处理器，否则当新的数据到达时，
* 这个事件会被事件循环一直调用 */
aeDeleteFileEvent(server.el,server.repl_transfer_s,AE_READABLE);
serverLog(LL_NOTICE, "MASTER <-> REPLICA sync: Loading DB in memory");
rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
/* 重新加载RDB文件 */
if (rdbLoad(server.rdb_filename,&rsi) != C_OK) {
serverLog(LL_WARNING,"Failed trying to load the MASTER synchronization DB from disk");
cancelReplicationHandshake();
/* 如果我们刚刚关闭了AOF，重新开启 */
if (aof_is_enabled) restartAOF();
return;
}
/* 最后我们设置主从同步状态为REPL_STATE_CONNECTED，
* 创建一个新的客户端，在创建时会注册可读事件为readQueryFromClient */
zfree(server.repl_transfer_tmpfile);
close(server.repl_transfer_fd);
replicationCreateMasterClient(server.repl_transfer_s,rsi.repl_stream_db);
server.repl_state = REPL_STATE_CONNECTED;
server.repl_down_since = 0;
/* 在完整重同步后，我们使用master的replid和偏移量，id2和偏移量将会被清空，
* 因为我们开始了一个新的复制流。 */
memcpy(server.replid,server.master->replid,sizeof(server.replid));
server.master_repl_offset = server.master->reploff;
clearReplicationId2();
/* 如果需要我们创建复制缓冲区。
* 不管slaves是否有sub-slaves，都需要有复制缓冲区来支持正确的故障转移 */
if (server.repl_backlog == NULL) createReplicationBacklog();
serverLog(LL_NOTICE, "MASTER <-> REPLICA sync: Finished with success");
/* 我们已经完成了同步，重启AOF。这将会触发一次AOF重写，当结束时将会开始追加一个新的AOF文件 */
if (aof_is_enabled) restartAOF();
}
return;
error:
cancelReplicationHandshake();
return;
}
命令传播
主从传播：复制流将会在命令执行完毕后生成，并传输给slaves
/* Call()是Redis命令执行的核心
*
* The following flags can be passed:
* CMD_CALL_NONE No flags.
* CMD_CALL_SLOWLOG 检查该命令执行时间，条件达到时写入慢日志
* CMD_CALL_STATS Populate command stats.
* CMD_CALL_PROPAGATE_AOF 如果该命令修改了数据库或者客户端强制，则追加到AOF日志中
* CMD_CALL_PROPAGATE_REPL 如果命令会修改数据库或者客户端设置了FORCE_PROGATION标志则发送到slaves
* CMD_CALL_PROPAGATE Alias for PROPAGATE_AOF|PROPAGATE_REPL.
* CMD_CALL_FULL Alias for SLOWLOG|STATS|PROPAGATE.
*
* 精确的传播行为还取决于客户端标志：
* 1。如果客户端带有CLIENT_FORCE_AOF或者CLIENT_FORCE_REPL，
* 并且调用该函数中时带有CMD_CALL_PROPAGATE_AOF/REPL标志，
* 即使没有修改数据库，也会进行传播到AOF和slaves。
* 2。如果客户端带有CLIENT_PREVENT_REPL_PROP或者CLIENT_PREVENT_AOF_PROP，
* 即使数据库被修改了，也不会传播到AOF和slaves中。
* 注意：不管客户端的标志是什么，
* 如果调用时CMD_CALL_PROPAGATE_AOF或者CMD_CALL_PROPAGATE_REPL，
* AOF和子slaves的传播行为都不会发生。
*
* Client flags are modified by the implementation of a given command
* using the following API:
* Client的标志可以被以下命令API的实现进行修改：
* forceCommandPropagation(client *c, int flags);
* preventCommandPropagation(client *c);
* preventCommandAOF(client *c);
* preventCommandReplication(client *c);
*/
void call(client *c, int flags) {
long long dirty, start, duration;
int client_old_flags = c->flags;
struct redisCommand *real_cmd = c->cmd;
/* 当有客户端在监视该服务器时，向监视客户端发送当前处理的命令请求的相关信息
* 在下列情况下不发送：
* 1. 服务器在加载数据库
* 2. 当前命令标志位为CMD_SKIP_MONITOR或CMD_ADMIN管理命令
* */
if (listLength(server.monitors) &&
!server.loading &&
!(c->cmd->flags & (CMD_SKIP_MONITOR|CMD_ADMIN)))
{
replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc);
}
/* 初始化：清空相关的标志，这些标志将会被命令按照要求进行设置，并初始化also_propagate数组 */
c->flags &= ~(CLIENT_FORCE_AOF|CLIENT_FORCE_REPL|CLIENT_PREVENT_PROP);
redisOpArray prev_also_propagate = server.also_propagate;
redisOpArrayInit(&server.also_propagate);
/* 执行命令并计算出处理时长 */
dirty = server.dirty;
start = ustime();
c->cmd->proc(c);
duration = ustime()-start;
dirty = server.dirty-dirty;
if (dirty < 0) dirty = 0;
/* When EVAL is called loading the AOF we don't want commands called
* from Lua to go into the slowlog or to populate statistics. */
if (server.loading && c->flags & CLIENT_LUA)
flags &= ~(CMD_CALL_SLOWLOG | CMD_CALL_STATS);
/* If the caller is Lua, we want to force the EVAL caller to propagate
* the script if the command flag or client flag are forcing the
* propagation. */
if (c->flags & CLIENT_LUA && server.lua_caller) {
if (c->flags & CLIENT_FORCE_REPL)
server.lua_caller->flags |= CLIENT_FORCE_REPL;
if (c->flags & CLIENT_FORCE_AOF)
server.lua_caller->flags |= CLIENT_FORCE_AOF;
}
/* 必要时记录慢日志，并且填充每个命令的统计信息在INFO命令状态中 */
/* 如果设置CMD_CALL_SLOWLOG位并且该命令不是EXEC命令，则需要记录慢日志 */
if (flags & CMD_CALL_SLOWLOG && c->cmd->proc != execCommand) {
char *latency_event = (c->cmd->flags & CMD_FAST) ?
"fast-command" : "command";
latencyAddSampleIfNeeded(latency_event,duration/1000);
slowlogPushEntryIfNeeded(c,c->argv,c->argc,duration);
}
if (flags & CMD_CALL_STATS) {
/* use the real command that was executed (cmd and lastamc) may be
* different, in case of MULTI-EXEC or re-written commands such as
* EXPIRE, GEOADD, etc. */
real_cmd->microseconds += duration;
real_cmd->calls++;
}
/* 传播命令到AOF文件和从服务器 */
if (flags & CMD_CALL_PROPAGATE &&
(c->flags & CLIENT_PREVENT_PROP) != CLIENT_PREVENT_PROP)
{
int propagate_flags = PROPAGATE_NONE;
/* 检查该命令是否修改了数据集，如果是，则进行传播 */
if (dirty) propagate_flags |= (PROPAGATE_AOF|PROPAGATE_REPL);
/* 如果客户端设置了强制传播，则也需要进行传播 */
if (c->flags & CLIENT_FORCE_REPL) propagate_flags |= PROPAGATE_REPL;
if (c->flags & CLIENT_FORCE_AOF) propagate_flags |= PROPAGATE_AOF;
/* 然而如果该命令实现了preventCommandPropagation()之类的方法，或者没有调用call()的相关标志，我们不进行传播 */
if (c->flags & CLIENT_PREVENT_REPL_PROP ||
!(flags & CMD_CALL_PROPAGATE_REPL))
propagate_flags &= ~PROPAGATE_REPL;
if (c->flags & CLIENT_PREVENT_AOF_PROP ||
!(flags & CMD_CALL_PROPAGATE_AOF))
propagate_flags &= ~PROPAGATE_AOF;
/* 仅当需要进行传播并且该命令不是Module命令时，才进行复制。
* Module命令以一种显式的方式进行复制，所以我们不会进行自动复制。 */
if (propagate_flags != PROPAGATE_NONE && !(c->cmd->flags & CMD_MODULE))
propagate(c->cmd,c->db->id,c->argv,c->argc,propagate_flags);
}
/* Restore the old replication flags, since call() can be executed
* recursively. */
c->flags &= ~(CLIENT_FORCE_AOF|CLIENT_FORCE_REPL|CLIENT_PREVENT_PROP);
c->flags |= client_old_flags &
(CLIENT_FORCE_AOF|CLIENT_FORCE_REPL|CLIENT_PREVENT_PROP);
/* Handle the alsoPropagate() API to handle commands that want to propagate
* multiple separated commands. Note that alsoPropagate() is not affected
* by CLIENT_PREVENT_PROP flag. */
if (server.also_propagate.numops) {
int j;
redisOp *rop;
if (flags & CMD_CALL_PROPAGATE) {
for (j = 0; j < server.also_propagate.numops; j++) {
rop = &server.also_propagate.ops[j];
int target = rop->target;
/* Whatever the command wish is, we honor the call() flags. */
if (!(flags&CMD_CALL_PROPAGATE_AOF)) target &= ~PROPAGATE_AOF;
if (!(flags&CMD_CALL_PROPAGATE_REPL)) target &= ~PROPAGATE_REPL;
if (target)
propagate(rop->cmd,rop->dbid,rop->argv,rop->argc,target);
}
}
redisOpArrayFree(&server.also_propagate);
}
server.also_propagate = prev_also_propagate;
server.stat_numcommands++;
}
/* 在指定数据库上下文中传播命令到AOF文件和slaves
* flags are an xor between:
* + PROPAGATE_NONE (no propagation of command at all)
* + PROPAGATE_AOF (propagate into the AOF file if is enabled)
* + PROPAGATE_REPL (propagate into the replication link)
*
* 这个函数不应该用于命令实现的内部。如果要在内部使用，请使用
* alsoPropagate(), preventCommandPropagation(), forceCommandPropagation().
*/
void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
int flags)
{
/* 如果AOF打开了，且PROPAGATE_AOF，写入到AOF文件中 */
if (server.aof_state != AOF_OFF && flags & PROPAGATE_AOF)
feedAppendOnlyFile(cmd,dbid,argv,argc);
// 如果PROPAGATE_REPL，传播到slaves
if (flags & PROPAGATE_REPL)
replicationFeedSlaves(server.slaves,dbid,argv,argc);
}
/* 传播写命令到slaves，并且填充复制积压。
* 当这个实例是master时，我们使用这个函数来接收clients的命令，来创建复制流。
* 如果当前实例是slave，并且有sub-slaves，我们将会使用replicationFeedSlavesFromMaster函数。 */
void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {
listNode *ln;
listIter li;
int j, len;
char llstr[LONG_STR_SIZE];
/* 仅当该实例是顶层master时，才进行主从复制。
* 当该实例是slave时，我们将直接代理复制流，来保证复制流的完全一致。
* 因为所有的slaves将会共享同一个复制流，它们应该有相同的复制历史和偏移量。 */
if (server.masterhost != NULL) return;
/* 如果没有slave，且没有复制积压缓冲区要填充，就直接返回 */
if (server.repl_backlog == NULL && listLength(slaves) == 0) return;
serverAssert(!(listLength(slaves) != 0 && server.repl_backlog == NULL));
/* 我们需要先对每一个slave发送SELECT命令以切换到正确的数据库 */
if (server.slaveseldb != dictid) {
robj *selectcmd;
/* For a few DBs we have pre-computed SELECT command. */
if (dictid >= 0 && dictid < PROTO_SHARED_SELECT_CMDS) {
selectcmd = shared.select[dictid];
} else {
int dictid_len;
dictid_len = ll2string(llstr,sizeof(llstr),dictid);
selectcmd = createObject(OBJ_STRING,
sdscatprintf(sdsempty(),
"*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n",
dictid_len, llstr));
}
/* 增加SELECT命令到复制积压缓冲区 */
if (server.repl_backlog) feedReplicationBacklogWithObject(selectcmd);
/* 把命令发送给slave */
listRewind(slaves,&li);
while((ln = listNext(&li))) {
client *slave = ln->value;
/* master正准备生成RDB文件，这条命令将会被包含进RDB中，不发送 */
if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) continue;
addReply(slave,selectcmd);
}
if (dictid < 0 || dictid >= PROTO_SHARED_SELECT_CMDS)
decrRefCount(selectcmd);
}
server.slaveseldb = dictid;
/* 将命令以RESP的格式写入积压缓冲区中 */
if (server.repl_backlog) {
char aux[LONG_STR_SIZE+3];
aux[0] = '*';
len = ll2string(aux+1,sizeof(aux)-1,argc);
aux[len+1] = '\r';
aux[len+2] = '\n';
feedReplicationBacklog(aux,len+3);
for (j = 0; j < argc; j++) {
long objlen = stringObjectLen(argv[j]);
aux[0] = '$';
len = ll2string(aux+1,sizeof(aux)-1,objlen);
aux[len+1] = '\r';
aux[len+2] = '\n';
feedReplicationBacklog(aux,len+3);
feedReplicationBacklogWithObject(argv[j]);
feedReplicationBacklog(aux+len+1,2);
}
}
/* 将命令写入到每个slaves */
listRewind(slaves,&li);
while((ln = listNext(&li))) {
client *slave = ln->value;
/* master正在生成RDB文件，这条命令将会被包含进RDB中，不发送 */
if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) continue;
/* slaves可能正在进行SYNC，我们先添加到client的output buffer中。
* 当SYNC完成后将会发送给slaves */
addReplyMultiBulkLen(slave,argc);
for (j = 0; j < argc; j++)
addReplyBulk(slave,argv[j]);
}
}
从从复制：从节点将会在命令执行完后，将master的复制流原样复制给sub-slave
/* 从TCP缓冲区中读取数据，写入到client->querybuf中，并进行处理 */
void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
client *c = (client*) privdata;
int nread, readlen;
size_t qblen;
UNUSED(el);
UNUSED(mask);
readlen = PROTO_IOBUF_LEN;
/* 我们尽可能的申请一块大内存=16KB，这样我们可以在读取过程中不必扩容或者拷贝 */
/* 如果请求是MultiBulk模式，并且存在未读取的bulk，且当前正在读取的bulk有待读取的剩余字节，
* 并且待读取的字节数大于32KB，我们将会扩容当前使得可以容纳当前bulk */
if (c->reqtype == PROTO_REQ_MULTIBULK && c->multibulklen && c->bulklen != -1
&& c->bulklen >= PROTO_MBULK_BIG_ARG)
{
ssize_t remaining = (size_t)(c->bulklen+2)-sdslen(c->querybuf);
/* Note that the 'remaining' variable may be zero in some edge case,
* for example once we resume a blocked client after CLIENT PAUSE. */
if (remaining > 0 && remaining < readlen) readlen = remaining;
}
qblen = sdslen(c->querybuf);
if (c->querybuf_peak < qblen) c->querybuf_peak = qblen;
c->querybuf = sdsMakeRoomFor(c->querybuf, readlen); // 扩大sds的内部缓冲区使得可以多容纳readlen字节数据
nread = read(fd, c->querybuf+qblen, readlen);
if (nread == -1) { // 读取出错
if (errno == EAGAIN) { // TCP缓冲区暂时无数据，返回下次继续读取
return;
} else {
serverLog(LL_VERBOSE, "Reading from client: %s",strerror(errno));
freeClient(c); // 真的读取出错，关闭客户端
return;
}
} else if (nread == 0) { // 客户端关闭
serverLog(LL_VERBOSE, "Client closed connection");
freeClient(c);
return;
} else if (c->flags & CLIENT_MASTER) {
/* 如果客户端为Master，则此命令是一个从master传播过来的命令，将会直接传播到sub-slaves
* 追加到pending_querybuf。我们将会在命令执行完成之后同步给sub-slaves。*/
c->pending_querybuf = sdscatlen(c->pending_querybuf,
c->querybuf+qblen,nread);
}
sdsIncrLen(c->querybuf,nread);
c->lastinteraction = server.unixtime;
if (c->flags & CLIENT_MASTER) c->read_reploff += nread;
server.stat_net_input_bytes += nread;
if (sdslen(c->querybuf) > server.client_max_querybuf_len) { // 如果查询缓冲区太长，则释放客户端连接
sds ci = catClientInfoString(sdsempty(),c), bytes = sdsempty();
bytes = sdscatrepr(bytes,c->querybuf,64);
serverLog(LL_WARNING,"Closing client that reached max query buffer length: %s (qbuf initial bytes: %s)", ci, bytes);
sdsfree(ci);
sdsfree(bytes);
freeClient(c);
return;
}
/* 处理输入缓冲区中的数据，并且进行复制操作。
* 在执行命令的前后，我们需要计算偏移量，来了解我们已经应用了master的复制流长度，
* 之后我们将会把这部分复制流发送给sub-slaves并记录到复制积压缓冲区中。*/
processInputBufferAndReplicate(c);
}
/* 这是processInputBuffer函数的包装，在客户端是master时，负责处理如何向子slave进行复制 */
void processInputBufferAndReplicate(client *c) {
if (!(c->flags & CLIENT_MASTER)) { // 该实例是top-master, 则通过replicationFeedSlaves复制
processInputBuffer(c);
} else {
/* 如果客户端是Master，说明该实例不是top-master,
* 则不仅需要处理缓冲区中的命令，还需要将命令复制到子Slave上和复制积压缓冲区中 */
size_t prev_offset = c->reploff;
processInputBuffer(c);
size_t applied = c->reploff - prev_offset;
if (applied) {
replicationFeedSlavesFromMasterStream(server.slaves,
c->pending_querybuf, applied);
sdsrange(c->pending_querybuf,applied,-1);
}
}
}
/* 这个函数用来实现代理：将我们从master客户端节点接收到的命令复制到子slave
* 为什么slave-slave间的复制不复用replicationFeedSlaves：
* 1) 在master->slave复制时会增加SELECT命令，slave->sub-slave没必要重复添加
* 2) 可以保证slave和sub-slave同master完全一致!。
* */
#include <ctype.h>
void replicationFeedSlavesFromMasterStream(list *slaves, char *buf, size_t buflen) {
listNode *ln;
listIter li;
/* Debugging: this is handy to see the stream sent from master
* to slaves. Disabled with if(0). */
if (0) {
printf("%zu:",buflen);
for (size_t j = 0; j < buflen; j++) {
printf("%c", isprint(buf[j]) ? buf[j] : '.');
}
printf("\n");
}
if (server.repl_backlog) feedReplicationBacklog(buf,buflen);
listRewind(slaves,&li);
while((ln = listNext(&li))) {
client *slave = ln->value;
/* 对于还在还未开始RDB生成的slaves，我们添加到输出缓冲区 */
if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) continue;
addReplyString(slave,buf,buflen);
}
}
心跳检测
Redis的主从心跳是双向无回复心跳：
- 双向：
- master -> slave: 在serverCron()中通过top-master在复制流中每10s插入一个PING命令实现，在非top-master中，通过代理复制流直接就能获得心跳能力。
- slave -> master: 在serverCron()中通过每1s向master发送REPLCONF ACK命令实现
- 无回复：master->slave的通道用于复制流传输，slave->master的通道用于REPLCONF-ACK心跳，仅能探测连接可用，无法探测服务可用
- master->slave: 如果对REPLCONF-ACK进行回复，将会与复制流混合，通过在命令实现中不调用addReply()写输出缓冲区来实现。
- slave -> master: 如果slave对命令进行回复，将会与REPLCONF-ACK混合，通过在addReply()检查client->flags&CLIENT_MASTER写输出缓冲区来实现
心跳发送
/* 复制核心函数，每秒执行一次，在serverCron中调用 */
void replicationCron(void) {
...
/* 当前实例作为slave, 并且master可以理解PSYNC，发送REPLCONf ACK给master，每秒1次，作用：
* 1) slave->master的心跳
* 2) 同步给master当前slave的复制偏移量
* 注意：如果master不支持PSYNC和复制偏移量。
* */
if (server.masterhost && server.master &&
!(server.master->flags & CLIENT_PRE_PSYNC))
replicationSendAck();
/* 如果我们有slaves，不断地PING它们。
* 这样slaves可以显式的实现一个到master的超时，并且能在TCP不可用时，监测到断连。 */
listIter li;
listNode *ln;
robj *ping_argv[1];
/* 当时实例作为master向slaves发送PING，每repl_ping_slave_period=10s一次
* 注意：这个功能实际上是通过写入到复制积压缓冲区中实现的，而不是直接发送给slave。
* 这意味着，在复制同步期间，所有的PING将会在slave同步期间不会真正发送给slave，
* 而是在slave的复制状态变更为ONLINE时才发送。
* */
if ((replication_cron_loops % server.repl_ping_slave_period) == 0 &&
listLength(server.slaves))
{
ping_argv[0] = createStringObject("PING",4);
replicationFeedSlaves(server.slaves, server.slaveseldb,
ping_argv, 1);
decrRefCount(ping_argv[0]);
}
...
}
/* 把REPLCONF ACK命令写入到输出缓冲区中。如果我们没有连接到master，命令无影响 */
void replicationSendAck(void) {
client *c = server.master;
if (c != NULL) {
// 必须先设置CLIENT_MASTER_FORCE_REPLY，否则addReply会写入失败
c->flags |= CLIENT_MASTER_FORCE_REPLY;
addReplyMultiBulkLen(c,3);
addReplyBulkCString(c,"REPLCONF");
addReplyBulkCString(c,"ACK");
addReplyBulkLongLong(c,c->reploff);
// 写入成功，设置会不响应master命令的状态
c->flags &= ~CLIENT_MASTER_FORCE_REPLY;
}
}
REPLCONF-ACK实现
/* REPLCONF <option> <value> <option> <value> ...
* 这个命令用于在SYNC命令之前配置复制进程。
* 当前这个命令用于和master通信，
* 1) 用来告诉master端口号等相关信息，使得master的info输出中可以正确的输出相关信息。
* 2) 也用来告诉master复制过程中的相关配置信息如CAPA来让master决策。
* */
void replconfCommand(client *c) {
int j;
if ((c->argc % 2) == 0) {
/* Number of arguments must be odd to make sure that every
* option has a corresponding value. */
addReply(c,shared.syntaxerr);
return;
}
/* Process every option-value pair. */
for (j = 1; j < c->argc; j+=2) {
if (!strcasecmp(c->argv[j]->ptr,"listening-port")) {
long port;
if ((getLongFromObjectOrReply(c,c->argv[j+1],
&port,NULL) != C_OK))
return;
c->slave_listening_port = port;
} else if (!strcasecmp(c->argv[j]->ptr,"ip-address")) {
sds ip = c->argv[j+1]->ptr;
if (sdslen(ip) < sizeof(c->slave_ip)) {
memcpy(c->slave_ip,ip,sdslen(ip)+1);
} else {
addReplyErrorFormat(c,"REPLCONF ip-address provided by "
"replica instance is too long: %zd bytes", sdslen(ip));
return;
}
} else if (!strcasecmp(c->argv[j]->ptr,"capa")) {
/* Ignore capabilities not understood by this master. */
if (!strcasecmp(c->argv[j+1]->ptr,"eof"))
c->slave_capa |= SLAVE_CAPA_EOF;
else if (!strcasecmp(c->argv[j+1]->ptr,"psync2"))
c->slave_capa |= SLAVE_CAPA_PSYNC2;
} else if (!strcasecmp(c->argv[j]->ptr,"ack")) {
/* REPLCONF ACK用来向master报告复制偏移量。这个内部命令仅仅被用于slave。 */
long long offset;
if (!(c->flags & CLIENT_SLAVE)) return;
if ((getLongLongFromObject(c->argv[j+1], &offset) != C_OK))
return;
if (offset > c->repl_ack_off)
c->repl_ack_off = offset;
c->repl_ack_time = server.unixtime;
/* 如果是无盘复制，当接收到第一个ACK时，我们需要让slave真正在线 */
if (c->repl_put_online_on_ack && c->replstate == SLAVE_STATE_ONLINE)
putSlaveOnline(c);
/* 这个命令什么都不会返回 */
return;
} else if (!strcasecmp(c->argv[j]->ptr,"getack")) {
/* REPLCONF GETACK is used in order to request an ACK ASAP
* to the slave. */
if (server.masterhost && server.master) replicationSendAck();
return;
} else {
addReplyErrorFormat(c,"Unrecognized REPLCONF option: %s",
(char*)c->argv[j]->ptr);
return;
}
}
addReply(c,shared.ok);
}
addReply实现
/* 把robj对象的字符串表示写入到客户端的output buffer */
void addReply(client *c, robj *obj) {
if (prepareClientToWrite(c) != C_OK) return;
if (sdsEncodedObject(obj)) {
if (_addReplyToBuffer(c,obj->ptr,sdslen(obj->ptr)) != C_OK)
_addReplyStringToList(c,obj->ptr,sdslen(obj->ptr));
} else if (obj->encoding == OBJ_ENCODING_INT) {
/* For integer encoded strings we just convert it into a string
* using our optimized function, and attach the resulting string
* to the output buffer. */
char buf[32];
size_t len = ll2string(buf,sizeof(buf),(long)obj->ptr);
if (_addReplyToBuffer(c,buf,len) != C_OK)
_addReplyStringToList(c,buf,len);
} else {
serverPanic("Wrong obj->encoding in addReply()");
}
}
/* 当我们每次想往客户端传输数据时，这个函数都会被调用.
*
* 如果客户端(正常的客户端)应该接受新的数据,这个函数将会返回C_OK,并且确保当socket可写时
* 在AE事件循环中安装好命令回复处理器.
*
* 当客户端不应该接收一个数据时,比如fake客户端(比如用来在内存中做AOF的),作为主服务器
* 或者安装命令回复处理器失败时,将会返回C_ERR.
*
* 这个函数在以下两种情况下不会安装命令回复处理器就回复C_OK：
* 1) 当命令回复处理器已经被安装了；
* 2) 当客户端是从服务器但是不在线，我们想要加速写，所以不确保会发送数据.
*
* 典型的，这个函数将会在reply准备好，在写入客户端的回复缓冲区前调用。
* 如果没有数据应该增加，将会返回ERR
*/
int prepareClientToWrite(client *c) {
/* Lua客户端和Module客户端一定需要获得数据，但是我们不安装命令回复器，因为没有socket */
if (c->flags & (CLIENT_LUA|CLIENT_MODULE)) return C_OK;
/* CLIENT REPLY OFF / SKIP handling: don't send replies. */
if (c->flags & (CLIENT_REPLY_OFF|CLIENT_REPLY_SKIP)) return C_ERR;
/* master不接受reply，除非设置了CLIENT_MASTER_FORCE_REPLY标志 */
if ((c->flags & CLIENT_MASTER) &&
!(c->flags & CLIENT_MASTER_FORCE_REPLY)) return C_ERR;
if (c->fd <= 0) return C_ERR; /* AOF加载时的Fake客户端 */
/* 如果当前已经安装了-输出缓冲区中仍然有数据，则不再重复安装 */
if (!clientHasPendingReplies(c)) clientInstallWriteHandler(c);
/* Authorize the caller to queue in the output buffer of this client. */
return C_OK;
}
附：PSYNC命令格式
PSYNC完整重同步
PSYNC完整重同步命令响应格式：
{{空行，可选，在RDB文件准备好前，用来作为心跳}}
{PSYNC命令响应}}
{{空行，可选，在RDB文件准备好前，用来作为心跳}}
${{RDB文件长度}}
{{RBD文件内容}}
{{复制缓冲区里的增量数据，以RESP协议给出}}
* example:
PSYNC ? -1
+FULLRESYNC 9efadab34a079389ac0b56d91b7ec43f461a0fb3 308
$281
REDIS0009� redis-ver6.0.6�
:_used-mem�`' �repl-stream-db��repl-id(9efadab34a079389ac0b56d91b7ec43f461a0fb3�
repl-offset�4�
aof-preamble���beahelloworldkvmy_msgs�Qx.
�a�b�s�Qx.cehW%�$|�*1
$4
PING
*1
$4
PING
*2
$6
SELECT
$1
0
*3
$3
set
$3
yhl
$5
dalao
*1
$4
PING
*1
$4
PING
PSYNC部分重同步
PSYNC部分重同步命令响应格式：
PSYNC 353ca630322b75bf51ed679d28f7c8c391634782 24
+CONTINUE
ING
*1
$4
PING
*1
$4
PING
*1
$4
PING
*2
$6
SELECT
$1
0
*3
$3
set
$1
a
$1
b
网友评论