设为首页收藏本站
切换到窄版

 找回密码
 用户注册

QQ登录

只需一步，快速开始

ACE Developer»论坛 › 开发基础 › 服务器端程序开发 › Redis源码分析：主从复制
返回列表 发新帖
查看: 6458|回复: 0

Redis源码分析：主从复制

[复制链接]
发表于 2012-2-7 10:13:12 | 显示全部楼层 |阅读模式
源码版本：redis 2.4.4
redis的主从复制实现简单却功能强大，其具有以下特点：
1. 一个master支持多个slave连接，slave可以接受其他slave的连接
2. 主从同步时，master和slave都是非阻塞的

redis主从复制可以用来：
1. data redundancy
2. slave作为master的扩展，提供一些read-only的服务
3. 可以将数据持久化放在slave做，从而提升master性能

通过简单的配置slave（master端无需配置），用户就能使用redis的主从复制
相关配置（redis.conf）：
slaveof <masterip> <masterport>
表示该redis服务作为slave，masterip和masterport分别为master 的ip和port

masterauth <master-password>
如果master设置了安全密码，则此处设置为相应的密码

slave-serve-stale-data yes
当slave丢失master或者同步正在进行时，如果发生对slave的服务请求：
slave-serve-stale-data设置为yes则slave依然正常提供服务
slave-serve-stale-data设置为no则slave返回client错误："SYNC with master in progress"

repl-ping-slave-period 10
slave发送PINGS到master的时间间隔

repl-timeout 60
IO超时时间


代码：
slave端
slave状态：
  2. /*
  3. Slave replication state - slave side */
  4. #define REDIS_REPL_NONE 0 /* No
  5. active replication */
  6. #define REDIS_REPL_CONNECT 1 /* Must connect to master
  7. */
  8. #define REDIS_REPL_CONNECTING 2 /* Connecting to master */
  9. #define
  10. REDIS_REPL_TRANSFER 3 /* Receiving .rdb from master */
  11. #define
  12. REDIS_REPL_CONNECTED 4 /* Connected to master */
  13. 初始化时设置
  14. server.replstate =
  15. REDIS_REPL_CONNECT
  16. 即slave需要连接master
  17. slave周期性调用replicationCron，查看slave状态：
  18. void replicationCron(void) {
  19.     /*判断是否IO超时*/
  20.     if (server.masterhost && server.replstate == REDIS_REPL_TRANSFER &&
  21.         (time(NULL)-server.repl_transfer_lastio) > server.repl_timeout)
  22.     {
  23.         redisLog(REDIS_WARNING,"Timeout receiving bulk data from MASTER...");
  24.         replicationAbortSyncTransfer(); //终止连接，并设置server.replstate = REDIS_REPL_CONNECT;
  25.     }
  27.     /* Timed out master when we are an already connected slave? */
  28.     if (server.masterhost && server.replstate == REDIS_REPL_CONNECTED &&
  29.         (time(NULL)-server.master->lastinteraction) > server.repl_timeout)
  30.     {
  31.         redisLog(REDIS_WARNING,"MASTER time out: no data nor PING received...");
  32.         freeClient(server.master);
  33.     }
  35.     /* Check if we should connect to a MASTER */
  36.     if (server.replstate == REDIS_REPL_CONNECT) {
  37.         redisLog(REDIS_NOTICE,"Connecting to MASTER...");
  38.         if (connectWithMaster() == REDIS_OK) { //连接master
  39.             redisLog(REDIS_NOTICE,"MASTER <-> SLAVE sync started");
  40.         }
  41.     }
  42.    
  43.     /* If we have attached slaves, PING them from time to time.
  44.      * So slaves can implement an explicit timeout to masters, and will
  45.      * be able to detect a link disconnection even if the TCP connection
  46.      * will not actually go down. */
  47.     if (!(server.cronloops % (server.repl_ping_slave_period*10))) {
  48.         listIter li;
  49.         listNode *ln;
  51.         listRewind(server.slaves,&li);
  52.         while((ln = listNext(&li))) {
  53.             redisClient *slave = ln->value;
  55.             /* Don't ping slaves that are in the middle of a bulk transfer
  56.              * with the master for first synchronization. */
  57.             if (slave->replstate == REDIS_REPL_SEND_BULK) continue;
  58.             if (slave->replstate == REDIS_REPL_ONLINE) {
  59.                 /* If the slave is online send a normal ping */
  60.                 addReplySds(slave,sdsnew("PING\r\n"));
  61.             } else {
  62.                 /* Otherwise we are in the pre-synchronization stage.
  63.                  * Just a newline will do the work of refreshing the
  64.                  * connection last interaction time, and at the same time
  65.                  * we'll be sure that being a single char there are no
  66.                  * short-write problems. */
  67.                 if (write(slave->fd, "\n", 1) == -1) {
  68.                     /* Don't worry, it's just a ping. */
  69.                 }
  70.             }
  71.         }
  72.     }
  73. }
  75. 当server.replstate ==
  76. REDIS_REPL_CONNECT时，slave连接master，连接成功后，slave执行syncWithMaster函数，syncWithMaster将向master发送SYNC命令
  77. int connectWithMaster(void) {
  78.     int fd;
  80.     fd = anetTcpNonBlockConnect(NULL,server.masterhost,server.masterport);
  81.     if (fd == -1) {
  82.         redisLog(REDIS_WARNING,"Unable to connect to MASTER: %s",
  83.             strerror(errno));
  84.         return REDIS_ERR;
  85.     }
  87.     if (aeCreateFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE,syncWithMaster,NULL) ==
  88.             AE_ERR)
  89.     {
  90.         close(fd);
  91.         redisLog(REDIS_WARNING,"Can't create readable event for SYNC");
  92.         return REDIS_ERR;
  93.     }
  95.     server.repl_transfer_s = fd;
  96.     server.replstate = REDIS_REPL_CONNECTING;
  97.     return REDIS_OK;
  98. }
复制代码

master端：
  2. master对于slave的连接和client的连接统一处理，在接收到slave发出的SYNC命令后，执行syncCommand,syncCommand
  3. 将查看当前状态，如果正在做快照，则等待，否则启动后台进程做快照。
  4. void syncCommand(redisClient *c) {
  5.     /* ignore SYNC if aleady slave or in monitor mode */
  6.     if (c->flags & REDIS_SLAVE) return;
  8.     /* Refuse SYNC requests if we are a slave but the link with our master
  9.      * is not ok... */
  10.     if (server.masterhost && server.replstate != REDIS_REPL_CONNECTED) {
  11.         addReplyError(c,"Can't SYNC while not connected with my master");
  12.         return;
  13.     }
  15.     /* SYNC can't be issued when the server has pending data to send to
  16.      * the client about already issued commands. We need a fresh reply
  17.      * buffer registering the differences between the BGSAVE and the current
  18.      * dataset, so that we can copy to other slaves if needed. */
  19.     if (listLength(c->reply) != 0) {
  20.         addReplyError(c,"SYNC is invalid with pending input");
  21.         return;
  22.     }
  24.     redisLog(REDIS_NOTICE,"Slave ask for synchronization");
  25.     /* Here we need to check if there is a background saving operation
  26.      * in progress, or if it is required to start one */
  27.     if (server.bgsavechildpid != -1) {
  28.        .....
  29.     } else {
  30.         /* Ok we don't have a BGSAVE in progress, let's start one */
  31.         redisLog(REDIS_NOTICE,"Starting BGSAVE for SYNC");
  32.         if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
  33.             redisLog(REDIS_NOTICE,"Replication failed, can't BGSAVE");
  34.             addReplyError(c,"Unable to perform background save");
  35.             return;
  36.         }
  37.         c->replstate = REDIS_REPL_WAIT_BGSAVE_END;
  38.     }
  39.     c->repldbfd = -1;
  40.     c->flags |= REDIS_SLAVE;
  41.     c->slaveseldb = 0;
  42.     listAddNodeTail(server.slaves,c);
  43.     return;
  44. }
  45. 在完成快照后，执行updateSlavesWaitingBgsave函数，updateSlavesWaitingBgsave将查看当前master的各个slave的状态，如果发现有在等待bgsave完成的，则注册事件sendBulkToSlave，sendBulkToSlave将快照文件发送给slavevoid updateSlavesWaitingBgsave(int bgsaveerr) {
  46.     listNode *ln;
  47.     int startbgsave = 0;
  48.     listIter li;
  50.     listRewind(server.slaves,&li);
  51.     while((ln = listNext(&li))) {
  52.         redisClient *slave = ln->value;
  54.         if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) {
  55.             startbgsave = 1;
  56.             slave->replstate = REDIS_REPL_WAIT_BGSAVE_END;
  57.         } else if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_END) {
  58.             struct redis_stat buf;
  60.             if (bgsaveerr != REDIS_OK) {
  61.                 freeClient(slave);
  62.                 redisLog(REDIS_WARNING,"SYNC failed. BGSAVE child returned an error");
  63.                 continue;
  64.             }
  65.             if ((slave->repldbfd = open(server.dbfilename,O_RDONLY)) == -1 ||
  66.                 redis_fstat(slave->repldbfd,&buf) == -1) {
  67.                 freeClient(slave);
  68.                 redisLog(REDIS_WARNING,"SYNC failed. Can't open/stat DB after BGSAVE: %s", strerror(errno));
  69.                 continue;
  70.             }
  71.             slave->repldboff = 0;
  72.             slave->repldbsize = buf.st_size;
  73.             slave->replstate = REDIS_REPL_SEND_BULK;
  74.             aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
  75.             if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave) == AE_ERR) {
  76.                 freeClient(slave);
  77.                 continue;
  78.             }
  79.         }
  80.     }
  81.     if (startbgsave) {
  82.         if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
  83.             listIter li;
  85.             listRewind(server.slaves,&li);
  86.             redisLog(REDIS_WARNING,"SYNC failed. BGSAVE failed");
  87.             while((ln = listNext(&li))) {
  88.                 redisClient *slave = ln->value;
  90.                 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START)
  91.                     freeClient(slave);
  92.             }
  93.         }
  94.     }
  95. }
复制代码

在slave完成第一次的同步后，后续如果master接收到改变db状态的命令，则调用replicationFeedSlaves将相应变更发送slave
  2. /* Call() is the core of Redis execution of a command */
  3. void call(redisClient *c) {
  4.     long long dirty, start = ustime(), duration;
  6.     dirty = server.dirty;
  7.     c->cmd->proc(c);
  8.     dirty = server.dirty-dirty;
  9.     duration = ustime()-start;
  10.     slowlogPushEntryIfNeeded(c->argv,c->argc,duration);
  12.     if (server.appendonly && dirty > 0)
  13.         feedAppendOnlyFile(c->cmd,c->db->id,c->argv,c->argc);
  14.     if ((dirty > 0 || c->cmd->flags & REDIS_CMD_FORCE_REPLICATION) &&
  15.         listLength(server.slaves))
  16.         replicationFeedSlaves(server.slaves,c->db->id,c->argv,c->argc);
  17.     if (listLength(server.monitors))
  18.         replicationFeedMonitors(server.monitors,c->db->id,c->argv,c->argc);
  19.     server.stat_numcommands++;
  20. }
复制代码
总结：
1. redis主从复制，并没有增加太多额外代码，但是功能强大，支持多个slave，并且支持slave作为master。
2. redis虽然宣称主从复制无阻塞，但是，由于redis使用单线程服务，而和slave的交互由处理线程统一处理，因此，对性能有影响。在slave第一次和master做同步时，如果master快照文件较大，则快照文件的传输将耗费较长时间，文件传输过程中master无法提供服务。

作者：yfkiss 发表于2012-2-6 22:07:47 原文链接

傲游高品质VPS主机，特价促销
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 用户注册

本版积分规则

Archiver|手机版|小黑屋|ACE Developer ( 京ICP备06055248号 )

GMT+8, 2024-11-24 13:12 , Processed in 0.015788 second(s), 6 queries , Redis On.

Powered by Discuz! X3.5

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表