From 8996bf77204b6084796608ebad3b1688212d8bfc Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 31 Oct 2011 11:13:28 +0100
Subject: [PATCH] 7c6da73

---
 redis.conf        | 11 +++++++++++
 src/config.c      | 12 ++++++++++++
 src/redis.c       |  2 ++
 src/redis.h       |  5 +++++
 src/replication.c |  9 +++------
 5 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/redis.conf b/redis.conf
index 1138f2fb..e59f184d 100644
--- a/redis.conf
+++ b/redis.conf
@@ -135,6 +135,17 @@ dir ./
 #
 slave-serve-stale-data yes
 
+# Slaves send PINGs to server in a predefined interval. It's possible to change
+# this interval with the repl_ping_slave_period option. The default value is 10
+# seconds.
+#
+# repl_ping_slave_period 10
+
+# The following option sets a timeout for both Bulk transfer I/O timeout and
+# master data or ping response timeout. The default value is 60 seconds.
+#
+# repl_timeout 60
+
 ################################## SECURITY ###################################
 
 # Require clients to issue AUTH <PASSWORD> before processing any other
diff --git a/src/config.c b/src/config.c
index 6e310701..9f71aaf6 100644
--- a/src/config.c
+++ b/src/config.c
@@ -194,6 +194,18 @@ void loadServerConfig(char *filename) {
             server.masterhost = sdsnew(argv[1]);
             server.masterport = atoi(argv[2]);
             server.replstate = REDIS_REPL_CONNECT;
+        } else if (!strcasecmp(argv[0],"repl-ping-slave-period") && argc == 2) {
+            server.repl_ping_slave_period = atoi(argv[1]);
+            if (server.repl_ping_slave_period <= 0) {
+                err = "repl-ping-slave-period must be 1 or greater";
+                goto loaderr;
+            }
+        } else if (!strcasecmp(argv[0],"repl-timeout") && argc == 2) {
+            server.repl_timeout = atoi(argv[1]);
+            if (server.repl_timeout <= 0) {
+                err = "repl-timeout must be 1 or greater";
+                goto loaderr;
+            }
         } else if (!strcasecmp(argv[0],"masterauth") && argc == 2) {
         	server.masterauth = zstrdup(argv[1]);
         } else if (!strcasecmp(argv[0],"slave-serve-stale-data") && argc == 2) {
diff --git a/src/redis.c b/src/redis.c
index 53ac5350..a7d8254b 100644
--- a/src/redis.c
+++ b/src/redis.c
@@ -869,6 +869,8 @@ void initServerConfig() {
     server.zset_max_ziplist_entries = REDIS_ZSET_MAX_ZIPLIST_ENTRIES;
     server.zset_max_ziplist_value = REDIS_ZSET_MAX_ZIPLIST_VALUE;
     server.shutdown_asap = 0;
+	server.repl_ping_slave_period = REDIS_REPL_PING_SLAVE_PERIOD;
+	server.repl_timeout = REDIS_REPL_TIMEOUT;
     server.cluster_enabled = 0;
     server.cluster.configfile = zstrdup("nodes.conf");
     server.lua_time_limit = REDIS_LUA_TIME_LIMIT;
diff --git a/src/redis.h b/src/redis.h
index 54b9fc11..dda0f6c9 100644
--- a/src/redis.h
+++ b/src/redis.h
@@ -57,6 +57,9 @@
 #define REDIS_SLOWLOG_MAX_LEN 64
 #define REDIS_MAX_CLIENTS 10000
 
+#define REDIS_REPL_TIMEOUT 60
+#define REDIS_REPL_PING_SLAVE_PERIOD 10
+
 /* Hash table parameters */
 #define REDIS_HT_MINFILL        10      /* Minimal hash table fill 10% */
 
@@ -591,6 +594,8 @@ struct redisServer {
     char *masterauth;
     char *masterhost;
     int masterport;
+	int repl_ping_slave_period;
+	int repl_timeout;
     redisClient *master;    /* client that is master for this slave */
     int repl_syncio_timeout; /* timeout for synchronous I/O calls */
     int replstate;          /* replication status if the instance is a slave */
diff --git a/src/replication.c b/src/replication.c
index 13a1927a..712af110 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -504,13 +504,10 @@ void slaveofCommand(redisClient *c) {
 
 /* --------------------------- REPLICATION CRON  ---------------------------- */
 
-#define REDIS_REPL_TIMEOUT 60
-#define REDIS_REPL_PING_SLAVE_PERIOD 10
-
 void replicationCron(void) {
     /* Bulk transfer I/O timeout? */
     if (server.masterhost && server.replstate == REDIS_REPL_TRANSFER &&
-        (time(NULL)-server.repl_transfer_lastio) > REDIS_REPL_TIMEOUT)
+        (time(NULL)-server.repl_transfer_lastio) > server.repl_timeout)
     {
         redisLog(REDIS_WARNING,"Timeout receiving bulk data from MASTER...");
         replicationAbortSyncTransfer();
@@ -518,7 +515,7 @@ void replicationCron(void) {
 
     /* Timed out master when we are an already connected slave? */
     if (server.masterhost && server.replstate == REDIS_REPL_CONNECTED &&
-        (time(NULL)-server.master->lastinteraction) > REDIS_REPL_TIMEOUT)
+        (time(NULL)-server.master->lastinteraction) > server.repl_timeout)
     {
         redisLog(REDIS_WARNING,"MASTER time out: no data nor PING received...");
         freeClient(server.master);
@@ -536,7 +533,7 @@ void replicationCron(void) {
      * So slaves can implement an explicit timeout to masters, and will
      * be able to detect a link disconnection even if the TCP connection
      * will not actually go down. */
-    if (!(server.cronloops % (REDIS_REPL_PING_SLAVE_PERIOD*10))) {
+    if (!(server.cronloops % (server.repl_ping_slave_period*10))) {
         listIter li;
         listNode *ln;
 
-- 
2.45.2