From 2ef8c2f6c22e27507e62bf937a5b4e9f7429fdbd Mon Sep 17 00:00:00 2001
From: Richard Li <aspirewit@gmail.com>
Date: Fri, 18 Aug 2017 11:27:04 +0800
Subject: [PATCH 001/219] Update the comment

---
 src/notify.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/notify.c b/src/notify.c
index 94a1f2e79..79c1fc048 100644
--- a/src/notify.c
+++ b/src/notify.c
@@ -29,8 +29,8 @@
 
 #include "server.h"
 
-/* This file implements keyspace events notification via Pub/Sub ad
- * described at http://redis.io/topics/keyspace-events. */
+/* This file implements keyspace events notification via Pub/Sub and
+ * described at https://redis.io/topics/notifications. */
 
 /* Turn a string representing notification classes into an integer
  * representing notification classes flags xored.

From e8901b2fe489013b17e943d2721f961a50bda07c Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Fri, 8 Dec 2017 15:37:08 +0800
Subject: [PATCH 002/219] zset: fix the int problem

---
 src/server.h |  2 +-
 src/t_zset.c | 22 +++++++++++++---------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/server.h b/src/server.h
index ee3b7df5c..9917c1f88 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1590,7 +1590,7 @@ void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr);
 void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr);
 unsigned char *zzlFirstInRange(unsigned char *zl, zrangespec *range);
 unsigned char *zzlLastInRange(unsigned char *zl, zrangespec *range);
-unsigned int zsetLength(const robj *zobj);
+unsigned long zsetLength(const robj *zobj);
 void zsetConvert(robj *zobj, int encoding);
 void zsetConvertToZiplistIfNeeded(robj *zobj, size_t maxelelen);
 int zsetScore(robj *zobj, sds member, double *score);
diff --git a/src/t_zset.c b/src/t_zset.c
index f7f4c6eb2..cfd5f2b9b 100644
--- a/src/t_zset.c
+++ b/src/t_zset.c
@@ -1100,8 +1100,8 @@ unsigned char *zzlDeleteRangeByRank(unsigned char *zl, unsigned int start, unsig
  * Common sorted set API
  *----------------------------------------------------------------------------*/
 
-unsigned int zsetLength(const robj *zobj) {
-    int length = -1;
+unsigned long zsetLength(const robj *zobj) {
+    unsigned long length = 0;
     if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
         length = zzlLength(zobj->ptr);
     } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
@@ -1878,7 +1878,7 @@ void zuiClearIterator(zsetopsrc *op) {
     }
 }
 
-int zuiLength(zsetopsrc *op) {
+unsigned long zuiLength(zsetopsrc *op) {
     if (op->subject == NULL)
         return 0;
 
@@ -2085,7 +2085,11 @@ int zuiFind(zsetopsrc *op, zsetopval *val, double *score) {
 }
 
 int zuiCompareByCardinality(const void *s1, const void *s2) {
-    return zuiLength((zsetopsrc*)s1) - zuiLength((zsetopsrc*)s2);
+    unsigned long first = zuiLength((zsetopsrc*)s1);
+    unsigned long second = zuiLength((zsetopsrc*)s2);
+    if (first > second) return 1;
+    if (first < second) return -1;
+    return 0;
 }
 
 #define REDIS_AGGR_SUM 1
@@ -2129,7 +2133,7 @@ void zunionInterGenericCommand(client *c, robj *dstkey, int op) {
     zsetopsrc *src;
     zsetopval zval;
     sds tmp;
-    unsigned int maxelelen = 0;
+    size_t maxelelen = 0;
     robj *dstobj;
     zset *dstzset;
     zskiplistNode *znode;
@@ -2363,8 +2367,8 @@ void zrangeGenericCommand(client *c, int reverse) {
     int withscores = 0;
     long start;
     long end;
-    int llen;
-    int rangelen;
+    long llen;
+    long rangelen;
 
     if ((getLongFromObjectOrReply(c, c->argv[2], &start, NULL) != C_OK) ||
         (getLongFromObjectOrReply(c, c->argv[3], &end, NULL) != C_OK)) return;
@@ -2671,7 +2675,7 @@ void zcountCommand(client *c) {
     robj *key = c->argv[1];
     robj *zobj;
     zrangespec range;
-    int count = 0;
+    unsigned long count = 0;
 
     /* Parse the range arguments */
     if (zslParseRange(c->argv[2],c->argv[3],&range) != C_OK) {
@@ -2748,7 +2752,7 @@ void zlexcountCommand(client *c) {
     robj *key = c->argv[1];
     robj *zobj;
     zlexrangespec range;
-    int count = 0;
+    unsigned long count = 0;
 
     /* Parse the range arguments */
     if (zslParseLexRange(c->argv[2],c->argv[3],&range) != C_OK) {

From 109ee497be24906e7931d33b71e3a6e78c5de77b Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Fri, 8 Dec 2017 16:09:27 +0800
Subject: [PATCH 003/219] zset: change the span of zskiplistNode to unsigned
 long

---
 src/server.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/server.h b/src/server.h
index 9917c1f88..f3a970659 100644
--- a/src/server.h
+++ b/src/server.h
@@ -335,7 +335,7 @@ typedef long long mstime_t; /* millisecond time type. */
 /* Anti-warning macro... */
 #define UNUSED(V) ((void) V)
 
-#define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^32 elements */
+#define ZSKIPLIST_MAXLEVEL 64 /* Should be enough for 2^64 elements */
 #define ZSKIPLIST_P 0.25      /* Skiplist P = 1/4 */
 
 /* Append only defines */
@@ -774,7 +774,7 @@ typedef struct zskiplistNode {
     struct zskiplistNode *backward;
     struct zskiplistLevel {
         struct zskiplistNode *forward;
-        unsigned int span;
+        unsigned long span;
     } level[];
 } zskiplistNode;
 

From 968cb2669346ebcb20016ac16923dcd31e31ad2f Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Fri, 26 Jan 2018 22:49:39 +0800
Subject: [PATCH 004/219] config: handle special configuration "" for auth

---
 src/config.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/config.c b/src/config.c
index eddfe1f11..1e3fd1848 100644
--- a/src/config.c
+++ b/src/config.c
@@ -390,7 +390,7 @@ void loadServerConfigFromString(char *config) {
             }
         } else if (!strcasecmp(argv[0],"masterauth") && argc == 2) {
             zfree(server.masterauth);
-            server.masterauth = zstrdup(argv[1]);
+            server.masterauth = argv[1][0] ? zstrdup(argv[1]) : NULL;
         } else if (!strcasecmp(argv[0],"slave-serve-stale-data") && argc == 2) {
             if ((server.repl_serve_stale_data = yesnotoi(argv[1])) == -1) {
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
@@ -496,7 +496,7 @@ void loadServerConfigFromString(char *config) {
                 err = "Password is longer than CONFIG_AUTHPASS_MAX_LEN";
                 goto loaderr;
             }
-            server.requirepass = zstrdup(argv[1]);
+            server.requirepass = argv[1][0] ? zstrdup(argv[1]) : NULL;
         } else if (!strcasecmp(argv[0],"pidfile") && argc == 2) {
             zfree(server.pidfile);
             server.pidfile = zstrdup(argv[1]);

From f4eb64cd3537ce34e0125fa1fb6cccb6dbfc3e48 Mon Sep 17 00:00:00 2001
From: "pan.liangp" <pan.liangp@r10f07454.sqa.zmf>
Date: Fri, 2 Mar 2018 17:16:00 +0800
Subject: [PATCH 005/219] move get clients max buffer calculate into info
 clients command

---
 src/server.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/server.c b/src/server.c
index 1a6f30381..8e62dd176 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2866,7 +2866,6 @@ sds genRedisInfoString(char *section) {
 
     getrusage(RUSAGE_SELF, &self_ru);
     getrusage(RUSAGE_CHILDREN, &c_ru);
-    getClientsMaxBuffers(&lol,&bib);
 
     /* Server */
     if (allsections || defsections || !strcasecmp(section,"server")) {
@@ -2936,6 +2935,7 @@ sds genRedisInfoString(char *section) {
 
     /* Clients */
     if (allsections || defsections || !strcasecmp(section,"clients")) {
+        getClientsMaxBuffers(&lol,&bib);
         if (sections++) info = sdscat(info,"\r\n");
         info = sdscatprintf(info,
             "# Clients\r\n"

From 54cae05ea736340b4afe463eb750f5acdfe07590 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Fri, 16 Mar 2018 00:44:50 +0800
Subject: [PATCH 006/219] rdb: incremental fsync when redis saves rdb

---
 src/aof.c    | 10 +++++-----
 src/bio.c    |  2 +-
 src/config.c | 12 ++++++++++++
 src/config.h |  6 +++---
 src/rdb.c    |  4 ++++
 src/rio.c    |  2 +-
 src/server.c |  3 ++-
 src/server.h |  6 ++++--
 8 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/src/aof.c b/src/aof.c
index 4a7d749d0..7712a779e 100644
--- a/src/aof.c
+++ b/src/aof.c
@@ -228,7 +228,7 @@ static void killAppendOnlyChild(void) {
 void stopAppendOnly(void) {
     serverAssert(server.aof_state != AOF_OFF);
     flushAppendOnlyFile(1);
-    aof_fsync(server.aof_fd);
+    redis_fsync(server.aof_fd);
     close(server.aof_fd);
 
     server.aof_fd = -1;
@@ -476,10 +476,10 @@ void flushAppendOnlyFile(int force) {
 
     /* Perform the fsync if needed. */
     if (server.aof_fsync == AOF_FSYNC_ALWAYS) {
-        /* aof_fsync is defined as fdatasync() for Linux in order to avoid
+        /* redis_fsync is defined as fdatasync() for Linux in order to avoid
          * flushing metadata. */
         latencyStartMonitor(latency);
-        aof_fsync(server.aof_fd); /* Let's try to get this data on the disk */
+        redis_fsync(server.aof_fd); /* Let's try to get this data on the disk */
         latencyEndMonitor(latency);
         latencyAddSampleIfNeeded("aof-fsync-always",latency);
         server.aof_last_fsync = server.unixtime;
@@ -1241,7 +1241,7 @@ int rewriteAppendOnlyFile(char *filename) {
     rioInitWithFile(&aof,fp);
 
     if (server.aof_rewrite_incremental_fsync)
-        rioSetAutoSync(&aof,AOF_AUTOSYNC_BYTES);
+        rioSetAutoSync(&aof,REDIS_AUTOSYNC_BYTES);
 
     if (server.aof_use_rdb_preamble) {
         int error;
@@ -1609,7 +1609,7 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
             oldfd = server.aof_fd;
             server.aof_fd = newfd;
             if (server.aof_fsync == AOF_FSYNC_ALWAYS)
-                aof_fsync(newfd);
+                redis_fsync(newfd);
             else if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
                 aof_background_fsync(newfd);
             server.aof_selected_db = -1; /* Make sure SELECT is re-issued */
diff --git a/src/bio.c b/src/bio.c
index da11f7b86..0c92d053b 100644
--- a/src/bio.c
+++ b/src/bio.c
@@ -187,7 +187,7 @@ void *bioProcessBackgroundJobs(void *arg) {
         if (type == BIO_CLOSE_FILE) {
             close((long)job->arg1);
         } else if (type == BIO_AOF_FSYNC) {
-            aof_fsync((long)job->arg1);
+            redis_fsync((long)job->arg1);
         } else if (type == BIO_LAZY_FREE) {
             /* What we free changes depending on what arguments are set:
              * arg1 -> free the object at pointer.
diff --git a/src/config.c b/src/config.c
index eddfe1f11..f4187633e 100644
--- a/src/config.c
+++ b/src/config.c
@@ -483,6 +483,13 @@ void loadServerConfigFromString(char *config) {
                  yesnotoi(argv[1])) == -1) {
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
             }
+        } else if (!strcasecmp(argv[0],"rdb-save-incremental-fsync") &&
+                   argc == 2)
+        {
+            if ((server.rdb_save_incremental_fsync =
+                 yesnotoi(argv[1])) == -1) {
+                err = "argument must be 'yes' or 'no'"; goto loaderr;
+            }
         } else if (!strcasecmp(argv[0],"aof-load-truncated") && argc == 2) {
             if ((server.aof_load_truncated = yesnotoi(argv[1])) == -1) {
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
@@ -999,6 +1006,8 @@ void configSetCommand(client *c) {
       "cluster-require-full-coverage",server.cluster_require_full_coverage) {
     } config_set_bool_field(
       "aof-rewrite-incremental-fsync",server.aof_rewrite_incremental_fsync) {
+    } config_set_bool_field(
+      "rdb-save-incremental-fsync",server.rdb_save_incremental_fsync) {
     } config_set_bool_field(
       "aof-load-truncated",server.aof_load_truncated) {
     } config_set_bool_field(
@@ -1311,6 +1320,8 @@ void configGetCommand(client *c) {
             server.repl_diskless_sync);
     config_get_bool_field("aof-rewrite-incremental-fsync",
             server.aof_rewrite_incremental_fsync);
+    config_get_bool_field("rdb-save-incremental-fsync",
+            server.rdb_save_incremental_fsync);
     config_get_bool_field("aof-load-truncated",
             server.aof_load_truncated);
     config_get_bool_field("aof-use-rdb-preamble",
@@ -2044,6 +2055,7 @@ int rewriteConfig(char *path) {
     rewriteConfigClientoutputbufferlimitOption(state);
     rewriteConfigNumericalOption(state,"hz",server.hz,CONFIG_DEFAULT_HZ);
     rewriteConfigYesNoOption(state,"aof-rewrite-incremental-fsync",server.aof_rewrite_incremental_fsync,CONFIG_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC);
+    rewriteConfigYesNoOption(state,"rdb-save-incremental-fsync",server.rdb_save_incremental_fsync,CONFIG_DEFAULT_RDB_SAVE_INCREMENTAL_FSYNC);
     rewriteConfigYesNoOption(state,"aof-load-truncated",server.aof_load_truncated,CONFIG_DEFAULT_AOF_LOAD_TRUNCATED);
     rewriteConfigYesNoOption(state,"aof-use-rdb-preamble",server.aof_use_rdb_preamble,CONFIG_DEFAULT_AOF_USE_RDB_PREAMBLE);
     rewriteConfigEnumOption(state,"supervised",server.supervised_mode,supervised_mode_enum,SUPERVISED_NONE);
diff --git a/src/config.h b/src/config.h
index c23f1c789..ee3ad508e 100644
--- a/src/config.h
+++ b/src/config.h
@@ -87,11 +87,11 @@
 #endif
 #endif
 
-/* Define aof_fsync to fdatasync() in Linux and fsync() for all the rest */
+/* Define redis_fsync to fdatasync() in Linux and fsync() for all the rest */
 #ifdef __linux__
-#define aof_fsync fdatasync
+#define redis_fsync fdatasync
 #else
-#define aof_fsync fsync
+#define redis_fsync fsync
 #endif
 
 /* Define rdb_fsync_range to sync_file_range() on Linux, otherwise we use
diff --git a/src/rdb.c b/src/rdb.c
index 8f896983b..c824ab208 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -1060,6 +1060,10 @@ int rdbSave(char *filename, rdbSaveInfo *rsi) {
     }
 
     rioInitWithFile(&rdb,fp);
+
+    if (server.rdb_save_incremental_fsync)
+        rioSetAutoSync(&rdb,REDIS_AUTOSYNC_BYTES);
+
     if (rdbSaveRio(&rdb,&error,RDB_SAVE_NONE,rsi) == C_ERR) {
         errno = error;
         goto werr;
diff --git a/src/rio.c b/src/rio.c
index 23b907060..c9c76b8f2 100644
--- a/src/rio.c
+++ b/src/rio.c
@@ -116,7 +116,7 @@ static size_t rioFileWrite(rio *r, const void *buf, size_t len) {
         r->io.file.buffered >= r->io.file.autosync)
     {
         fflush(r->io.file.fp);
-        aof_fsync(fileno(r->io.file.fp));
+        redis_fsync(fileno(r->io.file.fp));
         r->io.file.buffered = 0;
     }
     return retval;
diff --git a/src/server.c b/src/server.c
index 1a6f30381..f4d6e95a3 100644
--- a/src/server.c
+++ b/src/server.c
@@ -1416,6 +1416,7 @@ void initServerConfig(void) {
     server.aof_selected_db = -1; /* Make sure the first time will not match */
     server.aof_flush_postponed_start = 0;
     server.aof_rewrite_incremental_fsync = CONFIG_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC;
+    server.rdb_save_incremental_fsync = CONFIG_DEFAULT_RDB_SAVE_INCREMENTAL_FSYNC;
     server.aof_load_truncated = CONFIG_DEFAULT_AOF_LOAD_TRUNCATED;
     server.aof_use_rdb_preamble = CONFIG_DEFAULT_AOF_USE_RDB_PREAMBLE;
     server.pidfile = NULL;
@@ -2585,7 +2586,7 @@ int prepareForShutdown(int flags) {
         /* Append only file: flush buffers and fsync() the AOF at exit */
         serverLog(LL_NOTICE,"Calling fsync() on the AOF file.");
         flushAppendOnlyFile(1);
-        aof_fsync(server.aof_fd);
+        redis_fsync(server.aof_fd);
     }
 
     /* Create a new RDB file before exiting. */
diff --git a/src/server.h b/src/server.h
index 29919f5ee..d25613244 100644
--- a/src/server.h
+++ b/src/server.h
@@ -143,6 +143,7 @@ typedef long long mstime_t; /* millisecond time type. */
 #define CONFIG_DEFAULT_AOF_USE_RDB_PREAMBLE 0
 #define CONFIG_DEFAULT_ACTIVE_REHASHING 1
 #define CONFIG_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC 1
+#define CONFIG_DEFAULT_RDB_SAVE_INCREMENTAL_FSYNC 1
 #define CONFIG_DEFAULT_MIN_SLAVES_TO_WRITE 0
 #define CONFIG_DEFAULT_MIN_SLAVES_MAX_LAG 10
 #define NET_IP_STR_LEN 46 /* INET6_ADDRSTRLEN is 46, but we need to be sure */
@@ -183,7 +184,7 @@ typedef long long mstime_t; /* millisecond time type. */
 #define PROTO_INLINE_MAX_SIZE   (1024*64) /* Max size of inline reads */
 #define PROTO_MBULK_BIG_ARG     (1024*32)
 #define LONG_STR_SIZE      21          /* Bytes needed for long -> str + '\0' */
-#define AOF_AUTOSYNC_BYTES (1024*1024*32) /* fdatasync every 32MB */
+#define REDIS_AUTOSYNC_BYTES (1024*1024*32) /* fdatasync every 32MB */
 
 /* When configuring the server eventloop, we setup it so that the total number
  * of file descriptors we can handle are server.maxclients + RESERVED_FDS +
@@ -1021,7 +1022,8 @@ struct redisServer {
     time_t aof_rewrite_time_start;  /* Current AOF rewrite start time. */
     int aof_lastbgrewrite_status;   /* C_OK or C_ERR */
     unsigned long aof_delayed_fsync;  /* delayed AOF fsync() counter */
-    int aof_rewrite_incremental_fsync;/* fsync incrementally while rewriting? */
+    int aof_rewrite_incremental_fsync;/* fsync incrementally while aof rewriting? */
+    int rdb_save_incremental_fsync;   /* fsync incrementally while rdb saving? */
     int aof_last_write_status;      /* C_OK or C_ERR */
     int aof_last_write_errno;       /* Valid if aof_last_write_status is ERR */
     int aof_load_truncated;         /* Don't stop on unexpected AOF EOF. */

From fd0c4c027713d1d34a8dd5ef62556b9ac0940d45 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Fri, 16 Mar 2018 00:48:59 +0800
Subject: [PATCH 007/219] add rdb-save-incremental-fsync option in redis.conf

---
 redis.conf | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/redis.conf b/redis.conf
index 1e1f5313f..427fc7dda 100644
--- a/redis.conf
+++ b/redis.conf
@@ -1193,6 +1193,12 @@ hz 10
 # big latency spikes.
 aof-rewrite-incremental-fsync yes
 
+# When redis saves RDB file, if the following option is enabled
+# the file will be fsync-ed every 32 MB of data generated. This is useful
+# in order to commit the file to the disk more incrementally and avoid
+# big latency spikes.
+rdb-save-incremental-fsync yes
+
 # Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good
 # idea to start with the default settings and only change them after investigating
 # how to improve the performances and how the keys LFU change over time, which

From 83cf0e3668f61a57bbaaedf47d35d8943352d893 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Thu, 29 Mar 2018 17:36:15 +0800
Subject: [PATCH 008/219] adjust position of _dictNextPower in dictExpand

---
 src/dict.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/dict.c b/src/dict.c
index 97e636805..a7b77aad5 100644
--- a/src/dict.c
+++ b/src/dict.c
@@ -146,14 +146,14 @@ int dictResize(dict *d)
 /* Expand or create the hash table */
 int dictExpand(dict *d, unsigned long size)
 {
-    dictht n; /* the new hash table */
-    unsigned long realsize = _dictNextPower(size);
-
     /* the size is invalid if it is smaller than the number of
      * elements already inside the hash table */
     if (dictIsRehashing(d) || d->ht[0].used > size)
         return DICT_ERR;
 
+    dictht n; /* the new hash table */
+    unsigned long realsize = _dictNextPower(size);
+
     /* Rehashing to the same table size is not useful. */
     if (realsize == d->ht[0].size) return DICT_ERR;
 

From 0fd2b25c8dc646dd86fe95021f2e5c0224f075da Mon Sep 17 00:00:00 2001
From: charpty <charpty@gmail.com>
Date: Fri, 6 Apr 2018 16:42:48 +0800
Subject: [PATCH 009/219] Remove unnecessary return statements

Signed-off-by: charpty <charpty@gmail.com>
---
 src/server.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/server.c b/src/server.c
index 7f51778d7..6210fa18e 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2866,7 +2866,6 @@ void bytesToHuman(char *s, unsigned long long n) {
     if (n < 1024) {
         /* Bytes */
         sprintf(s,"%lluB",n);
-        return;
     } else if (n < (1024*1024)) {
         d = (double)n/(1024);
         sprintf(s,"%.2fK",d);

From 24036b4d32d857066a2ccfc6cef2e8a751634ad5 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Sun, 22 Apr 2018 22:30:44 +0800
Subject: [PATCH 010/219] RDB: expand dict if needed when rdb load object

---
 src/rdb.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/rdb.c b/src/rdb.c
index 27c3aa786..639be1ea5 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -1427,6 +1427,9 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
         o = createZsetObject();
         zs = o->ptr;
 
+        if (zsetlen > DICT_HT_INITIAL_SIZE)
+            dictExpand(zs->dict,zsetlen);
+
         /* Load every single element of the sorted set. */
         while(zsetlen--) {
             sds sdsele;
@@ -1495,6 +1498,9 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
             sdsfree(value);
         }
 
+        if (o->encoding == OBJ_ENCODING_HT && len > DICT_HT_INITIAL_SIZE)
+            dictExpand(o->ptr,len);
+
         /* Load remaining fields and values into the hash table */
         while (o->encoding == OBJ_ENCODING_HT && len > 0) {
             len--;

From fd9177dd33de2bc8fddf1d304b7b5810d98c2a1d Mon Sep 17 00:00:00 2001
From: Krzysztof Filipek <krzysztof.filipek@intel.com>
Date: Sun, 6 May 2018 20:18:48 +0200
Subject: [PATCH 011/219] Typo in preprocessor condition

---
 src/zmalloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/zmalloc.c b/src/zmalloc.c
index 7cb4e3729..638bf60ff 100644
--- a/src/zmalloc.c
+++ b/src/zmalloc.c
@@ -415,7 +415,7 @@ size_t zmalloc_get_memory_size(void) {
     mib[0] = CTL_HW;
 #if defined(HW_REALMEM)
     mib[1] = HW_REALMEM;        /* FreeBSD. ----------------- */
-#elif defined(HW_PYSMEM)
+#elif defined(HW_PHYSMEM)
     mib[1] = HW_PHYSMEM;        /* Others. ------------------ */
 #endif
     unsigned int size = 0;      /* 32-bit */

From 8d93f924ea44c4139d690a914af662b6f059709a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B5=B5=E7=A3=8A?= <zhaolei21@meituan.com>
Date: Tue, 8 May 2018 15:30:11 +0800
Subject: [PATCH 012/219] Fix dictScan(): It can't scan all buckets when dict
 is shrinking.

---
 src/dict.c | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/dict.c b/src/dict.c
index 97e636805..18cb9ee79 100644
--- a/src/dict.c
+++ b/src/dict.c
@@ -858,6 +858,15 @@ unsigned long dictScan(dict *d,
             de = next;
         }
 
+        /* Set unmasked bits so incrementing the reversed cursor
+         * operates on the masked bits */
+        v |= ~m0;
+
+        /* Increment the reverse cursor */
+        v = rev(v);
+        v++;
+        v = rev(v);
+
     } else {
         t0 = &d->ht[0];
         t1 = &d->ht[1];
@@ -892,22 +901,16 @@ unsigned long dictScan(dict *d,
                 de = next;
             }
 
-            /* Increment bits not covered by the smaller mask */
-            v = (((v | m0) + 1) & ~m0) | (v & m0);
+            /* Increment the reverse cursor not covered by the smaller mask.*/
+            v |= ~m1;
+            v = rev(v);
+            v++;
+            v = rev(v);
 
             /* Continue while bits covered by mask difference is non-zero */
         } while (v & (m0 ^ m1));
     }
 
-    /* Set unmasked bits so incrementing the reversed cursor
-     * operates on the masked bits of the smaller table */
-    v |= ~m0;
-
-    /* Increment the reverse cursor */
-    v = rev(v);
-    v++;
-    v = rev(v);
-
     return v;
 }
 

From af3471a5dc1bf26e7bc2d1578f9bf82e9c7168a2 Mon Sep 17 00:00:00 2001
From: Mota <motablow@gmail.com>
Date: Fri, 25 May 2018 16:49:23 +0800
Subject: [PATCH 013/219] Fix debug crash-and-recover help info.

---
 src/debug.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/debug.c b/src/debug.c
index f239eea5a..0ab864e7f 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -287,7 +287,7 @@ void debugCommand(client *c) {
         const char *help[] = {
 "assert -- Crash by assertion failed.",
 "change-repl-id -- Change the replication IDs of the instance. Dangerous, should be used only for testing the replication subsystem.",
-"crash-and-recovery <milliseconds> -- Hard crash and restart after <milliseconds> delay.",
+"crash-and-recover <milliseconds> -- Hard crash and restart after <milliseconds> delay.",
 "digest -- Outputs an hex signature representing the current DB content.",
 "htstats <dbid> -- Return hash table statistics of the specified Redis database.",
 "loadaof -- Flush the AOF buffers on disk and reload the AOF in memory.",

From ce2e0c02fc67658e3e891ff4f732a17db3adfb96 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Sun, 27 May 2018 16:34:58 +0800
Subject: [PATCH 014/219] MEMORY: fix the missing of monitor clients buffers

---
 src/object.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/object.c b/src/object.c
index 82b82632b..214edda5c 100644
--- a/src/object.c
+++ b/src/object.c
@@ -968,7 +968,7 @@ struct redisMemOverhead *getMemoryOverheadData(void) {
         listRewind(server.clients,&li);
         while((ln = listNext(&li))) {
             client *c = listNodeValue(ln);
-            if (c->flags & CLIENT_SLAVE)
+            if (c->flags & CLIENT_SLAVE && !(c->flags & CLIENT_MONITOR))
                 continue;
             mem += getClientOutputBufferMemoryUsage(c);
             mem += sdsAllocSize(c->querybuf);

From 9561fec496bc7e753a12d919a72d49cf56f1fa4b Mon Sep 17 00:00:00 2001
From: Remi Collet <remi@remirepo.net>
Date: Wed, 30 May 2018 15:33:06 +0200
Subject: [PATCH 015/219] include stdint.h for unit64_t definition

---
 src/zmalloc.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/zmalloc.c b/src/zmalloc.c
index 31e686c4f..3a3c579f2 100644
--- a/src/zmalloc.c
+++ b/src/zmalloc.c
@@ -30,6 +30,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 
 /* This function provide us access to the original libc free(). This is useful
  * for instance to free results obtained by backtrace_symbols(). We need

From 4bce88b11fdf68ab754cf9125ffaac02c6428ff5 Mon Sep 17 00:00:00 2001
From: artix <artix2@gmail.com>
Date: Mon, 28 May 2018 17:23:42 +0200
Subject: [PATCH 016/219] Cluster Manager: fixed infinite loop in rebalance
 (Issue #4941).

---
 src/redis-cli.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index d106d8f5d..e1c1983d5 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -4887,7 +4887,7 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
         listRewind(involved, &li);
         while ((ln = listNext(&li)) != NULL) {
             clusterManagerNode *n = ln->value;
-            if (n->balance < 0 && total_balance > 0) {
+            if (n->balance <= 0 && total_balance > 0) {
                 n->balance--;
                 total_balance--;
             }

From 2f963080c16b3645c4b5ae443c85ee9f9025789b Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 31 May 2018 17:11:46 +0200
Subject: [PATCH 017/219] Capitalize OBJECT HELP subcommands.

---
 src/object.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/object.c b/src/object.c
index 82b82632b..a61023c75 100644
--- a/src/object.c
+++ b/src/object.c
@@ -1161,10 +1161,10 @@ void objectCommand(client *c) {
 
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"encoding <key> -- Return the kind of internal representation used in order to store the value associated with a key.",
-"freq <key> -- Return the access frequency index of the key. The returned integer is proportional to the logarithm of the recent access frequency of the key.",
-"idletime <key> -- Return the idle time of the key, that is the approximated number of seconds elapsed since the last access to the key.",
-"refcount <key> -- Return the number of references of the value associated with the specified key.",
+"ENCODING <key> -- Return the kind of internal representation used in order to store the value associated with a key.",
+"FREQ <key> -- Return the access frequency index of the key. The returned integer is proportional to the logarithm of the recent access frequency of the key.",
+"IDLETIME <key> -- Return the idle time of the key, that is the approximated number of seconds elapsed since the last access to the key.",
+"REFCOUNT <key> -- Return the number of references of the value associated with the specified key.",
 NULL
         };
         addReplyHelp(c, help);

From b9d19371e402fc8e6d1ca70863ab0e06889ff1c3 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Thu, 31 May 2018 23:35:47 +0800
Subject: [PATCH 018/219] ZPOP: unblock multiple clients in right way

---
 src/blocked.c | 4 +++-
 src/t_zset.c  | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/blocked.c b/src/blocked.c
index 023fba0cd..8d1157c2c 100644
--- a/src/blocked.c
+++ b/src/blocked.c
@@ -314,8 +314,9 @@ void handleClientsBlockedOnKeys(void) {
                 if (de) {
                     list *clients = dictGetVal(de);
                     int numclients = listLength(clients);
+                    unsigned long zcard = zsetLength(o);
 
-                    while(numclients--) {
+                    while(numclients-- && zcard) {
                         listNode *clientnode = listFirst(clients);
                         client *receiver = clientnode->value;
 
@@ -332,6 +333,7 @@ void handleClientsBlockedOnKeys(void) {
                                      ? ZSET_MIN : ZSET_MAX;
                         unblockClient(receiver);
                         genericZpopCommand(receiver,&rl->key,1,where,1,NULL);
+                        zcard--;
 
                         /* Replicate the command. */
                         robj *argv[2];
diff --git a/src/t_zset.c b/src/t_zset.c
index 11c8a051c..ae0922342 100644
--- a/src/t_zset.c
+++ b/src/t_zset.c
@@ -3216,9 +3216,9 @@ void blockingGenericZpopCommand(client *c, int where) {
                 return;
             } else {
                 if (zsetLength(o) != 0) {
-                    /* Non empty zset, this is like a normal Z[REV]POP. */
+                    /* Non empty zset, this is like a normal ZPOP[MIN|MAX]. */
                     genericZpopCommand(c,&c->argv[j],1,where,1,NULL);
-                    /* Replicate it as an Z[REV]POP instead of BZ[REV]POP. */
+                    /* Replicate it as an ZPOP[MIN|MAX] instead of BZPOP[MIN|MAX]. */
                     rewriteClientCommandVector(c,2,
                         where == ZSET_MAX ? shared.zpopmax : shared.zpopmin,
                         c->argv[j]);

From d168b245b331e5fd24e7edb15d0d04213f3a180f Mon Sep 17 00:00:00 2001
From: artix <artix2@gmail.com>
Date: Fri, 1 Jun 2018 15:32:44 +0200
Subject: [PATCH 019/219] Cluster Manager: fixed master_id check in
 clusterManagerNodeLoadInfo

---
 src/redis-cli.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index e1c1983d5..f406d505a 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -3088,7 +3088,7 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
                 currentNode->flags |= CLUSTER_MANAGER_FLAG_FAIL;
             else if (strcmp(flag, "slave") == 0) {
                 currentNode->flags |= CLUSTER_MANAGER_FLAG_SLAVE;
-                if (master_id == 0) {
+                if (master_id != NULL) {
                     if (currentNode->replicate) sdsfree(currentNode->replicate);
                     currentNode->replicate = sdsnew(master_id);
                 }

From 7d269d5e633911628625d279b54e48c8b38fec90 Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Sat, 2 Jun 2018 14:29:43 +0800
Subject: [PATCH 020/219] Fix DEBUG LOADAOF so that redis-server will not crash
 unexpectedly and will not be inconsistent after we call debug loadaof. Before
 this commit, there were 2 problems:

1, When appendonly is set to no and there is not a appendonly file,
   redis-server will crash if we call DEBUG LOADAOF.
2, When appendonly is set to no and there is a appendonly file,
   redis-server will hold different data after loading  appendonly
   file.
---
 src/debug.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/debug.c b/src/debug.c
index 0ab864e7f..26ea41323 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -347,7 +347,11 @@ NULL
         serverLog(LL_WARNING,"DB reloaded by DEBUG RELOAD");
         addReply(c,shared.ok);
     } else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) {
-        if (server.aof_state == AOF_ON) flushAppendOnlyFile(1);
+        if (server.aof_state == AOF_OFF) {
+            addReply(c, shared.err);
+            return;
+        }
+        flushAppendOnlyFile(1);
         emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);
         if (loadAppendOnlyFile(server.aof_filename) != C_OK) {
             addReply(c,shared.err);

From 1749fe7a26e6ce53ab90271aa807380bd9458d3a Mon Sep 17 00:00:00 2001
From: michael-grunder <michael.grunder@gmail.com>
Date: Sat, 2 Jun 2018 18:22:20 -0700
Subject: [PATCH 021/219] Return early in XPENDING if sent a nonexistent
 consumer group.

---
 src/t_stream.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 6cbef56cb..ebcf1a558 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1728,8 +1728,10 @@ void xpendingCommand(client *c) {
 
         /* If a consumer name was mentioned but it does not exist, we can
          * just return an empty array. */
-        if (consumername && consumer == NULL)
+        if (consumername && consumer == NULL) {
             addReplyMultiBulkLen(c,0);
+            return;
+        }
 
         rax *pel = consumer ? consumer->pel : group->pel;
         unsigned char startkey[sizeof(streamID)];

From e1222d8b10552cda6f6fdf1178a2ca25ad77894b Mon Sep 17 00:00:00 2001
From: Yossi Gottlieb <yossigo@gmail.com>
Date: Sun, 3 Jun 2018 15:54:30 +0300
Subject: [PATCH 022/219] Clean gcc 7.x warnings, redis-cli cluster fix.

---
 src/hyperloglog.c | 14 +++++++-------
 src/lzf_d.c       | 23 +++++++++++++----------
 src/redis-cli.c   |  2 +-
 src/siphash.c     | 24 ++++++++++++------------
 4 files changed, 33 insertions(+), 30 deletions(-)

diff --git a/src/hyperloglog.c b/src/hyperloglog.c
index 0670c1cf5..01a409bb5 100644
--- a/src/hyperloglog.c
+++ b/src/hyperloglog.c
@@ -429,14 +429,14 @@ uint64_t MurmurHash64A (const void * key, int len, unsigned int seed) {
     }
 
     switch(len & 7) {
-    case 7: h ^= (uint64_t)data[6] << 48;
-    case 6: h ^= (uint64_t)data[5] << 40;
-    case 5: h ^= (uint64_t)data[4] << 32;
-    case 4: h ^= (uint64_t)data[3] << 24;
-    case 3: h ^= (uint64_t)data[2] << 16;
-    case 2: h ^= (uint64_t)data[1] << 8;
+    case 7: h ^= (uint64_t)data[6] << 48; /* fall-thru */
+    case 6: h ^= (uint64_t)data[5] << 40; /* fall-thru */
+    case 5: h ^= (uint64_t)data[4] << 32; /* fall-thru */
+    case 4: h ^= (uint64_t)data[3] << 24; /* fall-thru */
+    case 3: h ^= (uint64_t)data[2] << 16; /* fall-thru */
+    case 2: h ^= (uint64_t)data[1] << 8; /* fall-thru */
     case 1: h ^= (uint64_t)data[0];
-            h *= m;
+            h *= m; /* fall-thru */
     };
 
     h ^= h >> r;
diff --git a/src/lzf_d.c b/src/lzf_d.c
index c32be8e87..93f43c27c 100644
--- a/src/lzf_d.c
+++ b/src/lzf_d.c
@@ -86,6 +86,8 @@ lzf_decompress (const void *const in_data,  unsigned int in_len,
 #ifdef lzf_movsb
           lzf_movsb (op, ip, ctrl);
 #else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
           switch (ctrl)
             {
               case 32: *op++ = *ip++; case 31: *op++ = *ip++; case 30: *op++ = *ip++; case 29: *op++ = *ip++;
@@ -97,6 +99,7 @@ lzf_decompress (const void *const in_data,  unsigned int in_len,
               case  8: *op++ = *ip++; case  7: *op++ = *ip++; case  6: *op++ = *ip++; case  5: *op++ = *ip++;
               case  4: *op++ = *ip++; case  3: *op++ = *ip++; case  2: *op++ = *ip++; case  1: *op++ = *ip++;
             }
+#pragma GCC diagnostic pop
 #endif
         }
       else /* back reference */
@@ -163,17 +166,17 @@ lzf_decompress (const void *const in_data,  unsigned int in_len,
 
                 break;
 
-              case 9: *op++ = *ref++;
-              case 8: *op++ = *ref++;
-              case 7: *op++ = *ref++;
-              case 6: *op++ = *ref++;
-              case 5: *op++ = *ref++;
-              case 4: *op++ = *ref++;
-              case 3: *op++ = *ref++;
-              case 2: *op++ = *ref++;
-              case 1: *op++ = *ref++;
+              case 9: *op++ = *ref++; /* fall-thru */
+              case 8: *op++ = *ref++; /* fall-thru */
+              case 7: *op++ = *ref++; /* fall-thru */
+              case 6: *op++ = *ref++; /* fall-thru */
+              case 5: *op++ = *ref++; /* fall-thru */
+              case 4: *op++ = *ref++; /* fall-thru */
+              case 3: *op++ = *ref++; /* fall-thru */
+              case 2: *op++ = *ref++; /* fall-thru */
+              case 1: *op++ = *ref++; /* fall-thru */
               case 0: *op++ = *ref++; /* two octets more */
-                      *op++ = *ref++;
+                      *op++ = *ref++; /* fall-thru */
             }
 #endif
         }
diff --git a/src/redis-cli.c b/src/redis-cli.c
index f406d505a..05865a925 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -5091,7 +5091,7 @@ static int clusterManagerCommandImport(int argc, char **argv) {
 
     // Build a slot -> node map
     clusterManagerNode  *slots_map[CLUSTER_MANAGER_SLOTS];
-    memset(slots_map, 0, sizeof(slots_map) / sizeof(clusterManagerNode *));
+    memset(slots_map, 0, sizeof(slots_map));
     listIter li;
     listNode *ln;
     for (i = 0; i < CLUSTER_MANAGER_SLOTS; i++) {
diff --git a/src/siphash.c b/src/siphash.c
index 6c41fe6b6..6b9419031 100644
--- a/src/siphash.c
+++ b/src/siphash.c
@@ -142,12 +142,12 @@ uint64_t siphash(const uint8_t *in, const size_t inlen, const uint8_t *k) {
     }
 
     switch (left) {
-    case 7: b |= ((uint64_t)in[6]) << 48;
-    case 6: b |= ((uint64_t)in[5]) << 40;
-    case 5: b |= ((uint64_t)in[4]) << 32;
-    case 4: b |= ((uint64_t)in[3]) << 24;
-    case 3: b |= ((uint64_t)in[2]) << 16;
-    case 2: b |= ((uint64_t)in[1]) << 8;
+    case 7: b |= ((uint64_t)in[6]) << 48; /* fall-thru */
+    case 6: b |= ((uint64_t)in[5]) << 40; /* fall-thru */
+    case 5: b |= ((uint64_t)in[4]) << 32; /* fall-thru */
+    case 4: b |= ((uint64_t)in[3]) << 24; /* fall-thru */
+    case 3: b |= ((uint64_t)in[2]) << 16; /* fall-thru */
+    case 2: b |= ((uint64_t)in[1]) << 8; /* fall-thru */
     case 1: b |= ((uint64_t)in[0]); break;
     case 0: break;
     }
@@ -202,12 +202,12 @@ uint64_t siphash_nocase(const uint8_t *in, const size_t inlen, const uint8_t *k)
     }
 
     switch (left) {
-    case 7: b |= ((uint64_t)siptlw(in[6])) << 48;
-    case 6: b |= ((uint64_t)siptlw(in[5])) << 40;
-    case 5: b |= ((uint64_t)siptlw(in[4])) << 32;
-    case 4: b |= ((uint64_t)siptlw(in[3])) << 24;
-    case 3: b |= ((uint64_t)siptlw(in[2])) << 16;
-    case 2: b |= ((uint64_t)siptlw(in[1])) << 8;
+    case 7: b |= ((uint64_t)siptlw(in[6])) << 48; /* fall-thru */
+    case 6: b |= ((uint64_t)siptlw(in[5])) << 40; /* fall-thru */
+    case 5: b |= ((uint64_t)siptlw(in[4])) << 32; /* fall-thru */
+    case 4: b |= ((uint64_t)siptlw(in[3])) << 24; /* fall-thru */
+    case 3: b |= ((uint64_t)siptlw(in[2])) << 16; /* fall-thru */
+    case 2: b |= ((uint64_t)siptlw(in[1])) << 8; /* fall-thru */
     case 1: b |= ((uint64_t)siptlw(in[0])); break;
     case 0: break;
     }

From 10dedc25868c08bb1bf5da8252c8b11ad2ab370d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B5=B5=E7=A3=8A?= <zhaolei21@meituan.com>
Date: Fri, 20 Apr 2018 20:19:03 +0800
Subject: [PATCH 023/219] Fix core dump when using 'command getkeys' with wrong
 arguments.

---
 src/db.c     |  6 +++---
 src/server.c | 15 +++++++++++----
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/src/db.c b/src/db.c
index 5f733e2d8..694131dd6 100644
--- a/src/db.c
+++ b/src/db.c
@@ -1224,7 +1224,7 @@ int *zunionInterGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *nu
     num = atoi(argv[2]->ptr);
     /* Sanity check. Don't return any key if the command is going to
      * reply with syntax error. */
-    if (num > (argc-3)) {
+    if (num < 1 || num > (argc-3)) {
         *numkeys = 0;
         return NULL;
     }
@@ -1253,7 +1253,7 @@ int *evalGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys)
     num = atoi(argv[2]->ptr);
     /* Sanity check. Don't return any key if the command is going to
      * reply with syntax error. */
-    if (num > (argc-3)) {
+    if (num <= 0 || num > (argc-3)) {
         *numkeys = 0;
         return NULL;
     }
@@ -1398,7 +1398,7 @@ int *xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys)
     if (streams_pos != -1) num = argc - streams_pos - 1;
 
     /* Syntax error. */
-    if (streams_pos == -1 || num % 2 != 0) {
+    if (streams_pos == -1 || num == 0 || num % 2 != 0) {
         *numkeys = 0;
         return NULL;
     }
diff --git a/src/server.c b/src/server.c
index 404429beb..a9da88f4e 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2842,7 +2842,10 @@ NULL
         int *keys, numkeys, j;
 
         if (!cmd) {
-            addReplyErrorFormat(c,"Invalid command specified");
+            addReplyError(c,"Invalid command specified");
+            return;
+        } else if (cmd->getkeys_proc == NULL && cmd->firstkey == 0) {
+            addReplyError(c,"The command has no key arguments");
             return;
         } else if ((cmd->arity > 0 && cmd->arity != c->argc-2) ||
                    ((c->argc-2) < -cmd->arity))
@@ -2852,9 +2855,13 @@ NULL
         }
 
         keys = getKeysFromCommand(cmd,c->argv+2,c->argc-2,&numkeys);
-        addReplyMultiBulkLen(c,numkeys);
-        for (j = 0; j < numkeys; j++) addReplyBulk(c,c->argv[keys[j]+2]);
-        getKeysFreeResult(keys);
+        if (!keys) {
+            addReplyError(c,"Invalid arguments specified for command");
+        } else {
+            addReplyMultiBulkLen(c,numkeys);
+            for (j = 0; j < numkeys; j++) addReplyBulk(c,c->argv[keys[j]+2]);
+            getKeysFreeResult(keys);
+        }
     } else {
         addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try COMMAND HELP", (char*)c->argv[1]->ptr);
     }

From 7c6f1be5df4b3f453ab3928b2239ed60138e1cef Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 4 Jun 2018 12:58:26 +0200
Subject: [PATCH 024/219] XGROUP DESTROY implemented.

---
 src/t_stream.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 6cbef56cb..1f904eff2 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1542,7 +1542,6 @@ NULL
         /* Certain subcommands require the group to exist. */
         if ((cg = streamLookupCG(s,grpname)) == NULL &&
             (!strcasecmp(opt,"SETID") ||
-             !strcasecmp(opt,"DELGROUP") ||
              !strcasecmp(opt,"DELCONSUMER")))
         {
             addReplyErrorFormat(c, "-NOGROUP No such consumer group '%s' "
@@ -1569,7 +1568,14 @@ NULL
                 sdsnew("-BUSYGROUP Consumer Group name already exists\r\n"));
         }
     } else if (!strcasecmp(opt,"SETID") && c->argc == 5) {
-    } else if (!strcasecmp(opt,"DELGROUP") && c->argc == 4) {
+    } else if (!strcasecmp(opt,"DESTROY") && c->argc == 4) {
+        if (cg) {
+            raxRemove(s->cgroups,(unsigned char*)grpname,sdslen(grpname),NULL);
+            streamFreeCG(cg);
+            addReply(c,shared.cone);
+        } else {
+            addReply(c,shared.czero);
+        }
     } else if (!strcasecmp(opt,"DELCONSUMER") && c->argc == 5) {
         /* Delete the consumer and returns the number of pending messages
          * that were yet associated with such a consumer. */

From 05a29966410c82bd3603ae290a342e856158e18a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 4 Jun 2018 17:26:16 +0200
Subject: [PATCH 025/219] Rax library updated.

---
 src/rax.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++---------
 src/rax.h |  1 +
 2 files changed, 58 insertions(+), 10 deletions(-)

diff --git a/src/rax.c b/src/rax.c
index 4e45fd2c3..8764dd8c9 100644
--- a/src/rax.c
+++ b/src/rax.c
@@ -359,7 +359,18 @@ raxNode *raxCompressNode(raxNode *n, unsigned char *s, size_t len, raxNode **chi
  * parent's node is returned as '*plink' if not NULL. Finally, if the
  * search stopped in a compressed node, '*splitpos' returns the index
  * inside the compressed node where the search ended. This is useful to
- * know where to split the node for insertion. */
+ * know where to split the node for insertion.
+ *
+ * Note that when we stop in the middle of a compressed node with
+ * a perfect match, this function will return a length equal to the
+ * 'len' argument (all the key matched), and will return a *splitpos which is
+ * always positive (that will represent the index of the character immediately
+ * *after* the last match in the current compressed node).
+ *
+ * When instead we stop at a compressed node and *splitpos is zero, it
+ * means that the current node represents the key (that is, none of the
+ * compressed node characters are needed to represent the key, just all
+ * its parents nodes). */
 static inline size_t raxLowWalk(rax *rax, unsigned char *s, size_t len, raxNode **stopnode, raxNode ***plink, int *splitpos, raxStack *ts) {
     raxNode *h = rax->head;
     raxNode **parentlink = &rax->head;
@@ -405,10 +416,12 @@ static inline size_t raxLowWalk(rax *rax, unsigned char *s, size_t len, raxNode
 
 /* Insert the element 's' of size 'len', setting as auxiliary data
  * the pointer 'data'. If the element is already present, the associated
- * data is updated, and 0 is returned, otherwise the element is inserted
- * and 1 is returned. On out of memory the function returns 0 as well but
- * sets errno to ENOMEM, otherwise errno will be set to 0. */
-int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old) {
+ * data is updated (only if 'overwrite' is set to 1), and 0 is returned,
+ * otherwise the element is inserted and 1 is returned. On out of memory the
+ * function returns 0 as well but sets errno to ENOMEM, otherwise errno will
+ * be set to 0.
+ */
+int raxGenericInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old, int overwrite) {
     size_t i;
     int j = 0; /* Split position. If raxLowWalk() stops in a compressed
                   node, the index 'j' represents the char we stopped within the
@@ -426,7 +439,8 @@ int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old) {
      * data pointer. */
     if (i == len && (!h->iscompr || j == 0 /* not in the middle if j is 0 */)) {
         debugf("### Insert: node representing key exists\n");
-        if (!h->iskey || h->isnull) {
+        /* Make space for the value pointer if needed. */
+        if (!h->iskey || (h->isnull && overwrite)) {
             h = raxReallocForData(h,data);
             if (h) memcpy(parentlink,&h,sizeof(h));
         }
@@ -434,12 +448,17 @@ int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old) {
             errno = ENOMEM;
             return 0;
         }
+
+        /* Update the existing key if there is already one. */
         if (h->iskey) {
             if (old) *old = raxGetData(h);
-            raxSetData(h,data);
+            if (overwrite) raxSetData(h,data);
             errno = 0;
             return 0; /* Element already exists. */
         }
+
+        /* Otherwise set the node as a key. Note that raxSetData()
+         * will set h->iskey. */
         raxSetData(h,data);
         rax->numele++;
         return 1; /* Element inserted. */
@@ -793,6 +812,19 @@ oom:
     return 0;
 }
 
+/* Overwriting insert. Just a wrapper for raxGenericInsert() that will
+ * update the element if there is already one for the same key. */
+int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old) {
+    return raxGenericInsert(rax,s,len,data,old,1);
+}
+
+/* Non overwriting insert function: this if an element with the same key
+ * exists, the value is not updated and the function returns 0.
+ * This is a just a wrapper for raxGenericInsert(). */
+int raxTryInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old) {
+    return raxGenericInsert(rax,s,len,data,old,0);
+}
+
 /* Find a key in the rax, returns raxNotFound special void pointer value
  * if the item was not found, otherwise the value associated with the
  * item is returned. */
@@ -1523,11 +1555,26 @@ int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len) {
             /* If there was no mismatch we are into a node representing the
              * key, (but which is not a key or the seek operator does not
              * include 'eq'), or we stopped in the middle of a compressed node
-             * after processing all the key. Cotinue iterating as this was
+             * after processing all the key. Continue iterating as this was
              * a legitimate key we stopped at. */
             it->flags &= ~RAX_ITER_JUST_SEEKED;
-            if (gt && !raxIteratorNextStep(it,0)) return 0;
-            if (lt && !raxIteratorPrevStep(it,0)) return 0;
+            if (it->node->iscompr && it->node->iskey && splitpos && lt) {
+                /* If we stopped in the middle of a compressed node with
+                 * perfect match, and the condition is to seek a key "<" than
+                 * the specified one, then if this node is a key it already
+                 * represents our match. For instance we may have nodes:
+                 *
+                 * "f" -> "oobar" = 1 -> "" = 2
+                 *
+                 * Representing keys "f" = 1, "foobar" = 2. A seek for
+                 * the key < "foo" will stop in the middle of the "oobar"
+                 * node, but will be our match, representing the key "f".
+                 *
+                 * So in that case, we don't seek backward. */
+            } else {
+                if (gt && !raxIteratorNextStep(it,0)) return 0;
+                if (lt && !raxIteratorPrevStep(it,0)) return 0;
+            }
             it->flags |= RAX_ITER_JUST_SEEKED; /* Ignore next call. */
         }
     } else {
diff --git a/src/rax.h b/src/rax.h
index b4e2fd91e..5b4d45167 100644
--- a/src/rax.h
+++ b/src/rax.h
@@ -145,6 +145,7 @@ extern void *raxNotFound;
 /* Exported API. */
 rax *raxNew(void);
 int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old);
+int raxTryInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old);
 int raxRemove(rax *rax, unsigned char *s, size_t len, void **old);
 void *raxFind(rax *rax, unsigned char *s, size_t len);
 void raxFree(rax *rax);

From 36b392a0b2528ad22f016e9ca8fce93eb6dab3a0 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 4 Jun 2018 17:28:03 +0200
Subject: [PATCH 026/219] XGROUP SETID implemented + consumer groups core
 fixes.

Now that we have SETID, the inetrnals of consumer groups should be able
to handle the case of the same message delivered multiple times just
as a side effect of calling XREADGROUP. Normally this should never
happen but if the admin manually "XGROUP SETID mykey mygroup 0",
messages will get re-delivered to clients waiting for the ">" special
ID. The consumer groups internals were not able to handle the case of a
message re-delivered in this circumstances that was already assigned to
another owner.
---
 src/t_stream.c | 48 ++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 40 insertions(+), 8 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 1f904eff2..04125bfa7 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -41,6 +41,7 @@
 #define STREAM_ITEM_FLAG_SAMEFIELDS (1<<1)  /* Same fields as master entry. */
 
 void streamFreeCG(streamCG *cg);
+void streamFreeNACK(streamNACK *na);
 size_t streamReplyWithRangeFromConsumerPEL(client *c, stream *s, streamID *start, streamID *end, size_t count, streamConsumer *consumer);
 
 /* -----------------------------------------------------------------------
@@ -867,18 +868,41 @@ size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end
 
         /* If a group is passed, we need to create an entry in the
          * PEL (pending entries list) of this group *and* this consumer.
-         * Note that we are sure about the fact the message is not already
-         * associated with some other consumer, because if we reached this
-         * loop the IDs the user is requesting are greater than any message
-         * delivered for this group. */
+         *
+         * Note that we cannot be sure about the fact the message is not
+         * already owned by another consumer, because the admin is able
+         * to change the consumer group last delivered ID using the
+         * XGROUP SETID command. So if we find that there is already
+         * a NACK for the entry, we need to associate it to the new
+         * consumer. */
         if (group && !(flags & STREAM_RWR_NOACK)) {
             unsigned char buf[sizeof(streamID)];
             streamEncodeID(buf,&id);
+
+            /* Try to add a new NACK. Most of the time this will work and
+             * will not require extra lookups. We'll fix the problem later
+             * if we find that there is already a entry for this ID. */
             streamNACK *nack = streamCreateNACK(consumer);
             int retval = 0;
-            retval += raxInsert(group->pel,buf,sizeof(buf),nack,NULL);
-            retval += raxInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
-            serverAssert(retval == 2); /* Make sure entry was inserted. */
+            retval += raxTryInsert(group->pel,buf,sizeof(buf),nack,NULL);
+            retval += raxTryInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
+
+            /* Now we can check if the entry was already busy, and
+             * in that case reassign the entry to the new consumer. */
+            if (retval == 0) {
+                streamFreeNACK(nack);
+                nack = raxFind(group->pel,buf,sizeof(buf));
+                serverAssert(nack != raxNotFound);
+                raxRemove(nack->consumer->pel,buf,sizeof(buf),NULL);
+                /* Update the consumer and idle time. */
+                nack->consumer = consumer;
+                nack->delivery_time = mstime();
+                nack->delivery_count++;
+                /* Add the entry in the new consumer local PEL. */
+                raxInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
+            } else if (retval == 1) {
+                serverPanic("NACK half-created. Should not be possible.");
+            }
 
             /* Propagate as XCLAIM. */
             if (spi) {
@@ -1568,6 +1592,14 @@ NULL
                 sdsnew("-BUSYGROUP Consumer Group name already exists\r\n"));
         }
     } else if (!strcasecmp(opt,"SETID") && c->argc == 5) {
+        streamID id;
+        if (!strcmp(c->argv[4]->ptr,"$")) {
+            id = s->last_id;
+        } else if (streamParseIDOrReply(c,c->argv[4],&id,0) != C_OK) {
+            return;
+        }
+        cg->last_id = id;
+        addReply(c,shared.ok);
     } else if (!strcasecmp(opt,"DESTROY") && c->argc == 4) {
         if (cg) {
             raxRemove(s->cgroups,(unsigned char*)grpname,sdslen(grpname),NULL);
@@ -1976,7 +2008,7 @@ void xclaimCommand(client *c) {
             nack->delivery_time = deliverytime;
             /* Set the delivery attempts counter if given. */
             if (retrycount >= 0) nack->delivery_count = retrycount;
-            /* Add the entry in the new cosnumer local PEL. */
+            /* Add the entry in the new consumer local PEL. */
             raxInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
             /* Send the reply for this entry. */
             if (justid) {

From 9e25f3e1defd29d4cf37380870141c40bf97f121 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 5 Jun 2018 16:34:31 +0200
Subject: [PATCH 027/219] Remove XINFO <key> special form.

As observed by Michael Grunder this usage while practical is
inconsistent because for instance it does not work against a key called
HELP. Removed.
---
 src/t_stream.c | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 04125bfa7..fe702110a 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -2131,14 +2131,12 @@ void xtrimCommand(client *c) {
 /* XINFO CONSUMERS key group
  * XINFO GROUPS <key>
  * XINFO STREAM <key>
- * XINFO <key> (alias of XINFO STREAM key)
  * XINFO HELP. */
 void xinfoCommand(client *c) {
     const char *help[] = {
 "CONSUMERS <key> <groupname>  -- Show consumer groups of group <groupname>.",
 "GROUPS <key>                 -- Show the stream consumer groups.",
 "STREAM <key>                 -- Show information about the stream.",
-"<key>                        -- Alias for STREAM <key>.",
 "HELP                         -- Print this help.",
 NULL
     };
@@ -2150,16 +2148,15 @@ NULL
     if (!strcasecmp(c->argv[1]->ptr,"HELP")) {
         addReplyHelp(c, help);
         return;
+    } else if (c->argc < 3) {
+        addReplyError(c,"syntax error, try 'XINFO HELP'");
+        return;
     }
 
-    /* Handle the fact that no subcommand means "STREAM". */
-    if (c->argc == 2) {
-        opt = "STREAM";
-        key = c->argv[1];
-    } else {
-        opt = c->argv[1]->ptr;
-        key = c->argv[2];
-    }
+    /* With the exception of HELP handled before any other sub commands, all
+     * the ones are in the form of "<subcommand> <key>". */
+    opt = c->argv[1]->ptr;
+    key = c->argv[2];
 
     /* Lookup the key now, this is common for all the subcommands but HELP. */
     robj *o = lookupKeyWriteOrReply(c,key,shared.nokeyerr);
@@ -2218,9 +2215,7 @@ NULL
             addReplyLongLong(c,raxSize(cg->pel));
         }
         raxStop(&ri);
-    } else if (c->argc == 2 ||
-               (!strcasecmp(opt,"STREAM") && c->argc == 3))
-    {
+    } else if (!strcasecmp(opt,"STREAM") && c->argc == 3) {
         /* XINFO STREAM <key> (or the alias XINFO <key>). */
         addReplyMultiBulkLen(c,12);
         addReplyStatus(c,"length");

From 0a698e499a0b543b350544c63701ab944151c6ed Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 5 Jun 2018 17:01:47 +0200
Subject: [PATCH 028/219] ZPOP: invert score-ele to match ZRANGE WITHSCORES
 order.

---
 src/t_zset.c             |  2 +-
 tests/unit/type/zset.tcl | 50 ++++++++++++++++++++--------------------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/t_zset.c b/src/t_zset.c
index ae0922342..196864779 100644
--- a/src/t_zset.c
+++ b/src/t_zset.c
@@ -3163,8 +3163,8 @@ void genericZpopCommand(client *c, robj **keyv, int keyc, int where, int emitkey
             signalModifiedKey(c->db,key);
         }
 
-        addReplyDouble(c,score);
         addReplyBulkCBuffer(c,ele,sdslen(ele));
+        addReplyDouble(c,score);
         sdsfree(ele);
         arraylen += 2;
 
diff --git a/tests/unit/type/zset.tcl b/tests/unit/type/zset.tcl
index f25cfc122..45f024cc3 100644
--- a/tests/unit/type/zset.tcl
+++ b/tests/unit/type/zset.tcl
@@ -653,11 +653,11 @@ start_server {tags {"zset"}} {
             r del zset
             assert_equal {} [r zpopmin zset]
             create_zset zset {-1 a 1 b 2 c 3 d 4 e}
-            assert_equal {-1 a} [r zpopmin zset]
-            assert_equal {1 b} [r zpopmin zset]
-            assert_equal {4 e} [r zpopmax zset]
-            assert_equal {3 d} [r zpopmax zset]
-            assert_equal {2 c} [r zpopmin zset]
+            assert_equal {a -1} [r zpopmin zset]
+            assert_equal {b 1} [r zpopmin zset]
+            assert_equal {e 4} [r zpopmax zset]
+            assert_equal {d 3} [r zpopmax zset]
+            assert_equal {c 2} [r zpopmin zset]
             assert_equal 0 [r exists zset]
             r set foo bar
             assert_error "*WRONGTYPE*" {r zpopmin foo}
@@ -669,8 +669,8 @@ start_server {tags {"zset"}} {
             assert_equal {} [r zpopmin z1 2]
             assert_error "*WRONGTYPE*" {r zpopmin foo 2}
             create_zset z1 {0 a 1 b 2 c 3 d}
-            assert_equal {0 a 1 b} [r zpopmin z1 2]
-            assert_equal {3 d 2 c} [r zpopmax z1 2]
+            assert_equal {a 0 b 1} [r zpopmin z1 2]
+            assert_equal {d 3 c 2} [r zpopmax z1 2]
         }
 
         test "BZPOP with a single existing sorted set - $encoding" {
@@ -678,11 +678,11 @@ start_server {tags {"zset"}} {
             create_zset zset {0 a 1 b 2 c}
 
             $rd bzpopmin zset 5
-            assert_equal {zset 0 a} [$rd read]
+            assert_equal {zset a 0} [$rd read]
             $rd bzpopmin zset 5
-            assert_equal {zset 1 b} [$rd read]
+            assert_equal {zset b 1} [$rd read]
             $rd bzpopmax zset 5
-            assert_equal {zset 2 c} [$rd read]
+            assert_equal {zset c 2} [$rd read]
             assert_equal 0 [r exists zset]
         }
 
@@ -692,16 +692,16 @@ start_server {tags {"zset"}} {
             create_zset z2 {3 d 4 e 5 f}
 
             $rd bzpopmin z1 z2 5
-            assert_equal {z1 0 a} [$rd read]
+            assert_equal {z1 a 0} [$rd read]
             $rd bzpopmax z1 z2 5
-            assert_equal {z1 2 c} [$rd read]
+            assert_equal {z1 c 2} [$rd read]
             assert_equal 1 [r zcard z1]
             assert_equal 3 [r zcard z2]
 
             $rd bzpopmax z2 z1 5
-            assert_equal {z2 5 f} [$rd read]
+            assert_equal {z2 f 5} [$rd read]
             $rd bzpopmin z2 z1 5
-            assert_equal {z2 3 d} [$rd read]
+            assert_equal {z2 d 3} [$rd read]
             assert_equal 1 [r zcard z1]
             assert_equal 1 [r zcard z2]
         }
@@ -711,9 +711,9 @@ start_server {tags {"zset"}} {
             r del z1
             create_zset z2 {3 d 4 e 5 f}
             $rd bzpopmax z1 z2 5
-            assert_equal {z2 5 f} [$rd read]
+            assert_equal {z2 f 5} [$rd read]
             $rd bzpopmin z2 z1 5
-            assert_equal {z2 3 d} [$rd read]
+            assert_equal {z2 d 3} [$rd read]
             assert_equal 0 [r zcard z1]
             assert_equal 1 [r zcard z2]
         }
@@ -1107,7 +1107,7 @@ start_server {tags {"zset"}} {
             r del zset
             r zadd zset 1 bar
             $rd read
-        } {zset 1 bar}
+        } {zset bar 1}
 
         test "BZPOPMIN, ZADD + DEL + SET should not awake blocked client" {
             set rd [redis_deferring_client]
@@ -1124,7 +1124,7 @@ start_server {tags {"zset"}} {
             r del zset
             r zadd zset 1 bar
             $rd read
-        } {zset 1 bar}
+        } {zset bar 1}
 
         test "BZPOPMIN with same key multiple times should work" {
             set rd [redis_deferring_client]
@@ -1133,18 +1133,18 @@ start_server {tags {"zset"}} {
             # Data arriving after the BZPOPMIN.
             $rd bzpopmin z1 z2 z2 z1 0
             r zadd z1 0 a
-            assert_equal [$rd read] {z1 0 a}
+            assert_equal [$rd read] {z1 a 0}
             $rd bzpopmin z1 z2 z2 z1 0
             r zadd z2 1 b
-            assert_equal [$rd read] {z2 1 b}
+            assert_equal [$rd read] {z2 b 1}
 
             # Data already there.
             r zadd z1 0 a
             r zadd z2 1 b
             $rd bzpopmin z1 z2 z2 z1 0
-            assert_equal [$rd read] {z1 0 a}
+            assert_equal [$rd read] {z1 a 0}
             $rd bzpopmin z1 z2 z2 z1 0
-            assert_equal [$rd read] {z2 1 b}
+            assert_equal [$rd read] {z2 b 1}
         }
 
         test "MULTI/EXEC is isolated from the point of view of BZPOPMIN" {
@@ -1157,7 +1157,7 @@ start_server {tags {"zset"}} {
             r zadd zset 2 c
             r exec
             $rd read
-        } {zset 0 a}
+        } {zset a 0}
 
         test "BZPOPMIN with variadic ZADD" {
             set rd [redis_deferring_client]
@@ -1167,7 +1167,7 @@ start_server {tags {"zset"}} {
             if {$::valgrind} {after 100}
             assert_equal 2 [r zadd zset -1 foo 1 bar]
             if {$::valgrind} {after 100}
-            assert_equal {zset -1 foo} [$rd read]
+            assert_equal {zset foo -1} [$rd read]
             assert_equal {bar} [r zrange zset 0 -1]
         }
 
@@ -1177,7 +1177,7 @@ start_server {tags {"zset"}} {
             $rd bzpopmin zset 0
             after 1000
             r zadd zset 0 foo
-            assert_equal {zset 0 foo} [$rd read]
+            assert_equal {zset foo 0} [$rd read]
         }
     }
 

From b61416bdf47900fc777b205cafb7b7c8248bb76f Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 6 Jun 2018 11:40:19 +0200
Subject: [PATCH 029/219] Fix streamIteratorRemoveEntry() to update elements
 count.

Close #4989.
---
 src/t_stream.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/t_stream.c b/src/t_stream.c
index fe702110a..07af3ff85 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -691,6 +691,9 @@ void streamIteratorRemoveEntry(streamIterator *si, streamID *current) {
     aux = lpGetInteger(p);
     lp = lpReplaceInteger(lp,&p,aux+1);
 
+    /* Update the number of entries counter. */
+    si->stream->length--;
+
     /* Re-seek the iterator to fix the now messed up state. */
     streamID start, end;
     if (si->rev) {

From c85ae56edc982d28df5cb29eedcd9d8bc9840a05 Mon Sep 17 00:00:00 2001
From: shenlongxing <shenlongxing2012@gmail.com>
Date: Mon, 4 Jun 2018 23:59:21 +0800
Subject: [PATCH 030/219] Fix write() errno error

---
 src/cluster.c     | 2 +-
 src/redis-cli.c   | 2 +-
 src/replication.c | 7 ++++---
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index 0635d7c07..f457280b8 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -2120,7 +2120,7 @@ void clusterWriteHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
     nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
     if (nwritten <= 0) {
         serverLog(LL_DEBUG,"I/O error writing to node link: %s",
-            strerror(errno));
+            (nwritten == -1) ? strerror(errno) : "short write");
         handleLinkIOError(link);
         return;
     }
diff --git a/src/redis-cli.c b/src/redis-cli.c
index 05865a925..0ee9f84ed 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -5575,7 +5575,7 @@ static void getRDB(void) {
         nwritten = write(fd, buf, nread);
         if (nwritten != nread) {
             fprintf(stderr,"Error writing data to file: %s\n",
-                strerror(errno));
+                (nwritten == -1) ? strerror(errno) : "short write");
             exit(1);
         }
         payload -= nread;
diff --git a/src/replication.c b/src/replication.c
index 8c01bfb51..0b7d57910 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -1105,7 +1105,7 @@ void restartAOF() {
 #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;
+    ssize_t nread, readlen, nwritten;
     off_t left;
     UNUSED(el);
     UNUSED(privdata);
@@ -1206,8 +1206,9 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
     }
 
     server.repl_transfer_lastio = server.unixtime;
-    if (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 <-> SLAVE synchronization: %s", strerror(errno));
+    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 <-> SLAVE synchronization: %s", 
+            (nwritten == -1) ? strerror(errno) : "short write");
         goto error;
     }
     server.repl_transfer_read += nread;

From 19a438e2c09363d161ed1cfae415222d3d16bfb4 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 7 Jun 2018 14:24:45 +0200
Subject: [PATCH 031/219] Streams: use non static macro node limits.

Also add the concept of size/items limit, instead of just having as
limit the number of bytes.
---
 redis.conf     |  8 ++++++++
 src/server.c   |  2 ++
 src/server.h   |  6 +++++-
 src/t_stream.c | 14 +++++++++++++-
 4 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/redis.conf b/redis.conf
index f5b7d5fed..e7a227ab8 100644
--- a/redis.conf
+++ b/redis.conf
@@ -1106,6 +1106,14 @@ zset-max-ziplist-value 64
 # composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
 hll-sparse-max-bytes 3000
 
+# Streams macro node max size / items. The stream data structure is a radix
+# tree of big nodes that encode multiple items inside. Using this configuration
+# it is possible to configure how big a single node can be in bytes, and the
+# maximum number of items it may contain before switching to a new node when
+# appending new stream entries.
+stream-node-max-bytes 4096
+stream-node-max-entires 100
+
 # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
 # order to help rehashing the main Redis hash table (the one mapping top-level
 # keys to values). The hash table implementation Redis uses (see dict.c)
diff --git a/src/server.c b/src/server.c
index 647aee24b..375c6477c 100644
--- a/src/server.c
+++ b/src/server.c
@@ -1485,6 +1485,8 @@ void initServerConfig(void) {
     server.zset_max_ziplist_entries = OBJ_ZSET_MAX_ZIPLIST_ENTRIES;
     server.zset_max_ziplist_value = OBJ_ZSET_MAX_ZIPLIST_VALUE;
     server.hll_sparse_max_bytes = CONFIG_DEFAULT_HLL_SPARSE_MAX_BYTES;
+    server.stream_node_max_bytes = OBJ_STREAM_NODE_MAX_BYTES;
+    server.stream_node_max_entries = OBJ_STREAM_NODE_MAX_ENTRIES;
     server.shutdown_asap = 0;
     server.cluster_enabled = 0;
     server.cluster_node_timeout = CLUSTER_DEFAULT_NODE_TIMEOUT;
diff --git a/src/server.h b/src/server.h
index d9c512c5e..c34cdcfbf 100644
--- a/src/server.h
+++ b/src/server.h
@@ -348,12 +348,14 @@ typedef long long mstime_t; /* millisecond time type. */
 #define AOF_FSYNC_EVERYSEC 2
 #define CONFIG_DEFAULT_AOF_FSYNC AOF_FSYNC_EVERYSEC
 
-/* Zip structure related defaults */
+/* Zipped structures related defaults */
 #define OBJ_HASH_MAX_ZIPLIST_ENTRIES 512
 #define OBJ_HASH_MAX_ZIPLIST_VALUE 64
 #define OBJ_SET_MAX_INTSET_ENTRIES 512
 #define OBJ_ZSET_MAX_ZIPLIST_ENTRIES 128
 #define OBJ_ZSET_MAX_ZIPLIST_VALUE 64
+#define OBJ_STREAM_NODE_MAX_BYTES 4096
+#define OBJ_STREAM_NODE_MAX_ENTRIES 100
 
 /* List defaults */
 #define OBJ_LIST_MAX_ZIPLIST_SIZE -2
@@ -1177,6 +1179,8 @@ struct redisServer {
     size_t zset_max_ziplist_entries;
     size_t zset_max_ziplist_value;
     size_t hll_sparse_max_bytes;
+    size_t stream_node_max_bytes;
+    int64_t stream_node_max_entries;
     /* List parameters */
     int list_max_ziplist_size;
     int list_compress_depth;
diff --git a/src/t_stream.c b/src/t_stream.c
index 07af3ff85..e5d29764e 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -237,8 +237,20 @@ int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id,
      * regular stream entries (see below), and marks the fact that there are
      * no more entires, when we scan the stream from right to left. */
 
+    /* First of all, check if we can append to the current macro node or
+     * if we need to switch to the next one. 'lp' will be set to NULL if
+     * the current node is full. */
+    if (lp != NULL) {
+        if (lp_bytes > server.stream_node_max_bytes) {
+            lp = NULL;
+        } else {
+            int64_t count = lpGetInteger(lpFirst(lp));
+            if (count > server.stream_node_max_entries) lp = NULL;
+        }
+    }
+
     int flags = STREAM_ITEM_FLAG_NONE;
-    if (lp == NULL || lp_bytes > STREAM_BYTES_PER_LISTPACK) {
+    if (lp == NULL || lp_bytes > server.stream_node_max_bytes) {
         master_id = id;
         streamEncodeID(rax_key,&id);
         /* Create the listpack having the master entry ID and fields. */

From 6d34ff3645e97e4537ae9136ef4e015591142d01 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 7 Jun 2018 14:30:25 +0200
Subject: [PATCH 032/219] Streams: max node limits only checked if non zero.

---
 src/t_stream.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index e5d29764e..71ed63180 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -241,9 +241,11 @@ int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id,
      * if we need to switch to the next one. 'lp' will be set to NULL if
      * the current node is full. */
     if (lp != NULL) {
-        if (lp_bytes > server.stream_node_max_bytes) {
+        if (server.stream_node_max_bytes &&
+            lp_bytes > server.stream_node_max_bytes)
+        {
             lp = NULL;
-        } else {
+        } else if (server.stream_node_max_entries) {
             int64_t count = lpGetInteger(lpFirst(lp));
             if (count > server.stream_node_max_entries) lp = NULL;
         }

From dfb3bf1b1e0b0a85fc18d4b721cbe73efbca2e3b Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 7 Jun 2018 14:36:13 +0200
Subject: [PATCH 033/219] Streams: make macro node limits configurable.

---
 src/config.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/config.c b/src/config.c
index 5bc6aa2ed..bfb310303 100644
--- a/src/config.c
+++ b/src/config.c
@@ -547,6 +547,10 @@ void loadServerConfigFromString(char *config) {
             server.hash_max_ziplist_entries = memtoll(argv[1], NULL);
         } else if (!strcasecmp(argv[0],"hash-max-ziplist-value") && argc == 2) {
             server.hash_max_ziplist_value = memtoll(argv[1], NULL);
+        } else if (!strcasecmp(argv[0],"stream-node-max-bytes") && argc == 2) {
+            server.stream_node_max_bytes = memtoll(argv[1], NULL);
+        } else if (!strcasecmp(argv[0],"stream-node-max-entries") && argc == 2) {
+            server.stream_node_max_entries = atoi(argv[1]);
         } else if (!strcasecmp(argv[0],"list-max-ziplist-entries") && argc == 2){
             /* DEAD OPTION */
         } else if (!strcasecmp(argv[0],"list-max-ziplist-value") && argc == 2) {
@@ -1083,6 +1087,10 @@ void configSetCommand(client *c) {
       "hash-max-ziplist-entries",server.hash_max_ziplist_entries,0,LLONG_MAX) {
     } config_set_numerical_field(
       "hash-max-ziplist-value",server.hash_max_ziplist_value,0,LLONG_MAX) {
+    } config_set_numerical_field(
+      "stream-node-max-bytes",server.stream_node_max_bytes,0,LLONG_MAX) {
+    } config_set_numerical_field(
+      "stream-node-max-entries",server.stream_node_max_entries,0,LLONG_MAX) {
     } config_set_numerical_field(
       "list-max-ziplist-size",server.list_max_ziplist_size,INT_MIN,INT_MAX) {
     } config_set_numerical_field(
@@ -1267,6 +1275,10 @@ void configGetCommand(client *c) {
             server.hash_max_ziplist_entries);
     config_get_numerical_field("hash-max-ziplist-value",
             server.hash_max_ziplist_value);
+    config_get_numerical_field("stream-node-max-bytes",
+            server.stream_node_max_bytes);
+    config_get_numerical_field("stream-node-max-entries",
+            server.stream_node_max_entries);
     config_get_numerical_field("list-max-ziplist-size",
             server.list_max_ziplist_size);
     config_get_numerical_field("list-compress-depth",
@@ -2056,6 +2068,8 @@ int rewriteConfig(char *path) {
     rewriteConfigNotifykeyspaceeventsOption(state);
     rewriteConfigNumericalOption(state,"hash-max-ziplist-entries",server.hash_max_ziplist_entries,OBJ_HASH_MAX_ZIPLIST_ENTRIES);
     rewriteConfigNumericalOption(state,"hash-max-ziplist-value",server.hash_max_ziplist_value,OBJ_HASH_MAX_ZIPLIST_VALUE);
+    rewriteConfigNumericalOption(state,"stream-node-max-bytes",server.stream_node_max_bytes,OBJ_STREAM_NODE_MAX_BYTES);
+    rewriteConfigNumericalOption(state,"stream-node-max-entries",server.stream_node_max_entries,OBJ_STREAM_NODE_MAX_ENTRIES);
     rewriteConfigNumericalOption(state,"list-max-ziplist-size",server.list_max_ziplist_size,OBJ_LIST_MAX_ZIPLIST_SIZE);
     rewriteConfigNumericalOption(state,"list-compress-depth",server.list_compress_depth,OBJ_LIST_COMPRESS_DEPTH);
     rewriteConfigNumericalOption(state,"set-max-intset-entries",server.set_max_intset_entries,OBJ_SET_MAX_INTSET_ENTRIES);

From a7dbe37d53075118c6db37848007df49ca69ce9a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 7 Jun 2018 14:36:56 +0200
Subject: [PATCH 034/219] Typo: entires -> entries in several places.

---
 src/cluster.c  | 2 +-
 src/t_stream.c | 8 ++++----
 src/ziplist.c  | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index f457280b8..17ba6a744 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -2377,7 +2377,7 @@ void clusterSendPing(clusterLink *link, int type) {
      * same time.
      *
      * Since we have non-voting slaves that lower the probability of an entry
-     * to feature our node, we set the number of entires per packet as
+     * to feature our node, we set the number of entries per packet as
      * 10% of the total nodes we have. */
     wanted = floor(dictSize(server.cluster->nodes)/10);
     if (wanted < 3) wanted = 3;
diff --git a/src/t_stream.c b/src/t_stream.c
index 71ed63180..e6538bd89 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -222,7 +222,7 @@ int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id,
      * +-------+---------+------------+---------+--/--+---------+---------+-+
      *
      * count and deleted just represent respectively the total number of
-     * entires inside the listpack that are valid, and marked as deleted
+     * entries inside the listpack that are valid, and marked as deleted
      * (delted flag in the entry flags set). So the total number of items
      * actually inside the listpack (both deleted and not) is count+deleted.
      *
@@ -235,7 +235,7 @@ int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id,
      *
      * The "0" entry at the end is the same as the 'lp-count' entry in the
      * regular stream entries (see below), and marks the fact that there are
-     * no more entires, when we scan the stream from right to left. */
+     * no more entries, when we scan the stream from right to left. */
 
     /* First of all, check if we can append to the current macro node or
      * if we need to switch to the next one. 'lp' will be set to NULL if
@@ -832,7 +832,7 @@ void streamPropagateXCLAIM(client *c, robj *key, robj *group, robj *id, streamNA
  * Note that this function is recursive in certian cases. When it's called
  * with a non NULL group and consumer argument, it may call
  * streamReplyWithRangeFromConsumerPEL() in order to get entries from the
- * consumer pending entires list. However such a function will then call
+ * consumer pending entries list. However such a function will then call
  * streamReplyWithRange() in order to emit single entries (found in the
  * PEL by ID) to the client. This is the use case for the STREAM_RWR_RAWENTRIES
  * flag.
@@ -1840,7 +1840,7 @@ void xpendingCommand(client *c) {
  * becomes the specified <consumer>. If the minimum idle time specified
  * is zero, messages are claimed regardless of their idle time.
  *
- * All the messages that cannot be found inside the pending entires list
+ * All the messages that cannot be found inside the pending entries list
  * are ignored, but in case the FORCE option is used. In that case we
  * create the NACK (representing a not yet acknowledged message) entry in
  * the consumer group PEL.
diff --git a/src/ziplist.c b/src/ziplist.c
index ea27db7fb..90bb9c81e 100644
--- a/src/ziplist.c
+++ b/src/ziplist.c
@@ -27,7 +27,7 @@
  * traversal.
  *
  * <uint16_t zllen> is the number of entries. When there are more than
- * 2^16-2 entires, this value is set to 2^16-1 and we need to traverse the
+ * 2^16-2 entries, this value is set to 2^16-1 and we need to traverse the
  * entire list to know how many items it holds.
  *
  * <uint8_t zlend> is a special entry representing the end of the ziplist.
@@ -256,7 +256,7 @@
 #define ZIPLIST_ENTRY_END(zl)   ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)
 
 /* Increment the number of items field in the ziplist header. Note that this
- * macro should never overflow the unsigned 16 bit integer, since entires are
+ * macro should never overflow the unsigned 16 bit integer, since entries are
  * always pushed one at a time. When UINT16_MAX is reached we want the count
  * to stay there to signal that a full scan is needed to get the number of
  * items inside the ziplist. */

From f847dd3ad8aac54f1f5b2919da3b27155926d343 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 7 Jun 2018 14:37:56 +0200
Subject: [PATCH 035/219] Streams: better document the max node limits.

---
 redis.conf | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/redis.conf b/redis.conf
index e7a227ab8..3d1095c72 100644
--- a/redis.conf
+++ b/redis.conf
@@ -1110,7 +1110,10 @@ hll-sparse-max-bytes 3000
 # tree of big nodes that encode multiple items inside. Using this configuration
 # it is possible to configure how big a single node can be in bytes, and the
 # maximum number of items it may contain before switching to a new node when
-# appending new stream entries.
+# appending new stream entries. If any of the following settings are set to
+# zero, the limit is ignored, so for instance it is possible to set just a
+# max entires limit by setting max-bytes to 0 and max-entries to the desired
+# value.
 stream-node-max-bytes 4096
 stream-node-max-entires 100
 

From 018cf118d62e3881ffe6b5ff9e534e309c6ef3ab Mon Sep 17 00:00:00 2001
From: shenlongxing <shenlongxing2012@gmail.com>
Date: Thu, 7 Jun 2018 23:13:36 +0800
Subject: [PATCH 036/219] fix stream config typo

---
 redis.conf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/redis.conf b/redis.conf
index 3d1095c72..507527cc8 100644
--- a/redis.conf
+++ b/redis.conf
@@ -1115,7 +1115,7 @@ hll-sparse-max-bytes 3000
 # max entires limit by setting max-bytes to 0 and max-entries to the desired
 # value.
 stream-node-max-bytes 4096
-stream-node-max-entires 100
+stream-node-max-entries 100
 
 # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
 # order to help rehashing the main Redis hash table (the one mapping top-level

From 76ad23d012f194efa1acc0f8356d945b07681851 Mon Sep 17 00:00:00 2001
From: Itamar Haber <itamar@redislabs.com>
Date: Thu, 7 Jun 2018 18:34:58 +0300
Subject: [PATCH 037/219] Adds MODULE HELP and implements 
 addReplySubSyntaxError

---
 src/module.c     | 13 +++++++++++--
 src/networking.c | 12 ++++++++++++
 src/server.h     |  1 +
 3 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/module.c b/src/module.c
index cb03ad2cd..e4d6e2cf2 100644
--- a/src/module.c
+++ b/src/module.c
@@ -4499,7 +4499,15 @@ int moduleUnload(sds name) {
  * MODULE LOAD <path> [args...] */
 void moduleCommand(client *c) {
     char *subcmd = c->argv[1]->ptr;
-
+    if (c->argc == 2 && !strcasecmp(subcmd,"help")) {
+        const char *help[] = {
+"list -- Return a list of loaded modules.",
+"load <path> [arg ...] -- Load a module library from <path>.",
+"unload <name> -- Unload a module.",
+NULL
+        };
+        addReplyHelp(c, help);
+    } else
     if (!strcasecmp(subcmd,"load") && c->argc >= 3) {
         robj **argv = NULL;
         int argc = 0;
@@ -4548,7 +4556,8 @@ void moduleCommand(client *c) {
         }
         dictReleaseIterator(di);
     } else {
-        addReply(c,shared.syntaxerr);
+        addReplySubSyntaxError(c);
+        return;
     }
 }
 
diff --git a/src/networking.c b/src/networking.c
index 00558974e..ac28ba2b8 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -560,6 +560,18 @@ void addReplyHelp(client *c, const char **help) {
     setDeferredMultiBulkLength(c,blenp,blen);
 }
 
+/* Add a suggestive error reply.
+ * This function is typically invoked by from commands that support
+ * subcommands in response to an unknown subcommand or argument error. */
+void addReplySubSyntaxError(client *c) {
+    sds cmd = sdsnew((char*) c->argv[0]->ptr);
+    sdstoupper(cmd);
+    addReplyErrorFormat(c,
+        "Unknown subcommand or wrong number of arguments for '%s'. Try %s HELP.",
+        c->argv[1]->ptr,cmd);
+    sdsfree(cmd);    
+}
+
 /* Copy 'src' client output buffers into 'dst' client output buffers.
  * The function takes care of freeing the old output buffers of the
  * destination client. */
diff --git a/src/server.h b/src/server.h
index c34cdcfbf..26aee8932 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1410,6 +1410,7 @@ void addReplyHumanLongDouble(client *c, long double d);
 void addReplyLongLong(client *c, long long ll);
 void addReplyMultiBulkLen(client *c, long length);
 void addReplyHelp(client *c, const char **help);
+void addReplySubSyntaxError(client *c);
 void copyClientOutputBuffer(client *dst, client *src);
 size_t sdsZmallocSize(sds s);
 size_t getStringObjectSdsUsedMemory(robj *o);

From c199280edb7ad344bb3d2af7572469f74d506da7 Mon Sep 17 00:00:00 2001
From: Itamar Haber <itamar@redislabs.com>
Date: Thu, 7 Jun 2018 18:39:36 +0300
Subject: [PATCH 038/219] Globally applies  addReplySubSyntaxError

---
 src/cluster.c   | 3 +--
 src/config.c    | 3 +--
 src/debug.c     | 3 +--
 src/object.c    | 2 +-
 src/pubsub.c    | 3 +--
 src/scripting.c | 2 +-
 src/server.c    | 2 +-
 src/slowlog.c   | 2 +-
 8 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index 17ba6a744..56deb927c 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -4746,8 +4746,7 @@ NULL
         clusterReset(hard);
         addReply(c,shared.ok);
     } else {
-         addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try CLUSTER HELP",
-            (char*)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
         return;
     }
 }
diff --git a/src/config.c b/src/config.c
index bfb310303..4e6438e8e 100644
--- a/src/config.c
+++ b/src/config.c
@@ -2149,8 +2149,7 @@ NULL
             addReply(c,shared.ok);
         }
     } else {
-         addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try CONFIG HELP",
-            (char*)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
         return;
     }
 }
diff --git a/src/debug.c b/src/debug.c
index 0ab864e7f..0c5ea9a9e 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -553,8 +553,7 @@ NULL
         clearReplicationId2();
         addReply(c,shared.ok);
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try DEBUG HELP",
-            (char*)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
         return;
     }
 }
diff --git a/src/object.c b/src/object.c
index 19af1ec0d..a4942fbe9 100644
--- a/src/object.c
+++ b/src/object.c
@@ -1197,7 +1197,7 @@ NULL
          * when the key is read or overwritten. */
         addReplyLongLong(c,LFUDecrAndReturn(o));
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try OBJECT help", (char *)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
     }
 }
 
diff --git a/src/pubsub.c b/src/pubsub.c
index d1fffa20a..7f7be52da 100644
--- a/src/pubsub.c
+++ b/src/pubsub.c
@@ -372,7 +372,6 @@ NULL
         /* PUBSUB NUMPAT */
         addReplyLongLong(c,listLength(server.pubsub_patterns));
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try PUBSUB HELP",
-            (char*)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
     }
 }
diff --git a/src/scripting.c b/src/scripting.c
index 3c0597c7a..85bce7bef 100644
--- a/src/scripting.c
+++ b/src/scripting.c
@@ -1514,7 +1514,7 @@ NULL
             return;
         }
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try SCRIPT HELP", (char*)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
     }
 }
 
diff --git a/src/server.c b/src/server.c
index 375c6477c..1e4d54b8b 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2866,7 +2866,7 @@ NULL
         for (j = 0; j < numkeys; j++) addReplyBulk(c,c->argv[keys[j]+2]);
         getKeysFreeResult(keys);
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try COMMAND HELP", (char*)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
     }
 }
 
diff --git a/src/slowlog.c b/src/slowlog.c
index 2613435af..aed5707da 100644
--- a/src/slowlog.c
+++ b/src/slowlog.c
@@ -187,6 +187,6 @@ NULL
         }
         setDeferredMultiBulkLength(c,totentries,sent);
     } else {
-         addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try SLOWLOG HELP", (char*)c->argv[1]->ptr);
+        addReplySubSyntaxError(c);
     }
 }

From b2fc2eaecb85b34a12c2b6a4db91fa5fc466870b Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 7 Jun 2018 18:52:01 +0200
Subject: [PATCH 039/219] Add the stream group to the script generating the
 help.

---
 utils/generate-command-help.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/utils/generate-command-help.rb b/utils/generate-command-help.rb
index f3dfb31b3..29acef69d 100755
--- a/utils/generate-command-help.rb
+++ b/utils/generate-command-help.rb
@@ -14,7 +14,8 @@ GROUPS = [
   "scripting",
   "hyperloglog",
   "cluster",
-  "geo"
+  "geo",
+  "stream"
 ].freeze
 
 GROUPS_BY_NAME = Hash[*

From 2268d7e5dd3a44a95f0e44ffe1afccebd8264b64 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 7 Jun 2018 18:53:00 +0200
Subject: [PATCH 040/219] redis-cli inline help updated.

---
 src/help.h | 113 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 107 insertions(+), 6 deletions(-)

diff --git a/src/help.h b/src/help.h
index 5f927c303..005afd941 100644
--- a/src/help.h
+++ b/src/help.h
@@ -1,4 +1,4 @@
-/* Automatically generated by utils/generate-command-help.rb, do not edit. */
+/* Automatically generated by generate-command-help.rb, do not edit. */
 
 #ifndef __REDIS_HELP_H
 #define __REDIS_HELP_H
@@ -17,7 +17,8 @@ static char *commandGroups[] = {
     "scripting",
     "hyperloglog",
     "cluster",
-    "geo"
+    "geo",
+    "stream"
 };
 
 struct commandHelp {
@@ -82,6 +83,16 @@ struct commandHelp {
     "Pop a value from a list, push it to another list and return it; or block until one is available",
     2,
     "2.2.0" },
+    { "BZPOPMAX",
+    "key [key ...] timeout",
+    "Remove and return the member with the highest score from one or more sorted sets, or block until one is available",
+    4,
+    "5.0.0" },
+    { "BZPOPMIN",
+    "key [key ...] timeout",
+    "Remove and return the member with the lowest score from one or more sorted sets, or block until one is available",
+    4,
+    "5.0.0" },
     { "CLIENT GETNAME",
     "-",
     "Get the current connection name",
@@ -318,12 +329,12 @@ struct commandHelp {
     0,
     "1.2.0" },
     { "FLUSHALL",
-    "-",
+    "[ASYNC]",
     "Remove all keys from all databases",
     9,
     "1.0.0" },
     { "FLUSHDB",
-    "-",
+    "[ASYNC]",
     "Remove all keys from the current database",
     9,
     "1.0.0" },
@@ -532,6 +543,36 @@ struct commandHelp {
     "Trim a list to the specified range",
     2,
     "1.0.0" },
+    { "MEMORY DOCTOR",
+    "-",
+    "Outputs memory problems report",
+    9,
+    "4.0.0" },
+    { "MEMORY HELP",
+    "-",
+    "Show helpful text about the different subcommands",
+    9,
+    "4.0.0" },
+    { "MEMORY MALLOC-STATS",
+    "-",
+    "Show allocator internal stats",
+    9,
+    "4.0.0" },
+    { "MEMORY PURGE",
+    "-",
+    "Ask the allocator to release memory",
+    9,
+    "4.0.0" },
+    { "MEMORY STATS",
+    "-",
+    "Show memory usage details",
+    9,
+    "4.0.0" },
+    { "MEMORY USAGE",
+    "key [SAMPLES count]",
+    "Estimate the memory usage of a key",
+    9,
+    "4.0.0" },
     { "MGET",
     "key [key ...]",
     "Get the values of all the given keys",
@@ -723,7 +764,7 @@ struct commandHelp {
     10,
     "3.2.0" },
     { "SCRIPT EXISTS",
-    "script [script ...]",
+    "sha1 [sha1 ...]",
     "Check existence of scripts in the script cache.",
     10,
     "2.6.0" },
@@ -758,7 +799,7 @@ struct commandHelp {
     8,
     "1.0.0" },
     { "SET",
-    "key value [EX seconds] [PX milliseconds] [NX|XX]",
+    "key value [expiration EX seconds|PX milliseconds] [NX|XX]",
     "Set the string value of a key",
     1,
     "1.0.0" },
@@ -867,6 +908,11 @@ struct commandHelp {
     "Add multiple sets and store the resulting set in a key",
     3,
     "1.0.0" },
+    { "SWAPDB",
+    "index index",
+    "Swaps two Redis databases",
+    8,
+    "4.0.0" },
     { "SYNC",
     "-",
     "Internal command used for replication",
@@ -877,6 +923,11 @@ struct commandHelp {
     "Return the current server time",
     9,
     "2.6.0" },
+    { "TOUCH",
+    "key [key ...]",
+    "Alters the last access time of a key(s). Returns the number of existing keys specified.",
+    0,
+    "3.2.1" },
     { "TTL",
     "key",
     "Get the time to live for a key",
@@ -887,6 +938,11 @@ struct commandHelp {
     "Determine the type stored at key",
     0,
     "1.0.0" },
+    { "UNLINK",
+    "key [key ...]",
+    "Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.",
+    0,
+    "4.0.0" },
     { "UNSUBSCRIBE",
     "[channel [channel ...]]",
     "Stop listening for messages posted to the given channels",
@@ -907,6 +963,41 @@ struct commandHelp {
     "Watch the given keys to determine execution of the MULTI/EXEC block",
     7,
     "2.2.0" },
+    { "XADD",
+    "key ID field string [field string ...]",
+    "Appends a new entry to a stream",
+    14,
+    "5.0.0" },
+    { "XLEN",
+    "key",
+    "Return the number of entires in a stream",
+    14,
+    "5.0.0" },
+    { "XPENDING",
+    "key group [start end count] [consumer]",
+    "Return information and entries from a stream conusmer group pending entries list, that are messages fetched but never acknowledged.",
+    14,
+    "5.0.0" },
+    { "XRANGE",
+    "key start end [COUNT count]",
+    "Return a range of elements in a stream, with IDs matching the specified IDs interval",
+    14,
+    "5.0.0" },
+    { "XREAD",
+    "[COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]",
+    "Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.",
+    14,
+    "5.0.0" },
+    { "XREADGROUP",
+    "GROUP group consumer [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]",
+    "Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.",
+    14,
+    "5.0.0" },
+    { "XREVRANGE",
+    "key end start [COUNT count]",
+    "Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE",
+    14,
+    "5.0.0" },
     { "ZADD",
     "key [NX|XX] [CH] [INCR] score member [score member ...]",
     "Add one or more members to a sorted set, or update its score if it already exists",
@@ -937,6 +1028,16 @@ struct commandHelp {
     "Count the number of members in a sorted set between a given lexicographical range",
     4,
     "2.8.9" },
+    { "ZPOPMAX",
+    "key [count]",
+    "Remove and return members with the highest scores in a sorted set",
+    4,
+    "5.0.0" },
+    { "ZPOPMIN",
+    "key [count]",
+    "Remove and return members with the lowest scores in a sorted set",
+    4,
+    "5.0.0" },
     { "ZRANGE",
     "key start stop [WITHSCORES]",
     "Return a range of members in a sorted set, by index",

From 269e80526f1f90142661b9e25bff3a08639ce59c Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 8 Jun 2018 11:17:20 +0200
Subject: [PATCH 041/219] Implement DEBUG htstats-key.

---
 src/debug.c     | 29 +++++++++++++++++++++++++++++
 src/redis-cli.c |  2 ++
 2 files changed, 31 insertions(+)

diff --git a/src/debug.c b/src/debug.c
index 0ab864e7f..078ac3c67 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -290,6 +290,7 @@ void debugCommand(client *c) {
 "crash-and-recover <milliseconds> -- Hard crash and restart after <milliseconds> delay.",
 "digest -- Outputs an hex signature representing the current DB content.",
 "htstats <dbid> -- Return hash table statistics of the specified Redis database.",
+"htstats-key <key> -- Like htstats but for the hash table stored as key's value.",
 "loadaof -- Flush the AOF buffers on disk and reload the AOF in memory.",
 "lua-always-replicate-commands (0|1) -- Setting it to 1 makes Lua replication defaulting to replicating single commands, without the script having to enable effects replication.",
 "object <key> -- Show low level info about key and associated value.",
@@ -547,6 +548,34 @@ NULL
         stats = sdscat(stats,buf);
 
         addReplyBulkSds(c,stats);
+    } else if (!strcasecmp(c->argv[1]->ptr,"htstats-key") && c->argc == 3) {
+        robj *o;
+        dict *ht = NULL;
+
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))
+                == NULL) return;
+
+        /* Get the hash table reference from the object, if possible. */
+        switch (o->encoding) {
+        case OBJ_ENCODING_SKIPLIST:
+            {
+                zset *zs = o->ptr;
+                ht = zs->dict;
+            }
+            break;
+        case OBJ_ENCODING_HT:
+            ht = o->ptr;
+            break;
+        }
+
+        if (ht == NULL) {
+            addReplyError(c,"The value stored at the specified key is not "
+                            "represented using an hash table");
+        } else {
+            char buf[4096];
+            dictGetStats(buf,sizeof(buf),ht);
+            addReplyBulkCString(c,buf);
+        }
     } else if (!strcasecmp(c->argv[1]->ptr,"change-repl-id") && c->argc == 2) {
         serverLog(LL_WARNING,"Changing replication IDs after receiving DEBUG change-repl-id");
         changeReplicationId();
diff --git a/src/redis-cli.c b/src/redis-cli.c
index 0ee9f84ed..af5e6a230 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -1075,6 +1075,8 @@ static int cliSendCommand(int argc, char **argv, long repeat) {
     if (!strcasecmp(command,"info") ||
         (argc >= 2 && !strcasecmp(command,"debug") &&
                        !strcasecmp(argv[1],"htstats")) ||
+        (argc >= 2 && !strcasecmp(command,"debug") &&
+                       !strcasecmp(argv[1],"htstats-key")) ||
         (argc >= 2 && !strcasecmp(command,"memory") &&
                       (!strcasecmp(argv[1],"malloc-stats") ||
                        !strcasecmp(argv[1],"doctor"))) ||

From 1210dd8a20ae4ffea88c3c68457e7e057410110e Mon Sep 17 00:00:00 2001
From: shenlongxing <shenlongxing2012@gmail.com>
Date: Sat, 9 Jun 2018 22:24:33 +0800
Subject: [PATCH 042/219] fix integer case error

---
 src/config.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/config.c b/src/config.c
index bfb310303..1b229c43e 100644
--- a/src/config.c
+++ b/src/config.c
@@ -1110,7 +1110,7 @@ void configSetCommand(client *c) {
     } config_set_numerical_field(
       "slowlog-max-len",ll,0,LLONG_MAX) {
       /* Cast to unsigned. */
-        server.slowlog_max_len = (unsigned)ll;
+        server.slowlog_max_len = (unsigned long)ll;
     } config_set_numerical_field(
       "latency-monitor-threshold",server.latency_monitor_threshold,0,LLONG_MAX){
     } config_set_numerical_field(

From 21ef0376feaaacee22b7913cb08948f65f9b8198 Mon Sep 17 00:00:00 2001
From: Itamar Haber <itamar@redislabs.com>
Date: Sat, 9 Jun 2018 20:54:05 +0300
Subject: [PATCH 043/219] Capitalizes subscommands

---
 src/module.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/module.c b/src/module.c
index e4d6e2cf2..3aaa94fe4 100644
--- a/src/module.c
+++ b/src/module.c
@@ -4501,9 +4501,9 @@ void moduleCommand(client *c) {
     char *subcmd = c->argv[1]->ptr;
     if (c->argc == 2 && !strcasecmp(subcmd,"help")) {
         const char *help[] = {
-"list -- Return a list of loaded modules.",
-"load <path> [arg ...] -- Load a module library from <path>.",
-"unload <name> -- Unload a module.",
+"LIST -- Return a list of loaded modules.",
+"LOAD <path> [arg ...] -- Load a module library from <path>.",
+"UNLOAD <name> -- Unload a module.",
 NULL
         };
         addReplyHelp(c, help);

From fefde6e3e4addf860829d4848386d90889590eac Mon Sep 17 00:00:00 2001
From: Itamar Haber <itamar@redislabs.com>
Date: Sat, 9 Jun 2018 21:03:52 +0300
Subject: [PATCH 044/219] Capitalizes subcommands & orders lexicographically

---
 src/cluster.c   | 40 ++++++++++++++++++++--------------------
 src/config.c    |  8 ++++----
 src/debug.c     | 38 +++++++++++++++++++-------------------
 src/pubsub.c    |  6 +++---
 src/scripting.c | 10 +++++-----
 src/server.c    |  6 +++---
 src/slowlog.c   |  6 +++---
 7 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index 56deb927c..39aab0cc7 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -4178,27 +4178,27 @@ void clusterCommand(client *c) {
 
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"addslots <slot> [slot ...] -- Assign slots to current node.",
-"bumpepoch -- Advance the cluster config epoch.",
-"count-failure-reports <node-id> -- Return number of failure reports for <node-id>.",
-"countkeysinslot <slot> - Return the number of keys in <slot>.",
-"delslots <slot> [slot ...] -- Delete slots information from current node.",
-"failover [force|takeover] -- Promote current slave node to being a master.",
-"forget <node-id> -- Remove a node from the cluster.",
-"getkeysinslot <slot> <count> -- Return key names stored by current node in a slot.",
-"flushslots -- Delete current node own slots information.",
-"info - Return onformation about the cluster.",
-"keyslot <key> -- Return the hash slot for <key>.",
-"meet <ip> <port> [bus-port] -- Connect nodes into a working cluster.",
-"myid -- Return the node id.",
-"nodes -- Return cluster configuration seen by node. Output format:",
+"ADDSLOTS <slot> [slot ...] -- Assign slots to current node.",
+"BUMPEPOCH -- Advance the cluster config epoch.",
+"COUNT-failure-reports <node-id> -- Return number of failure reports for <node-id>.",
+"COUNTKEYSINSLOT <slot> - Return the number of keys in <slot>.",
+"DELSLOTS <slot> [slot ...] -- Delete slots information from current node.",
+"FAILOVER [force|takeover] -- Promote current slave node to being a master.",
+"FORGET <node-id> -- Remove a node from the cluster.",
+"GETKEYSINSLOT <slot> <count> -- Return key names stored by current node in a slot.",
+"FLUSHSLOTS -- Delete current node own slots information.",
+"INFO - Return onformation about the cluster.",
+"KEYSLOT <key> -- Return the hash slot for <key>.",
+"MEET <ip> <port> [bus-port] -- Connect nodes into a working cluster.",
+"MYID -- Return the node id.",
+"NODES -- Return cluster configuration seen by node. Output format:",
 "    <id> <ip:port> <flags> <master> <pings> <pongs> <epoch> <link> <slot> ... <slot>",
-"replicate <node-id> -- Configure current node as slave to <node-id>.",
-"reset [hard|soft] -- Reset current node (default: soft).",
-"set-config-epoch <epoch> - Set config epoch of current node.",
-"setslot <slot> (importing|migrating|stable|node <node-id>) -- Set slot state.",
-"slaves <node-id> -- Return <node-id> slaves.",
-"slots -- Return information about slots range mappings. Each range is made of:",
+"REPLICATE <node-id> -- Configure current node as slave to <node-id>.",
+"RESET [hard|soft] -- Reset current node (default: soft).",
+"SET-config-epoch <epoch> - Set config epoch of current node.",
+"SETSLOT <slot> (importing|migrating|stable|node <node-id>) -- Set slot state.",
+"SLAVES <node-id> -- Return <node-id> slaves.",
+"SLOTS -- Return information about slots range mappings. Each range is made of:",
 "    start, end, master and replicas IP addresses, ports and ids",
 NULL
         };
diff --git a/src/config.c b/src/config.c
index 4e6438e8e..edcafa7ad 100644
--- a/src/config.c
+++ b/src/config.c
@@ -2121,10 +2121,10 @@ void configCommand(client *c) {
 
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"get <pattern> -- Return parameters matching the glob-like <pattern> and their values.",
-"set <parameter> <value> -- Set parameter to value.",
-"resetstat -- Reset statistics reported by INFO.",
-"rewrite -- Rewrite the configuration file.",
+"GET <pattern> -- Return parameters matching the glob-like <pattern> and their values.",
+"SET <parameter> <value> -- Set parameter to value.",
+"RESETSTAT -- Reset statistics reported by INFO.",
+"REWRITE -- Rewrite the configuration file.",
 NULL
         };
         addReplyHelp(c, help);
diff --git a/src/debug.c b/src/debug.c
index 0c5ea9a9e..7a9bddebd 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -285,25 +285,25 @@ void computeDatasetDigest(unsigned char *final) {
 void debugCommand(client *c) {
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"assert -- Crash by assertion failed.",
-"change-repl-id -- Change the replication IDs of the instance. Dangerous, should be used only for testing the replication subsystem.",
-"crash-and-recover <milliseconds> -- Hard crash and restart after <milliseconds> delay.",
-"digest -- Outputs an hex signature representing the current DB content.",
-"htstats <dbid> -- Return hash table statistics of the specified Redis database.",
-"loadaof -- Flush the AOF buffers on disk and reload the AOF in memory.",
-"lua-always-replicate-commands (0|1) -- Setting it to 1 makes Lua replication defaulting to replicating single commands, without the script having to enable effects replication.",
-"object <key> -- Show low level info about key and associated value.",
-"panic -- Crash the server simulating a panic.",
-"populate <count> [prefix] [size] -- Create <count> string keys named key:<num>. If a prefix is specified is used instead of the 'key' prefix.",
-"reload -- Save the RDB on disk and reload it back in memory.",
-"restart -- Graceful restart: save config, db, restart.",
-"sdslen <key> -- Show low level SDS string info representing key and value.",
-"segfault -- Crash the server with sigsegv.",
-"set-active-expire (0|1) -- Setting it to 0 disables expiring keys in background when they are not accessed (otherwise the Redis behavior). Setting it to 1 reenables back the default.",
-"sleep <seconds> -- Stop the server for <seconds>. Decimals allowed.",
-"structsize -- Return the size of different Redis core C structures.",
-"ziplist <key> -- Show low level info about the ziplist encoding.",
-"error <string> -- Return a Redis protocol error with <string> as message. Useful for clients unit tests to simulate Redis errors.",
+"ASSERT -- Crash by assertion failed.",
+"CHANGE-REPL-ID -- Change the replication IDs of the instance. Dangerous, should be used only for testing the replication subsystem.",
+"CRASH-and-recover <milliseconds> -- Hard crash and restart after <milliseconds> delay.",
+"DIGEST -- Output a hex signature representing the current DB content.",
+"ERROR <string> -- Return a Redis protocol error with <string> as message. Useful for clients unit tests to simulate Redis errors.",
+"HTSTATS <dbid> -- Return hash table statistics of the specified Redis database.",
+"LOADAOF -- Flush the AOF buffers on disk and reload the AOF in memory.",
+"LUA-ALWAYS-REPLICATE-COMMANDS (0|1) -- Setting it to 1 makes Lua replication defaulting to replicating single commands, without the script having to enable effects replication.",
+"OBJECT <key> -- Show low level info about key and associated value.",
+"PANIC -- Crash the server simulating a panic.",
+"POPULATE <count> [prefix] [size] -- Create <count> string keys named key:<num>. If a prefix is specified is used instead of the 'key' prefix.",
+"RELOAD -- Save the RDB on disk and reload it back in memory.",
+"RESTART -- Graceful restart: save config, db, restart.",
+"SDSLEN <key> -- Show low level SDS string info representing key and value.",
+"SEGFAULT -- Crash the server with sigsegv.",
+"SET-ACTIVE-EXPIRE (0|1) -- Setting it to 0 disables expiring keys in background when they are not accessed (otherwise the Redis behavior). Setting it to 1 reenables back the default.",
+"SLEEP <seconds> -- Stop the server for <seconds>. Decimals allowed.",
+"STRUCTSIZE -- Return the size of different Redis core C structures.",
+"ZIPLIST <key> -- Show low level info about the ziplist encoding.",
 NULL
         };
         addReplyHelp(c, help);
diff --git a/src/pubsub.c b/src/pubsub.c
index 7f7be52da..86a7f1c50 100644
--- a/src/pubsub.c
+++ b/src/pubsub.c
@@ -327,9 +327,9 @@ void publishCommand(client *c) {
 void pubsubCommand(client *c) {
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"channels [<pattern>] -- Return the currently active channels matching a pattern (default: all).",
-"numpat -- Return number of subscriptions to patterns.",
-"numsub [channel-1 .. channel-N] -- Returns the number of subscribers for the specified channels (excluding patterns, default: none).",
+"CHANNELS [<pattern>] -- Return the currently active channels matching a pattern (default: all).",
+"NUMPAT -- Return number of subscriptions to patterns.",
+"NUMSUB [channel-1 .. channel-N] -- Returns the number of subscribers for the specified channels (excluding patterns, default: none).",
 NULL
         };
         addReplyHelp(c, help);
diff --git a/src/scripting.c b/src/scripting.c
index 85bce7bef..f65540d89 100644
--- a/src/scripting.c
+++ b/src/scripting.c
@@ -1457,11 +1457,11 @@ void evalShaCommand(client *c) {
 void scriptCommand(client *c) {
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"debug (yes|sync|no) -- Set the debug mode for subsequent scripts executed.",
-"exists <sha1> [<sha1> ...] -- Return information about the existence of the scripts in the script cache.",
-"flush -- Flush the Lua scripts cache. Very dangerous on slaves.",
-"kill -- Kill the currently executing Lua script.",
-"load <script> -- Load a script into the scripts cache, without executing it.",
+"DEBUG (yes|sync|no) -- Set the debug mode for subsequent scripts executed.",
+"EXISTS <sha1> [<sha1> ...] -- Return information about the existence of the scripts in the script cache.",
+"FLUSH -- Flush the Lua scripts cache. Very dangerous on slaves.",
+"KILL -- Kill the currently executing Lua script.",
+"LOAD <script> -- Load a script into the scripts cache, without executing it.",
 NULL
         };
         addReplyHelp(c, help);
diff --git a/src/server.c b/src/server.c
index 1e4d54b8b..394b5ab43 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2826,9 +2826,9 @@ void commandCommand(client *c) {
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
 "(no subcommand) -- Return details about all Redis commands.",
-"count -- Return the total number of commands in this Redis server.",
-"getkeys <full-command> -- Return the keys from a full Redis command.",
-"info [command-name ...] -- Return details about multiple Redis commands.",
+"COUNT -- Return the total number of commands in this Redis server.",
+"GETKEYS <full-command> -- Return the keys from a full Redis command.",
+"INFO [command-name ...] -- Return details about multiple Redis commands.",
 NULL
         };
         addReplyHelp(c, help);
diff --git a/src/slowlog.c b/src/slowlog.c
index aed5707da..27f18e138 100644
--- a/src/slowlog.c
+++ b/src/slowlog.c
@@ -142,11 +142,11 @@ void slowlogReset(void) {
 void slowlogCommand(client *c) {
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"get [count] -- Return top entries from the slowlog (default: 10)."
+"GET [count] -- Return top entries from the slowlog (default: 10)."
 "    Entries are made of:",
 "    id, timestamp, time in microseconds, arguments array, client IP and port, client name",
-"len -- Return the length of the slowlog.",
-"reset -- Reset the slowlog.",
+"LEN -- Return the length of the slowlog.",
+"RESET -- Reset the slowlog.",
 NULL
         };
         addReplyHelp(c, help);

From c04082cf138f1f51cedf05ee9ad36fb6763cafc6 Mon Sep 17 00:00:00 2001
From: michael-grunder <michael.grunder@gmail.com>
Date: Sun, 10 Jun 2018 08:55:58 -0700
Subject: [PATCH 045/219] Abort in XGROUP if the key is not a stream

---
 src/t_stream.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 075386dd3..c48928018 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1576,7 +1576,7 @@ NULL
     /* Lookup the key now, this is common for all the subcommands but HELP. */
     if (c->argc >= 4) {
         robj *o = lookupKeyWriteOrReply(c,c->argv[2],shared.nokeyerr);
-        if (o == NULL) return;
+        if (o == NULL || checkType(c,o,OBJ_STREAM)) return;
         s = o->ptr;
         grpname = c->argv[3]->ptr;
 

From cc81c6f1d3905bd8ddfd0198aefcf3abc3d4d068 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Mon, 11 Jun 2018 00:14:17 +0800
Subject: [PATCH 046/219] Streams: lookupKey[Read->Write]OrReply in xdel and
 xtrim

---
 src/t_stream.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 075386dd3..eb1113030 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -2056,7 +2056,7 @@ void xclaimCommand(client *c) {
 void xdelCommand(client *c) {
     robj *o;
 
-    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL
+    if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL
         || checkType(c,o,OBJ_STREAM)) return;
     stream *s = o->ptr;
 
@@ -2097,7 +2097,7 @@ void xtrimCommand(client *c) {
 
     /* If the key does not exist, we are ok returning zero, that is, the
      * number of elements removed from the stream. */
-    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL
+    if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL
         || checkType(c,o,OBJ_STREAM)) return;
     stream *s = o->ptr;
 

From b8913ce72141237570ddfa07a1e412a03d714c51 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Mon, 11 Jun 2018 01:17:52 +0800
Subject: [PATCH 047/219] Streams: checkType for xread & xinfo

---
 src/t_stream.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 075386dd3..6ef1ce517 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1310,14 +1310,13 @@ void xreadCommand(client *c) {
          * starting from now. */
         int id_idx = i - streams_arg - streams_count;
         robj *key = c->argv[i-streams_count];
-        robj *o;
+        robj *o = lookupKeyRead(c->db,key);
+        if (o && checkType(c,o,OBJ_STREAM)) goto cleanup;
         streamCG *group = NULL;
 
         /* If a group was specified, than we need to be sure that the
          * key and group actually exist. */
         if (groupname) {
-            o = lookupKeyRead(c->db,key);
-            if (o && checkType(c,o,OBJ_STREAM)) goto cleanup;
             if (o == NULL ||
                 (group = streamLookupCG(o->ptr,groupname->ptr)) == NULL)
             {
@@ -1331,8 +1330,6 @@ void xreadCommand(client *c) {
         }
 
         if (strcmp(c->argv[i]->ptr,"$") == 0) {
-            o = lookupKeyRead(c->db,key);
-            if (o && checkType(c,o,OBJ_STREAM)) goto cleanup;
             if (o) {
                 stream *s = o->ptr;
                 ids[id_idx] = s->last_id;
@@ -2179,7 +2176,7 @@ NULL
 
     /* Lookup the key now, this is common for all the subcommands but HELP. */
     robj *o = lookupKeyWriteOrReply(c,key,shared.nokeyerr);
-    if (o == NULL) return;
+    if (o == NULL || checkType(c,o,OBJ_STREAM)) return;
     s = o->ptr;
 
     /* Dispatch the different subcommands. */

From 27beaf2f2246cc4c502014f81877da592d2aeaa2 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 11 Jun 2018 12:51:25 +0200
Subject: [PATCH 048/219] Regression test for the dictScan() issue #4906.

---
 tests/unit/scan.tcl | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/tests/unit/scan.tcl b/tests/unit/scan.tcl
index 1d84f128d..a02f3a585 100644
--- a/tests/unit/scan.tcl
+++ b/tests/unit/scan.tcl
@@ -236,4 +236,42 @@ start_server {tags {"scan"}} {
         set first_score [lindex $res 1]
         assert {$first_score != 0}
     }
+
+    test "SCAN regression test for issue #4906" {
+        r del set
+        set toremove {}
+        array set found {}
+        for {set j 0} {$j < 500} {incr j} {
+            r sadd set $j
+            if {$j >= 100} {
+                lappend toremove $j
+            }
+        }
+
+        # Start scanning
+        set cursor 0
+        set iteration 0
+        while {!($cursor == 0 && $iteration != 0)} {
+            lassign [r sscan set $cursor] cursor items
+
+            # Mark found items. We expect to find from 0 to 99 at the end
+            # since those elements will never be removed during the scanning.
+            foreach i $items {
+                set found($i) 1
+            }
+            incr iteration
+            # At some point remove most of the items to trigger the
+            # rehashing to a smaller hash table.
+            if {$iteration == 1} {
+                r srem set {*}$toremove
+            }
+        }
+
+        # Verify that SSCAN reported everything from 0 to 99
+        for {set j 0} {$j < 100} {incr j} {
+            if {![info exists found($j)]} {
+                fail "SSCAN element missing $j"
+            }
+        }
+    }
 }

From 00613bed06af890b9f09befc71de3f2aedabbacb Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 11 Jun 2018 13:10:03 +0200
Subject: [PATCH 049/219] Improved regression test for #4906.

Removing the fix about 50% of the times the test will not be able to
pass cleanly. It's very hard to write a test that will always fail, or
actually, it is possible but then it's likely that it will consistently
pass if we change some random bit, so better to use randomization here.
---
 tests/unit/scan.tcl | 68 +++++++++++++++++++++++++--------------------
 1 file changed, 38 insertions(+), 30 deletions(-)

diff --git a/tests/unit/scan.tcl b/tests/unit/scan.tcl
index a02f3a585..a8cc81163 100644
--- a/tests/unit/scan.tcl
+++ b/tests/unit/scan.tcl
@@ -238,39 +238,47 @@ start_server {tags {"scan"}} {
     }
 
     test "SCAN regression test for issue #4906" {
-        r del set
-        set toremove {}
-        array set found {}
-        for {set j 0} {$j < 500} {incr j} {
-            r sadd set $j
-            if {$j >= 100} {
-                lappend toremove $j
-            }
-        }
+        for {set k 0} {$k < 100} {incr k} {
+            r del set
+            r sadd set x; # Make sure it's not intset encoded
+            set toremove {}
+            unset -nocomplain found
+            array set found {}
 
-        # Start scanning
-        set cursor 0
-        set iteration 0
-        while {!($cursor == 0 && $iteration != 0)} {
-            lassign [r sscan set $cursor] cursor items
-
-            # Mark found items. We expect to find from 0 to 99 at the end
-            # since those elements will never be removed during the scanning.
-            foreach i $items {
-                set found($i) 1
+            # Populate the set
+            set numele [expr {100+[randomInt 1000]}]
+            for {set j 0} {$j < $numele} {incr j} {
+                r sadd set $j
+                if {$j >= 100} {
+                    lappend toremove $j
+                }
             }
-            incr iteration
-            # At some point remove most of the items to trigger the
-            # rehashing to a smaller hash table.
-            if {$iteration == 1} {
-                r srem set {*}$toremove
-            }
-        }
 
-        # Verify that SSCAN reported everything from 0 to 99
-        for {set j 0} {$j < 100} {incr j} {
-            if {![info exists found($j)]} {
-                fail "SSCAN element missing $j"
+            # Start scanning
+            set cursor 0
+            set iteration 0
+            set del_iteration [randomInt 10]
+            while {!($cursor == 0 && $iteration != 0)} {
+                lassign [r sscan set $cursor] cursor items
+
+                # Mark found items. We expect to find from 0 to 99 at the end
+                # since those elements will never be removed during the scanning.
+                foreach i $items {
+                    set found($i) 1
+                }
+                incr iteration
+                # At some point remove most of the items to trigger the
+                # rehashing to a smaller hash table.
+                if {$iteration == $del_iteration} {
+                    r srem set {*}$toremove
+                }
+            }
+
+            # Verify that SSCAN reported everything from 0 to 99
+            for {set j 0} {$j < 100} {incr j} {
+                if {![info exists found($j)]} {
+                    fail "SSCAN element missing $j"
+                }
             }
         }
     }

From 34bd44187ae4a5947995abe8f8e26a5dacb3159b Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 11 Jun 2018 16:51:06 +0200
Subject: [PATCH 050/219] Fix client unblocking for XREADGROUP, issue #4978.

We unblocked the client too early, when the group name object was no
longer valid in client->bpop, so propagating XCLAIM later in
streamPropagateXCLAIM() deferenced a field already set to NULL.
---
 src/blocked.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/blocked.c b/src/blocked.c
index 8d1157c2c..e0dd56724 100644
--- a/src/blocked.c
+++ b/src/blocked.c
@@ -398,12 +398,6 @@ void handleClientsBlockedOnKeys(void) {
                                            1);
                             }
 
-                            /* Note that after we unblock the client, 'gt'
-                             * and other receiver->bpop stuff are no longer
-                             * valid, so we must do the setup above before
-                             * this call. */
-                            unblockClient(receiver);
-
                             /* Emit the two elements sub-array consisting of
                              * the name of the stream and the data we
                              * extracted from it. Wrapped in a single-item
@@ -419,6 +413,12 @@ void handleClientsBlockedOnKeys(void) {
                             streamReplyWithRange(receiver,s,&start,NULL,
                                                  receiver->bpop.xread_count,
                                                  0, group, consumer, 0, &pi);
+
+                            /* Note that after we unblock the client, 'gt'
+                             * and other receiver->bpop stuff are no longer
+                             * valid, so we must do the setup above before
+                             * this call. */
+                            unblockClient(receiver);
                         }
                     }
                 }

From cec404f099e3a1a3ce6e94c01ce45d851bd3e843 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 11 Jun 2018 17:12:28 +0200
Subject: [PATCH 051/219] Use a less aggressive query buffer resize policy.

A user with many connections (10 thousand) on a single Redis server
reports in issue #4983 that sometimes Redis is idle becuase at the same
time many clients need to resize their query buffer according to the old
policy.

It looks like this was created by the fact that we allow the query
buffer to grow without problems to a size up to PROTO_MBULK_BIG_ARG
normally, but when the client is idle we immediately are more strict,
and a query buffer greater than 1024 bytes is already enough to trigger
the resize. So for instance if most of the clients stop at the same time
this issue should be easily triggered.

This behavior actually looks odd, and there should be only a clear limit
after we say, let's look at this query buffer to check if it's time to
resize it. This commit puts the limit at PROTO_MBULK_BIG_ARG, and the
check is performed both if compared to the peak usage the current usage
is too big, or if the client is idle.

Then when the check is performed, to waste just a few kbytes is
considered enough to proceed with the resize. This should fix the issue.
---
 src/server.c | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/server.c b/src/server.c
index 375c6477c..16c807f61 100644
--- a/src/server.c
+++ b/src/server.c
@@ -845,13 +845,14 @@ int clientsCronResizeQueryBuffer(client *c) {
 
     /* There are two conditions to resize the query buffer:
      * 1) Query buffer is > BIG_ARG and too big for latest peak.
-     * 2) Client is inactive and the buffer is bigger than 1k. */
-    if (((querybuf_size > PROTO_MBULK_BIG_ARG) &&
-         (querybuf_size/(c->querybuf_peak+1)) > 2) ||
-         (querybuf_size > 1024 && idletime > 2))
+     * 2) Query buffer is > BIG_ARG and client is idle. */
+    if (querybuf_size > PROTO_MBULK_BIG_ARG &&
+         ((querybuf_size/(c->querybuf_peak+1)) > 2 ||
+          idletime > 2))
     {
-        /* Only resize the query buffer if it is actually wasting space. */
-        if (sdsavail(c->querybuf) > 1024) {
+        /* Only resize the query buffer if it is actually wasting
+         * at least a few kbytes. */
+        if (sdsavail(c->querybuf) > 1024*4) {
             c->querybuf = sdsRemoveFreeSpace(c->querybuf);
         }
     }

From fac3e8aab55671bc8842214e7384f4174deb6578 Mon Sep 17 00:00:00 2001
From: Baoyi Chen <chen.bao.yi@qq.com>
Date: Tue, 12 Jun 2018 08:52:18 +0800
Subject: [PATCH 052/219] fix typo

fix [#5005](https://github.com/antirez/redis/issues/5005)
---
 src/t_stream.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index c826f1602..2e70681f2 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1554,13 +1554,13 @@ uint64_t streamDelConsumer(streamCG *cg, sds name) {
 
 /* XGROUP CREATE <key> <groupname> <id or $>
  * XGROUP SETID <key> <id or $>
- * XGROUP DELGROUP <key> <groupname>
+ * XGROUP DESTROY <key> <groupname>
  * XGROUP DELCONSUMER <key> <groupname> <consumername> */
 void xgroupCommand(client *c) {
     const char *help[] = {
 "CREATE      <key> <groupname> <id or $>  -- Create a new consumer group.",
 "SETID       <key> <groupname> <id or $>  -- Set the current group ID.",
-"DELGROUP    <key> <groupname>            -- Remove the specified group.",
+"DESTROY    <key> <groupname>            -- Remove the specified group.",
 "DELCONSUMER <key> <groupname> <consumer> -- Remove the specified conusmer.",
 "HELP                                     -- Prints this help.",
 NULL

From 923e63e5ecfcfbbc849e61c61069665aabbb6b0a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 09:27:32 +0200
Subject: [PATCH 053/219] Streams: increment dirty counter for XGROUP
 SETID/DESTROY.

See issue #5005 comments.
---
 src/t_stream.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/t_stream.c b/src/t_stream.c
index c826f1602..035e82837 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1614,11 +1614,13 @@ NULL
         }
         cg->last_id = id;
         addReply(c,shared.ok);
+        server.dirty++;
     } else if (!strcasecmp(opt,"DESTROY") && c->argc == 4) {
         if (cg) {
             raxRemove(s->cgroups,(unsigned char*)grpname,sdslen(grpname),NULL);
             streamFreeCG(cg);
             addReply(c,shared.cone);
+            server.dirty++;
         } else {
             addReply(c,shared.czero);
         }

From 7659619824755b929251faff457d3873b9742f2b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=90=83=E7=8A=B6=E9=97=AA=E7=94=B5?= <zwkno1@gmail.com>
Date: Tue, 12 Jun 2018 15:28:28 +0800
Subject: [PATCH 054/219] Update geohash.c

fix geohasEncode bug when step > 31
---
 src/geohash.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/geohash.c b/src/geohash.c
index 1ae7a7e05..b40282e76 100644
--- a/src/geohash.c
+++ b/src/geohash.c
@@ -144,8 +144,8 @@ int geohashEncode(const GeoHashRange *long_range, const GeoHashRange *lat_range,
         (longitude - long_range->min) / (long_range->max - long_range->min);
 
     /* convert to fixed point based on the step size */
-    lat_offset *= (1 << step);
-    long_offset *= (1 << step);
+    lat_offset *= (1ULL << step);
+    long_offset *= (1ULL << step);
     hash->bits = interleave64(lat_offset, long_offset);
     return 1;
 }

From 7cc1312789aca0bd25bf21f27801430245a17c5a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 10:22:03 +0200
Subject: [PATCH 055/219] Streams: fix backward iteration when entry is not
 flagged SAMEFIELD.

See issue #5006. The comment in the code was also wrong and
was rectified as well.
---
 src/t_stream.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index d7515c93f..58ffda484 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -647,7 +647,12 @@ int streamIteratorGetID(streamIterator *si, streamID *id, int64_t *numfields) {
                 for (int64_t i = 0; i < to_discard; i++)
                     si->lp_ele = lpNext(si->lp,si->lp_ele);
             } else {
-                int prev_times = 4; /* flag + id ms/seq diff + numfields. */
+                int prev_times = 4; /* flag + id ms + id seq + one more to
+                                       go back to the previous entry "count"
+                                       field. */
+                /* If the entry was not flagged SAMEFIELD we also read the
+                 * number of fields, so go back one more. */
+                if (!(flags & STREAM_ITEM_FLAG_SAMEFIELDS)) prev_times++;
                 while(prev_times--) si->lp_ele = lpPrev(si->lp,si->lp_ele);
             }
         }

From 13957c9d072b86bf8a084380591fcdc219aae108 Mon Sep 17 00:00:00 2001
From: Shen Longxing <shenlongxing2012@gmail.com>
Date: Tue, 12 Jun 2018 17:59:32 +0800
Subject: [PATCH 056/219] fix active-defrag-threshold value error

The active-defrag-threshold-lower/active-defrag-threshold-upper min/max  value in redis.conf should be consistent with 'config set' command.
---
 src/config.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/config.c b/src/config.c
index 1b229c43e..a6e45e033 100644
--- a/src/config.c
+++ b/src/config.c
@@ -509,14 +509,16 @@ void loadServerConfigFromString(char *config) {
             server.rdb_filename = zstrdup(argv[1]);
         } else if (!strcasecmp(argv[0],"active-defrag-threshold-lower") && argc == 2) {
             server.active_defrag_threshold_lower = atoi(argv[1]);
-            if (server.active_defrag_threshold_lower < 0) {
-                err = "active-defrag-threshold-lower must be 0 or greater";
+            if (server.active_defrag_threshold_lower < 0 ||
+                server.active_defrag_threshold_lower > 1000) {
+                err = "active-defrag-threshold-lower must be between 0 and 1000";
                 goto loaderr;
             }
         } else if (!strcasecmp(argv[0],"active-defrag-threshold-upper") && argc == 2) {
             server.active_defrag_threshold_upper = atoi(argv[1]);
-            if (server.active_defrag_threshold_upper < 0) {
-                err = "active-defrag-threshold-upper must be 0 or greater";
+            if (server.active_defrag_threshold_upper < 0 ||
+                server.active_defrag_threshold_upper > 1000) {
+                err = "active-defrag-threshold-upper must be between 0 and 1000";
                 goto loaderr;
             }
         } else if (!strcasecmp(argv[0],"active-defrag-ignore-bytes") && argc == 2) {

From 6bf65138de07d934b6ab5c9708918b37e841dabf Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 13:13:35 +0200
Subject: [PATCH 057/219] Regression test for issue #5006.

---
 tests/unit/type/stream.tcl | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/tests/unit/type/stream.tcl b/tests/unit/type/stream.tcl
index 7302d8a6d..d495c227b 100644
--- a/tests/unit/type/stream.tcl
+++ b/tests/unit/type/stream.tcl
@@ -253,4 +253,20 @@ start_server {
             }
         }
     }
+
+    test {XREVRANGE regression test for issue #5006} {
+        # Add non compressed entries
+        r xadd teststream 1234567891230 key1 value1
+        r xadd teststream 1234567891240 key2 value2
+        r xadd teststream 1234567891250 key3 value3
+
+        # Add SAMEFIELD compressed entries
+        r xadd teststream2 1234567891230 key1 value1
+        r xadd teststream2 1234567891240 key1 value2
+        r xadd teststream2 1234567891250 key1 value3
+
+        assert_equal [r xrevrange teststream 1234567891245 -] {{1234567891240-0 {key2 value2}} {1234567891230-0 {key1 value1}}}
+
+        assert_equal [r xrevrange teststream2 1234567891245 -] {{1234567891240-0 {key1 value2}} {1234567891230-0 {key1 value1}}}
+    }
 }

From bcc42028c1aa2d6427f14184088895112a6bd23a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 13:20:46 +0200
Subject: [PATCH 058/219] Fix XGROUP help missing space.

---
 src/t_stream.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 58ffda484..3cb4c32c0 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1565,7 +1565,7 @@ void xgroupCommand(client *c) {
     const char *help[] = {
 "CREATE      <key> <groupname> <id or $>  -- Create a new consumer group.",
 "SETID       <key> <groupname> <id or $>  -- Set the current group ID.",
-"DESTROY    <key> <groupname>            -- Remove the specified group.",
+"DESTROY     <key> <groupname>            -- Remove the specified group.",
 "DELCONSUMER <key> <groupname> <consumer> -- Remove the specified conusmer.",
 "HELP                                     -- Prints this help.",
 NULL

From 6b675b95252e7d7bbd3bc78d23e4a244a0310b4c Mon Sep 17 00:00:00 2001
From: Itamar Haber <itamar@redislabs.com>
Date: Tue, 12 Jun 2018 14:52:50 +0300
Subject: [PATCH 059/219] Applies addReplySubSyntaxError to stream commands

---
 src/t_stream.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 075386dd3..4b3c264a6 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1634,7 +1634,7 @@ NULL
     } else if (!strcasecmp(opt,"HELP")) {
         addReplyHelp(c, help);
     } else {
-        addReply(c,shared.syntaxerr);
+        addReplySubSyntaxError(c);
     }
 }
 
@@ -2261,7 +2261,7 @@ NULL
                                      STREAM_RWR_RAWENTRIES,NULL);
         if (!count) addReply(c,shared.nullbulk);
     } else {
-        addReplyError(c,"syntax error, try 'XINFO HELP'");
+        addReplySubSyntaxError(c);
     }
 }
 

From 4774d6169108e96a246d062772022b68601a37e5 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 14:12:53 +0200
Subject: [PATCH 060/219] Streams: improve type correctness in t_stream.c.

---
 src/t_stream.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 3cb4c32c0..a2f203991 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -172,7 +172,7 @@ int streamCompareID(streamID *a, streamID *b) {
  * if the ID was generated by the function. However the function may return
  * C_ERR if an ID was given via 'use_id', but adding it failed since the
  * current top ID is greater or equal. */
-int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id, streamID *use_id) {
+int streamAppendItem(stream *s, robj **argv, int64_t numfields, streamID *added_id, streamID *use_id) {
     /* If an ID was given, check that it's greater than the last entry ID
      * or return an error. */
     if (use_id && streamCompareID(use_id,&s->last_id) <= 0) return C_ERR;
@@ -260,7 +260,7 @@ int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id,
         lp = lpAppendInteger(lp,1); /* One item, the one we are adding. */
         lp = lpAppendInteger(lp,0); /* Zero deleted so far. */
         lp = lpAppendInteger(lp,numfields);
-        for (int i = 0; i < numfields; i++) {
+        for (int64_t i = 0; i < numfields; i++) {
             sds field = argv[i*2]->ptr;
             lp = lpAppend(lp,(unsigned char*)field,sdslen(field));
         }
@@ -285,10 +285,10 @@ int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id,
 
         /* Check if the entry we are adding, have the same fields
          * as the master entry. */
-        int master_fields_count = lpGetInteger(lp_ele);
+        int64_t master_fields_count = lpGetInteger(lp_ele);
         lp_ele = lpNext(lp,lp_ele);
         if (numfields == master_fields_count) {
-            int i;
+            int64_t i;
             for (i = 0; i < master_fields_count; i++) {
                 sds field = argv[i*2]->ptr;
                 int64_t e_len;
@@ -332,14 +332,14 @@ int streamAppendItem(stream *s, robj **argv, int numfields, streamID *added_id,
     lp = lpAppendInteger(lp,id.seq - master_id.seq);
     if (!(flags & STREAM_ITEM_FLAG_SAMEFIELDS))
         lp = lpAppendInteger(lp,numfields);
-    for (int i = 0; i < numfields; i++) {
+    for (int64_t i = 0; i < numfields; i++) {
         sds field = argv[i*2]->ptr, value = argv[i*2+1]->ptr;
         if (!(flags & STREAM_ITEM_FLAG_SAMEFIELDS))
             lp = lpAppend(lp,(unsigned char*)field,sdslen(field));
         lp = lpAppend(lp,(unsigned char*)value,sdslen(value));
     }
     /* Compute and store the lp-count field. */
-    int lp_count = numfields;
+    int64_t lp_count = numfields;
     lp_count += 3; /* Add the 3 fixed fields flags + ms-diff + seq-diff. */
     if (!(flags & STREAM_ITEM_FLAG_SAMEFIELDS)) {
         /* If the item is not compressed, it also has the fields other than
@@ -579,7 +579,7 @@ int streamIteratorGetID(streamIterator *si, streamID *id, int64_t *numfields) {
                 /* If we are going backward, read the number of elements this
                  * entry is composed of, and jump backward N times to seek
                  * its start. */
-                int lp_count = lpGetInteger(si->lp_ele);
+                int64_t lp_count = lpGetInteger(si->lp_ele);
                 if (lp_count == 0) { /* We reached the master entry. */
                     si->lp = NULL;
                     si->lp_ele = NULL;
@@ -642,14 +642,14 @@ int streamIteratorGetID(streamIterator *si, streamID *id, int64_t *numfields) {
              * forward, or seek the previous entry if we are going
              * backward. */
             if (!si->rev) {
-                int to_discard = (flags & STREAM_ITEM_FLAG_SAMEFIELDS) ?
-                                    *numfields : *numfields*2;
+                int64_t to_discard = (flags & STREAM_ITEM_FLAG_SAMEFIELDS) ?
+                                      *numfields : *numfields*2;
                 for (int64_t i = 0; i < to_discard; i++)
                     si->lp_ele = lpNext(si->lp,si->lp_ele);
             } else {
-                int prev_times = 4; /* flag + id ms + id seq + one more to
-                                       go back to the previous entry "count"
-                                       field. */
+                int64_t prev_times = 4; /* flag + id ms + id seq + one more to
+                                           go back to the previous entry "count"
+                                           field. */
                 /* If the entry was not flagged SAMEFIELD we also read the
                  * number of fields, so go back one more. */
                 if (!(flags & STREAM_ITEM_FLAG_SAMEFIELDS)) prev_times++;

From f70e88c1f6e2c7db676ea39dfa323d7c613df787 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 17:21:57 +0200
Subject: [PATCH 061/219] RDB: store times consistently in little endian.

I'm not sure how this escaped the attention of Redis users for years,
but finally @oranagra reported this issue... Thanks to Oran.
---
 src/rdb.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/rdb.c b/src/rdb.c
index 5ec06f9a8..7d5fd5fc4 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -100,6 +100,9 @@ int rdbLoadType(rio *rdb) {
     return type;
 }
 
+/* This is only used to load old databases stored with the RDB_OPCODE_EXPIRETIME
+ * opcode. New versions of Redis store using the RDB_OPCODE_EXPIRETIME_MS
+ * opcode. */
 time_t rdbLoadTime(rio *rdb) {
     int32_t t32;
     rdbLoadRaw(rdb,&t32,4);
@@ -108,12 +111,14 @@ time_t rdbLoadTime(rio *rdb) {
 
 int rdbSaveMillisecondTime(rio *rdb, long long t) {
     int64_t t64 = (int64_t) t;
+    memrev64ifbe(&t64); /* Store in little endian. */
     return rdbWriteRaw(rdb,&t64,8);
 }
 
 long long rdbLoadMillisecondTime(rio *rdb) {
     int64_t t64;
     rdbLoadRaw(rdb,&t64,8);
+    memrev64ifbe(&t64); /* Convert in big endian if the system is BE. */
     return (long long)t64;
 }
 

From e534e9aa8368dc2578384f33a874730a5ac83da9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 17:28:40 +0200
Subject: [PATCH 062/219] In scanDatabaseForReadyLists() now we need to handle
 ZSETs as well.

Since the introduction of ZPOP makes this needed. Thanks to @oranagra
for reporting.
---
 src/db.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/db.c b/src/db.c
index 6c039e129..16928aa09 100644
--- a/src/db.c
+++ b/src/db.c
@@ -942,16 +942,18 @@ void moveCommand(client *c) {
 }
 
 /* Helper function for dbSwapDatabases(): scans the list of keys that have
- * one or more blocked clients for B[LR]POP or other list blocking commands
- * and signal the keys are ready if they are lists. See the comment where
- * the function is used for more info. */
+ * one or more blocked clients for B[LR]POP or other blocking commands
+ * and signal the keys as ready if they are of the right type. See the comment
+ * where the function is used for more info. */
 void scanDatabaseForReadyLists(redisDb *db) {
     dictEntry *de;
     dictIterator *di = dictGetSafeIterator(db->blocking_keys);
     while((de = dictNext(di)) != NULL) {
         robj *key = dictGetKey(de);
         robj *value = lookupKey(db,key,LOOKUP_NOTOUCH);
-        if (value && (value->type == OBJ_LIST || value->type == OBJ_STREAM))
+        if (value && (value->type == OBJ_LIST ||
+                      value->type == OBJ_STREAM ||
+                      value->type == OBJ_ZSET))
             signalKeyAsReady(db, key);
     }
     dictReleaseIterator(di);

From b38682199b09bb77e11d9a3d4130fd8ebf8df7df Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 17:31:04 +0200
Subject: [PATCH 063/219] Fix rdbSaveKeyValuePair() integer overflow.

Again thanks to @oranagra. The object idle time does not fit into an int
sometimes: use the native type that the serialization function will get
as argument, which is uint64_t.
---
 src/rdb.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/rdb.c b/src/rdb.c
index 7d5fd5fc4..97b2d035e 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -993,8 +993,7 @@ size_t rdbSavedObjectLen(robj *o) {
  * On error -1 is returned.
  * On success if the key was actually saved 1 is returned, otherwise 0
  * is returned (the key was already expired). */
-int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime)
-{
+int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime) {
     int savelru = server.maxmemory_policy & MAXMEMORY_FLAG_LRU;
     int savelfu = server.maxmemory_policy & MAXMEMORY_FLAG_LFU;
 
@@ -1006,7 +1005,7 @@ int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime)
 
     /* Save the LRU info. */
     if (savelru) {
-        int idletime = estimateObjectIdleTime(val);
+        uint64_t idletime = estimateObjectIdleTime(val);
         idletime /= 1000; /* Using seconds is enough and requires less space.*/
         if (rdbSaveType(rdb,RDB_OPCODE_IDLE) == -1) return -1;
         if (rdbSaveLen(rdb,idletime) == -1) return -1;

From 6b8a24a665d0f9bb7cb55cca9ef9e413bdf94e41 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 18:10:41 +0200
Subject: [PATCH 064/219] Streams: generate a few additional events.

Currently it does not look it's sensible to generate events for streams
consumer groups modification, being them metadata, however at least for
key-level events, like the creation or removal of a consumer group, I
added a few events here and there. Later we can evaluate if it makes
sense to add more. From the POV instead of WAIT (in Redis transaciton)
and signaling the key as modified, it looks like that the transaction
should not fail when a stream is modified, so no calls are made in
consumer groups related functions to signalModifiedKey().
---
 src/t_stream.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index a2f203991..bcef4355a 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1379,7 +1379,7 @@ void xreadCommand(client *c) {
             /* Emit the two elements sub-array consisting of the name
              * of the stream and the data we extracted from it. */
             addReplyMultiBulkLen(c,2);
-            addReplyBulk(c,c->argv[i+streams_arg]);
+            addReplyBulk(c,c->argv[streams_arg+i]);
             streamConsumer *consumer = NULL;
             if (groups) consumer = streamLookupConsumer(groups[i],
                                                         consumername->ptr,1);
@@ -1606,6 +1606,8 @@ NULL
         if (cg) {
             addReply(c,shared.ok);
             server.dirty++;
+            notifyKeyspaceEvent(NOTIFY_STREAM,"xgroup-create",
+                                c->argv[2],c->db->id);
         } else {
             addReplySds(c,
                 sdsnew("-BUSYGROUP Consumer Group name already exists\r\n"));
@@ -1620,12 +1622,15 @@ NULL
         cg->last_id = id;
         addReply(c,shared.ok);
         server.dirty++;
+        notifyKeyspaceEvent(NOTIFY_STREAM,"xgroup-setid",c->argv[2],c->db->id);
     } else if (!strcasecmp(opt,"DESTROY") && c->argc == 4) {
         if (cg) {
             raxRemove(s->cgroups,(unsigned char*)grpname,sdslen(grpname),NULL);
             streamFreeCG(cg);
             addReply(c,shared.cone);
             server.dirty++;
+            notifyKeyspaceEvent(NOTIFY_STREAM,"xgroup-destroy",
+                                c->argv[2],c->db->id);
         } else {
             addReply(c,shared.czero);
         }
@@ -1635,6 +1640,8 @@ NULL
         long long pending = streamDelConsumer(cg,c->argv[4]->ptr);
         addReplyLongLong(c,pending);
         server.dirty++;
+        notifyKeyspaceEvent(NOTIFY_STREAM,"xgroup-delconsumer",
+                            c->argv[2],c->db->id);
     } else if (!strcasecmp(opt,"HELP")) {
         addReplyHelp(c, help);
     } else {

From 032ea657d7ca1923ebebda5f2cfeaa69bfbfb4f5 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 12 Jun 2018 18:21:39 +0200
Subject: [PATCH 065/219] RDB: Apply fix to rdbLoadMillisecondTime() only for
 new RDB versions.

This way we let big endian systems to still load old RDB versions.
However newver versions will be saved and loaded in a way that make RDB
expires cross-endian again. Thanks to @oranagra for the reporting and
the discussion about this problem, leading to this fix.
---
 src/rdb.c | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/rdb.c b/src/rdb.c
index 97b2d035e..10566fc55 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -115,10 +115,22 @@ int rdbSaveMillisecondTime(rio *rdb, long long t) {
     return rdbWriteRaw(rdb,&t64,8);
 }
 
-long long rdbLoadMillisecondTime(rio *rdb) {
+/* This function loads a time from the RDB file. It gets the version of the
+ * RDB because, unfortunately, before Redis 5 (RDB version 9), the function
+ * failed to convert data to/from little endian, so RDB files with keys having
+ * expires could not be shared between big endian and little endian systems
+ * (because the expire time will be totally wrong). The fix for this is just
+ * to call memrev64ifbe(), however if we fix this for all the RDB versions,
+ * this call will introduce an incompatibility for big endian systems:
+ * after upgrading to Redis version 5 they will no longer be able to load their
+ * own old RDB files. Because of that, we instead fix the function only for new
+ * RDB versions, and load older RDB versions as we used to do in the past,
+ * allowing big endian systems to load their own old RDB files. */
+long long rdbLoadMillisecondTime(rio *rdb, int rdbver) {
     int64_t t64;
     rdbLoadRaw(rdb,&t64,8);
-    memrev64ifbe(&t64); /* Convert in big endian if the system is BE. */
+    if (rdbver >= 9) /* Check the top comment of this function. */
+        memrev64ifbe(&t64); /* Convert in big endian if the system is BE. */
     return (long long)t64;
 }
 
@@ -1693,7 +1705,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
                 unsigned char rawid[sizeof(streamID)];
                 rdbLoadRaw(rdb,rawid,sizeof(rawid));
                 streamNACK *nack = streamCreateNACK(NULL);
-                nack->delivery_time = rdbLoadMillisecondTime(rdb);
+                nack->delivery_time = rdbLoadMillisecondTime(rdb,RDB_VERSION);
                 nack->delivery_count = rdbLoadLen(rdb,NULL);
                 if (!raxInsert(cgroup->pel,rawid,sizeof(rawid),nack,NULL))
                     rdbExitReportCorruptRDB("Duplicated gobal PEL entry "
@@ -1712,7 +1724,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
                 streamConsumer *consumer = streamLookupConsumer(cgroup,cname,
                                            1);
                 sdsfree(cname);
-                consumer->seen_time = rdbLoadMillisecondTime(rdb);
+                consumer->seen_time = rdbLoadMillisecondTime(rdb,RDB_VERSION);
 
                 /* Load the PEL about entries owned by this specific
                  * consumer. */
@@ -1877,7 +1889,7 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
         } else if (type == RDB_OPCODE_EXPIRETIME_MS) {
             /* EXPIRETIME_MS: milliseconds precision expire times introduced
              * with RDB v3. Like EXPIRETIME but no with more precision. */
-            expiretime = rdbLoadMillisecondTime(rdb);
+            expiretime = rdbLoadMillisecondTime(rdb,rdbver);
             continue; /* Read next opcode. */
         } else if (type == RDB_OPCODE_FREQ) {
             /* FREQ: LFU frequency. */

From 52a00201fca331217c3b4b8b634f6a0f57d6b7d3 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 14 May 2018 17:45:40 +0200
Subject: [PATCH 066/219] Security: fix Lua cmsgpack library stack overflow.

During an auditing effort, the Apple Vulnerability Research team discovered
a critical Redis security issue affecting the Lua scripting part of Redis.

-- Description of the problem

Several years ago I merged a pull request including many small changes at
the Lua MsgPack library (that originally I authored myself). The Pull
Request entered Redis in commit 90b6337c1, in 2014.
Unfortunately one of the changes included a variadic Lua function that
lacked the check for the available Lua C stack. As a result, calling the
"pack" MsgPack library function with a large number of arguments, results
into pushing into the Lua C stack a number of new values proportional to
the number of arguments the function was called with. The pushed values,
moreover, are controlled by untrusted user input.

This in turn causes stack smashing which we believe to be exploitable,
while not very deterministic, but it is likely that an exploit could be
created targeting specific versions of Redis executables. However at its
minimum the issue results in a DoS, crashing the Redis server.

-- Versions affected

Versions greater or equal to Redis 2.8.18 are affected.

-- Reproducing

Reproduce with this (based on the original reproduction script by
Apple security team):

https://gist.github.com/antirez/82445fcbea6d9b19f97014cc6cc79f8a

-- Verification of the fix

The fix was tested in the following way:

1) I checked that the problem is no longer observable running the trigger.
2) The Lua code was analyzed to understand the stack semantics, and that
actually enough stack is allocated in all the cases of mp_pack() calls.
3) The mp_pack() function was modified in order to show exactly what items
in the stack were being set, to make sure that there is no silent overflow
even after the fix.

-- Credits

Thank you to the Apple team and to the other persons that helped me
checking the patch and coordinating this communication.
---
 deps/lua/src/lua_cmsgpack.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/deps/lua/src/lua_cmsgpack.c b/deps/lua/src/lua_cmsgpack.c
index 90a388f3f..ba75ed455 100644
--- a/deps/lua/src/lua_cmsgpack.c
+++ b/deps/lua/src/lua_cmsgpack.c
@@ -515,6 +515,9 @@ int mp_pack(lua_State *L) {
     if (nargs == 0)
         return luaL_argerror(L, 0, "MessagePack pack needs input.");
 
+    if (!lua_checkstack(L, nargs))
+        return luaL_argerror(L, 0, "Too many arguments for MessagePack pack.");
+
     buf = mp_buf_new(L);
     for(i = 1; i <= nargs; i++) {
         /* Copy argument i to top of stack for _encode processing;

From 1eb08bcd4634ae42ec45e8284923ac048beaa4c3 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 14 May 2018 17:49:06 +0200
Subject: [PATCH 067/219] Security: update Lua struct package for security.

During an auditing Apple found that the "struct" Lua package
we ship with Redis (http://www.inf.puc-rio.br/~roberto/struct/) contains
a security problem. A bound-checking statement fails because of integer
overflow. The bug exists since we initially integrated this package with
Lua, when scripting was introduced, so every version of Redis with
EVAL/EVALSHA capabilities exposed is affected.

Instead of just fixing the bug, the library was updated to the latest
version shipped by the author.
---
 deps/lua/src/lua_struct.c | 46 +++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/deps/lua/src/lua_struct.c b/deps/lua/src/lua_struct.c
index a602bb430..b03a002da 100644
--- a/deps/lua/src/lua_struct.c
+++ b/deps/lua/src/lua_struct.c
@@ -1,7 +1,7 @@
 /*
 ** {======================================================
 ** Library for packing/unpacking structures.
-** $Id: struct.c,v 1.4 2012/07/04 18:54:29 roberto Exp $
+** $Id: struct.c,v 1.7 2018/05/11 22:04:31 roberto Exp $
 ** See Copyright Notice at the end of this file
 ** =======================================================
 */
@@ -15,8 +15,8 @@
 ** h/H - signed/unsigned short
 ** l/L - signed/unsigned long
 ** T   - size_t
-** i/In - signed/unsigned integer with size `n' (default is size of int)
-** cn - sequence of `n' chars (from/to a string); when packing, n==0 means
+** i/In - signed/unsigned integer with size 'n' (default is size of int)
+** cn - sequence of 'n' chars (from/to a string); when packing, n==0 means
         the whole string; when unpacking, n==0 means use the previous
         read number as the string length
 ** s - zero-terminated string
@@ -89,14 +89,12 @@ typedef struct Header {
 } Header;
 
 
-static int getnum (lua_State *L, const char **fmt, int df) {
+static int getnum (const char **fmt, int df) {
   if (!isdigit(**fmt))  /* no number? */
     return df;  /* return default value */
   else {
     int a = 0;
     do {
-      if (a > (INT_MAX / 10) || a * 10 > (INT_MAX - (**fmt - '0')))
-        luaL_error(L, "integral size overflow");
       a = a*10 + *((*fmt)++) - '0';
     } while (isdigit(**fmt));
     return a;
@@ -117,9 +115,9 @@ static size_t optsize (lua_State *L, char opt, const char **fmt) {
     case 'f':  return sizeof(float);
     case 'd':  return sizeof(double);
     case 'x': return 1;
-    case 'c': return getnum(L, fmt, 1);
+    case 'c': return getnum(fmt, 1);
     case 'i': case 'I': {
-      int sz = getnum(L, fmt, sizeof(int));
+      int sz = getnum(fmt, sizeof(int));
       if (sz > MAXINTSIZE)
         luaL_error(L, "integral size %d is larger than limit of %d",
                        sz, MAXINTSIZE);
@@ -152,7 +150,7 @@ static void controloptions (lua_State *L, int opt, const char **fmt,
     case '>': h->endian = BIG; return;
     case '<': h->endian = LITTLE; return;
     case '!': {
-      int a = getnum(L, fmt, MAXALIGN);
+      int a = getnum(fmt, MAXALIGN);
       if (!isp2(a))
         luaL_error(L, "alignment %d is not a power of 2", a);
       h->align = a;
@@ -296,20 +294,21 @@ static int b_unpack (lua_State *L) {
   size_t ld;
   const char *data = luaL_checklstring(L, 2, &ld);
   size_t pos = luaL_optinteger(L, 3, 1) - 1;
+  int n = 0;  /* number of results */
   defaultoptions(&h);
-  lua_settop(L, 2);
   while (*fmt) {
     int opt = *fmt++;
     size_t size = optsize(L, opt, &fmt);
     pos += gettoalign(pos, &h, opt, size);
     luaL_argcheck(L, pos+size <= ld, 2, "data string too short");
-    luaL_checkstack(L, 1, "too many results");
+    /* stack space for item + next position */
+    luaL_checkstack(L, 2, "too many results");
     switch (opt) {
       case 'b': case 'B': case 'h': case 'H':
       case 'l': case 'L': case 'T': case 'i':  case 'I': {  /* integer types */
         int issigned = islower(opt);
         lua_Number res = getinteger(data+pos, h.endian, issigned, size);
-        lua_pushnumber(L, res);
+        lua_pushnumber(L, res); n++;
         break;
       }
       case 'x': {
@@ -319,25 +318,26 @@ static int b_unpack (lua_State *L) {
         float f;
         memcpy(&f, data+pos, size);
         correctbytes((char *)&f, sizeof(f), h.endian);
-        lua_pushnumber(L, f);
+        lua_pushnumber(L, f); n++;
         break;
       }
       case 'd': {
         double d;
         memcpy(&d, data+pos, size);
         correctbytes((char *)&d, sizeof(d), h.endian);
-        lua_pushnumber(L, d);
+        lua_pushnumber(L, d); n++;
         break;
       }
       case 'c': {
         if (size == 0) {
-          if (!lua_isnumber(L, -1))
-            luaL_error(L, "format `c0' needs a previous size");
+          if (n == 0 || !lua_isnumber(L, -1))
+            luaL_error(L, "format 'c0' needs a previous size");
           size = lua_tonumber(L, -1);
-          lua_pop(L, 1);
-          luaL_argcheck(L, pos+size <= ld, 2, "data string too short");
+          lua_pop(L, 1); n--;
+          luaL_argcheck(L, size <= ld && pos <= ld - size,
+                           2, "data string too short");
         }
-        lua_pushlstring(L, data+pos, size);
+        lua_pushlstring(L, data+pos, size); n++;
         break;
       }
       case 's': {
@@ -345,15 +345,15 @@ static int b_unpack (lua_State *L) {
         if (e == NULL)
           luaL_error(L, "unfinished string in data");
         size = (e - (data+pos)) + 1;
-        lua_pushlstring(L, data+pos, size - 1);
+        lua_pushlstring(L, data+pos, size - 1); n++;
         break;
       }
       default: controloptions(L, opt, &fmt, &h);
     }
     pos += size;
   }
-  lua_pushinteger(L, pos + 1);
-  return lua_gettop(L) - 2;
+  lua_pushinteger(L, pos + 1);  /* next position */
+  return n + 1;
 }
 
 
@@ -399,7 +399,7 @@ LUALIB_API int luaopen_struct (lua_State *L) {
 
 
 /******************************************************************************
-* Copyright (C) 2010-2012 Lua.org, PUC-Rio.  All rights reserved.
+* Copyright (C) 2010-2018 Lua.org, PUC-Rio.  All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the

From 5ccb6f7a791bf3490357b00a898885759d98bab0 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 15 May 2018 12:29:56 +0200
Subject: [PATCH 068/219] Security: more cmsgpack fixes by @soloestoy.

@soloestoy sent me this additional fixes, after searching for similar
problems to the one reported in mp_pack(). I'm committing the changes
because it was not possible during to make a public PR to protect Redis
users and give Redis providers some time to patch their systems.
---
 deps/lua/src/lua_cmsgpack.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/deps/lua/src/lua_cmsgpack.c b/deps/lua/src/lua_cmsgpack.c
index ba75ed455..892154793 100644
--- a/deps/lua/src/lua_cmsgpack.c
+++ b/deps/lua/src/lua_cmsgpack.c
@@ -385,6 +385,7 @@ void mp_encode_lua_table_as_array(lua_State *L, mp_buf *buf, int level) {
 #endif
 
     mp_encode_array(L,buf,len);
+    luaL_checkstack(L, 1, "in function mp_encode_lua_table_as_array");
     for (j = 1; j <= len; j++) {
         lua_pushnumber(L,j);
         lua_gettable(L,-2);
@@ -400,6 +401,7 @@ void mp_encode_lua_table_as_map(lua_State *L, mp_buf *buf, int level) {
      * Lua API, we need to iterate a first time. Note that an alternative
      * would be to do a single run, and then hack the buffer to insert the
      * map opcodes for message pack. Too hackish for this lib. */
+    luaL_checkstack(L, 3, "in function mp_encode_lua_table_as_map");
     lua_pushnil(L);
     while(lua_next(L,-2)) {
         lua_pop(L,1); /* remove value, keep key for next iteration. */
@@ -522,6 +524,7 @@ int mp_pack(lua_State *L) {
     for(i = 1; i <= nargs; i++) {
         /* Copy argument i to top of stack for _encode processing;
          * the encode function pops it from the stack when complete. */
+        luaL_checkstack(L, 1, "in function mp_check");
         lua_pushvalue(L, i);
 
         mp_encode_lua_type(L,buf,0);
@@ -550,6 +553,7 @@ void mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {
     int index = 1;
 
     lua_newtable(L);
+    luaL_checkstack(L, 1, "in function mp_decode_to_lua_array");
     while(len--) {
         lua_pushnumber(L,index++);
         mp_decode_to_lua_type(L,c);
@@ -824,6 +828,9 @@ int mp_unpack_full(lua_State *L, int limit, int offset) {
          * subtract the entire buffer size from the unprocessed size
          * to get our next start offset */
         int offset = len - c.left;
+
+        luaL_checkstack(L, 1, "in function mp_unpack_full");
+
         /* Return offset -1 when we have have processed the entire buffer. */
         lua_pushinteger(L, c.left == 0 ? -1 : offset);
         /* Results are returned with the arg elements still

From e89086e09a38cc6713bcd4b9c29abf92cf393936 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 15 May 2018 13:13:49 +0200
Subject: [PATCH 069/219] Security: fix Lua struct package offset handling.

After the first fix to the struct package I found another similar
problem, which is fixed by this patch. It could be reproduced easily by
running the following script:

    return struct.unpack('f', "xxxxxxxxxxxxx",-3)

The above will access bytes before the 'data' pointer.
---
 deps/lua/src/lua_struct.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/deps/lua/src/lua_struct.c b/deps/lua/src/lua_struct.c
index b03a002da..4d5f027b8 100644
--- a/deps/lua/src/lua_struct.c
+++ b/deps/lua/src/lua_struct.c
@@ -293,14 +293,18 @@ static int b_unpack (lua_State *L) {
   const char *fmt = luaL_checkstring(L, 1);
   size_t ld;
   const char *data = luaL_checklstring(L, 2, &ld);
-  size_t pos = luaL_optinteger(L, 3, 1) - 1;
+  size_t pos = luaL_optinteger(L, 3, 1);
+  luaL_argcheck(L, pos > 0, 3, "offset must be 1 or greater");
+  pos--; /* Lua indexes are 1-based, but here we want 0-based for C
+          * pointer math. */
   int n = 0;  /* number of results */
   defaultoptions(&h);
   while (*fmt) {
     int opt = *fmt++;
     size_t size = optsize(L, opt, &fmt);
     pos += gettoalign(pos, &h, opt, size);
-    luaL_argcheck(L, pos+size <= ld, 2, "data string too short");
+    luaL_argcheck(L, size <= ld && pos <= ld - size,
+                   2, "data string too short");
     /* stack space for item + next position */
     luaL_checkstack(L, 2, "too many results");
     switch (opt) {

From ce17f76bbd95f68ab6716adcbf12d49e3822b87c Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 11 Jun 2018 12:08:42 +0200
Subject: [PATCH 070/219] Security: fix redis-cli buffer overflow.

Thanks to Fakhri Zulkifli for reporting it.

The fix switched to dynamic allocation, copying the final prompt in the
static buffer only at the end.
---
 src/redis-cli.c | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index af5e6a230..b1ece6250 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -258,20 +258,25 @@ static long long mstime(void) {
 }
 
 static void cliRefreshPrompt(void) {
-    int len;
-
     if (config.eval_ldb) return;
-    if (config.hostsocket != NULL)
-        len = snprintf(config.prompt,sizeof(config.prompt),"redis %s",
-                       config.hostsocket);
-    else
-        len = anetFormatAddr(config.prompt, sizeof(config.prompt),
-                           config.hostip, config.hostport);
+
+    sds prompt = sdsempty();
+    if (config.hostsocket != NULL) {
+        prompt = sdscatfmt(prompt,"redis %s",config.hostsocket);
+    } else {
+        char addr[256];
+        anetFormatAddr(addr, sizeof(addr), config.hostip, config.hostport);
+        prompt = sdscatlen(prompt,addr,strlen(addr));
+    }
+
     /* Add [dbnum] if needed */
     if (config.dbnum != 0)
-        len += snprintf(config.prompt+len,sizeof(config.prompt)-len,"[%d]",
-            config.dbnum);
-    snprintf(config.prompt+len,sizeof(config.prompt)-len,"> ");
+        prompt = sdscatfmt(prompt,"[%i]",config.dbnum);
+
+    /* Copy the prompt in the static buffer. */
+    prompt = sdscatlen(prompt,"> ",2);
+    snprintf(config.prompt,sizeof(config.prompt),"%s",prompt);
+    sdsfree(prompt);
 }
 
 /* Return the name of the dotfile for the specified 'dotfilename'.

From 963002d71e64ffd1491b398eea3f57a34d928464 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Wed, 13 Jun 2018 20:35:40 +0800
Subject: [PATCH 071/219] optimize reply list memory usage

---
 src/networking.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/networking.c b/src/networking.c
index 00558974e..02e77307e 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -247,7 +247,7 @@ void _addReplyStringToList(client *c, const char *s, size_t len) {
 
         /* Append to this object when possible. If tail == NULL it was
          * set via addDeferredMultiBulkLength(). */
-        if (tail && sdslen(tail)+len <= PROTO_REPLY_CHUNK_BYTES) {
+        if (tail && (sdsavail(tail) >= len || sdslen(tail)+len <= PROTO_REPLY_CHUNK_BYTES)) {
             tail = sdscatlen(tail,s,len);
             listNodeValue(ln) = tail;
             c->reply_bytes += len;

From e4e5a670e7e28485d6ba812759d7faabd90966d2 Mon Sep 17 00:00:00 2001
From: shenlongxing <shenlongxing2012@gmail.com>
Date: Wed, 13 Jun 2018 23:27:53 +0800
Subject: [PATCH 072/219] Fix config_set_numerical_field() integer overflow.

---
 src/config.c | 54 ++++++++++++++++++++++++++--------------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/config.c b/src/config.c
index a6e45e033..984111468 100644
--- a/src/config.c
+++ b/src/config.c
@@ -1062,15 +1062,15 @@ void configSetCommand(client *c) {
     /* Numerical fields.
      * config_set_numerical_field(name,var,min,max) */
     } config_set_numerical_field(
-      "tcp-keepalive",server.tcpkeepalive,0,LLONG_MAX) {
+      "tcp-keepalive",server.tcpkeepalive,0,INT_MAX) {
     } config_set_numerical_field(
-      "maxmemory-samples",server.maxmemory_samples,1,LLONG_MAX) {
+      "maxmemory-samples",server.maxmemory_samples,1,INT_MAX) {
     } config_set_numerical_field(
-      "lfu-log-factor",server.lfu_log_factor,0,LLONG_MAX) {
+      "lfu-log-factor",server.lfu_log_factor,0,INT_MAX) {
     } config_set_numerical_field(
-      "lfu-decay-time",server.lfu_decay_time,0,LLONG_MAX) {
+      "lfu-decay-time",server.lfu_decay_time,0,INT_MAX) {
     } config_set_numerical_field(
-      "timeout",server.maxidletime,0,LONG_MAX) {
+      "timeout",server.maxidletime,0,INT_MAX) {
     } config_set_numerical_field(
       "active-defrag-threshold-lower",server.active_defrag_threshold_lower,0,1000) {
     } config_set_numerical_field(
@@ -1082,15 +1082,15 @@ void configSetCommand(client *c) {
     } config_set_numerical_field(
       "active-defrag-cycle-max",server.active_defrag_cycle_max,1,99) {
     } config_set_numerical_field(
-      "active-defrag-max-scan-fields",server.active_defrag_max_scan_fields,1,LLONG_MAX) {
+      "active-defrag-max-scan-fields",server.active_defrag_max_scan_fields,1,LONG_MAX) {
     } config_set_numerical_field(
-      "auto-aof-rewrite-percentage",server.aof_rewrite_perc,0,LLONG_MAX){
+      "auto-aof-rewrite-percentage",server.aof_rewrite_perc,0,INT_MAX){
     } config_set_numerical_field(
-      "hash-max-ziplist-entries",server.hash_max_ziplist_entries,0,LLONG_MAX) {
+      "hash-max-ziplist-entries",server.hash_max_ziplist_entries,0,LONG_MAX) {
     } config_set_numerical_field(
-      "hash-max-ziplist-value",server.hash_max_ziplist_value,0,LLONG_MAX) {
+      "hash-max-ziplist-value",server.hash_max_ziplist_value,0,LONG_MAX) {
     } config_set_numerical_field(
-      "stream-node-max-bytes",server.stream_node_max_bytes,0,LLONG_MAX) {
+      "stream-node-max-bytes",server.stream_node_max_bytes,0,LONG_MAX) {
     } config_set_numerical_field(
       "stream-node-max-entries",server.stream_node_max_entries,0,LLONG_MAX) {
     } config_set_numerical_field(
@@ -1098,40 +1098,40 @@ void configSetCommand(client *c) {
     } config_set_numerical_field(
       "list-compress-depth",server.list_compress_depth,0,INT_MAX) {
     } config_set_numerical_field(
-      "set-max-intset-entries",server.set_max_intset_entries,0,LLONG_MAX) {
+      "set-max-intset-entries",server.set_max_intset_entries,0,LONG_MAX) {
     } config_set_numerical_field(
-      "zset-max-ziplist-entries",server.zset_max_ziplist_entries,0,LLONG_MAX) {
+      "zset-max-ziplist-entries",server.zset_max_ziplist_entries,0,LONG_MAX) {
     } config_set_numerical_field(
-      "zset-max-ziplist-value",server.zset_max_ziplist_value,0,LLONG_MAX) {
+      "zset-max-ziplist-value",server.zset_max_ziplist_value,0,LONG_MAX) {
     } config_set_numerical_field(
-      "hll-sparse-max-bytes",server.hll_sparse_max_bytes,0,LLONG_MAX) {
+      "hll-sparse-max-bytes",server.hll_sparse_max_bytes,0,LONG_MAX) {
     } config_set_numerical_field(
-      "lua-time-limit",server.lua_time_limit,0,LLONG_MAX) {
+      "lua-time-limit",server.lua_time_limit,0,LONG_MAX) {
     } config_set_numerical_field(
       "slowlog-log-slower-than",server.slowlog_log_slower_than,0,LLONG_MAX) {
     } config_set_numerical_field(
-      "slowlog-max-len",ll,0,LLONG_MAX) {
+      "slowlog-max-len",ll,0,LONG_MAX) {
       /* Cast to unsigned. */
         server.slowlog_max_len = (unsigned long)ll;
     } config_set_numerical_field(
       "latency-monitor-threshold",server.latency_monitor_threshold,0,LLONG_MAX){
     } config_set_numerical_field(
-      "repl-ping-slave-period",server.repl_ping_slave_period,1,LLONG_MAX) {
+      "repl-ping-slave-period",server.repl_ping_slave_period,1,INT_MAX) {
     } config_set_numerical_field(
-      "repl-timeout",server.repl_timeout,1,LLONG_MAX) {
+      "repl-timeout",server.repl_timeout,1,INT_MAX) {
     } config_set_numerical_field(
-      "repl-backlog-ttl",server.repl_backlog_time_limit,0,LLONG_MAX) {
+      "repl-backlog-ttl",server.repl_backlog_time_limit,0,LONG_MAX) {
     } config_set_numerical_field(
-      "repl-diskless-sync-delay",server.repl_diskless_sync_delay,0,LLONG_MAX) {
+      "repl-diskless-sync-delay",server.repl_diskless_sync_delay,0,INT_MAX) {
     } config_set_numerical_field(
-      "slave-priority",server.slave_priority,0,LLONG_MAX) {
+      "slave-priority",server.slave_priority,0,INT_MAX) {
     } config_set_numerical_field(
       "slave-announce-port",server.slave_announce_port,0,65535) {
     } config_set_numerical_field(
-      "min-slaves-to-write",server.repl_min_slaves_to_write,0,LLONG_MAX) {
+      "min-slaves-to-write",server.repl_min_slaves_to_write,0,INT_MAX) {
         refreshGoodSlavesCount();
     } config_set_numerical_field(
-      "min-slaves-max-lag",server.repl_min_slaves_max_lag,0,LLONG_MAX) {
+      "min-slaves-max-lag",server.repl_min_slaves_max_lag,0,INT_MAX) {
         refreshGoodSlavesCount();
     } config_set_numerical_field(
       "cluster-node-timeout",server.cluster_node_timeout,0,LLONG_MAX) {
@@ -1140,17 +1140,17 @@ void configSetCommand(client *c) {
     } config_set_numerical_field(
       "cluster-announce-bus-port",server.cluster_announce_bus_port,0,65535) {
     } config_set_numerical_field(
-      "cluster-migration-barrier",server.cluster_migration_barrier,0,LLONG_MAX){
+      "cluster-migration-barrier",server.cluster_migration_barrier,0,INT_MAX){
     } config_set_numerical_field(
-      "cluster-slave-validity-factor",server.cluster_slave_validity_factor,0,LLONG_MAX) {
+      "cluster-slave-validity-factor",server.cluster_slave_validity_factor,0,INT_MAX) {
     } config_set_numerical_field(
-      "hz",server.hz,0,LLONG_MAX) {
+      "hz",server.hz,0,INT_MAX) {
         /* Hz is more an hint from the user, so we accept values out of range
          * but cap them to reasonable values. */
         if (server.hz < CONFIG_MIN_HZ) server.hz = CONFIG_MIN_HZ;
         if (server.hz > CONFIG_MAX_HZ) server.hz = CONFIG_MAX_HZ;
     } config_set_numerical_field(
-      "watchdog-period",ll,0,LLONG_MAX) {
+      "watchdog-period",ll,0,INT_MAX) {
         if (ll)
             enableWatchdog(ll);
         else

From 2ffa533f8556b3c642b1099b98ba8b59889b1250 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Thu, 14 Jun 2018 01:30:07 +0800
Subject: [PATCH 073/219] fix exists command on slave

---
 src/db.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/db.c b/src/db.c
index 16928aa09..3307cdee9 100644
--- a/src/db.c
+++ b/src/db.c
@@ -467,8 +467,7 @@ void existsCommand(client *c) {
     int j;
 
     for (j = 1; j < c->argc; j++) {
-        expireIfNeeded(c->db,c->argv[j]);
-        if (dbExists(c->db,c->argv[j])) count++;
+        if (lookupKeyRead(c->db,c->argv[j])) count++;
     }
     addReplyLongLong(c,count);
 }

From a4f658b2b5d4be9c3592434d74a5de9cd678158c Mon Sep 17 00:00:00 2001
From: Fuxin Hao <haofxpro@gmail.com>
Date: Thu, 14 Jun 2018 16:44:19 +0800
Subject: [PATCH 074/219] Fix update_zmalloc_stat_alloc in zrealloc

---
 src/zmalloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/zmalloc.c b/src/zmalloc.c
index a08ae489e..56fb0798d 100644
--- a/src/zmalloc.c
+++ b/src/zmalloc.c
@@ -165,7 +165,7 @@ void *zrealloc(void *ptr, size_t size) {
 
     *((size_t*)newptr) = size;
     update_zmalloc_stat_free(oldsize);
-    update_zmalloc_stat_alloc(size);
+    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
     return (char*)newptr+PREFIX_SIZE;
 #endif
 }

From 1e92fde3d34237ff4d30f8a46f74c34f037ed1dd Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 14 Jun 2018 12:21:54 +0200
Subject: [PATCH 075/219] Fix SCAN bug regression test, avoiding empty SREM
 call.

---
 tests/unit/scan.tcl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/unit/scan.tcl b/tests/unit/scan.tcl
index a8cc81163..c0f4349d2 100644
--- a/tests/unit/scan.tcl
+++ b/tests/unit/scan.tcl
@@ -246,7 +246,7 @@ start_server {tags {"scan"}} {
             array set found {}
 
             # Populate the set
-            set numele [expr {100+[randomInt 1000]}]
+            set numele [expr {101+[randomInt 1000]}]
             for {set j 0} {$j < $numele} {incr j} {
                 r sadd set $j
                 if {$j >= 100} {

From d6e8fe77afdb79853dd62581be2e785f0014bdf9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 14 Jun 2018 18:08:05 +0200
Subject: [PATCH 076/219] Fix infinite loop in dbRandomKey().

Thanks to @kevinmcgehee for signaling the issue and reasoning about the
consequences and potential fixes.

Issue #5015.
---
 src/db.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/db.c b/src/db.c
index 16928aa09..b4190f864 100644
--- a/src/db.c
+++ b/src/db.c
@@ -223,6 +223,8 @@ int dbExists(redisDb *db, robj *key) {
  * The function makes sure to return keys not already expired. */
 robj *dbRandomKey(redisDb *db) {
     dictEntry *de;
+    int maxtries = 100;
+    int allvolatile = dictSize(db->dict) == dictSize(db->expires);
 
     while(1) {
         sds key;
@@ -234,6 +236,17 @@ robj *dbRandomKey(redisDb *db) {
         key = dictGetKey(de);
         keyobj = createStringObject(key,sdslen(key));
         if (dictFind(db->expires,key)) {
+            if (allvolatile && server.masterhost && --maxtries == 0) {
+                /* If the DB is composed only of keys with an expire set,
+                 * it could happen that all the keys are already logically
+                 * expired in the slave, so the function cannot stop because
+                 * expireIfNeeded() is false, nor it can stop because
+                 * dictGetRandomKey() returns NULL (there are keys to return).
+                 * To prevent the infinite loop we do some tries, but if there
+                 * are the conditions for an infinite loop, eventually we
+                 * return a key name that may be already expired. */
+                return keyobj;
+            }
             if (expireIfNeeded(db,keyobj)) {
                 decrRefCount(keyobj);
                 continue; /* search for another key. This expired. */

From 6a66b93b186506bcd37f147cbb353f0961a03870 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 14 Jun 2018 18:57:58 +0200
Subject: [PATCH 077/219] Sentinel: add an option to deny online script
 reconfiguration.

The ability of "SENTINEL SET" to change the reconfiguration script at
runtime is a problem even in the security model of Redis: any client
inside the network may set any executable to be ran once a failover is
triggered.

This option adds protection for this problem: by default the two
SENTINEL SET subcommands modifying scripts paths are denied. However the
user is still able to rever that using the Sentinel configuration file
in order to allow such a feature.
---
 sentinel.conf  |  9 +++++++++
 src/sentinel.c | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/sentinel.conf b/sentinel.conf
index 0e1b266ed..38b097254 100644
--- a/sentinel.conf
+++ b/sentinel.conf
@@ -194,3 +194,12 @@ sentinel failover-timeout mymaster 180000
 #
 # sentinel client-reconfig-script mymaster /var/redis/reconfig.sh
 
+# SECURITY
+#
+# By default SENTINEL SET will not be able to change the notification-script
+# and client-reconfig-script at runtime. This avoids a trivial security issue
+# where clients can set the script to anything and trigger a failover in order
+# to get the program executed.
+
+sentinel deny-scripts-reconfig yes
+
diff --git a/src/sentinel.c b/src/sentinel.c
index ef1be7291..d3818707b 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -84,6 +84,7 @@ typedef struct sentinelAddr {
 #define SENTINEL_MAX_PENDING_COMMANDS 100
 #define SENTINEL_ELECTION_TIMEOUT 10000
 #define SENTINEL_MAX_DESYNC 1000
+#define SENTINEL_DEFAULT_DENY_SCRIPTS_RECONFIG 1
 
 /* Failover machine different states. */
 #define SENTINEL_FAILOVER_STATE_NONE 0  /* No failover in progress. */
@@ -241,6 +242,8 @@ struct sentinelState {
     int announce_port;  /* Port that is gossiped to other sentinels if
                            non zero. */
     unsigned long simfailure_flags; /* Failures simulation. */
+    int deny_scripts_reconfig; /* Allow SENTINEL SET ... to change script
+                                  paths at runtime? */
 } sentinel;
 
 /* A script execution job. */
@@ -468,6 +471,7 @@ void initSentinel(void) {
     sentinel.announce_ip = NULL;
     sentinel.announce_port = 0;
     sentinel.simfailure_flags = SENTINEL_SIMFAILURE_NONE;
+    sentinel.deny_scripts_reconfig = SENTINEL_DEFAULT_DENY_SCRIPTS_RECONFIG;
     memset(sentinel.myid,0,sizeof(sentinel.myid));
 }
 
@@ -1684,6 +1688,12 @@ char *sentinelHandleConfiguration(char **argv, int argc) {
     } else if (!strcasecmp(argv[0],"announce-port") && argc == 2) {
         /* announce-port <port> */
         sentinel.announce_port = atoi(argv[1]);
+    } else if (!strcasecmp(argv[0],"deny-scripts-reconfig") && argc == 2) {
+        /* deny-scripts-reconfig <yes|no> */
+        if ((sentinel.deny_scripts_reconfig = yesnotoi(argv[1])) == -1) {
+            return "Please specify yes or no for the "
+                   "deny-scripts-reconfig options.";
+        }
     } else {
         return "Unrecognized sentinel configuration statement.";
     }
@@ -1704,6 +1714,12 @@ void rewriteConfigSentinelOption(struct rewriteConfigState *state) {
     line = sdscatprintf(sdsempty(), "sentinel myid %s", sentinel.myid);
     rewriteConfigRewriteLine(state,"sentinel",line,1);
 
+    /* sentinel deny-scripts-reconfig. */
+    line = sdscatprintf(sdsempty(), "sentinel deny-scripts-reconfig %s",
+        sentinel.deny_scripts_reconfig ? "yes" : "no");
+    rewriteConfigRewriteLine(state,"sentinel",line,
+        sentinel.deny_scripts_reconfig != SENTINEL_DEFAULT_DENY_SCRIPTS_RECONFIG);
+
     /* For every master emit a "sentinel monitor" config entry. */
     di = dictGetIterator(sentinel.masters);
     while((de = dictNext(di)) != NULL) {
@@ -3331,6 +3347,14 @@ void sentinelSetCommand(client *c) {
             changes++;
        } else if (!strcasecmp(option,"notification-script")) {
             /* notification-script <path> */
+            if (sentinel.deny_scripts_reconfig) {
+                addReplyError(c,
+                    "Reconfiguration of scripts path is denied for "
+                    "security reasons. Check the deny-scripts-reconfig "
+                    "configuration directive in your Sentinel configuration");
+                return;
+            }
+
             if (strlen(value) && access(value,X_OK) == -1) {
                 addReplyError(c,
                     "Notification script seems non existing or non executable");
@@ -3342,6 +3366,14 @@ void sentinelSetCommand(client *c) {
             changes++;
        } else if (!strcasecmp(option,"client-reconfig-script")) {
             /* client-reconfig-script <path> */
+            if (sentinel.deny_scripts_reconfig) {
+                addReplyError(c,
+                    "Reconfiguration of scripts path is denied for "
+                    "security reasons. Check the deny-scripts-reconfig "
+                    "configuration directive in your Sentinel configuration");
+                return;
+            }
+
             if (strlen(value) && access(value,X_OK) == -1) {
                 addReplyError(c,
                     "Client reconfiguration script seems non existing or "

From 79a1c19ac28ae7feb23630507c2c192e84ba2cb7 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Sun, 17 Jun 2018 10:44:01 +0200
Subject: [PATCH 078/219] XADD MAXLEN should return an error for values < 0.

---
 src/t_stream.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/t_stream.c b/src/t_stream.c
index bcef4355a..20daeee91 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1105,6 +1105,11 @@ void xaddCommand(client *c) {
             }
             if (getLongLongFromObjectOrReply(c,c->argv[i+1],&maxlen,NULL)
                 != C_OK) return;
+
+            if (maxlen < 0) {
+                addReplyError(c,"The MAXLEN argument must be equal or greater than zero. A value of zero means that no trimming should be performed.");
+                return;
+            }
             i++;
             maxlen_arg_idx = i;
         } else {

From d4c4f20a4585d6c7facfdbe6699c68cb5f56bc47 Mon Sep 17 00:00:00 2001
From: Max Vetrov <maxvetrov555@yandex.ru>
Date: Sun, 17 Jun 2018 21:25:51 +0200
Subject: [PATCH 079/219] Update sort.c

Redundant second if, and we may use "not" operation for bool, I suppose it's faster.
---
 src/sort.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/sort.c b/src/sort.c
index 7ddd37d95..7feae9206 100644
--- a/src/sort.c
+++ b/src/sort.c
@@ -447,7 +447,7 @@ void sortCommand(client *c) {
     serverAssertWithInfo(c,sortval,j == vectorlen);
 
     /* Now it's time to load the right scores in the sorting vector */
-    if (dontsort == 0) {
+    if (!dontsort) {
         for (j = 0; j < vectorlen; j++) {
             robj *byval;
             if (sortby) {
@@ -487,9 +487,7 @@ void sortCommand(client *c) {
                 decrRefCount(byval);
             }
         }
-    }
 
-    if (dontsort == 0) {
         server.sort_desc = desc;
         server.sort_alpha = alpha;
         server.sort_bypattern = sortby ? 1 : 0;

From 62f9ac6f436356dc7679d06bedeb98948bcebeb0 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 18 Jun 2018 10:05:18 +0200
Subject: [PATCH 080/219] Streams: Change XADD MAXLEN handling of values <= 0.

Now a MAXLEN of 0 really does what it means: it will create a zero
entries stream. This is useful in order to make sure that the behavior
is identical to XTRIM, that must be able to reduce the stream to zero
elements when MAXLEN is given.

Also now MAXLEN with a count < 0 will return an error.
---
 src/t_stream.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 20daeee91..6d8fd92ce 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1081,7 +1081,7 @@ invalid:
 void xaddCommand(client *c) {
     streamID id;
     int id_given = 0; /* Was an ID different than "*" specified? */
-    long long maxlen = 0;   /* 0 means no maximum length. */
+    long long maxlen = -1;  /* If left to -1 no trimming is performed. */
     int approx_maxlen = 0;  /* If 1 only delete whole radix tree nodes, so
                                the maxium length is not applied verbatim. */
     int maxlen_arg_idx = 0; /* Index of the count in MAXLEN, for rewriting. */
@@ -1107,7 +1107,7 @@ void xaddCommand(client *c) {
                 != C_OK) return;
 
             if (maxlen < 0) {
-                addReplyError(c,"The MAXLEN argument must be equal or greater than zero. A value of zero means that no trimming should be performed.");
+                addReplyError(c,"The MAXLEN argument must be >= 0.");
                 return;
             }
             i++;
@@ -1149,7 +1149,7 @@ void xaddCommand(client *c) {
     server.dirty++;
 
     /* Remove older elements if MAXLEN was specified. */
-    if (maxlen) {
+    if (maxlen >= 0) {
         if (!streamTrimByLength(s,maxlen,approx_maxlen)) {
             /* If no trimming was performed, for instance because approximated
              * trimming length was specified, rewrite the MAXLEN argument

From a0b27dae85ae071b60d4c5196e7d18d72fbbba2b Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 18 Jun 2018 13:51:19 +0200
Subject: [PATCH 081/219] Streams: fix xreadGetKeys() buffer overflow.

The loop allocated a buffer for the right number of keys positions, then
overflowed it going past the limit.

Related to #4857 and cause of the memory violation seen in #5028.
---
 src/db.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/db.c b/src/db.c
index 2219194b1..83ffbcc92 100644
--- a/src/db.c
+++ b/src/db.c
@@ -1422,7 +1422,7 @@ int *xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys)
                  there are also the IDs, one per key. */
 
     keys = zmalloc(sizeof(int) * num);
-    for (i = streams_pos+1; i < argc; i++) keys[i-streams_pos-1] = i;
+    for (i = streams_pos+1; i < argc-num; i++) keys[i-streams_pos-1] = i;
     *numkeys = num;
     return keys;
 }

From 20766608439c30584be720dcb47f055c4051c95d Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 18 Jun 2018 14:06:06 +0200
Subject: [PATCH 082/219] Streams: fix xreadGetKeys() for correctness.

The old version could not handle the fact that "STREAMS" is a valid key
name for streams. Now we really try to parse the command like the
command implementation would do.

Related to #5028 and 4857.
---
 src/db.c | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/db.c b/src/db.c
index 877294ee8..c86ec3ee3 100644
--- a/src/db.c
+++ b/src/db.c
@@ -1398,18 +1398,32 @@ int *georadiusGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numk
 }
 
 /* XREAD [BLOCK <milliseconds>] [COUNT <count>] [GROUP <groupname> <ttl>]
- *       [RETRY <milliseconds> <ttl>] STREAMS key_1 key_2 ... key_N
- *       ID_1 ID_2 ... ID_N */
+ *       STREAMS key_1 key_2 ... key_N ID_1 ID_2 ... ID_N */
 int *xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys) {
     int i, num, *keys;
     UNUSED(cmd);
 
-    /* We need to seek the last argument that contains "STREAMS", because other
-     * arguments before may contain it (for example the group name). */
+    /* We need to parse the options of the command in order to seek the first
+     * "STREAMS" string which is actually the option. This is needed because
+     * "STREAMS" could also be the name of the consumer group and even the
+     * name of the stream key. */
     int streams_pos = -1;
     for (i = 1; i < argc; i++) {
         char *arg = argv[i]->ptr;
-        if (!strcasecmp(arg, "streams")) streams_pos = i;
+        if (!strcasecmp(arg, "block")) {
+            i++; /* Skip option argument. */
+        } else if (!strcasecmp(arg, "count")) {
+            i++; /* Skip option argument. */
+        } else if (!strcasecmp(arg, "group")) {
+            i += 2; /* Skip option argument. */
+        } else if (!strcasecmp(arg, "noack")) {
+            /* Nothing to do. */
+        } else if (!strcasecmp(arg, "streams")) {
+            streams_pos = i;
+            break;
+        } else {
+            break; /* Syntax error. */
+        }
     }
     if (streams_pos != -1) num = argc - streams_pos - 1;
 

From bd92389c2dc1afcf53218880fc31ba45e66f4ded Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 18 Jun 2018 16:54:13 +0200
Subject: [PATCH 083/219] Refactor createObjectFromLongLong() to be suitable
 for value objects.

---
 src/object.c | 34 ++++++++++++++++++++++++++++++++--
 src/server.h |  1 +
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/src/object.c b/src/object.c
index 19af1ec0d..a77f2aeda 100644
--- a/src/object.c
+++ b/src/object.c
@@ -123,9 +123,25 @@ robj *createStringObject(const char *ptr, size_t len) {
         return createRawStringObject(ptr,len);
 }
 
-robj *createStringObjectFromLongLong(long long value) {
+/* Create a string object from a long long value. When possible returns a
+ * shared integer object, or at least an integer encoded one.
+ *
+ * If valueobj is non zero, the function avoids returning a a shared
+ * integer, because the object is going to be used as value in the Redis key
+ * space (for instance when the INCR command is used), so we want LFU/LRU
+ * values specific for each key. */
+robj *createStringObjectFromLongLongWithOptions(long long value, int valueobj) {
     robj *o;
-    if (value >= 0 && value < OBJ_SHARED_INTEGERS) {
+
+    if (server.maxmemory == 0 ||
+        !(server.maxmemory_policy & MAXMEMORY_FLAG_NO_SHARED_INTEGERS))
+    {
+        /* If the maxmemory policy permits, we can still return shared integers
+         * even if valueobj is true. */
+        valueobj = 0;
+    }
+
+    if (value >= 0 && value < OBJ_SHARED_INTEGERS && valueobj == 0) {
         incrRefCount(shared.integers[value]);
         o = shared.integers[value];
     } else {
@@ -140,6 +156,20 @@ robj *createStringObjectFromLongLong(long long value) {
     return o;
 }
 
+/* Wrapper for createStringObjectFromLongLongWithOptions() always demanding
+ * to create a shared object if possible. */
+robj *createStringObjectFromLongLong(long long value) {
+    return createStringObjectFromLongLongWithOptions(value,0);
+}
+
+/* Wrapper for createStringObjectFromLongLongWithOptions() avoiding a shared
+ * object when LFU/LRU info are needed, that is, when the object is used
+ * as a value in the key space, and Redis is configured to evict based on
+ * LFU/LRU. */
+robj *createStringObjectFromLongLongForValue(long long value) {
+    return createStringObjectFromLongLongWithOptions(value,1);
+}
+
 /* Create a string object from a long double. If humanfriendly is non-zero
  * it does not use exponential format and trims trailing zeroes at the end,
  * however this results in loss of precision. Otherwise exp format is used
diff --git a/src/server.h b/src/server.h
index 264380d8e..e3bba8ace 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1501,6 +1501,7 @@ robj *tryObjectEncoding(robj *o);
 robj *getDecodedObject(robj *o);
 size_t stringObjectLen(robj *o);
 robj *createStringObjectFromLongLong(long long value);
+robj *createStringObjectFromLongLongForValue(long long value);
 robj *createStringObjectFromLongDouble(long double value, int humanfriendly);
 robj *createQuicklistObject(void);
 robj *createZiplistObject(void);

From 0ed0dc3c02dfffdf6bfb9e32f1335ddc34f37723 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 18 Jun 2018 16:56:28 +0200
Subject: [PATCH 084/219] Fix incrDecrCommand() to create shared objects when
 needed.

See #5011.
---
 src/t_string.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/t_string.c b/src/t_string.c
index 75375f446..e121df73e 100644
--- a/src/t_string.c
+++ b/src/t_string.c
@@ -361,7 +361,7 @@ void incrDecrCommand(client *c, long long incr) {
         new = o;
         o->ptr = (void*)((long)value);
     } else {
-        new = createStringObjectFromLongLong(value);
+        new = createStringObjectFromLongLongForValue(value);
         if (o) {
             dbOverwrite(c->db,c->argv[1],new);
         } else {

From 6967d0bd5aac7c7d112bb3da3c6068dac930c6fc Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 18 Jun 2018 17:09:00 +0200
Subject: [PATCH 085/219] Revert fix #4976 just leaving the flush() part.

---
 src/debug.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/debug.c b/src/debug.c
index 478214751..a54591bd4 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -348,11 +348,7 @@ NULL
         serverLog(LL_WARNING,"DB reloaded by DEBUG RELOAD");
         addReply(c,shared.ok);
     } else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) {
-        if (server.aof_state == AOF_OFF) {
-            addReply(c, shared.err);
-            return;
-        }
-        flushAppendOnlyFile(1);
+        if (server.aof_state != AOF_OFF) flushAppendOnlyFile(1);
         emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);
         if (loadAppendOnlyFile(server.aof_filename) != C_OK) {
             addReply(c,shared.err);

From 36524060dfe2d9fb7722aa2e327068883c931e04 Mon Sep 17 00:00:00 2001
From: Benjamin Holst <bepahol@users.noreply.github.com>
Date: Mon, 18 Jun 2018 22:41:26 -0700
Subject: [PATCH 086/219] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 42ab47853..8dbad7dbf 100644
--- a/README.md
+++ b/README.md
@@ -435,7 +435,7 @@ top comment inside `server.c`.
 After the command operates in some way, it returns a reply to the client,
 usually using `addReply()` or a similar function defined inside `networking.c`.
 
-There are tons of commands implementations inside th Redis source code
+There are tons of commands implementations inside the Redis source code
 that can serve as examples of actual commands implementations. To write
 a few toy commands can be a good exercise to familiarize with the code base.
 

From ba92b517b8c22a4d62c583c0a6ac94fb9a0c2486 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 19 Jun 2018 15:43:06 +0200
Subject: [PATCH 087/219] Remove AOF optimization to skip expired keys.

Basically we cannot be sure that if the key is expired while writing the
AOF, the main thread will surely find the key expired. There are
possible race conditions like the moment at which the "now" is sampled,
and the fact that time may jump backward.

Think about the following:

SET a 5
EXPIRE a 1

AOF rewrite starts after about 1 second. The child process finds the key
expired, while in the main thread instead an INCR command is called
against the key "a" immediately after a fork, and the scheduler was
faster to give execution time to the main thread, so "a" is yet not
expired.

The main thread will generate an INCR a command to the AOF log that will
be appended to the rewritten AOF file, but that INCR command will target
a non existin "a" key, so a new non volatile key "a" will be created.

Two observations:

A) In theory by computing "now" before the fork, we should be sure that
if a key is expired at that time, it will be expired later when the
main thread will try to access to such key. However this does not take
into account the fact that the computer time may jump backward.

B) Technically we may still make the process safe by using a monotonic
time source.

However there were other similar related bugs, and in general the new
"vision" is that Redis persistence files should represent the memory
state without trying to be too smart: this makes the design more
consistent, bugs less likely to arise from complex interactions, and in
the end what is to fix is the Redis expire process to have less expired
keys in RAM.

Thanks to Oran Agra and Guy Benoish for writing me an email outlining
this problem, after they conducted a Redis 5 code review.
---
 src/aof.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/aof.c b/src/aof.c
index ab50897aa..f7993c680 100644
--- a/src/aof.c
+++ b/src/aof.c
@@ -1247,9 +1247,6 @@ int rewriteAppendOnlyFileRio(rio *aof) {
 
             expiretime = getExpire(db,&key);
 
-            /* If this key is already expired skip it */
-            if (expiretime != -1 && expiretime < now) continue;
-
             /* Save the key and associated value */
             if (o->type == OBJ_STRING) {
                 /* Emit a SET command */

From 5cd3c9529df93b7e726256e2de17985a57f00e7b Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Tue, 19 Jun 2018 16:43:12 +0300
Subject: [PATCH 088/219] 64 bit RDB_OPCODE_RESIZEDB in rdb saving

this complication in the code is from times were rdbSaveLen didn't support 64 bits.
---
 src/rdb.c | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/rdb.c b/src/rdb.c
index e37e2f94b..5522cee76 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -1127,13 +1127,9 @@ int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
          * is currently the largest type we are able to represent in RDB sizes.
          * However this does not limit the actual size of the DB to load since
          * these sizes are just hints to resize the hash tables. */
-        uint32_t db_size, expires_size;
-        db_size = (dictSize(db->dict) <= UINT32_MAX) ?
-                                dictSize(db->dict) :
-                                UINT32_MAX;
-        expires_size = (dictSize(db->expires) <= UINT32_MAX) ?
-                                dictSize(db->expires) :
-                                UINT32_MAX;
+        uint64_t db_size, expires_size;
+        db_size = dictSize(db->dict);
+        expires_size = dictSize(db->expires);
         if (rdbSaveType(rdb,RDB_OPCODE_RESIZEDB) == -1) goto werr;
         if (rdbSaveLen(rdb,db_size) == -1) goto werr;
         if (rdbSaveLen(rdb,expires_size) == -1) goto werr;

From 26229aa6072c24021f90638852417aafe3537b6e Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Tue, 19 Jun 2018 16:46:41 +0300
Subject: [PATCH 089/219] use safe macro (non empty) in memrev64ifbe to
 eliminate empty if warning

---
 src/endianconv.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/endianconv.h b/src/endianconv.h
index 08f553136..d0c8e5b38 100644
--- a/src/endianconv.h
+++ b/src/endianconv.h
@@ -46,9 +46,9 @@ uint64_t intrev64(uint64_t v);
 /* variants of the function doing the actual convertion only if the target
  * host is big endian */
 #if (BYTE_ORDER == LITTLE_ENDIAN)
-#define memrev16ifbe(p)
-#define memrev32ifbe(p)
-#define memrev64ifbe(p)
+#define memrev16ifbe(p) ((void)(0))
+#define memrev32ifbe(p) ((void)(0))
+#define memrev64ifbe(p) ((void)(0))
 #define intrev16ifbe(v) (v)
 #define intrev32ifbe(v) (v)
 #define intrev64ifbe(v) (v)

From e94b2053c6cb00e604a0c9f0f51db78250400c36 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 19 Jun 2018 15:53:32 +0200
Subject: [PATCH 090/219] Modify clusterRedirectClient() to handle ZPOP and
 XREAD.

---
 src/cluster.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cluster.c b/src/cluster.c
index 17ba6a744..961241d47 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -5589,7 +5589,11 @@ void clusterRedirectClient(client *c, clusterNode *n, int hashslot, int error_co
  * longer handles, the client is sent a redirection error, and the function
  * returns 1. Otherwise 0 is returned and no operation is performed. */
 int clusterRedirectBlockedClientIfNeeded(client *c) {
-    if (c->flags & CLIENT_BLOCKED && c->btype == BLOCKED_LIST) {
+    if (c->flags & CLIENT_BLOCKED &&
+        (c->btype == BLOCKED_LIST ||
+         c->btype == BLOCKED_ZSET ||
+         c->btype == BLOCKED_STREAM))
+    {
         dictEntry *de;
         dictIterator *di;
 

From 333c98c43a1f7debac0f5579df62b41259a3efd5 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 19 Jun 2018 15:54:05 +0200
Subject: [PATCH 091/219] AOF: remove no longer used variable "now".

---
 src/aof.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/aof.c b/src/aof.c
index f7993c680..594c3f666 100644
--- a/src/aof.c
+++ b/src/aof.c
@@ -1221,7 +1221,6 @@ int rewriteAppendOnlyFileRio(rio *aof) {
     dictIterator *di = NULL;
     dictEntry *de;
     size_t processed = 0;
-    long long now = mstime();
     int j;
 
     for (j = 0; j < server.dbnum; j++) {

From f31b0405f0023d8916efac3aa9b0c16d4db69fc4 Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Tue, 19 Jun 2018 16:54:22 +0300
Subject: [PATCH 092/219] fix redis-rdb-check to provide proper arguments to
 rdbLoadMillisecondTime

due to incorrect forward declaration, it didn't provide all arguments.
this lead to random value being read from the stack and return of incorrect time,
which in this case doesn't matter since no one uses it.
---
 src/rdb.h             | 2 ++
 src/redis-check-rdb.c | 3 +--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/rdb.h b/src/rdb.h
index 3c46a2737..7b9486169 100644
--- a/src/rdb.h
+++ b/src/rdb.h
@@ -129,6 +129,8 @@ int rdbLoadType(rio *rdb);
 int rdbSaveTime(rio *rdb, time_t t);
 time_t rdbLoadTime(rio *rdb);
 int rdbSaveLen(rio *rdb, uint64_t len);
+int rdbSaveMillisecondTime(rio *rdb, long long t);
+long long rdbLoadMillisecondTime(rio *rdb, int rdbver);
 uint64_t rdbLoadLen(rio *rdb, int *isencoded);
 int rdbLoadLenByRef(rio *rdb, int *isencoded, uint64_t *lenptr);
 int rdbSaveObjectType(rio *rdb, robj *o);
diff --git a/src/redis-check-rdb.c b/src/redis-check-rdb.c
index 6283e93d8..50854be0c 100644
--- a/src/redis-check-rdb.c
+++ b/src/redis-check-rdb.c
@@ -34,7 +34,6 @@
 
 void createSharedObjects(void);
 void rdbLoadProgressCallback(rio *r, const void *buf, size_t len);
-long long rdbLoadMillisecondTime(rio *rdb);
 int rdbCheckMode = 0;
 
 struct {
@@ -224,7 +223,7 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
             /* EXPIRETIME_MS: milliseconds precision expire times introduced
              * with RDB v3. Like EXPIRETIME but no with more precision. */
             rdbstate.doing = RDB_CHECK_DOING_READ_EXPIRE;
-            if ((expiretime = rdbLoadMillisecondTime(&rdb)) == -1) goto eoferr;
+            if ((expiretime = rdbLoadMillisecondTime(&rdb, rdbver)) == -1) goto eoferr;
             continue; /* Read next opcode. */
         } else if (type == RDB_OPCODE_FREQ) {
             /* FREQ: LFU frequency. */

From 4848fbec8b95b8783f5becbdd72e461c9fa30716 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 19 Jun 2018 16:03:00 +0200
Subject: [PATCH 093/219] Modules: convert hash to hash table for big objects.

---
 src/module.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/module.c b/src/module.c
index cb03ad2cd..b5ef0da02 100644
--- a/src/module.c
+++ b/src/module.c
@@ -2239,6 +2239,9 @@ int RM_HashSet(RedisModuleKey *key, int flags, ...) {
          * to avoid a useless copy. */
         if (flags & REDISMODULE_HASH_CFIELDS)
             low_flags |= HASH_SET_TAKE_FIELD;
+
+        robj *argv[2] = {field,value};
+        hashTypeTryConversion(key->value,argv,0,1);
         updated += hashTypeSet(key->value, field->ptr, value->ptr, low_flags);
 
         /* If CFIELDS is active, SDS string ownership is now of hashTypeSet(),

From e72190252e3622721a2e6260881285905b1beef7 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 19 Jun 2018 16:29:15 +0200
Subject: [PATCH 094/219] Test RDB stream encoding saving/loading.

---
 tests/integration/rdb.tcl | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/tests/integration/rdb.tcl b/tests/integration/rdb.tcl
index 66aad4cc7..d645b2b54 100644
--- a/tests/integration/rdb.tcl
+++ b/tests/integration/rdb.tcl
@@ -39,6 +39,23 @@ start_server [list overrides [list "dir" $server_path]] {
     } {0000000000000000000000000000000000000000}
 }
 
+start_server [list overrides [list "dir" $server_path]] {
+    test {Test RDB stream encoding} {
+        for {set j 0} {$j < 1000} {incr j} {
+            if {rand() < 0.9} {
+                r xadd stream * foo $j
+            } else {
+                r xadd stream * bar $j
+            }
+        }
+        set digest [r debug digest]
+        r debug reload
+        set newdigest [r debug digest]
+        assert {$digest eq $newdigest}
+        r del stream
+    }
+}
+
 # Helper function to start a server and kill it, just to check the error
 # logged.
 set defaults {}

From 482785ac62aab0bcaf53eb7eb6f7e005629ff0fa Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Tue, 19 Jun 2018 16:59:45 +0300
Subject: [PATCH 095/219] add malloc_usable_size for libc malloc

this reduces the extra 8 bytes we save before each pointer.
but more importantly maybe, it makes the valgrind runs to be more similiar
to our normal runs.

note: the change in malloc_stats struct in server.h is to eliminate an name conflict.
structs that are not typedefed are resolved from a separate name space.
---
 src/server.h  | 6 +++---
 src/zmalloc.h | 5 +++++
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/server.h b/src/server.h
index e3bba8ace..f7aff36b1 100644
--- a/src/server.h
+++ b/src/server.h
@@ -882,13 +882,13 @@ typedef struct rdbSaveInfo {
 
 #define RDB_SAVE_INFO_INIT {-1,0,"000000000000000000000000000000",-1}
 
-typedef struct malloc_stats {
+struct malloc_stats {
     size_t zmalloc_used;
     size_t process_rss;
     size_t allocator_allocated;
     size_t allocator_active;
     size_t allocator_resident;
-} malloc_stats;
+};
 
 /*-----------------------------------------------------------------------------
  * Global server state
@@ -995,7 +995,7 @@ struct redisServer {
     long long slowlog_entry_id;     /* SLOWLOG current entry ID */
     long long slowlog_log_slower_than; /* SLOWLOG time limit (to get logged) */
     unsigned long slowlog_max_len;     /* SLOWLOG max number of items logged */
-    malloc_stats cron_malloc_stats; /* sampled in serverCron(). */
+    struct malloc_stats cron_malloc_stats; /* sampled in serverCron(). */
     long long stat_net_input_bytes; /* Bytes read from network. */
     long long stat_net_output_bytes; /* Bytes written to network. */
     size_t stat_rdb_cow_bytes;      /* Copy on write bytes during RDB saving. */
diff --git a/src/zmalloc.h b/src/zmalloc.h
index 3c926bcbe..49b33b883 100644
--- a/src/zmalloc.h
+++ b/src/zmalloc.h
@@ -63,6 +63,11 @@
 
 #ifndef ZMALLOC_LIB
 #define ZMALLOC_LIB "libc"
+#ifdef __GLIBC__
+#include <malloc.h>
+#define HAVE_MALLOC_SIZE 1
+#define zmalloc_size(p) malloc_usable_size(p)
+#endif
 #endif
 
 /* We can enable the Redis defrag capabilities only if we are using Jemalloc

From b5197f1fc9d6fde776168951094e44d5e8742a89 Mon Sep 17 00:00:00 2001
From: Guy Benoish <guy.benoish@redislabs.com>
Date: Wed, 20 Jun 2018 14:40:18 +0700
Subject: [PATCH 096/219] Enhance RESTORE with RDBv9 new features

RESTORE now supports:
1. Setting LRU/LFU
2. Absolute-time TTL

Other related changes:
1. RDB loading will not override LRU bits when RDB file
   does not contain the LRU opcode.
2. RDB loading will not set LRU/LFU bits if the server's
   maxmemory-policy does not match.
---
 src/cluster.c       | 34 +++++++++++++++++++++++++++++++---
 src/object.c        | 26 ++++++++++++++++++++++++++
 src/rdb.c           | 27 ++++++++-------------------
 src/server.h        |  2 ++
 tests/unit/dump.tcl | 33 +++++++++++++++++++++++++++++++++
 5 files changed, 100 insertions(+), 22 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index 961241d47..dac03ec71 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -4835,15 +4835,39 @@ void dumpCommand(client *c) {
 
 /* RESTORE key ttl serialized-value [REPLACE] */
 void restoreCommand(client *c) {
-    long long ttl;
+    long long ttl, lfu_freq = -1, lru_idle = -1, lru_clock;
     rio payload;
-    int j, type, replace = 0;
+    int j, type, replace = 0, absttl = 0;
     robj *obj;
 
     /* Parse additional options */
     for (j = 4; j < c->argc; j++) {
+        int additional = c->argc-j-1;
         if (!strcasecmp(c->argv[j]->ptr,"replace")) {
             replace = 1;
+        } else if (!strcasecmp(c->argv[j]->ptr,"absttl")) {
+            absttl = 1;
+        } else if (!strcasecmp(c->argv[j]->ptr,"idletime") && additional >= 1 &&
+                   lfu_freq == -1)
+        {
+            if (getLongLongFromObjectOrReply(c,c->argv[j+1],&lru_idle,NULL)
+                    != C_OK) return;
+            if (lru_idle < 0) {
+                addReplyError(c,"Invalid IDLETIME value, must be >= 0");
+                return;
+            }
+            lru_clock = LRU_CLOCK();
+            j++; /* Consume additional arg. */
+        } else if (!strcasecmp(c->argv[j]->ptr,"freq") && additional >= 1 &&
+                   lru_idle == -1)
+        {
+            if (getLongLongFromObjectOrReply(c,c->argv[j+1],&lfu_freq,NULL)
+                    != C_OK) return;
+            if (lfu_freq < 0 || lfu_freq > 255) {
+                addReplyError(c,"Invalid FREQ value, must be >= 0 and <= 255");
+                return;
+            }
+            j++; /* Consume additional arg. */
         } else {
             addReply(c,shared.syntaxerr);
             return;
@@ -4884,7 +4908,11 @@ void restoreCommand(client *c) {
 
     /* Create the key and set the TTL if any */
     dbAdd(c->db,c->argv[1],obj);
-    if (ttl) setExpire(c,c->db,c->argv[1],mstime()+ttl);
+    if (ttl) {
+        if (!absttl) ttl+=mstime();
+        setExpire(c,c->db,c->argv[1],ttl);
+    }
+    objectSetLRUOrLFU(obj,lfu_freq,lru_idle,lru_clock);
     signalModifiedKey(c->db,c->argv[1]);
     addReply(c,shared.ok);
     server.dirty++;
diff --git a/src/object.c b/src/object.c
index a77f2aeda..89166582b 100644
--- a/src/object.c
+++ b/src/object.c
@@ -1166,6 +1166,32 @@ sds getMemoryDoctorReport(void) {
     return s;
 }
 
+/* Set the object LRU/LFU depending on server.maxmemory_policy.
+ * The lfu_freq arg is only relevant if policy is MAXMEMORY_FLAG_LFU.
+ * The lru_idle and lru_clock args are only relevant if policy 
+ * is MAXMEMORY_FLAG_LRU.
+ * Either or both of them may be <0, in that case, nothing is set. */
+void objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
+                       long long lru_clock) {
+    if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
+        if (lfu_freq >= 0) {
+            serverAssert(lfu_freq <= 255);
+            val->lru = (LFUGetTimeInMinutes()<<8) | lfu_freq;
+        }
+    } else if (lru_idle >= 0) {
+        /* Serialized LRU idle time is in seconds. Scale
+         * according to the LRU clock resolution this Redis
+         * instance was compiled with (normally 1000 ms, so the
+         * below statement will expand to lru_idle*1000/1000. */
+        lru_idle = lru_idle*1000/LRU_CLOCK_RESOLUTION;
+        val->lru = lru_clock - lru_idle;
+        /* If the lru field overflows (since LRU it is a wrapping
+         * clock), the best we can do is to provide the maximum
+         * representable idle time. */
+        if (val->lru < 0) val->lru = lru_clock+1;
+    }
+}
+
 /* ======================= The OBJECT and MEMORY commands =================== */
 
 /* This is a helper function for the OBJECT command. We need to lookup keys
diff --git a/src/rdb.c b/src/rdb.c
index e37e2f94b..d14c3bd23 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -1871,11 +1871,9 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
     }
 
     /* Key-specific attributes, set by opcodes before the key type. */
-    long long expiretime = -1, now = mstime();
+    long long lru_idle = -1, lfu_freq = -1, expiretime = -1, now = mstime();
     long long lru_clock = LRU_CLOCK();
-    uint64_t lru_idle = -1;
-    int lfu_freq = -1;
-
+    
     while(1) {
         robj *key, *val;
 
@@ -1903,7 +1901,9 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
             continue; /* Read next opcode. */
         } else if (type == RDB_OPCODE_IDLE) {
             /* IDLE: LRU idle time. */
-            if ((lru_idle = rdbLoadLen(rdb,NULL)) == RDB_LENERR) goto eoferr;
+            uint64_t qword;
+            if ((qword = rdbLoadLen(rdb,NULL)) == RDB_LENERR) goto eoferr;
+            lru_idle = qword;
             continue; /* Read next opcode. */
         } else if (type == RDB_OPCODE_EOF) {
             /* EOF: End of file, exit the main loop. */
@@ -2022,20 +2022,9 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
 
             /* Set the expire time if needed */
             if (expiretime != -1) setExpire(NULL,db,key,expiretime);
-            if (lfu_freq != -1) {
-                val->lru = (LFUGetTimeInMinutes()<<8) | lfu_freq;
-            } else {
-                /* LRU idle time loaded from RDB is in seconds. Scale
-                 * according to the LRU clock resolution this Redis
-                 * instance was compiled with (normaly 1000 ms, so the
-                 * below statement will expand to lru_idle*1000/1000. */
-                lru_idle = lru_idle*1000/LRU_CLOCK_RESOLUTION;
-                val->lru = lru_clock - lru_idle;
-                /* If the lru field overflows (since LRU it is a wrapping
-                 * clock), the best we can do is to provide the maxium
-                 * representable idle time. */
-                if (val->lru < 0) val->lru = lru_clock+1;
-            }
+            
+            /* Set usage information (for eviction). */
+            objectSetLRUOrLFU(val,lfu_freq,lru_idle,lru_clock);
 
             /* Decrement the key refcount since dbAdd() will take its
              * own reference. */
diff --git a/src/server.h b/src/server.h
index f7aff36b1..a130d5b1d 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1772,6 +1772,8 @@ robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply);
 robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags);
 robj *objectCommandLookup(client *c, robj *key);
 robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply);
+void objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
+                       long long lru_clock);
 #define LOOKUP_NONE 0
 #define LOOKUP_NOTOUCH (1<<0)
 void dbAdd(redisDb *db, robj *key, robj *val);
diff --git a/tests/unit/dump.tcl b/tests/unit/dump.tcl
index 8bb0165c6..3e6051fed 100644
--- a/tests/unit/dump.tcl
+++ b/tests/unit/dump.tcl
@@ -25,6 +25,39 @@ start_server {tags {"dump"}} {
         assert {$ttl >= (2569591501-3000) && $ttl <= 2569591501}
         r get foo
     } {bar}
+    
+    test {RESTORE can set an absolute expire} {
+        r set foo bar
+        set encoded [r dump foo]
+        r del foo
+        set now [clock milliseconds]
+        r restore foo [expr $now+3000] $encoded absttl
+        set ttl [r pttl foo]
+        assert {$ttl >= 2998 && $ttl <= 3000}
+        r get foo
+    } {bar}
+    
+    test {RESTORE can set LRU} {
+        r set foo bar
+        set encoded [r dump foo]
+        r del foo
+        r config set maxmemory-policy allkeys-lru
+        r restore foo 0 $encoded idletime 1000
+        set idle [r object idletime foo]
+        assert {$idle >= 1000 && $idle <= 1002}
+        r get foo
+    } {bar}
+    
+    test {RESTORE can set LFU} {
+        r set foo bar
+        set encoded [r dump foo]
+        r del foo
+        r config set maxmemory-policy allkeys-lfu
+        r restore foo 0 $encoded freq 100
+        set freq [r object freq foo]
+        assert {$freq == 100}
+        r get foo
+    } {bar}
 
     test {RESTORE returns an error of the key already exists} {
         r set foo bar

From df6644fe0e858e40ea61c576597c51ddc82feef9 Mon Sep 17 00:00:00 2001
From: youjiali1995 <zlwgx1023@gmail.com>
Date: Thu, 21 Jun 2018 18:08:37 +0800
Subject: [PATCH 097/219] Fix rdbLoadIntegerObject() to create shared objects
 when needed.

---
 src/rdb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rdb.c b/src/rdb.c
index e37e2f94b..9c1f9f978 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -288,7 +288,7 @@ void *rdbLoadIntegerObject(rio *rdb, int enctype, int flags, size_t *lenptr) {
         memcpy(p,buf,len);
         return p;
     } else if (encode) {
-        return createStringObjectFromLongLong(val);
+        return createStringObjectFromLongLongForValue(val);
     } else {
         return createObject(OBJ_STRING,sdsfromlonglong(val));
     }

From ec55df117f0554aaf0d36e2fbb875aea93105b3d Mon Sep 17 00:00:00 2001
From: shenlongxing <shenlongxing2012@gmail.com>
Date: Thu, 21 Jun 2018 22:08:09 +0800
Subject: [PATCH 098/219] fix typo

---
 src/db.c              | 2 +-
 src/expire.c          | 2 +-
 src/module.c          | 2 +-
 tests/unit/expire.tcl | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/db.c b/src/db.c
index c86ec3ee3..95019cee7 100644
--- a/src/db.c
+++ b/src/db.c
@@ -90,7 +90,7 @@ robj *lookupKey(redisDb *db, robj *key, int flags) {
  *  LOOKUP_NONE (or zero): no special flags are passed.
  *  LOOKUP_NOTOUCH: don't alter the last access time of the key.
  *
- * Note: this function also returns NULL is the key is logically expired
+ * Note: this function also returns NULL if the key is logically expired
  * but still existing, in case this is a slave, since this API is called only
  * for read operations. Even if the key expiry is master-driven, we can
  * correctly report a key is expired on slaves even if the master is lagging
diff --git a/src/expire.c b/src/expire.c
index ce7882e4c..0b92ee3fe 100644
--- a/src/expire.c
+++ b/src/expire.c
@@ -112,7 +112,7 @@ void activeExpireCycle(int type) {
 
     if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
         /* Don't start a fast cycle if the previous cycle did not exit
-         * for time limt. Also don't repeat a fast cycle for the same period
+         * for time limit. Also don't repeat a fast cycle for the same period
          * as the fast cycle total duration itself. */
         if (!timelimit_exit) return;
         if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
diff --git a/src/module.c b/src/module.c
index b5ef0da02..5f6ddb9c6 100644
--- a/src/module.c
+++ b/src/module.c
@@ -3399,7 +3399,7 @@ void RM_LogRaw(RedisModule *module, const char *levelstr, const char *fmt, va_li
  *
  * If the specified log level is invalid, verbose is used by default.
  * There is a fixed limit to the length of the log line this function is able
- * to emit, this limti is not specified but is guaranteed to be more than
+ * to emit, this limit is not specified but is guaranteed to be more than
  * a few lines of text.
  */
 void RM_Log(RedisModuleCtx *ctx, const char *levelstr, const char *fmt, ...) {
diff --git a/tests/unit/expire.tcl b/tests/unit/expire.tcl
index eddc7c303..de24eabed 100644
--- a/tests/unit/expire.tcl
+++ b/tests/unit/expire.tcl
@@ -121,7 +121,7 @@ start_server {tags {"expire"}} {
         list $a $b
     } {somevalue {}}
 
-    test {TTL returns tiem to live in seconds} {
+    test {TTL returns time to live in seconds} {
         r del x
         r setex x 10 somevalue
         set ttl [r ttl x]

From 20e10dc7b8eeff9aa5356fd123a7c70e994e6eb4 Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Thu, 21 Jun 2018 17:58:29 +0300
Subject: [PATCH 099/219] fix streams memory estimation, missing raxSeek

---
 src/object.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/object.c b/src/object.c
index a77f2aeda..d17f9d1f2 100644
--- a/src/object.c
+++ b/src/object.c
@@ -745,7 +745,7 @@ char *strEncoding(int encoding) {
  * size of a radix tree that is used to store Stream IDs.
  *
  * Note: to guess the size of the radix tree is not trivial, so we
- * approximate it considering 128 bytes of data overhead for each
+ * approximate it considering 16 bytes of data overhead for each
  * key (the ID), and then adding the number of bare nodes, plus some
  * overhead due by the data and child pointers. This secret recipe
  * was obtained by checking the average radix tree created by real
@@ -904,6 +904,7 @@ size_t objectComputeSize(robj *o, size_t sample_size) {
                  * structures and the PEL memory usage. */
                 raxIterator cri;
                 raxStart(&cri,cg->consumers);
+                raxSeek(&cri,"^",NULL,0);
                 while(raxNext(&cri)) {
                     streamConsumer *consumer = cri.data;
                     asize += sizeof(*consumer);

From db6b99f90cc569c8126e2b7b0123508d8b8b015d Mon Sep 17 00:00:00 2001
From: michael-grunder <michael.grunder@gmail.com>
Date: Thu, 21 Jun 2018 12:30:42 -0700
Subject: [PATCH 100/219] Update ZPOPMIN/ZPOPMAX command declaration

Unlike the BZPOP variants, these functions take a single key.  This fixes
an erroneous CROSSSLOT error when passing a count to a cluster enabled
server.
---
 src/server.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/server.c b/src/server.c
index a59a75acb..3ac1278aa 100644
--- a/src/server.c
+++ b/src/server.c
@@ -198,8 +198,8 @@ struct redisCommand redisCommandTable[] = {
     {"zrank",zrankCommand,3,"rF",0,NULL,1,1,1,0,0},
     {"zrevrank",zrevrankCommand,3,"rF",0,NULL,1,1,1,0,0},
     {"zscan",zscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
-    {"zpopmin",zpopminCommand,-2,"wF",0,NULL,1,-1,1,0,0},
-    {"zpopmax",zpopmaxCommand,-2,"wF",0,NULL,1,-1,1,0,0},
+    {"zpopmin",zpopminCommand,-2,"wF",0,NULL,1,1,1,0,0},
+    {"zpopmax",zpopmaxCommand,-2,"wF",0,NULL,1,1,1,0,0},
     {"bzpopmin",bzpopminCommand,-2,"wsF",0,NULL,1,-2,1,0,0},
     {"bzpopmax",bzpopmaxCommand,-2,"wsF",0,NULL,1,-2,1,0,0},
     {"hset",hsetCommand,-4,"wmF",0,NULL,1,1,1,0,0},

From dfcc20f4fd30e4373bbd4bc20d500af50796d23c Mon Sep 17 00:00:00 2001
From: Guy Benoish <guy.benoish@redislabs.com>
Date: Sun, 24 Jun 2018 16:53:01 +0700
Subject: [PATCH 101/219] Fix compiler warning in restoreCommand

---
 src/cluster.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cluster.c b/src/cluster.c
index dac03ec71..9b8425598 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -4835,7 +4835,7 @@ void dumpCommand(client *c) {
 
 /* RESTORE key ttl serialized-value [REPLACE] */
 void restoreCommand(client *c) {
-    long long ttl, lfu_freq = -1, lru_idle = -1, lru_clock;
+    long long ttl, lfu_freq = -1, lru_idle = -1, lru_clock = -1;
     rio payload;
     int j, type, replace = 0, absttl = 0;
     robj *obj;

From 72e8a33b35262aa8b4f094d592f271eae433bf0c Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 14:06:05 +0200
Subject: [PATCH 102/219] Sentinel command renaming: base machanism
 implemented.

---
 src/sentinel.c | 79 ++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 64 insertions(+), 15 deletions(-)

diff --git a/src/sentinel.c b/src/sentinel.c
index d3818707b..775cb4c93 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -178,6 +178,10 @@ typedef struct sentinelRedisInstance {
     mstime_t o_down_since_time; /* Objectively down since time. */
     mstime_t down_after_period; /* Consider it down after that period. */
     mstime_t info_refresh;  /* Time at which we received INFO output from it. */
+    dict *renamed_commands;     /* Commands renamed in this instance:
+                                   Sentinel will use the alternative commands
+                                   mapped on this table to send things like
+                                   SLAVEOF, CONFING, INFO, ... */
 
     /* Role and the first time we observed it.
      * This is useful in order to delay replacing what the instance reports
@@ -384,6 +388,7 @@ void sentinelSimFailureCrash(void);
 
 uint64_t dictSdsHash(const void *key);
 int dictSdsKeyCompare(void *privdata, const void *key1, const void *key2);
+int dictSdsKeyCaseCompare(void *privdata, const void *key1, const void *key2);
 void releaseSentinelRedisInstance(sentinelRedisInstance *ri);
 
 void dictInstancesValDestructor (void *privdata, void *obj) {
@@ -417,6 +422,16 @@ dictType leaderVotesDictType = {
     NULL                       /* val destructor */
 };
 
+/* Instance renamed commands table. */
+dictType renamedCommandsDictType = {
+    dictSdsHash,               /* hash function */
+    NULL,                      /* key dup */
+    NULL,                      /* val dup */
+    dictSdsKeyCaseCompare,     /* key compare */
+    dictSdsDestructor,         /* key destructor */
+    dictSdsDestructor          /* val destructor */
+};
+
 /* =========================== Initialization =============================== */
 
 void sentinelCommand(client *c);
@@ -1211,6 +1226,7 @@ sentinelRedisInstance *createSentinelRedisInstance(char *name, int flags, char *
     ri->master = master;
     ri->slaves = dictCreate(&instancesDictType,NULL);
     ri->info_refresh = 0;
+    ri->renamed_commands = dictCreate(&renamedCommandsDictType,NULL);
 
     /* Failover state. */
     ri->leader = NULL;
@@ -1258,6 +1274,7 @@ void releaseSentinelRedisInstance(sentinelRedisInstance *ri) {
     sdsfree(ri->auth_pass);
     sdsfree(ri->info);
     releaseSentinelAddr(ri->addr);
+    dictRelease(ri->renamed_commands);
 
     /* Clear state into the master if needed. */
     if ((ri->flags & SRI_SLAVE) && (ri->flags & SRI_PROMOTED) && ri->master)
@@ -1572,6 +1589,21 @@ char *sentinelGetInstanceTypeString(sentinelRedisInstance *ri) {
     else return "unknown";
 }
 
+/* This function is used in order to send commands to Redis instances: the
+ * commands we send from Sentinel may be renamed, a common case is a master
+ * with CONFIG and SLAVEOF commands renamed for security concerns. In that
+ * case we check the ri->renamed_command table (or if the instance is a slave,
+ * we check the one of the master), and map the command that we should send
+ * to the set of renamed commads. However, if the command was not renamed,
+ * we just return "command" itself. */
+char *sentinelInstanceMapCommand(sentinelRedisInstance *ri, char *command) {
+    sds sc = sdsnew(command);
+    if (ri->master) ri = ri->master;
+    char *retval = dictFetchValue(ri->renamed_commands, sc);
+    sdsfree(sc);
+    return retval ? retval : command;
+}
+
 /* ============================ Config handling ============================= */
 char *sentinelHandleConfiguration(char **argv, int argc) {
     sentinelRedisInstance *ri;
@@ -1891,7 +1923,8 @@ void sentinelSendAuthIfNeeded(sentinelRedisInstance *ri, redisAsyncContext *c) {
                                                  ri->master->auth_pass;
 
     if (auth_pass) {
-        if (redisAsyncCommand(c, sentinelDiscardReplyCallback, ri, "AUTH %s",
+        if (redisAsyncCommand(c, sentinelDiscardReplyCallback, ri, "%s %s",
+            sentinelInstanceMapCommand(ri,"AUTH"),
             auth_pass) == C_OK) ri->link->pending_commands++;
     }
 }
@@ -1907,7 +1940,9 @@ void sentinelSetClientName(sentinelRedisInstance *ri, redisAsyncContext *c, char
 
     snprintf(name,sizeof(name),"sentinel-%.8s-%s",sentinel.myid,type);
     if (redisAsyncCommand(c, sentinelDiscardReplyCallback, ri,
-        "CLIENT SETNAME %s", name) == C_OK)
+        "%s SETNAME %s",
+        sentinelInstanceMapCommand(ri,"CLIENT"),
+        name) == C_OK)
     {
         ri->link->pending_commands++;
     }
@@ -1969,8 +2004,9 @@ void sentinelReconnectInstance(sentinelRedisInstance *ri) {
             sentinelSetClientName(ri,link->pc,"pubsub");
             /* Now we subscribe to the Sentinels "Hello" channel. */
             retval = redisAsyncCommand(link->pc,
-                sentinelReceiveHelloMessages, ri, "SUBSCRIBE %s",
-                    SENTINEL_HELLO_CHANNEL);
+                sentinelReceiveHelloMessages, ri, "%s %s",
+                sentinelInstanceMapCommand(ri,"SUBSCRIBE"),
+                SENTINEL_HELLO_CHANNEL);
             if (retval != C_OK) {
                 /* If we can't subscribe, the Pub/Sub connection is useless
                  * and we can simply disconnect it and try again. */
@@ -2304,8 +2340,11 @@ void sentinelPingReplyCallback(redisAsyncContext *c, void *reply, void *privdata
             {
                 if (redisAsyncCommand(ri->link->cc,
                         sentinelDiscardReplyCallback, ri,
-                        "SCRIPT KILL") == C_OK)
+                        "%s KILL",
+                        sentinelInstanceMapCommand(ri,"SCRIPT")) == C_OK)
+                {
                     ri->link->pending_commands++;
+                }
                 ri->flags |= SRI_SCRIPT_KILL_SENT;
             }
         }
@@ -2511,8 +2550,9 @@ int sentinelSendHello(sentinelRedisInstance *ri) {
         master->name,master_addr->ip,master_addr->port,
         (unsigned long long) master->config_epoch);
     retval = redisAsyncCommand(ri->link->cc,
-        sentinelPublishReplyCallback, ri, "PUBLISH %s %s",
-            SENTINEL_HELLO_CHANNEL,payload);
+        sentinelPublishReplyCallback, ri, "%s %s %s",
+        sentinelInstanceMapCommand(ri,"PUBLISH"),
+        SENTINEL_HELLO_CHANNEL,payload);
     if (retval != C_OK) return C_ERR;
     ri->link->pending_commands++;
     return C_OK;
@@ -2557,7 +2597,8 @@ int sentinelForceHelloUpdateForMaster(sentinelRedisInstance *master) {
  * queued in the connection. */
 int sentinelSendPing(sentinelRedisInstance *ri) {
     int retval = redisAsyncCommand(ri->link->cc,
-        sentinelPingReplyCallback, ri, "PING");
+        sentinelPingReplyCallback, ri, "%s",
+        sentinelInstanceMapCommand(ri,"PING"));
     if (retval == C_OK) {
         ri->link->pending_commands++;
         ri->link->last_ping_time = mstime();
@@ -2621,7 +2662,8 @@ void sentinelSendPeriodicCommands(sentinelRedisInstance *ri) {
         (now - ri->info_refresh) > info_period))
     {
         retval = redisAsyncCommand(ri->link->cc,
-            sentinelInfoReplyCallback, ri, "INFO");
+            sentinelInfoReplyCallback, ri, "%s",
+            sentinelInstanceMapCommand(ri,"INFO"));
         if (retval == C_OK) ri->link->pending_commands++;
     }
 
@@ -3617,7 +3659,8 @@ void sentinelAskMasterStateToOtherSentinels(sentinelRedisInstance *master, int f
         ll2string(port,sizeof(port),master->addr->port);
         retval = redisAsyncCommand(ri->link->cc,
                     sentinelReceiveIsMasterDownReply, ri,
-                    "SENTINEL is-master-down-by-addr %s %s %llu %s",
+                    "%s is-master-down-by-addr %s %s %llu %s",
+                    sentinelInstanceMapCommand(ri,"SENTINEL"),
                     master->addr->ip, port,
                     sentinel.current_epoch,
                     (master->failover_state > SENTINEL_FAILOVER_STATE_NONE) ?
@@ -3796,17 +3839,21 @@ int sentinelSendSlaveOf(sentinelRedisInstance *ri, char *host, int port) {
      * Note that we don't check the replies returned by commands, since we
      * will observe instead the effects in the next INFO output. */
     retval = redisAsyncCommand(ri->link->cc,
-        sentinelDiscardReplyCallback, ri, "MULTI");
+        sentinelDiscardReplyCallback, ri, "%s",
+        sentinelInstanceMapCommand(ri,"MULTI"));
     if (retval == C_ERR) return retval;
     ri->link->pending_commands++;
 
     retval = redisAsyncCommand(ri->link->cc,
-        sentinelDiscardReplyCallback, ri, "SLAVEOF %s %s", host, portstr);
+        sentinelDiscardReplyCallback, ri, "%s %s %s",
+        sentinelInstanceMapCommand(ri,"SLAVEOF"),
+        host, portstr);
     if (retval == C_ERR) return retval;
     ri->link->pending_commands++;
 
     retval = redisAsyncCommand(ri->link->cc,
-        sentinelDiscardReplyCallback, ri, "CONFIG REWRITE");
+        sentinelDiscardReplyCallback, ri, "%s REWRITE",
+        sentinelInstanceMapCommand(ri,"CONFIG"));
     if (retval == C_ERR) return retval;
     ri->link->pending_commands++;
 
@@ -3816,12 +3863,14 @@ int sentinelSendSlaveOf(sentinelRedisInstance *ri, char *host, int port) {
      * recognized as a syntax error, and the transaction will not fail (but
      * only the unsupported command will fail). */
     retval = redisAsyncCommand(ri->link->cc,
-        sentinelDiscardReplyCallback, ri, "CLIENT KILL TYPE normal");
+        sentinelDiscardReplyCallback, ri, "%s KILL TYPE normal",
+        sentinelInstanceMapCommand(ri,"CLIENT"));
     if (retval == C_ERR) return retval;
     ri->link->pending_commands++;
 
     retval = redisAsyncCommand(ri->link->cc,
-        sentinelDiscardReplyCallback, ri, "EXEC");
+        sentinelDiscardReplyCallback, ri, "%s",
+        sentinelInstanceMapCommand(ri,"EXEC"));
     if (retval == C_ERR) return retval;
     ri->link->pending_commands++;
 

From 60df7dbea14953a5bab62f59ce0d11b464a7507d Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 16:47:39 +0200
Subject: [PATCH 103/219] Sentinel command renaming: rename-command option
 parsing.

---
 src/sentinel.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/sentinel.c b/src/sentinel.c
index 775cb4c93..047d6fbf9 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -1713,6 +1713,17 @@ char *sentinelHandleConfiguration(char **argv, int argc) {
             si->runid = sdsnew(argv[4]);
             sentinelTryConnectionSharing(si);
         }
+    } else if (!strcasecmp(argv[0],"rename-command") && argc == 4) {
+        /* rename-command <name> <command> <renamed-command> */
+        ri = sentinelGetMasterByName(argv[1]);
+        if (!ri) return "No such master with specified name.";
+        sds oldcmd = sdsnew(argv[2]);
+        sds newcmd = sdsnew(argv[3]);
+        if (dictAdd(ri->renamed_commands,oldcmd,newcmd) != DICT_OK) {
+            sdsfree(oldcmd);
+            sdsfree(newcmd);
+            return "Same command renamed multiple times with rename-command.";
+        }
     } else if (!strcasecmp(argv[0],"announce-ip") && argc == 2) {
         /* announce-ip <ip-address> */
         if (strlen(argv[1]))

From c303e768bf992ebf9042110faab6a7630e426cfe Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 16:55:01 +0200
Subject: [PATCH 104/219] Sentinel command renaming: config rewriting.

---
 src/sentinel.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/sentinel.c b/src/sentinel.c
index 047d6fbf9..7eb482a3c 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -1870,6 +1870,18 @@ void rewriteConfigSentinelOption(struct rewriteConfigState *state) {
             rewriteConfigRewriteLine(state,"sentinel",line,1);
         }
         dictReleaseIterator(di2);
+
+        /* sentinel rename-command */
+        di2 = dictGetIterator(master->renamed_commands);
+        while((de = dictNext(di2)) != NULL) {
+            sds oldname = dictGetKey(de);
+            sds newname = dictGetVal(de);
+            line = sdscatprintf(sdsempty(),
+                "sentinel rename-command %s %s %s",
+                master->name, oldname, newname);
+            rewriteConfigRewriteLine(state,"sentinel",line,1);
+        }
+        dictReleaseIterator(di2);
     }
 
     /* sentinel current-epoch is a global state valid for all the masters. */

From 903582dd7b1a2cecdb2268b641466c6456aaac9e Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 17:12:39 +0200
Subject: [PATCH 105/219] Sentinel: make SENTINEL SET able to handle different
 arities.

---
 src/sentinel.c | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/sentinel.c b/src/sentinel.c
index 7eb482a3c..c367efee3 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3180,7 +3180,7 @@ void sentinelCommand(client *c) {
             addReplySds(c,e);
         }
     } else if (!strcasecmp(c->argv[1]->ptr,"set")) {
-        if (c->argc < 3 || c->argc % 2 == 0) goto numargserr;
+        if (c->argc < 3) goto numargserr;
         sentinelSetCommand(c);
     } else if (!strcasecmp(c->argv[1]->ptr,"info-cache")) {
         /* SENTINEL INFO-CACHE <name> */
@@ -3385,33 +3385,37 @@ void sentinelSetCommand(client *c) {
         == NULL) return;
 
     /* Process option - value pairs. */
-    for (j = 3; j < c->argc; j += 2) {
+    for (j = 3; j < c->argc; j++) {
+        int moreargs = (c->argc-1) - j;
         option = c->argv[j]->ptr;
-        value = c->argv[j+1]->ptr;
         robj *o = c->argv[j+1];
         long long ll;
 
-        if (!strcasecmp(option,"down-after-milliseconds")) {
+        if (!strcasecmp(option,"down-after-milliseconds") && moreargs > 0) {
             /* down-after-millisecodns <milliseconds> */
+            value = c->argv[++j]->ptr;
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->down_after_period = ll;
             sentinelPropagateDownAfterPeriod(ri);
             changes++;
-        } else if (!strcasecmp(option,"failover-timeout")) {
+        } else if (!strcasecmp(option,"failover-timeout") && moreargs > 0) {
             /* failover-timeout <milliseconds> */
+            value = c->argv[++j]->ptr;
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->failover_timeout = ll;
             changes++;
-       } else if (!strcasecmp(option,"parallel-syncs")) {
+        } else if (!strcasecmp(option,"parallel-syncs") && moreargs > 0) {
             /* parallel-syncs <milliseconds> */
+            value = c->argv[++j]->ptr;
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->parallel_syncs = ll;
             changes++;
-       } else if (!strcasecmp(option,"notification-script")) {
+        } else if (!strcasecmp(option,"notification-script") && moreargs > 0) {
             /* notification-script <path> */
+            value = c->argv[++j]->ptr;
             if (sentinel.deny_scripts_reconfig) {
                 addReplyError(c,
                     "Reconfiguration of scripts path is denied for "
@@ -3429,8 +3433,9 @@ void sentinelSetCommand(client *c) {
             sdsfree(ri->notification_script);
             ri->notification_script = strlen(value) ? sdsnew(value) : NULL;
             changes++;
-       } else if (!strcasecmp(option,"client-reconfig-script")) {
+        } else if (!strcasecmp(option,"client-reconfig-script") && moreargs > 0) {
             /* client-reconfig-script <path> */
+            value = c->argv[++j]->ptr;
             if (sentinel.deny_scripts_reconfig) {
                 addReplyError(c,
                     "Reconfiguration of scripts path is denied for "
@@ -3449,20 +3454,22 @@ void sentinelSetCommand(client *c) {
             sdsfree(ri->client_reconfig_script);
             ri->client_reconfig_script = strlen(value) ? sdsnew(value) : NULL;
             changes++;
-       } else if (!strcasecmp(option,"auth-pass")) {
+        } else if (!strcasecmp(option,"auth-pass") && moreargs > 0) {
             /* auth-pass <password> */
+            value = c->argv[++j]->ptr;
             sdsfree(ri->auth_pass);
             ri->auth_pass = strlen(value) ? sdsnew(value) : NULL;
             changes++;
-       } else if (!strcasecmp(option,"quorum")) {
+        } else if (!strcasecmp(option,"quorum") && moreargs > 0) {
             /* quorum <count> */
+            value = c->argv[++j]->ptr;
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->quorum = ll;
             changes++;
         } else {
-            addReplyErrorFormat(c,"Unknown option '%s' for SENTINEL SET",
-                option);
+            addReplyErrorFormat(c,"Unknown option or number of arguments for "
+                                  "SENTINEL SET '%s'", option);
             if (changes) sentinelFlushConfig();
             return;
         }

From 91a384a5cdcc01912331ad3bd467b2785f3d406b Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 17:13:20 +0200
Subject: [PATCH 106/219] Sentinel command renaming: implement SENTINEL SET.

---
 src/sentinel.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/sentinel.c b/src/sentinel.c
index c367efee3..f69713973 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3467,6 +3467,25 @@ void sentinelSetCommand(client *c) {
                 goto badfmt;
             ri->quorum = ll;
             changes++;
+        } else if (!strcasecmp(option,"rename-command") && moreargs > 1) {
+            /* rename-command <oldname> <newname>
+             *
+             * Note: if newname is the empty string the command renaming
+             * entry is deleted. */
+            sds oldname = c->argv[++j]->ptr;
+            sds newname = c->argv[++j]->ptr;
+
+            /* Remove any older renaming for this command. */
+            dictDelete(ri->renamed_commands,oldname);
+
+            /* If the target name length is not zero, we need to add the
+             * actual entry to the renamed table. */
+            if (sdslen(newname)) {
+                oldname = sdsdup(oldname);
+                newname = sdsdup(newname);
+                dictAdd(ri->renamed_commands,oldname,newname);
+            }
+            changes++;
         } else {
             addReplyErrorFormat(c,"Unknown option or number of arguments for "
                                   "SENTINEL SET '%s'", option);

From b72cecd7c89efdd5beef994723d30dba69df6947 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 17:23:32 +0200
Subject: [PATCH 107/219] Sentinel command renaming: fix CONFIG SET after
 refactoring.

---
 src/sentinel.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/sentinel.c b/src/sentinel.c
index f69713973..e11f6b845 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3388,12 +3388,12 @@ void sentinelSetCommand(client *c) {
     for (j = 3; j < c->argc; j++) {
         int moreargs = (c->argc-1) - j;
         option = c->argv[j]->ptr;
-        robj *o = c->argv[j+1];
         long long ll;
+        int old_j = j; /* Used to know what to log as an event. */
 
         if (!strcasecmp(option,"down-after-milliseconds") && moreargs > 0) {
             /* down-after-millisecodns <milliseconds> */
-            value = c->argv[++j]->ptr;
+            robj *o = c->argv[++j];
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->down_after_period = ll;
@@ -3401,14 +3401,14 @@ void sentinelSetCommand(client *c) {
             changes++;
         } else if (!strcasecmp(option,"failover-timeout") && moreargs > 0) {
             /* failover-timeout <milliseconds> */
-            value = c->argv[++j]->ptr;
+            robj *o = c->argv[++j];
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->failover_timeout = ll;
             changes++;
         } else if (!strcasecmp(option,"parallel-syncs") && moreargs > 0) {
             /* parallel-syncs <milliseconds> */
-            value = c->argv[++j]->ptr;
+            robj *o = c->argv[++j];
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->parallel_syncs = ll;
@@ -3462,7 +3462,7 @@ void sentinelSetCommand(client *c) {
             changes++;
         } else if (!strcasecmp(option,"quorum") && moreargs > 0) {
             /* quorum <count> */
-            value = c->argv[++j]->ptr;
+            robj *o = c->argv[++j];
             if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
                 goto badfmt;
             ri->quorum = ll;

From a9c500889533aeb6a8c828f146acda9798164813 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 17:24:04 +0200
Subject: [PATCH 108/219] Sentinel command renaming: fix CONFIG SET event
 logging.

---
 src/sentinel.c | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/sentinel.c b/src/sentinel.c
index e11f6b845..7b8d85c47 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3492,7 +3492,23 @@ void sentinelSetCommand(client *c) {
             if (changes) sentinelFlushConfig();
             return;
         }
-        sentinelEvent(LL_WARNING,"+set",ri,"%@ %s %s",option,value);
+
+        /* Log the event. */
+        int numargs = j-old_j+1;
+        switch(numargs) {
+        case 2:
+            sentinelEvent(LL_WARNING,"+set",ri,"%@ %s %s",c->argv[old_j]->ptr,
+                                                          c->argv[old_j+1]->ptr);
+            break;
+        case 3:
+            sentinelEvent(LL_WARNING,"+set",ri,"%@ %s %s %s",c->argv[old_j]->ptr,
+                                                             c->argv[old_j+1]->ptr,
+                                                             c->argv[old_j+2]->ptr);
+            break;
+        default:
+            sentinelEvent(LL_WARNING,"+set",ri,"%@ %s",c->argv[old_j]->ptr);
+            break;
+        }
     }
 
     if (changes) sentinelFlushConfig();

From 2358de681670f6f2d64d1860765573c43c7f1606 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 17:31:57 +0200
Subject: [PATCH 109/219] Sentinel command renaming: use case sensitive hashing
 for the dict.

---
 src/sentinel.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/sentinel.c b/src/sentinel.c
index 7b8d85c47..de49cdebb 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -387,6 +387,7 @@ void sentinelSimFailureCrash(void);
 /* ========================= Dictionary types =============================== */
 
 uint64_t dictSdsHash(const void *key);
+uint64_t dictSdsCaseHash(const void *key);
 int dictSdsKeyCompare(void *privdata, const void *key1, const void *key2);
 int dictSdsKeyCaseCompare(void *privdata, const void *key1, const void *key2);
 void releaseSentinelRedisInstance(sentinelRedisInstance *ri);
@@ -424,7 +425,7 @@ dictType leaderVotesDictType = {
 
 /* Instance renamed commands table. */
 dictType renamedCommandsDictType = {
-    dictSdsHash,               /* hash function */
+    dictSdsCaseHash,           /* hash function */
     NULL,                      /* key dup */
     NULL,                      /* val dup */
     dictSdsKeyCaseCompare,     /* key compare */

From 8ba670f55c88c0412e5646e35cf02fda655b8ed8 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 17:45:01 +0200
Subject: [PATCH 110/219] Sentinel command renaming: document it into
 sentinel.conf.

---
 sentinel.conf | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/sentinel.conf b/sentinel.conf
index 38b097254..3703c7394 100644
--- a/sentinel.conf
+++ b/sentinel.conf
@@ -203,3 +203,22 @@ sentinel failover-timeout mymaster 180000
 
 sentinel deny-scripts-reconfig yes
 
+# REDIS COMMANDS RENAMING
+#
+# Sometimes the Redis server has certain commands, that are needed for Sentinel
+# to work correctly, renamed to unguessable strings. This is often the case
+# of CONFIG and SLAVEOF in the context of providers that provide Redis as
+# a service, and don't want the customers to reconfigure the instances outside
+# of the administration console.
+#
+# In such case it is possible to tell Sentinel to use different command names
+# instead of the normal ones. For example if the master "mymaster", and the
+# associated slaves, have "CONFIG" all renamed to "GUESSME", I could use:
+#
+# sentinel rename-command mymaster CONFIG GUESSME
+#
+# After such configuration is set, every time Sentinel would use CONFIG it will
+# use GUESSME instead. Note that there is no actual need to respect the command
+# case, so writing "config guessme" is the same in the example above.
+#
+# SENTINEL SET can also be used in order to perform this configuration at runtime.

From fc0c9c8097a5b2bc8728bec9cfee26817a702f09 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 25 Jun 2018 17:50:45 +0200
Subject: [PATCH 111/219] Sentinel: drop the renamed-command entry in a more
 natural way.

Instead of telling the user to set the renamed command to "" to remove
the renaming, to the obvious thing when a command is renamed to itself.

So if I want to remove the renaming of PING, I just rename it to PING
again.
---
 src/sentinel.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/sentinel.c b/src/sentinel.c
index de49cdebb..18743e91d 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3469,19 +3469,16 @@ void sentinelSetCommand(client *c) {
             ri->quorum = ll;
             changes++;
         } else if (!strcasecmp(option,"rename-command") && moreargs > 1) {
-            /* rename-command <oldname> <newname>
-             *
-             * Note: if newname is the empty string the command renaming
-             * entry is deleted. */
+            /* rename-command <oldname> <newname> */
             sds oldname = c->argv[++j]->ptr;
             sds newname = c->argv[++j]->ptr;
 
             /* Remove any older renaming for this command. */
             dictDelete(ri->renamed_commands,oldname);
 
-            /* If the target name length is not zero, we need to add the
-             * actual entry to the renamed table. */
-            if (sdslen(newname)) {
+            /* If the target name is the same as the source name there
+             * is no need to add an entry mapping to itself. */
+            if (!dictSdsKeyCaseCompare(NULL,oldname,newname)) {
                 oldname = sdsdup(oldname);
                 newname = sdsdup(newname);
                 dictAdd(ri->renamed_commands,oldname,newname);

From e8d68b6b72c7bbba63120d9024138dacd583d22d Mon Sep 17 00:00:00 2001
From: Madelyn Olson <matolson@amazon.com>
Date: Tue, 19 Jun 2018 05:38:53 +0000
Subject: [PATCH 112/219] Fixed replication authentication with whitespace in
 password

---
 src/replication.c | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/replication.c b/src/replication.c
index 0b7d57910..5b344f49e 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -1315,23 +1315,30 @@ error:
 #define SYNC_CMD_FULL (SYNC_CMD_READ|SYNC_CMD_WRITE)
 char *sendSynchronousCommand(int flags, int fd, ...) {
 
-    /* Create the command to send to the master, we use simple inline
-     * protocol for simplicity as currently we only send simple strings. */
+    /* Create the command to send to the master, we use redis binary
+     * protocol to make sure correct arguments are sent. This function
+     * is not safe for all binary data.*/
     if (flags & SYNC_CMD_WRITE) {
         char *arg;
         va_list ap;
         sds cmd = sdsempty();
+        sds cmdargs = sdsempty();
+        int argslen = 0;
         va_start(ap,fd);
 
         while(1) {
             arg = va_arg(ap, char*);
             if (arg == NULL) break;
 
-            if (sdslen(cmd) != 0) cmd = sdscatlen(cmd," ",1);
-            cmd = sdscat(cmd,arg);
+            cmdargs = sdscatprintf(cmdargs,"$%zu\r\n%s\r\n",strlen(arg),arg);
+            argslen++;
         }
-        cmd = sdscatlen(cmd,"\r\n",2);
+
         va_end(ap);
+
+        cmd = sdscatprintf(cmd,"*%zu\r\n",argslen);
+        cmd = sdscatsds(cmd,cmdargs);
+        sdsfree(cmdargs);
         
         /* Transfer command to the server. */
         if (syncWrite(fd,cmd,sdslen(cmd),server.repl_syncio_timeout*1000)

From 45731edc4b215431716ec904f62a7d4d212b9d4b Mon Sep 17 00:00:00 2001
From: Madelyn Olson <matolson@amazon.com>
Date: Tue, 26 Jun 2018 00:57:35 +0000
Subject: [PATCH 113/219] Addressed comments

---
 src/replication.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/replication.c b/src/replication.c
index 5b344f49e..2091476d6 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -1317,7 +1317,7 @@ char *sendSynchronousCommand(int flags, int fd, ...) {
 
     /* Create the command to send to the master, we use redis binary
      * protocol to make sure correct arguments are sent. This function
-     * is not safe for all binary data.*/
+     * is not safe for all binary data. */
     if (flags & SYNC_CMD_WRITE) {
         char *arg;
         va_list ap;

From 3cf8dd2c84daf2f4ad1c1777f36b61a5f846a9c6 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 26 Jun 2018 09:15:46 +0200
Subject: [PATCH 114/219] Sentinel: fix SENTINEL SET error reporting.

Thanks to @shenlongxing for reporting the problem.
Related to #5062.
---
 src/sentinel.c | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/sentinel.c b/src/sentinel.c
index 18743e91d..512b224e6 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3380,7 +3380,8 @@ void sentinelRoleCommand(client *c) {
 void sentinelSetCommand(client *c) {
     sentinelRedisInstance *ri;
     int j, changes = 0;
-    char *option, *value;
+    int badarg = 0; /* Bad argument position for error reporting. */
+    char *option;
 
     if ((ri = sentinelGetMasterByNameOrReplyError(c,c->argv[2]))
         == NULL) return;
@@ -3395,28 +3396,34 @@ void sentinelSetCommand(client *c) {
         if (!strcasecmp(option,"down-after-milliseconds") && moreargs > 0) {
             /* down-after-millisecodns <milliseconds> */
             robj *o = c->argv[++j];
-            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
+            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0) {
+                badarg = j;
                 goto badfmt;
+            }
             ri->down_after_period = ll;
             sentinelPropagateDownAfterPeriod(ri);
             changes++;
         } else if (!strcasecmp(option,"failover-timeout") && moreargs > 0) {
             /* failover-timeout <milliseconds> */
             robj *o = c->argv[++j];
-            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
+            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0) {
+                badarg = j;
                 goto badfmt;
+            }
             ri->failover_timeout = ll;
             changes++;
         } else if (!strcasecmp(option,"parallel-syncs") && moreargs > 0) {
             /* parallel-syncs <milliseconds> */
             robj *o = c->argv[++j];
-            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
+            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0) {
+                badarg = j;
                 goto badfmt;
+            }
             ri->parallel_syncs = ll;
             changes++;
         } else if (!strcasecmp(option,"notification-script") && moreargs > 0) {
             /* notification-script <path> */
-            value = c->argv[++j]->ptr;
+            char *value = c->argv[++j]->ptr;
             if (sentinel.deny_scripts_reconfig) {
                 addReplyError(c,
                     "Reconfiguration of scripts path is denied for "
@@ -3436,7 +3443,7 @@ void sentinelSetCommand(client *c) {
             changes++;
         } else if (!strcasecmp(option,"client-reconfig-script") && moreargs > 0) {
             /* client-reconfig-script <path> */
-            value = c->argv[++j]->ptr;
+            char *value = c->argv[++j]->ptr;
             if (sentinel.deny_scripts_reconfig) {
                 addReplyError(c,
                     "Reconfiguration of scripts path is denied for "
@@ -3457,15 +3464,17 @@ void sentinelSetCommand(client *c) {
             changes++;
         } else if (!strcasecmp(option,"auth-pass") && moreargs > 0) {
             /* auth-pass <password> */
-            value = c->argv[++j]->ptr;
+            char *value = c->argv[++j]->ptr;
             sdsfree(ri->auth_pass);
             ri->auth_pass = strlen(value) ? sdsnew(value) : NULL;
             changes++;
         } else if (!strcasecmp(option,"quorum") && moreargs > 0) {
             /* quorum <count> */
             robj *o = c->argv[++j];
-            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0)
+            if (getLongLongFromObject(o,&ll) == C_ERR || ll <= 0) {
+                badarg = j;
                 goto badfmt;
+            }
             ri->quorum = ll;
             changes++;
         } else if (!strcasecmp(option,"rename-command") && moreargs > 1) {
@@ -3516,7 +3525,7 @@ void sentinelSetCommand(client *c) {
 badfmt: /* Bad format errors */
     if (changes) sentinelFlushConfig();
     addReplyErrorFormat(c,"Invalid argument '%s' for SENTINEL SET '%s'",
-            value, option);
+        c->argv[badarg]->ptr,option);
 }
 
 /* Our fake PUBLISH command: it is actually useful only to receive hello messages

From 1f1e724f47d42538fc77d8f8bf6d6622b204dc62 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 26 Jun 2018 14:37:22 +0200
Subject: [PATCH 115/219] Remove black space.

---
 src/replication.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/replication.c b/src/replication.c
index 2091476d6..a023f8175 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -1339,7 +1339,7 @@ char *sendSynchronousCommand(int flags, int fd, ...) {
         cmd = sdscatprintf(cmd,"*%zu\r\n",argslen);
         cmd = sdscatsds(cmd,cmdargs);
         sdsfree(cmdargs);
-        
+
         /* Transfer command to the server. */
         if (syncWrite(fd,cmd,sdslen(cmd),server.repl_syncio_timeout*1000)
             == -1)

From 27178a3fde83c1b81624083670d922313aca1370 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 26 Jun 2018 14:38:31 +0200
Subject: [PATCH 116/219] Fix type of argslen in sendSynchronousCommand().

Related to #5037.
---
 src/replication.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/replication.c b/src/replication.c
index a023f8175..00c2a7199 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -1323,7 +1323,7 @@ char *sendSynchronousCommand(int flags, int fd, ...) {
         va_list ap;
         sds cmd = sdsempty();
         sds cmdargs = sdsempty();
-        int argslen = 0;
+        size_t argslen = 0;
         va_start(ap,fd);
 
         while(1) {

From 438317796b7a34b100e47ce2c5acdf184dfdf53d Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 26 Jun 2018 16:08:32 +0200
Subject: [PATCH 117/219] Sentinel: test command renaming feature.

---
 tests/sentinel/tests/07-down-conditions.tcl | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/sentinel/tests/07-down-conditions.tcl b/tests/sentinel/tests/07-down-conditions.tcl
index a60656e59..fb2993b6f 100644
--- a/tests/sentinel/tests/07-down-conditions.tcl
+++ b/tests/sentinel/tests/07-down-conditions.tcl
@@ -66,3 +66,13 @@ test "SDOWN is triggered by misconfigured instance repling with errors" {
     R 0 bgsave
     ensure_master_up
 }
+
+# We use this test setup to also test command renaming, as a side
+# effect of the master going down if we send PONG instead of PING
+test "SDOWN is triggered if we rename PING to PONG" {
+    ensure_master_up
+    S 4 SENTINEL SET mymaster rename-command PING PONG
+    ensure_master_down
+    S 4 SENTINEL SET mymaster rename-command PING PING
+    ensure_master_up
+}

From 751eea24c44a762f0e5d04477defa27e26f2d9d9 Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Tue, 26 Jun 2018 14:14:04 +0300
Subject: [PATCH 118/219] test suite infra improvements and fix

* fail the test (exit code) in case of timeout.
* add --wait-server to allow attaching a debugger
* add --dont-clean to keep log files when tests are done
---
 tests/support/server.tcl |  6 ++++++
 tests/test_helper.tcl    | 13 +++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/tests/support/server.tcl b/tests/support/server.tcl
index c36b30775..5578f1fd6 100644
--- a/tests/support/server.tcl
+++ b/tests/support/server.tcl
@@ -276,6 +276,12 @@ proc start_server {options {code undefined}} {
             error_and_quit $config_file $line
         }
 
+        if {$::wait_server} {
+            set msg "server started PID: [dict get $srv "pid"]. press any key to continue..."
+            puts $msg
+            read stdin 1
+        }
+
         while 1 {
             # check that the server actually started and is ready for connections
             if {[exec grep -i "Ready to accept" | wc -l < $stdout] > 0} {
diff --git a/tests/test_helper.tcl b/tests/test_helper.tcl
index 8b4d1eacf..8c6a3b814 100644
--- a/tests/test_helper.tcl
+++ b/tests/test_helper.tcl
@@ -82,6 +82,8 @@ set ::force_failure 0
 set ::timeout 600; # 10 minutes without progresses will quit the test.
 set ::last_progress [clock seconds]
 set ::active_servers {} ; # Pids of active Redis instances.
+set ::dont_clean 0
+set ::wait_server 0
 
 # Set to 1 when we are running in client mode. The Redis test uses a
 # server-client model to run tests simultaneously. The server instance
@@ -175,6 +177,9 @@ proc s {args} {
 }
 
 proc cleanup {} {
+    if {$::dont_clean} {
+        return
+    }
     if {!$::quiet} {puts -nonewline "Cleanup: may take some time... "}
     flush stdout
     catch {exec rm -rf {*}[glob tests/tmp/redis.conf.*]}
@@ -224,6 +229,7 @@ proc test_server_cron {} {
     if {$elapsed > $::timeout} {
         set err "\[[colorstr red TIMEOUT]\]: clients state report follows."
         puts $err
+        lappend ::failed_tests $err
         show_clients_state
         kill_clients
         force_kill_all_servers
@@ -410,6 +416,8 @@ proc print_help_screen {} {
         "--clients <num>    Number of test clients (default 16)."
         "--timeout <sec>    Test timeout in seconds (default 10 min)."
         "--force-failure    Force the execution of a test that always fails."
+        "--dont-clean       don't delete redis log files after the run"
+        "--wait-server      wait after server is started (so that you can attach a debugger)"
         "--help             Print this help screen."
     } "\n"]
 }
@@ -463,6 +471,11 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
     } elseif {$opt eq {--clients}} {
         set ::numclients $arg
         incr j
+    } elseif {$opt eq {--dont-clean}} {
+        set ::dont_clean 1
+    } elseif {$opt eq {--wait-server}} {
+        set ::wait_server 1
+        incr j
     } elseif {$opt eq {--timeout}} {
         set ::timeout $arg
         incr j

From e8099cabd19c4e3a46c94c39e69e13191d43f5eb Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Tue, 26 Jun 2018 14:13:24 +0300
Subject: [PATCH 119/219] add defrag hint support into jemalloc 5

---
 .../internal/jemalloc_internal_inlines_c.h    | 28 +++++++++++++++++++
 .../include/jemalloc/jemalloc_macros.h.in     |  4 +++
 deps/jemalloc/src/jemalloc.c                  | 11 ++++++++
 3 files changed, 43 insertions(+)

diff --git a/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h b/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
index c829ac60c..540c168e5 100644
--- a/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
+++ b/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
@@ -215,4 +215,32 @@ ixalloc(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size, size_t extra,
 	return arena_ralloc_no_move(tsdn, ptr, oldsize, size, extra, zero);
 }
 
+JEMALLOC_ALWAYS_INLINE int
+iget_defrag_hint(tsdn_t *tsdn, void* ptr, int *bin_util, int *run_util) {
+	int defrag = 0;
+	rtree_ctx_t rtree_ctx_fallback;
+	rtree_ctx_t *rtree_ctx = tsdn_rtree_ctx(tsdn, &rtree_ctx_fallback);
+	szind_t szind;
+	bool is_slab;
+	rtree_szind_slab_read(tsdn, &extents_rtree, rtree_ctx, (uintptr_t)ptr, true, &szind, &is_slab);
+	if (likely(is_slab)) {
+		/* Small allocation. */
+		extent_t *slab = iealloc(tsdn, ptr);
+		arena_t *arena = extent_arena_get(slab);
+		szind_t binind = extent_szind_get(slab);
+		bin_t *bin = &arena->bins[binind];
+		malloc_mutex_lock(tsdn, &bin->lock);
+		/* don't bother moving allocations from the slab currently used for new allocations */
+		if (slab != bin->slabcur) {
+			const bin_info_t *bin_info = &bin_infos[binind];
+			size_t availregs = bin_info->nregs * bin->stats.curslabs;
+			*bin_util = (bin->stats.curregs<<16) / availregs;
+			*run_util = ((bin_info->nregs - extent_nfree_get(slab))<<16) / bin_info->nregs;
+			defrag = 1;
+		}
+		malloc_mutex_unlock(tsdn, &bin->lock);
+	}
+	return defrag;
+}
+
 #endif /* JEMALLOC_INTERNAL_INLINES_C_H */
diff --git a/deps/jemalloc/include/jemalloc/jemalloc_macros.h.in b/deps/jemalloc/include/jemalloc/jemalloc_macros.h.in
index aee55438c..daf9e571b 100644
--- a/deps/jemalloc/include/jemalloc/jemalloc_macros.h.in
+++ b/deps/jemalloc/include/jemalloc/jemalloc_macros.h.in
@@ -120,3 +120,7 @@
 #  define JEMALLOC_RESTRICT_RETURN
 #  define JEMALLOC_ALLOCATOR
 #endif
+
+/* This version of Jemalloc, modified for Redis, has the je_get_defrag_hint()
+ * function. */
+#define JEMALLOC_FRAG_HINT
diff --git a/deps/jemalloc/src/jemalloc.c b/deps/jemalloc/src/jemalloc.c
index f93c16fa3..5b936cb48 100644
--- a/deps/jemalloc/src/jemalloc.c
+++ b/deps/jemalloc/src/jemalloc.c
@@ -3324,3 +3324,14 @@ jemalloc_postfork_child(void) {
 }
 
 /******************************************************************************/
+
+/* Helps the application decide if a pointer is worth re-allocating in order to reduce fragmentation.
+ * returns 0 if the allocation is in the currently active run,
+ * or when it is not causing any frag issue (large or huge bin)
+ * returns the bin utilization and run utilization both in fixed point 16:16.
+ * If the application decides to re-allocate it should use MALLOCX_TCACHE_NONE when doing so. */
+JEMALLOC_EXPORT int JEMALLOC_NOTHROW
+get_defrag_hint(void* ptr, int *bin_util, int *run_util) {
+	assert(ptr != NULL);
+	return iget_defrag_hint(TSDN_NULL, ptr, bin_util, run_util);
+}

From 5616d4c6036eeea416f38aa2e41a57249e69277f Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Tue, 26 Jun 2018 14:14:35 +0300
Subject: [PATCH 120/219] add active defrag support for streams

---
 src/config.c                 |   5 +
 src/defrag.c                 | 210 ++++++++++++++++++++++++++++++++---
 src/rax.c                    |   7 +-
 src/rax.h                    |  10 ++
 tests/integration/rdb.tcl    |   2 +
 tests/unit/memefficiency.tcl |  21 +++-
 6 files changed, 230 insertions(+), 25 deletions(-)

diff --git a/src/config.c b/src/config.c
index c7fc11556..c39b61e6c 100644
--- a/src/config.c
+++ b/src/config.c
@@ -431,6 +431,11 @@ void loadServerConfigFromString(char *config) {
             if ((server.active_defrag_enabled = yesnotoi(argv[1])) == -1) {
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
             }
+            if (server.active_defrag_enabled) {
+#ifndef HAVE_DEFRAG
+                err = "active defrag can't be enabled without proper jemalloc support"; goto loaderr;
+#endif
+            }
         } else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
             if ((server.daemonize = yesnotoi(argv[1])) == -1) {
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
diff --git a/src/defrag.c b/src/defrag.c
index aae72adcb..b25fceb1e 100644
--- a/src/defrag.c
+++ b/src/defrag.c
@@ -592,6 +592,171 @@ long defragSet(redisDb *db, dictEntry *kde) {
     return defragged;
 }
 
+/* Defrag callback for radix tree iterator, called for each node,
+ * used in order to defrag the nodes allocations. */
+int defragRaxNode(raxNode **noderef) {
+    raxNode *newnode = activeDefragAlloc(*noderef);
+    if (newnode) {
+        *noderef = newnode;
+        return 1;
+    }
+    return 0;
+}
+
+/* returns 0 if no more work needs to be been done, and 1 if time is up and more work is needed. */
+int scanLaterStraemListpacks(robj *ob, unsigned long *cursor, long long endtime, long long *defragged) {
+    static unsigned char last[sizeof(streamID)];
+    raxIterator ri;
+    long iterations = 0;
+    if (ob->type != OBJ_STREAM || ob->encoding != OBJ_ENCODING_STREAM) {
+        *cursor = 0;
+        return 0;
+    }
+
+    stream *s = ob->ptr;
+    raxStart(&ri,s->rax);
+    if (*cursor == 0) {
+        /* if cursor is 0, we start new iteration */
+        defragRaxNode(&s->rax->head);
+        /* assign the iterator node callback before the seek, so that the
+         * initial nodes that are processed till the first item are covered */
+        ri.node_cb = defragRaxNode;
+        raxSeek(&ri,"^",NULL,0);
+    } else {
+        /* if cursor is non-zero, we seek to the static 'last' */
+        if (!raxSeek(&ri,">", last, sizeof(last))) {
+            *cursor = 0;
+            return 0;
+        }
+        /* assign the iterator node callback after the seek, so that the
+         * initial nodes that are processed till now aren't covered */
+        ri.node_cb = defragRaxNode;
+    }
+
+    (*cursor)++;
+    while (raxNext(&ri)) {
+        void *newdata = activeDefragAlloc(ri.data);
+        if (newdata)
+            raxSetData(ri.node, ri.data=newdata), (*defragged)++;
+        if (++iterations > 16) {
+            if (ustime() > endtime) {
+                serverAssert(ri.key_len==sizeof(last));
+                memcpy(last,ri.key,ri.key_len);
+                raxStop(&ri);
+                return 1;
+            }
+            iterations = 0;
+        }
+    }
+    raxStop(&ri);
+    *cursor = 0;
+    return 0;
+}
+
+/* optional callback used defrag each rax element (not including the element pointer itself) */
+typedef void *(raxDefragFunction)(raxIterator *ri, void *privdata, long *defragged);
+
+/* defrag radix tree including:
+ * 1) rax struct
+ * 2) rax nodes
+ * 3) rax entry data (only if defrag_data is specified)
+ * 4) call a callback per element, and allow the callback to return a new pointer for the element */
+long defragRadixTree(rax **raxref, int defrag_data, raxDefragFunction *element_cb, void *element_cb_data) {
+    long defragged = 0;
+    raxIterator ri;
+    rax* rax;
+    if ((rax = activeDefragAlloc(*raxref)))
+        defragged++, *raxref = rax;
+    rax = *raxref;
+    raxStart(&ri,rax);
+    ri.node_cb = defragRaxNode;
+    defragRaxNode(&rax->head);
+    raxSeek(&ri,"^",NULL,0);
+    while (raxNext(&ri)) {
+        void *newdata = NULL;
+        if (element_cb)
+            newdata = element_cb(&ri, element_cb_data, &defragged);
+        if (defrag_data && !newdata)
+            newdata = activeDefragAlloc(ri.data);
+        if (newdata)
+            raxSetData(ri.node, ri.data=newdata), defragged++;
+    }
+    raxStop(&ri);
+    return defragged;
+}
+
+typedef struct {
+    streamCG *cg;
+    streamConsumer *c;
+} PendingEntryContext;
+
+void* defragStreamConsumerPendingEntry(raxIterator *ri, void *privdata, long *defragged) {
+    UNUSED(defragged);
+    PendingEntryContext *ctx = privdata;
+    streamNACK *nack = ri->data, *newnack;
+    nack->consumer = ctx->c; /* update nack pointer to consumer */
+    newnack = activeDefragAlloc(nack);
+    if (newnack) {
+        /* update consumer group pointer to the nack */
+        void *prev;
+        raxInsert(ctx->cg->pel, ri->key, ri->key_len, newnack, &prev);
+        serverAssert(prev==nack);
+        /* note: we don't increment 'defragged' that's done by the caller */
+    }
+    return newnack;
+}
+
+void* defragStreamConsumer(raxIterator *ri, void *privdata, long *defragged) {
+    streamConsumer *c = ri->data;
+    streamCG *cg = privdata;
+    void *newc = activeDefragAlloc(c);
+    if (newc) {
+        /* note: we don't increment 'defragged' that's done by the caller */
+        c = newc;
+    }
+    sds newsds = activeDefragSds(c->name);
+    if (newsds)
+        (*defragged)++, c->name = newsds;
+    if (c->pel) {
+        PendingEntryContext pel_ctx = {cg, c};
+        *defragged += defragRadixTree(&c->pel, 0, defragStreamConsumerPendingEntry, &pel_ctx);
+    }
+    return newc; /* returns NULL if c was not defragged */
+}
+
+void* defragStreamConsumerGroup(raxIterator *ri, void *privdata, long *defragged) {
+    streamCG *cg = ri->data;
+    UNUSED(privdata);
+    if (cg->consumers)
+        *defragged += defragRadixTree(&cg->consumers, 0, defragStreamConsumer, cg);
+    if (cg->pel)
+        *defragged += defragRadixTree(&cg->pel, 0, NULL, NULL);
+    return NULL;
+}
+
+long defragStream(redisDb *db, dictEntry *kde) {
+    long defragged = 0;
+    robj *ob = dictGetVal(kde);
+    serverAssert(ob->type == OBJ_STREAM && ob->encoding == OBJ_ENCODING_STREAM);
+    stream *s = ob->ptr, *news;
+
+    /* handle the main struct */
+    if ((news = activeDefragAlloc(s)))
+        defragged++, ob->ptr = s = news;
+
+    if (raxSize(s->rax) > server.active_defrag_max_scan_fields) {
+        rax *newrax = activeDefragAlloc(s->rax);
+        if (newrax)
+            defragged++, s->rax = newrax;
+        defragLater(db, kde);
+    } else
+        defragged += defragRadixTree(&s->rax, 1, NULL, NULL);
+
+    if (s->cgroups)
+        defragged += defragRadixTree(&s->cgroups, 1, defragStreamConsumerGroup, NULL);
+    return defragged;
+}
+
 /* for each key we scan in the main dict, this function will attempt to defrag
  * all the various pointers it has. Returns a stat of how many pointers were
  * moved. */
@@ -660,6 +825,8 @@ long defragKey(redisDb *db, dictEntry *de) {
         } else {
             serverPanic("Unknown hash encoding");
         }
+    } else if (ob->type == OBJ_STREAM) {
+        defragged += defragStream(db, de);
     } else if (ob->type == OBJ_MODULE) {
         /* Currently defragmenting modules private data types
          * is not supported. */
@@ -680,7 +847,7 @@ void defragScanCallback(void *privdata, const dictEntry *de) {
     server.stat_active_defrag_scanned++;
 }
 
-/* Defrag scan callback for for each hash table bicket,
+/* Defrag scan callback for each hash table bicket,
  * used in order to defrag the dictEntry allocations. */
 void defragDictBucketCallback(void *privdata, dictEntry **bucketref) {
     UNUSED(privdata); /* NOTE: this function is also used by both activeDefragCycle and scanLaterHash, etc. don't use privdata */
@@ -728,27 +895,29 @@ long defragOtherGlobals() {
     return defragged;
 }
 
-unsigned long defragLaterItem(dictEntry *de, unsigned long cursor) {
-    long defragged = 0;
+/* returns 0 more work may or may not be needed (see non-zero cursor),
+ * and 1 if time is up and more work is needed. */
+int defragLaterItem(dictEntry *de, unsigned long *cursor, long long endtime) {
     if (de) {
         robj *ob = dictGetVal(de);
         if (ob->type == OBJ_LIST) {
-            defragged += scanLaterList(ob);
-            cursor = 0; /* list has no scan, we must finish it in one go */
+            server.stat_active_defrag_hits += scanLaterList(ob);
+            *cursor = 0; /* list has no scan, we must finish it in one go */
         } else if (ob->type == OBJ_SET) {
-            defragged += scanLaterSet(ob, &cursor);
+            server.stat_active_defrag_hits += scanLaterSet(ob, cursor);
         } else if (ob->type == OBJ_ZSET) {
-            defragged += scanLaterZset(ob, &cursor);
+            server.stat_active_defrag_hits += scanLaterZset(ob, cursor);
         } else if (ob->type == OBJ_HASH) {
-            defragged += scanLaterHash(ob, &cursor);
+            server.stat_active_defrag_hits += scanLaterHash(ob, cursor);
+        } else if (ob->type == OBJ_STREAM) {
+            return scanLaterStraemListpacks(ob, cursor, endtime, &server.stat_active_defrag_hits);
         } else {
-            cursor = 0; /* object type may have changed since we schedule it for later */
+            *cursor = 0; /* object type may have changed since we schedule it for later */
         }
     } else {
-        cursor = 0; /* object may have been deleted already */
+        *cursor = 0; /* object may have been deleted already */
     }
-    server.stat_active_defrag_hits += defragged;
-    return cursor;
+    return 0;
 }
 
 /* returns 0 if no more work needs to be been done, and 1 if time is up and more work is needed. */
@@ -788,17 +957,22 @@ int defragLaterStep(redisDb *db, long long endtime) {
         dictEntry *de = dictFind(db->dict, current_key);
         key_defragged = server.stat_active_defrag_hits;
         do {
-            cursor = defragLaterItem(de, cursor);
+            int quit = 0;
+            if (defragLaterItem(de, &cursor, endtime))
+                quit = 1; /* time is up, we didn't finish all the work */
+
+            /* Don't start a new BIG key in this loop, this is because the
+             * next key can be a list, and scanLaterList must be done in once cycle */
+            if (!cursor)
+                quit = 1;
 
             /* Once in 16 scan iterations, 512 pointer reallocations, or 64 fields
              * (if we have a lot of pointers in one hash bucket, or rehashing),
-             * check if we reached the time limit.
-             * But regardless, don't start a new BIG key in this loop, this is because the
-             * next key can be a list, and scanLaterList must be done in once cycle */
-            if (!cursor || (++iterations > 16 ||
+             * check if we reached the time limit. */
+            if (quit || (++iterations > 16 ||
                             server.stat_active_defrag_hits - prev_defragged > 512 ||
                             server.stat_active_defrag_scanned - prev_scanned > 64)) {
-                if (!cursor || ustime() > endtime) {
+                if (quit || ustime() > endtime) {
                     if(key_defragged != server.stat_active_defrag_hits)
                         server.stat_active_defrag_key_hits++;
                     else
diff --git a/src/rax.c b/src/rax.c
index 8764dd8c9..fff580272 100644
--- a/src/rax.c
+++ b/src/rax.c
@@ -1167,6 +1167,7 @@ void raxStart(raxIterator *it, rax *rt) {
     it->key = it->key_static_string;
     it->key_max = RAX_ITER_STATIC_LEN;
     it->data = NULL;
+    it->node_cb = NULL;
     raxStackInit(&it->stack);
 }
 
@@ -1240,6 +1241,8 @@ int raxIteratorNextStep(raxIterator *it, int noup) {
             if (!raxIteratorAddChars(it,it->node->data,
                 it->node->iscompr ? it->node->size : 1)) return 0;
             memcpy(&it->node,cp,sizeof(it->node));
+            if (it->node_cb && it->node_cb(&it->node))
+                memcpy(cp,&it->node,sizeof(it->node));
             /* For "next" step, stop every time we find a key along the
              * way, since the key is lexicograhically smaller compared to
              * what follows in the sub-children. */
@@ -1292,6 +1295,8 @@ int raxIteratorNextStep(raxIterator *it, int noup) {
                         raxIteratorAddChars(it,it->node->data+i,1);
                         if (!raxStackPush(&it->stack,it->node)) return 0;
                         memcpy(&it->node,cp,sizeof(it->node));
+                        if (it->node_cb && it->node_cb(&it->node))
+                            memcpy(cp,&it->node,sizeof(it->node));
                         if (it->node->iskey) {
                             it->data = raxGetData(it->node);
                             return 1;
@@ -1325,7 +1330,7 @@ int raxSeekGreatest(raxIterator *it) {
 
 /* Like raxIteratorNextStep() but implements an iteration step moving
  * to the lexicographically previous element. The 'noup' option has a similar
- * effect to the one of raxIteratorPrevSte(). */
+ * effect to the one of raxIteratorNextStep(). */
 int raxIteratorPrevStep(raxIterator *it, int noup) {
     if (it->flags & RAX_ITER_EOF) {
         return 1;
diff --git a/src/rax.h b/src/rax.h
index 5b4d45167..9e6bc0b51 100644
--- a/src/rax.h
+++ b/src/rax.h
@@ -119,6 +119,12 @@ typedef struct raxStack {
     int oom; /* True if pushing into this stack failed for OOM at some point. */
 } raxStack;
 
+/* Optional callback used for iterators and be notified on each rax node.
+ * This is used by active defrag, the return value is an indication that
+ * the noderef was chagned, and the tree needs to be updated.
+ * This is currently only supported in forward iterations (raxNext) */
+typedef int (*raxNodeCallback)(raxNode **noderef);
+
 /* Radix tree iterator state is encapsulated into this data structure. */
 #define RAX_ITER_STATIC_LEN 128
 #define RAX_ITER_JUST_SEEKED (1<<0) /* Iterator was just seeked. Return current
@@ -137,6 +143,7 @@ typedef struct raxIterator {
     unsigned char key_static_string[RAX_ITER_STATIC_LEN];
     raxNode *node;          /* Current node. Only for unsafe iteration. */
     raxStack stack;         /* Stack used for unsafe iteration. */
+    raxNodeCallback node_cb;
 } raxIterator;
 
 /* A special pointer returned for not found items. */
@@ -161,4 +168,7 @@ int raxEOF(raxIterator *it);
 void raxShow(rax *rax);
 uint64_t raxSize(rax *rax);
 
+/* internals */
+void raxSetData(raxNode *n, void *data);
+
 #endif
diff --git a/tests/integration/rdb.tcl b/tests/integration/rdb.tcl
index d645b2b54..f51a3c13d 100644
--- a/tests/integration/rdb.tcl
+++ b/tests/integration/rdb.tcl
@@ -48,6 +48,8 @@ start_server [list overrides [list "dir" $server_path]] {
                 r xadd stream * bar $j
             }
         }
+        r xgroup create stream mygroup $
+        r xreadgroup GROUP mygroup Alice COUNT 1 STREAMS stream >
         set digest [r debug digest]
         r debug reload
         set newdigest [r debug digest]
diff --git a/tests/unit/memefficiency.tcl b/tests/unit/memefficiency.tcl
index 1796d695c..ed37a68ed 100644
--- a/tests/unit/memefficiency.tcl
+++ b/tests/unit/memefficiency.tcl
@@ -97,10 +97,15 @@ start_server {tags {"defrag"}} {
             r config set active-defrag-ignore-bytes 2mb
             r config set maxmemory 0
             r config set list-max-ziplist-size 5 ;# list of 10k items will have 2000 quicklist nodes
+            r config set stream-node-max-entries 5
             r hmset hash h1 v1 h2 v2 h3 v3
             r lpush list a b c d
             r zadd zset 0 a 1 b 2 c 3 d
             r sadd set a b c d
+            r xadd stream * item 1 value a
+            r xadd stream * item 2 value b
+            r xgroup create stream mygroup $
+            r xreadgroup GROUP mygroup Alice COUNT 1 STREAMS stream >
 
             # create big keys with 10k items
             set rd [redis_deferring_client]
@@ -109,8 +114,9 @@ start_server {tags {"defrag"}} {
                 $rd lpush biglist [concat "asdfasdfasdf" $j]
                 $rd zadd bigzset $j [concat "asdfasdfasdf" $j]
                 $rd sadd bigset [concat "asdfasdfasdf" $j]
+                $rd xadd bigstream * item 1 value a
             }
-            for {set j 0} {$j < 40000} {incr j} {
+            for {set j 0} {$j < 50000} {incr j} {
                 $rd read ; # Discard replies
             }
 
@@ -134,7 +140,7 @@ start_server {tags {"defrag"}} {
             for {set j 0} {$j < 500000} {incr j} {
                 $rd read ; # Discard replies
             }
-            assert {[r dbsize] == 500008}
+            assert {[r dbsize] == 500010}
 
             # create some fragmentation
             for {set j 0} {$j < 500000} {incr j 2} {
@@ -143,7 +149,7 @@ start_server {tags {"defrag"}} {
             for {set j 0} {$j < 500000} {incr j 2} {
                 $rd read ; # Discard replies
             }
-            assert {[r dbsize] == 250008}
+            assert {[r dbsize] == 250010}
 
             # start defrag
             after 120 ;# serverCron only updates the info once in 100ms
@@ -155,6 +161,7 @@ start_server {tags {"defrag"}} {
             r config set latency-monitor-threshold 5
             r latency reset
 
+            set digest [r debug digest]
             catch {r config set activedefrag yes} e
             if {![string match {DISABLED*} $e]} {
                 # wait for the active defrag to start working (decision once a second)
@@ -193,9 +200,11 @@ start_server {tags {"defrag"}} {
                 # due to high fragmentation, 10hz, and active-defrag-cycle-max set to 75,
                 # we expect max latency to be not much higher than 75ms
                 assert {$max_latency <= 80}
-            } else {
-                set _ ""
             }
-        } {}
+            # verify the data isn't corrupted or changed
+            set newdigest [r debug digest]
+            assert {$digest eq $newdigest}
+            r save ;# saving an rdb iterates over all the data / pointers
+        } {OK}
     }
 }

From ed65d734e73ac431686c2b14d58dfc21c0b954d6 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 27 Jun 2018 13:11:50 +0200
Subject: [PATCH 121/219] CLIENT ID implemented.

---
 src/networking.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/networking.c b/src/networking.c
index 02e77307e..cfe23c6cc 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1553,6 +1553,7 @@ void clientCommand(client *c) {
 
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
+"id      -- Return the ID of the current connection.",
 "getname -- Return the name of the current connection.",
 "kill <ip:port> -- Kill connection made from <ip:port>.",
 "kill <option> <value> [option value ...] -- Kill connections. Options are:",
@@ -1566,6 +1567,9 @@ void clientCommand(client *c) {
 NULL
         };
         addReplyHelp(c, help);
+    } else if (!strcasecmp(c->argv[1]->ptr,"id") && c->argc == 2) {
+        /* CLIENT ID */
+        addReplyLongLong(c,c->id);
     } else if (!strcasecmp(c->argv[1]->ptr,"list") && c->argc == 2) {
         /* CLIENT LIST */
         sds o = getAllClientsInfoString();

From fb39bfd7af088a5ec01aec06c9488b5893eb1ceb Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 27 Jun 2018 13:26:01 +0200
Subject: [PATCH 122/219] Take clients in a ID -> Client handle dictionary.

---
 src/networking.c | 4 ++++
 src/server.c     | 1 +
 src/server.h     | 1 +
 3 files changed, 6 insertions(+)

diff --git a/src/networking.c b/src/networking.c
index cfe23c6cc..cbbad5419 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -75,6 +75,8 @@ void linkClient(client *c) {
      * this way removing the client in unlinkClient() will not require
      * a linear scan, but just a constant time operation. */
     c->client_list_node = listLast(server.clients);
+    uint64_t id = htonu64(c->id);
+    raxInsert(server.clients_index,(unsigned char*)&id,sizeof(id),c,NULL);
 }
 
 client *createClient(int fd) {
@@ -720,6 +722,8 @@ void unlinkClient(client *c) {
     if (c->fd != -1) {
         /* Remove from the list of active clients. */
         if (c->client_list_node) {
+            uint64_t id = htonu64(c->id);
+            raxRemove(server.clients_index,(unsigned char*)&id,sizeof(id),NULL);
             listDelNode(server.clients,c->client_list_node);
             c->client_list_node = NULL;
         }
diff --git a/src/server.c b/src/server.c
index 3ac1278aa..5f779d8da 100644
--- a/src/server.c
+++ b/src/server.c
@@ -1890,6 +1890,7 @@ void initServer(void) {
     server.pid = getpid();
     server.current_client = NULL;
     server.clients = listCreate();
+    server.clients_index = raxNew();
     server.clients_to_close = listCreate();
     server.slaves = listCreate();
     server.monitors = listCreate();
diff --git a/src/server.h b/src/server.h
index a130d5b1d..feccc7aab 100644
--- a/src/server.h
+++ b/src/server.h
@@ -952,6 +952,7 @@ struct redisServer {
     list *clients_pending_write; /* There is to write or install handler. */
     list *slaves, *monitors;    /* List of slaves and MONITORs */
     client *current_client; /* Current client, only used on crash report */
+    rax *clients_index;         /* Active clients dictionary by client ID. */
     int clients_paused;         /* True if clients are currently paused */
     mstime_t clients_pause_end_time; /* Time when we undo clients_paused */
     char neterr[ANET_ERR_LEN];   /* Error buffer for anet.c */

From 71295ee305345fba9a73766b6fc084b2c15bc303 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 27 Jun 2018 13:52:46 +0200
Subject: [PATCH 123/219] CLIENT UNBLOCK implemented.

---
 src/networking.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/networking.c b/src/networking.c
index cbbad5419..fe8a78ec5 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -868,6 +868,15 @@ void freeClientsInAsyncFreeQueue(void) {
     }
 }
 
+/* Return a client by ID, or NULL if the client ID is not in the set
+ * of registered clients. Note that "fake clients", created with -1 as FD,
+ * are not registered clients. */
+client *lookupClientByID(uint64_t id) {
+    id = htonu64(id);
+    client *c = raxFind(server.clients_index,(unsigned char*)&id,sizeof(id));
+    return (c == raxNotFound) ? NULL : c;
+}
+
 /* Write data in output buffers to client. Return C_OK if the client
  * is still valid after the call, C_ERR if it was freed. */
 int writeToClient(int fd, client *c, int handler_installed) {
@@ -1679,6 +1688,19 @@ NULL
         /* If this client has to be closed, flag it as CLOSE_AFTER_REPLY
          * only after we queued the reply to its output buffers. */
         if (close_this_client) c->flags |= CLIENT_CLOSE_AFTER_REPLY;
+    } else if (!strcasecmp(c->argv[1]->ptr,"unblock") && c->argc == 3) {
+        /* CLIENT UNBLOCK <id> */
+        long long id;
+        if (getLongLongFromObjectOrReply(c,c->argv[2],&id,NULL)
+            != C_OK) return;
+        struct client *target = lookupClientByID(id);
+        if (target && target->flags & CLIENT_BLOCKED) {
+            replyToBlockedClientTimedOut(target);
+            unblockClient(target);
+            addReply(c,shared.cone);
+        } else {
+            addReply(c,shared.czero);
+        }
     } else if (!strcasecmp(c->argv[1]->ptr,"setname") && c->argc == 3) {
         int j, len = sdslen(c->argv[2]->ptr);
         char *p = c->argv[2]->ptr;

From de495ee7abc2d21b1d55e706c71bbe027408ef61 Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Wed, 27 Jun 2018 15:32:18 +0300
Subject: [PATCH 124/219] minor fix in creating a stream NACK for rdb and
 defrag tests

---
 tests/integration/rdb.tcl    | 2 +-
 tests/unit/memefficiency.tcl | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/integration/rdb.tcl b/tests/integration/rdb.tcl
index f51a3c13d..58a098edc 100644
--- a/tests/integration/rdb.tcl
+++ b/tests/integration/rdb.tcl
@@ -48,7 +48,7 @@ start_server [list overrides [list "dir" $server_path]] {
                 r xadd stream * bar $j
             }
         }
-        r xgroup create stream mygroup $
+        r xgroup create stream mygroup 0
         r xreadgroup GROUP mygroup Alice COUNT 1 STREAMS stream >
         set digest [r debug digest]
         r debug reload
diff --git a/tests/unit/memefficiency.tcl b/tests/unit/memefficiency.tcl
index ed37a68ed..c8e95de13 100644
--- a/tests/unit/memefficiency.tcl
+++ b/tests/unit/memefficiency.tcl
@@ -104,7 +104,7 @@ start_server {tags {"defrag"}} {
             r sadd set a b c d
             r xadd stream * item 1 value a
             r xadd stream * item 2 value b
-            r xgroup create stream mygroup $
+            r xgroup create stream mygroup 0
             r xreadgroup GROUP mygroup Alice COUNT 1 STREAMS stream >
 
             # create big keys with 10k items

From 6d0acb330a00a5c373ab17c36c5a20ae3b72e063 Mon Sep 17 00:00:00 2001
From: Mustafa Paltun <mpaltun@gmail.com>
Date: Wed, 27 Jun 2018 16:33:31 +0300
Subject: [PATCH 125/219] Update help.h

---
 src/help.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/help.h b/src/help.h
index 005afd941..c89f1f44b 100644
--- a/src/help.h
+++ b/src/help.h
@@ -975,7 +975,7 @@ struct commandHelp {
     "5.0.0" },
     { "XPENDING",
     "key group [start end count] [consumer]",
-    "Return information and entries from a stream conusmer group pending entries list, that are messages fetched but never acknowledged.",
+    "Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.",
     14,
     "5.0.0" },
     { "XRANGE",

From 010dc172d40fe5785b380c4a6ebea9d11fa39532 Mon Sep 17 00:00:00 2001
From: Mustafa Paltun <mpaltun@gmail.com>
Date: Wed, 27 Jun 2018 16:35:30 +0300
Subject: [PATCH 126/219] Update t_stream.c

---
 src/t_stream.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 6d8fd92ce..16913f37e 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -945,7 +945,7 @@ size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end
 /* This is an helper function for streamReplyWithRange() when called with
  * group and consumer arguments, but with a range that is referring to already
  * delivered messages. In this case we just emit messages that are already
- * in the history of the conusmer, fetching the IDs from its PEL.
+ * in the history of the consumer, fetching the IDs from its PEL.
  *
  * Note that this function does not have a 'rev' argument because it's not
  * possible to iterate in reverse using a group. Basically this function
@@ -1571,7 +1571,7 @@ void xgroupCommand(client *c) {
 "CREATE      <key> <groupname> <id or $>  -- Create a new consumer group.",
 "SETID       <key> <groupname> <id or $>  -- Set the current group ID.",
 "DESTROY     <key> <groupname>            -- Remove the specified group.",
-"DELCONSUMER <key> <groupname> <consumer> -- Remove the specified conusmer.",
+"DELCONSUMER <key> <groupname> <consumer> -- Remove the specified consumer.",
 "HELP                                     -- Prints this help.",
 NULL
     };

From 2214043b5c84c69279077343846657c17c0214ac Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 27 Jun 2018 18:51:06 +0200
Subject: [PATCH 127/219] CLIENT UNBLOCK: support unblocking by error.

---
 src/networking.c | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/networking.c b/src/networking.c
index fe8a78ec5..cacb214f1 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1688,14 +1688,33 @@ NULL
         /* If this client has to be closed, flag it as CLOSE_AFTER_REPLY
          * only after we queued the reply to its output buffers. */
         if (close_this_client) c->flags |= CLIENT_CLOSE_AFTER_REPLY;
-    } else if (!strcasecmp(c->argv[1]->ptr,"unblock") && c->argc == 3) {
-        /* CLIENT UNBLOCK <id> */
+    } else if (!strcasecmp(c->argv[1]->ptr,"unblock") && (c->argc == 3 ||
+                                                          c->argc == 4))
+    {
+        /* CLIENT UNBLOCK <id> [timeout|error] */
         long long id;
+        int unblock_error = 0;
+
+        if (c->argc == 4) {
+            if (!strcasecmp(c->argv[3]->ptr,"timeout")) {
+                unblock_error = 0;
+            } else if (!strcasecmp(c->argv[3]->ptr,"error")) {
+                unblock_error = 1;
+            } else {
+                addReplyError(c,
+                    "CLIENT UNBLOCK reason should be TIMEOUT or ERROR");
+                return;
+            }
+        }
         if (getLongLongFromObjectOrReply(c,c->argv[2],&id,NULL)
             != C_OK) return;
         struct client *target = lookupClientByID(id);
         if (target && target->flags & CLIENT_BLOCKED) {
-            replyToBlockedClientTimedOut(target);
+            if (unblock_error)
+                addReplyError(target,
+                    "-UNBLOCKED client unblocked via CLIENT UNBLOCK");
+            else
+                replyToBlockedClientTimedOut(target);
             unblockClient(target);
             addReply(c,shared.cone);
         } else {

From 3c27db1cd9a452c52b9b4384dc887bca2d34f2e3 Mon Sep 17 00:00:00 2001
From: shenlongxing <shenlongxing2012@gmail.com>
Date: Thu, 28 Jun 2018 01:08:55 +0800
Subject: [PATCH 128/219] fix empty string for sentinel rename-command

---
 src/sentinel.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/sentinel.c b/src/sentinel.c
index 512b224e6..f7fcfe823 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3482,6 +3482,11 @@ void sentinelSetCommand(client *c) {
             sds oldname = c->argv[++j]->ptr;
             sds newname = c->argv[++j]->ptr;
 
+            if ((sdslen(oldname) == 0) || (sdslen(newname) == 0)) {
+                badarg = sdslen(newname) ? j-1 : j;
+                goto badfmt;
+            }
+
             /* Remove any older renaming for this command. */
             dictDelete(ri->renamed_commands,oldname);
 

From 4a70ff74510a0f594232fd13682e358f851e1990 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 28 Jun 2018 00:17:10 +0200
Subject: [PATCH 129/219] Add unblock in CLIENT HELP.

---
 src/networking.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/networking.c b/src/networking.c
index cacb214f1..82a72692e 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1577,6 +1577,7 @@ void clientCommand(client *c) {
 "pause <timeout> -- Suspend all Redis clients for <timout> milliseconds.",
 "reply (on|off|skip) -- Control the replies sent to the current connection.",
 "setname <name> -- Assign the name <name> to the current connection.",
+"unblock -- Unblock the specified blocked client by pause or error.",
 NULL
         };
         addReplyHelp(c, help);

From ab55f9da5eb10aabd78304941903e8657aa210e6 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 28 Jun 2018 00:21:32 +0200
Subject: [PATCH 130/219] Make CLIENT HELP output nicer to the eyes.

---
 src/networking.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/networking.c b/src/networking.c
index 82a72692e..da14709cc 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1566,18 +1566,18 @@ void clientCommand(client *c) {
 
     if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
         const char *help[] = {
-"id      -- Return the ID of the current connection.",
-"getname -- Return the name of the current connection.",
-"kill <ip:port> -- Kill connection made from <ip:port>.",
+"id                     -- Return the ID of the current connection.",
+"getname                -- Return the name of the current connection.",
+"kill <ip:port>         -- Kill connection made from <ip:port>.",
 "kill <option> <value> [option value ...] -- Kill connections. Options are:",
-"     addr <ip:port> -- Kill connection made from <ip:port>.",
-"     type (normal|master|slave|pubsub) -- Kill connections by type.",
-"     skipme (yes|no) -- Skip killing current connection (default: yes).",
-"list -- Return information about client connections.",
-"pause <timeout> -- Suspend all Redis clients for <timout> milliseconds.",
-"reply (on|off|skip) -- Control the replies sent to the current connection.",
-"setname <name> -- Assign the name <name> to the current connection.",
-"unblock -- Unblock the specified blocked client by pause or error.",
+"     addr <ip:port>                      -- Kill connection made from <ip:port>",
+"     type (normal|master|slave|pubsub)   -- Kill connections by type.",
+"     skipme (yes|no)   -- Skip killing current connection (default: yes).",
+"list                   -- Return information about client connections.",
+"pause <timeout>        -- Suspend all Redis clients for <timout> milliseconds.",
+"reply (on|off|skip)    -- Control the replies sent to the current connection.",
+"setname <name>         -- Assign the name <name> to the current connection.",
+"unblock                -- Unblock the specified blocked client.",
 NULL
         };
         addReplyHelp(c, help);

From 007e3cbd7072ab4a0ae5cc0d3df00c7f9427ba99 Mon Sep 17 00:00:00 2001
From: Akshay Nagpal <akshaynagpal@users.noreply.github.com>
Date: Wed, 27 Jun 2018 20:08:39 -0400
Subject: [PATCH 131/219] Added link to Google Group

---
 CONTRIBUTING | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTING b/CONTRIBUTING
index f57de3fd9..5b0f02953 100644
--- a/CONTRIBUTING
+++ b/CONTRIBUTING
@@ -8,7 +8,9 @@ each source file that you contribute.
 # IMPORTANT: HOW TO USE REDIS GITHUB ISSUES
 
 * Github issues SHOULD ONLY BE USED to report bugs, and for DETAILED feature
-  requests. Everything else belongs to the Redis Google Group.
+  requests. Everything else belongs to the Redis Google Group:
+      
+      https://groups.google.com/forum/m/#!forum/Redis-db
 
   PLEASE DO NOT POST GENERAL QUESTIONS that are not about bugs or suspected
   bugs in the Github issues system. We'll be very happy to help you and provide

From 1fcf2737a63cfa0fba4ebc0802fff8e237855ddf Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Thu, 28 Jun 2018 17:22:59 +0800
Subject: [PATCH 132/219] fix some compile warnings

---
 src/db.c       | 2 +-
 src/sentinel.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/db.c b/src/db.c
index 95019cee7..151e948c9 100644
--- a/src/db.c
+++ b/src/db.c
@@ -1400,7 +1400,7 @@ int *georadiusGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numk
 /* XREAD [BLOCK <milliseconds>] [COUNT <count>] [GROUP <groupname> <ttl>]
  *       STREAMS key_1 key_2 ... key_N ID_1 ID_2 ... ID_N */
 int *xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys) {
-    int i, num, *keys;
+    int i, num = 0, *keys;
     UNUSED(cmd);
 
     /* We need to parse the options of the command in order to seek the first
diff --git a/src/sentinel.c b/src/sentinel.c
index 512b224e6..c820169af 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -3525,7 +3525,7 @@ void sentinelSetCommand(client *c) {
 badfmt: /* Bad format errors */
     if (changes) sentinelFlushConfig();
     addReplyErrorFormat(c,"Invalid argument '%s' for SENTINEL SET '%s'",
-        c->argv[badarg]->ptr,option);
+        (char*)c->argv[badarg]->ptr,option);
 }
 
 /* Our fake PUBLISH command: it is actually useful only to receive hello messages

From f5538642cc410dd7b14e0eec5c4217c0a501138f Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Thu, 28 Jun 2018 17:28:38 +0800
Subject: [PATCH 133/219] clients: show pubsub flag in client list

---
 src/networking.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/networking.c b/src/networking.c
index da14709cc..fd9e2d608 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1506,6 +1506,7 @@ sds catClientInfoString(sds s, client *client) {
             *p++ = 'S';
     }
     if (client->flags & CLIENT_MASTER) *p++ = 'M';
+    if (client->flags & CLIENT_PUBSUB) *p++ = 'P';
     if (client->flags & CLIENT_MULTI) *p++ = 'x';
     if (client->flags & CLIENT_BLOCKED) *p++ = 'b';
     if (client->flags & CLIENT_DIRTY_CAS) *p++ = 'd';

From b9cbd04b573c9f3e3092d45bb2f3181441307e79 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Thu, 28 Jun 2018 17:43:05 +0800
Subject: [PATCH 134/219] clients: add type option for client list

---
 src/debug.c      |  2 +-
 src/networking.c | 20 +++++++++++++++++---
 src/redis-cli.c  |  2 +-
 src/server.h     |  2 +-
 4 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/debug.c b/src/debug.c
index a54591bd4..b8d0690e2 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -1077,7 +1077,7 @@ void sigsegvHandler(int sig, siginfo_t *info, void *secret) {
     infostring = genRedisInfoString("all");
     serverLogRaw(LL_WARNING|LL_RAW, infostring);
     serverLogRaw(LL_WARNING|LL_RAW, "\n------ CLIENT LIST OUTPUT ------\n");
-    clients = getAllClientsInfoString();
+    clients = getAllClientsInfoString(-1);
     serverLogRaw(LL_WARNING|LL_RAW, clients);
     sdsfree(infostring);
     sdsfree(clients);
diff --git a/src/networking.c b/src/networking.c
index fd9e2d608..4248a52f1 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1545,7 +1545,7 @@ sds catClientInfoString(sds s, client *client) {
         client->lastcmd ? client->lastcmd->name : "NULL");
 }
 
-sds getAllClientsInfoString(void) {
+sds getAllClientsInfoString(int type) {
     listNode *ln;
     listIter li;
     client *client;
@@ -1554,6 +1554,7 @@ sds getAllClientsInfoString(void) {
     listRewind(server.clients,&li);
     while ((ln = listNext(&li)) != NULL) {
         client = listNodeValue(ln);
+        if (type != -1 && getClientType(client) != type) continue;
         o = catClientInfoString(o,client);
         o = sdscatlen(o,"\n",1);
     }
@@ -1575,6 +1576,7 @@ void clientCommand(client *c) {
 "     type (normal|master|slave|pubsub)   -- Kill connections by type.",
 "     skipme (yes|no)   -- Skip killing current connection (default: yes).",
 "list                   -- Return information about client connections.",
+"     type (normal|master|slave|pubsub)   -- Return information about client connections by type.",
 "pause <timeout>        -- Suspend all Redis clients for <timout> milliseconds.",
 "reply (on|off|skip)    -- Control the replies sent to the current connection.",
 "setname <name>         -- Assign the name <name> to the current connection.",
@@ -1585,9 +1587,21 @@ NULL
     } else if (!strcasecmp(c->argv[1]->ptr,"id") && c->argc == 2) {
         /* CLIENT ID */
         addReplyLongLong(c,c->id);
-    } else if (!strcasecmp(c->argv[1]->ptr,"list") && c->argc == 2) {
+    } else if (!strcasecmp(c->argv[1]->ptr,"list")) {
         /* CLIENT LIST */
-        sds o = getAllClientsInfoString();
+        int type = -1;
+        if (c->argc == 4 && !strcasecmp(c->argv[2]->ptr,"type")) {
+            type = getClientTypeByName(c->argv[3]->ptr);
+            if (type == -1) {
+                addReplyErrorFormat(c,"Unknown client type '%s'",
+                    (char*) c->argv[3]->ptr);
+                return;
+             }
+        } else if (c->argc != 2) {
+            addReply(c,shared.syntaxerr);
+            return;
+        }
+        sds o = getAllClientsInfoString(type);
         addReplyBulkCBuffer(c,o,sdslen(o));
         sdsfree(o);
     } else if (!strcasecmp(c->argv[1]->ptr,"reply") && c->argc == 3) {
diff --git a/src/redis-cli.c b/src/redis-cli.c
index b1ece6250..6b51560ad 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -1088,7 +1088,7 @@ static int cliSendCommand(int argc, char **argv, long repeat) {
         (argc == 2 && !strcasecmp(command,"cluster") &&
                       (!strcasecmp(argv[1],"nodes") ||
                        !strcasecmp(argv[1],"info"))) ||
-        (argc == 2 && !strcasecmp(command,"client") &&
+        (argc >= 2 && !strcasecmp(command,"client") &&
                        !strcasecmp(argv[1],"list")) ||
         (argc == 3 && !strcasecmp(command,"latency") &&
                        !strcasecmp(argv[1],"graph")) ||
diff --git a/src/server.h b/src/server.h
index feccc7aab..7de9934a4 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1421,7 +1421,7 @@ void getClientsMaxBuffers(unsigned long *longest_output_list,
                           unsigned long *biggest_input_buffer);
 char *getClientPeerId(client *client);
 sds catClientInfoString(sds s, client *client);
-sds getAllClientsInfoString(void);
+sds getAllClientsInfoString(int type);
 void rewriteClientCommandVector(client *c, int argc, ...);
 void rewriteClientCommandArgument(client *c, int i, robj *newval);
 void replaceClientCommandVector(client *c, int argc, robj **argv);

From 0b74fd6766b29c2a132828477f4e0f12af85efad Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Thu, 28 Jun 2018 18:17:04 +0800
Subject: [PATCH 135/219] Add --no-auth-warning help message.

---
 src/redis-cli.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index b1ece6250..51080d08d 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -1463,6 +1463,8 @@ static void usage(void) {
 "  --cluster <command> [args...] [opts...]\n"
 "                     Cluster Manager command and arguments (see below).\n"
 "  --verbose          Verbose mode.\n"
+"  --no-auth-warning  Don't show warning message when using password on command\n"
+"                     line interface.\n"
 "  --help             Output this help and exit.\n"
 "  --version          Output version and exit.\n"
 "\n"

From 5baf50d850e1c58967fe3d2601ea61ee0d7b4ecd Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 28 Jun 2018 12:19:04 +0200
Subject: [PATCH 136/219] Rax library updated (node callback).

---
 src/rax.c |  4 ++++
 src/rax.h | 20 +++++++++++++++-----
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/rax.c b/src/rax.c
index fff580272..c2aa95c3d 100644
--- a/src/rax.c
+++ b/src/rax.c
@@ -1241,6 +1241,8 @@ int raxIteratorNextStep(raxIterator *it, int noup) {
             if (!raxIteratorAddChars(it,it->node->data,
                 it->node->iscompr ? it->node->size : 1)) return 0;
             memcpy(&it->node,cp,sizeof(it->node));
+            /* Call the node callback if any, and replace the node pointer
+             * if the callback returns true. */
             if (it->node_cb && it->node_cb(&it->node))
                 memcpy(cp,&it->node,sizeof(it->node));
             /* For "next" step, stop every time we find a key along the
@@ -1295,6 +1297,8 @@ int raxIteratorNextStep(raxIterator *it, int noup) {
                         raxIteratorAddChars(it,it->node->data+i,1);
                         if (!raxStackPush(&it->stack,it->node)) return 0;
                         memcpy(&it->node,cp,sizeof(it->node));
+                        /* Call the node callback if any, and replace the node
+                         * pointer if the callback returns true. */
                         if (it->node_cb && it->node_cb(&it->node))
                             memcpy(cp,&it->node,sizeof(it->node));
                         if (it->node->iskey) {
diff --git a/src/rax.h b/src/rax.h
index 9e6bc0b51..226cd9b70 100644
--- a/src/rax.h
+++ b/src/rax.h
@@ -119,9 +119,18 @@ typedef struct raxStack {
     int oom; /* True if pushing into this stack failed for OOM at some point. */
 } raxStack;
 
-/* Optional callback used for iterators and be notified on each rax node.
- * This is used by active defrag, the return value is an indication that
- * the noderef was chagned, and the tree needs to be updated.
+/* Optional callback used for iterators and be notified on each rax node,
+ * including nodes not representing keys. If the callback returns true
+ * the callback changed the node pointer in the iterator structure, and the
+ * iterator implementation will have to replace the pointer in the radix tree
+ * internals. This allows the callback to reallocate the node to perform
+ * very special operations, normally not needed by normal applications.
+ *
+ * This callback is used to perform very low level analysis of the radix tree
+ * structure, scanning each possible node (but the root node), or in order to
+ * reallocate the nodes to reduce the allocation fragmentation (this is the
+ * Redis application for this callback).
+ *
  * This is currently only supported in forward iterations (raxNext) */
 typedef int (*raxNodeCallback)(raxNode **noderef);
 
@@ -143,7 +152,7 @@ typedef struct raxIterator {
     unsigned char key_static_string[RAX_ITER_STATIC_LEN];
     raxNode *node;          /* Current node. Only for unsafe iteration. */
     raxStack stack;         /* Stack used for unsafe iteration. */
-    raxNodeCallback node_cb;
+    raxNodeCallback node_cb; /* Optional node callback. Normally set to NULL. */
 } raxIterator;
 
 /* A special pointer returned for not found items. */
@@ -168,7 +177,8 @@ int raxEOF(raxIterator *it);
 void raxShow(rax *rax);
 uint64_t raxSize(rax *rax);
 
-/* internals */
+/* Internal API. May be used by the node callback in order to access rax nodes
+ * in a low level way, so this function is exported as well. */
 void raxSetData(raxNode *n, void *data);
 
 #endif

From bde05e9c327bf80debcbbfc047f247f1944c4ff6 Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Thu, 28 Jun 2018 18:22:06 +0800
Subject: [PATCH 137/219] Avoid -Woverlength-strings compile warning.

Using another fprintf call to output the rest help message.
---
 src/redis-cli.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 51080d08d..3b992f40b 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -1467,7 +1467,10 @@ static void usage(void) {
 "                     line interface.\n"
 "  --help             Output this help and exit.\n"
 "  --version          Output version and exit.\n"
-"\n"
+"\n",
+    version, REDIS_CLI_DEFAULT_PIPE_TIMEOUT);
+    /* Using another fprintf call to avoid -Woverlength-strings compile warning */
+    fprintf(stderr,
 "Cluster Manager Commands:\n"
 "  Use --cluster help to list all available cluster manager commands.\n"
 "\n"
@@ -1484,8 +1487,7 @@ static void usage(void) {
 "When no command is given, redis-cli starts in interactive mode.\n"
 "Type \"help\" in interactive mode for information on available commands\n"
 "and settings.\n"
-"\n",
-        version, REDIS_CLI_DEFAULT_PIPE_TIMEOUT);
+"\n");
     sdsfree(version);
     exit(1);
 }

From 7becf54e51ee226bf9cb3a4d5a297d0381f4b571 Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Thu, 28 Jun 2018 18:38:24 +0800
Subject: [PATCH 138/219] Don't output password warning message when
 --no-auth-warning is used.

---
 src/redis-cli.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 3b992f40b..cf03161fb 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -220,6 +220,7 @@ static struct config {
     int last_cmd_type;
     int verbose;
     clusterManagerCommand cluster_manager_command;
+    int no_auth_warning;
 } config;
 
 /* User preferences. */
@@ -1235,8 +1236,9 @@ static int parseOptions(int argc, char **argv) {
             config.interval = seconds*1000000;
         } else if (!strcmp(argv[i],"-n") && !lastarg) {
             config.dbnum = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--no-auth-warning")) {
+            config.no_auth_warning = 1;
         } else if (!strcmp(argv[i],"-a") && !lastarg) {
-            fputs("Warning: Using a password with '-a' option on the command line interface may not be safe.\n", stderr);
             config.auth = argv[++i];
         } else if (!strcmp(argv[i],"-u") && !lastarg) {
             parseRedisUri(argv[++i]);
@@ -1387,6 +1389,12 @@ static int parseOptions(int argc, char **argv) {
         fprintf(stderr,"Try %s --help for more information.\n", argv[0]);
         exit(1);
     }
+
+    if (!config.no_auth_warning) {
+        fputs("Warning: Using a password with '-a' or '-u' option on the command"
+              " line interface may not be safe.\n", stderr);
+    }
+
     return i;
 }
 
@@ -6555,6 +6563,7 @@ int main(int argc, char **argv) {
     config.enable_ldb_on_eval = 0;
     config.last_cmd_type = -1;
     config.verbose = 0;
+    config.no_auth_warning = 0;
     config.cluster_manager_command.name = NULL;
     config.cluster_manager_command.argc = 0;
     config.cluster_manager_command.argv = NULL;

From bbd0ca952292979f54b5479d9397d1510f8bb84c Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Thu, 28 Jun 2018 18:39:42 +0800
Subject: [PATCH 139/219] Fix code format issue.

---
 src/redis-cli.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index cf03161fb..7926ab81f 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -4867,7 +4867,7 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
     }
     /* Calculate the slots balance for each node. It's the number of
      * slots the node should lose (if positive) or gain (if negative)
-     * in order to be balanced. */	
+     * in order to be balanced. */  
     int threshold_reached = 0, total_balance = 0;
     float threshold = config.cluster_manager_command.threshold;
     i = 0;
@@ -4879,9 +4879,9 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
                         n->weight);
         n->balance = n->slots_count - expected;
         total_balance += n->balance;
-	/* Compute the percentage of difference between the
-	 * expected number of slots and the real one, to see
-	 * if it's over the threshold specified by the user. */
+        /* Compute the percentage of difference between the
+         * expected number of slots and the real one, to see
+         * if it's over the threshold specified by the user. */
         int over_threshold = 0;
         if (threshold > 0) {
             if (n->slots_count > 0) {

From 1139070a0ffd4fcf79a1420241746b9c626625ce Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Thu, 28 Jun 2018 18:47:28 +0800
Subject: [PATCH 140/219] Fix trailing white space.

---
 src/redis-cli.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 7926ab81f..b6acfefc9 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -4867,7 +4867,7 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
     }
     /* Calculate the slots balance for each node. It's the number of
      * slots the node should lose (if positive) or gain (if negative)
-     * in order to be balanced. */  
+     * in order to be balanced. */
     int threshold_reached = 0, total_balance = 0;
     float threshold = config.cluster_manager_command.threshold;
     i = 0;

From 9f1856268c9dfb8ef56f1778aa4ef99f9d504bff Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Thu, 28 Jun 2018 19:09:22 +0800
Subject: [PATCH 141/219] Check if password is used on command line interface.

---
 src/redis-cli.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index b6acfefc9..3e44d2c7c 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -1390,7 +1390,7 @@ static int parseOptions(int argc, char **argv) {
         exit(1);
     }
 
-    if (!config.no_auth_warning) {
+    if (!config.no_auth_warning && config.auth != NULL) {
         fputs("Warning: Using a password with '-a' or '-u' option on the command"
               " line interface may not be safe.\n", stderr);
     }

From d751d98b508fd86c5e38919167e3564f80d4958e Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 29 Jun 2018 18:02:58 +0200
Subject: [PATCH 142/219] Change CLIENT LIST TYPE help string.

Making it more similar to KILL.
---
 src/networking.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/networking.c b/src/networking.c
index 4248a52f1..b9f17cd73 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1575,8 +1575,8 @@ void clientCommand(client *c) {
 "     addr <ip:port>                      -- Kill connection made from <ip:port>",
 "     type (normal|master|slave|pubsub)   -- Kill connections by type.",
 "     skipme (yes|no)   -- Skip killing current connection (default: yes).",
-"list                   -- Return information about client connections.",
-"     type (normal|master|slave|pubsub)   -- Return information about client connections by type.",
+"list [options ...]     -- Return information about client connections. Options:",
+"     type (normal|master|slave|pubsub)   -- Return clients of specified type.",
 "pause <timeout>        -- Suspend all Redis clients for <timout> milliseconds.",
 "reply (on|off|skip)    -- Control the replies sent to the current connection.",
 "setname <name>         -- Assign the name <name> to the current connection.",

From aeb7bc3ec6ef9721fee36c1e275fd73f7a984391 Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Sat, 30 Jun 2018 09:29:35 +0800
Subject: [PATCH 143/219] cluster.tcl: Add master consecutively down test.

---
 tests/cluster/tests/05-slave-selection.tcl | 77 ++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/tests/cluster/tests/05-slave-selection.tcl b/tests/cluster/tests/05-slave-selection.tcl
index 6efedce5d..bcb0fa1ea 100644
--- a/tests/cluster/tests/05-slave-selection.tcl
+++ b/tests/cluster/tests/05-slave-selection.tcl
@@ -92,3 +92,80 @@ test "Node #10 should eventually replicate node #5" {
         fail "#10 didn't became slave of #5"
     }
 }
+
+source "../tests/includes/init-tests.tcl"
+
+# Create a cluster with 3 master and 15 slaves, so that we have 5
+# slaves for eatch master.
+test "Create a 3 nodes cluster" {
+    create_cluster 3 15
+}
+
+test "Cluster is up" {
+    assert_cluster_state ok
+}
+
+test "The first master has actually 5 slaves" {
+    assert {[llength [lindex [R 0 role] 2]] == 5}
+}
+
+test {Slaves of #0 are instance #3, #6, #9, #12 and #15 as expected} {
+    set port0 [get_instance_attrib redis 0 port]
+    assert {[lindex [R 3 role] 2] == $port0}
+    assert {[lindex [R 6 role] 2] == $port0}
+    assert {[lindex [R 9 role] 2] == $port0}
+    assert {[lindex [R 12 role] 2] == $port0}
+    assert {[lindex [R 15 role] 2] == $port0}
+}
+
+test {Instance #3, #6, #9, #12 and #15 synced with the master} {
+    wait_for_condition 1000 50 {
+        [RI 3 master_link_status] eq {up} &&
+        [RI 6 master_link_status] eq {up} &&
+        [RI 9 master_link_status] eq {up} &&
+        [RI 12 master_link_status] eq {up} &&
+        [RI 15 master_link_status] eq {up}
+    } else {
+        fail "Instance #3 or #6 or #9 or #12 or #15 master link status is not up"
+    }
+}
+
+proc master_detected {instances} {
+    foreach instance [dict keys $instances] {
+        if {[RI $instance role] eq {master}} {
+            return true
+        }
+    }
+
+    return false
+}
+
+test "New Master down consecutively" {
+    set instances [dict create 0 1 3 1 6 1 9 1 12 1 15 1]
+
+    set loops [expr {[dict size $instances]-1}]
+    for {set i 0} {$i < $loops} {incr i} {
+        set master_id -1
+        foreach instance [dict keys $instances] {
+            if {[RI $instance role] eq {master}} {
+                set master_id $instance
+                break;
+            }
+        }
+
+        if {$master_id eq -1} {
+            fail "no master detected, #loop $i"
+        }
+
+        set instances [dict remove $instances $master_id]
+
+        kill_instance redis $master_id
+        wait_for_condition 1000 50 {
+            [master_detected $instances]
+        } else {
+            failover "No failover detected when master $master_id fails"
+        }
+
+        assert_cluster_state ok
+    }
+}

From 2e167f7d0e9abb5c49f8f0fb22a3fe2340ad0e31 Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Sat, 30 Jun 2018 09:39:08 +0800
Subject: [PATCH 144/219] fix server.repl_down_since resetting, so that slaves
 could failover automatically as expected.

---
 src/replication.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/replication.c b/src/replication.c
index 00c2a7199..d5b5dc23c 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -1087,6 +1087,7 @@ void replicationCreateMasterClient(int fd, int dbid) {
     if (server.master->reploff == -1)
         server.master->flags |= CLIENT_PRE_PSYNC;
     if (dbid != -1) selectDb(server.master,dbid);
+    server.repl_down_since = 0;
 }
 
 void restartAOF() {
@@ -1950,7 +1951,6 @@ void replicationSetMaster(char *ip, int port) {
      * our own parameters, to later PSYNC with the new master. */
     if (was_master) replicationCacheMasterUsingMyself();
     server.repl_state = REPL_STATE_CONNECT;
-    server.repl_down_since = 0;
 }
 
 /* Cancel replication, setting the instance as a master itself. */

From 7de1ada070da9f929d5c5cfab7f07a5de07305e7 Mon Sep 17 00:00:00 2001
From: chendianqiang <chendianqiang@chendianqiangdeMacBook-Pro.local>
Date: Sun, 1 Jul 2018 14:43:53 +0800
Subject: [PATCH 145/219] limit the size of pending-querybuf in masterclient

---
 src/server.c                   | 11 +++++++++++
 src/server.h                   |  1 +
 tests/test_helper.tcl          |  1 +
 tests/unit/pendingquerybuf.tcl | 35 ++++++++++++++++++++++++++++++++++
 4 files changed, 48 insertions(+)
 create mode 100644 tests/unit/pendingquerybuf.tcl

diff --git a/src/server.c b/src/server.c
index 647aee24b..224054d2d 100644
--- a/src/server.c
+++ b/src/server.c
@@ -858,6 +858,17 @@ int clientsCronResizeQueryBuffer(client *c) {
     /* Reset the peak again to capture the peak memory usage in the next
      * cycle. */
     c->querybuf_peak = 0;
+
+    if (c->flags & CLIENT_MASTER) {
+        /* There are two conditions to resize the pending query buffer:
+         * 1) Pending Query buffer is > LIMIT_PENDING_QUERYBUF.
+         * 2) used length is smaller than pending_querybuf_size/2 */
+        size_t pending_querybuf_size = sdsAllocSize(c->pending_querybuf);
+        if(pending_querybuf_size > LIMIT_PENDING_QUERYBUF &&
+                sdslen(c->pending_querybuf) < (pending_querybuf_size>>1)){
+            c->pending_querybuf = sdsRemoveFreeSpace(c->pending_querybuf);
+        }
+    }
     return 0;
 }
 
diff --git a/src/server.h b/src/server.h
index d9c512c5e..b0492963e 100644
--- a/src/server.h
+++ b/src/server.h
@@ -184,6 +184,7 @@ typedef long long mstime_t; /* millisecond time type. */
 #define PROTO_MBULK_BIG_ARG     (1024*32)
 #define LONG_STR_SIZE      21          /* Bytes needed for long -> str + '\0' */
 #define AOF_AUTOSYNC_BYTES (1024*1024*32) /* fdatasync every 32MB */
+#define LIMIT_PENDING_QUERYBUF (4*1024*1024) /* 4mb */
 
 /* When configuring the server eventloop, we setup it so that the total number
  * of file descriptors we can handle are server.maxclients + RESERVED_FDS +
diff --git a/tests/test_helper.tcl b/tests/test_helper.tcl
index 8b4d1eacf..3e2443577 100644
--- a/tests/test_helper.tcl
+++ b/tests/test_helper.tcl
@@ -61,6 +61,7 @@ set ::all_tests {
     unit/hyperloglog
     unit/lazyfree
     unit/wait
+    unit/pendingquerybuf
 }
 # Index to the next test to run in the ::all_tests list.
 set ::next_test 0
diff --git a/tests/unit/pendingquerybuf.tcl b/tests/unit/pendingquerybuf.tcl
new file mode 100644
index 000000000..caa940d8e
--- /dev/null
+++ b/tests/unit/pendingquerybuf.tcl
@@ -0,0 +1,35 @@
+proc info_memory {r property} {
+    if {[regexp "\r\n$property:(.*?)\r\n" [{*}$r info memory] _ value]} {
+        set _ $value
+    }
+}
+
+proc prepare_value {size} {
+    set _v "c" 
+    for {set i 1} {$i < $size} {incr i} {
+        append _v 0   
+    }
+    return $_v
+}
+
+start_server {tags {"wait"}} {
+start_server {} {
+    set slave [srv 0 client]
+    set slave_host [srv 0 host]
+    set slave_port [srv 0 port]
+    set master [srv -1 client]
+    set master_host [srv -1 host]
+    set master_port [srv -1 port]
+
+    test "pending querybuf: check size of pending_querybuf after set a big value" {
+        $slave slaveof $master_host $master_port
+        set _v [prepare_value [expr 32*1024*1024]]
+        $master set key $_v 
+        after 2000
+        set m_usedmemory [info_memory $master used_memory]
+        set s_usedmemory [info_memory $slave used_memory]
+        if { $s_usedmemory > $m_usedmemory + 10*1024*1024 } {
+            fail "the used_memory of slave is too larger than master.Master:$m_usedmemory Slave:$s_usedmemory"
+        }
+    }  
+}}

From 2833cfbe395d7211d5ad54445556f9e2c0d7ff0c Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Mon, 2 Jul 2018 19:24:14 +0800
Subject: [PATCH 146/219] fix tests/test_helper.tcl with --wait-server option.
 Issue #5063 added --wait-server option, but can not work.

---
 tests/test_helper.tcl | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/test_helper.tcl b/tests/test_helper.tcl
index 8c6a3b814..a025b994a 100644
--- a/tests/test_helper.tcl
+++ b/tests/test_helper.tcl
@@ -475,7 +475,6 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
         set ::dont_clean 1
     } elseif {$opt eq {--wait-server}} {
         set ::wait_server 1
-        incr j
     } elseif {$opt eq {--timeout}} {
         set ::timeout $arg
         incr j

From 2edcafb35d3cc2dcc516ba68bb173f7765424eea Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 2 Jul 2018 18:49:34 +0200
Subject: [PATCH 147/219] addReplySubSyntaxError() renamed to
 addReplySubcommandSyntaxError().

---
 src/cluster.c    | 2 +-
 src/config.c     | 2 +-
 src/debug.c      | 2 +-
 src/module.c     | 2 +-
 src/networking.c | 4 ++--
 src/object.c     | 2 +-
 src/pubsub.c     | 2 +-
 src/scripting.c  | 2 +-
 src/server.c     | 2 +-
 src/server.h     | 2 +-
 src/slowlog.c    | 2 +-
 src/t_stream.c   | 4 ++--
 12 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index f218690b9..0ee63a6cd 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -4746,7 +4746,7 @@ NULL
         clusterReset(hard);
         addReply(c,shared.ok);
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
         return;
     }
 }
diff --git a/src/config.c b/src/config.c
index 2f76c9479..aedef4888 100644
--- a/src/config.c
+++ b/src/config.c
@@ -2168,7 +2168,7 @@ NULL
             addReply(c,shared.ok);
         }
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
         return;
     }
 }
diff --git a/src/debug.c b/src/debug.c
index 37f95143f..32be3c59c 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -582,7 +582,7 @@ NULL
         clearReplicationId2();
         addReply(c,shared.ok);
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
         return;
     }
 }
diff --git a/src/module.c b/src/module.c
index 0cf92cef8..fc88e6a28 100644
--- a/src/module.c
+++ b/src/module.c
@@ -4559,7 +4559,7 @@ NULL
         }
         dictReleaseIterator(di);
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
         return;
     }
 }
diff --git a/src/networking.c b/src/networking.c
index 03214fd99..8aec27280 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -565,13 +565,13 @@ void addReplyHelp(client *c, const char **help) {
 /* Add a suggestive error reply.
  * This function is typically invoked by from commands that support
  * subcommands in response to an unknown subcommand or argument error. */
-void addReplySubSyntaxError(client *c) {
+void addReplySubcommandSyntaxError(client *c) {
     sds cmd = sdsnew((char*) c->argv[0]->ptr);
     sdstoupper(cmd);
     addReplyErrorFormat(c,
         "Unknown subcommand or wrong number of arguments for '%s'. Try %s HELP.",
         c->argv[1]->ptr,cmd);
-    sdsfree(cmd);    
+    sdsfree(cmd);
 }
 
 /* Copy 'src' client output buffers into 'dst' client output buffers.
diff --git a/src/object.c b/src/object.c
index a6ba558cf..e927ea027 100644
--- a/src/object.c
+++ b/src/object.c
@@ -1254,7 +1254,7 @@ NULL
          * when the key is read or overwritten. */
         addReplyLongLong(c,LFUDecrAndReturn(o));
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
     }
 }
 
diff --git a/src/pubsub.c b/src/pubsub.c
index 86a7f1c50..859eb46a3 100644
--- a/src/pubsub.c
+++ b/src/pubsub.c
@@ -372,6 +372,6 @@ NULL
         /* PUBSUB NUMPAT */
         addReplyLongLong(c,listLength(server.pubsub_patterns));
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
     }
 }
diff --git a/src/scripting.c b/src/scripting.c
index f65540d89..857859e70 100644
--- a/src/scripting.c
+++ b/src/scripting.c
@@ -1514,7 +1514,7 @@ NULL
             return;
         }
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
     }
 }
 
diff --git a/src/server.c b/src/server.c
index 5c9f30bc9..5dab35e36 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2876,7 +2876,7 @@ NULL
             getKeysFreeResult(keys);
         }
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
     }
 }
 
diff --git a/src/server.h b/src/server.h
index fa1f7823e..cd1d72aba 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1413,7 +1413,7 @@ void addReplyHumanLongDouble(client *c, long double d);
 void addReplyLongLong(client *c, long long ll);
 void addReplyMultiBulkLen(client *c, long length);
 void addReplyHelp(client *c, const char **help);
-void addReplySubSyntaxError(client *c);
+void addReplySubcommandSyntaxError(client *c);
 void copyClientOutputBuffer(client *dst, client *src);
 size_t sdsZmallocSize(sds s);
 size_t getStringObjectSdsUsedMemory(robj *o);
diff --git a/src/slowlog.c b/src/slowlog.c
index 27f18e138..8e183fca4 100644
--- a/src/slowlog.c
+++ b/src/slowlog.c
@@ -187,6 +187,6 @@ NULL
         }
         setDeferredMultiBulkLength(c,totentries,sent);
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
     }
 }
diff --git a/src/t_stream.c b/src/t_stream.c
index 76bef22a8..a5c2b8737 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1650,7 +1650,7 @@ NULL
     } else if (!strcasecmp(opt,"HELP")) {
         addReplyHelp(c, help);
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
     }
 }
 
@@ -2277,7 +2277,7 @@ NULL
                                      STREAM_RWR_RAWENTRIES,NULL);
         if (!count) addReply(c,shared.nullbulk);
     } else {
-        addReplySubSyntaxError(c);
+        addReplySubcommandSyntaxError(c);
     }
 }
 

From 677d10b2a8ff7f13033ccfe56ffcd246dbe70fb6 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 3 Jul 2018 12:42:14 +0200
Subject: [PATCH 148/219] Set repl_down_since to zero on state change.

PR #5081 fixes an "interesting" bug about Redis Cluster failover but in
general about the updating of repl_down_since, that is used in order to
count the time a slave was left disconnected from its master.

While the fix provided resolves the specific issue, in general the
validity of repl_down_since is limited to states that are different
than the state CONNECTED, and the disconnected time is set when the
state is DISCONNECTED. However from CONNECTED to other states, the state
machine must always go to DISCONNECTED first. So it makes sense to set
the field to zero (since it is meaningless in that context) when the
state is set to CONNECTED.
---
 src/replication.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/replication.c b/src/replication.c
index d5b5dc23c..487aa75f1 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -1087,7 +1087,6 @@ void replicationCreateMasterClient(int fd, int dbid) {
     if (server.master->reploff == -1)
         server.master->flags |= CLIENT_PRE_PSYNC;
     if (dbid != -1) selectDb(server.master,dbid);
-    server.repl_down_since = 0;
 }
 
 void restartAOF() {
@@ -1280,6 +1279,7 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
         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;
         /* After a full resynchroniziation we use the replication ID and
          * offset of the master. The secondary ID / offset are cleared since
          * we are starting a new history. */
@@ -2217,6 +2217,7 @@ void replicationResurrectCachedMaster(int newfd) {
     server.master->authenticated = 1;
     server.master->lastinteraction = server.unixtime;
     server.repl_state = REPL_STATE_CONNECTED;
+    server.repl_down_since = 0;
 
     /* Re-add to the list of clients. */
     linkClient(server.master);

From 549b8b99733e49d2464666a22da8b56b1d9a3b52 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 3 Jul 2018 13:23:29 +0200
Subject: [PATCH 149/219] Improve style of PR #5084.

---
 src/server.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/server.c b/src/server.c
index 7e3533e3a..b7d1e5e82 100644
--- a/src/server.c
+++ b/src/server.c
@@ -860,13 +860,19 @@ int clientsCronResizeQueryBuffer(client *c) {
      * cycle. */
     c->querybuf_peak = 0;
 
+    /* Clients representing masters also use a "pending query buffer" that
+     * is the yet not applied part of the stream we are reading. Such buffer
+     * also needs resizing from time to time, otherwise after a very large
+     * transfer (a huge value or a big MIGRATE operation) it will keep using
+     * a lot of memory. */
     if (c->flags & CLIENT_MASTER) {
         /* There are two conditions to resize the pending query buffer:
          * 1) Pending Query buffer is > LIMIT_PENDING_QUERYBUF.
-         * 2) used length is smaller than pending_querybuf_size/2 */
+         * 2) Used length is smaller than pending_querybuf_size/2 */
         size_t pending_querybuf_size = sdsAllocSize(c->pending_querybuf);
         if(pending_querybuf_size > LIMIT_PENDING_QUERYBUF &&
-                sdslen(c->pending_querybuf) < (pending_querybuf_size>>1)){
+           sdslen(c->pending_querybuf) < (pending_querybuf_size/2))
+        {
             c->pending_querybuf = sdsRemoveFreeSpace(c->pending_querybuf);
         }
     }

From 94b3ee61420f8638d9cdba32877864deef91d5e9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 3 Jul 2018 13:25:41 +0200
Subject: [PATCH 150/219] Clarify the pending_querybuf field of clients.

---
 src/server.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/server.h b/src/server.h
index 063651bd6..c60cadfc1 100644
--- a/src/server.h
+++ b/src/server.h
@@ -700,9 +700,10 @@ typedef struct client {
     redisDb *db;            /* Pointer to currently SELECTed DB. */
     robj *name;             /* As set by CLIENT SETNAME. */
     sds querybuf;           /* Buffer we use to accumulate client queries. */
-    sds pending_querybuf;   /* If this is a master, this buffer represents the
-                               yet not applied replication stream that we
-                               are receiving from the master. */
+    sds pending_querybuf;   /* If this client is flagged as master, this buffer
+                               represents the yet not applied portion of the
+                               replication stream that we are receiving from
+                               the master. */
     size_t querybuf_peak;   /* Recent (100ms or more) peak of querybuf size. */
     int argc;               /* Num of arguments of current command. */
     robj **argv;            /* Arguments of current command. */

From 93238575f77630f24e0472bdbf7eecb73a4652a8 Mon Sep 17 00:00:00 2001
From: Jack Drogon <jack.xsuperman@gmail.com>
Date: Sun, 1 Jul 2018 13:24:50 +0800
Subject: [PATCH 151/219] Fix typo

---
 deps/README.md                          |  6 +++---
 redis.conf                              |  2 +-
 src/aof.c                               |  6 +++---
 src/atomicvar.h                         |  2 +-
 src/bitops.c                            |  8 ++++----
 src/cluster.c                           | 10 +++++-----
 src/cluster.h                           |  2 +-
 src/db.c                                |  6 +++---
 src/dict.c                              |  2 +-
 src/endianconv.h                        |  2 +-
 src/geo.c                               |  2 +-
 src/hyperloglog.c                       |  6 +++---
 src/latency.c                           |  2 +-
 src/lazyfree.c                          |  4 ++--
 src/listpack.c                          |  6 +++---
 src/module.c                            |  6 +++---
 src/modules/gendoc.rb                   |  2 +-
 src/quicklist.c                         |  4 ++--
 src/rax.c                               |  4 ++--
 src/rax.h                               |  2 +-
 src/rdb.c                               |  6 +++---
 src/redis-cli.c                         | 22 +++++++++++-----------
 src/redis-trib.rb                       | 12 ++++++------
 src/redisassert.h                       |  2 +-
 src/replication.c                       | 12 ++++++------
 src/sds.c                               |  2 +-
 src/sentinel.c                          | 12 ++++++------
 src/server.c                            |  4 ++--
 src/server.h                            |  4 ++--
 src/sort.c                              |  6 +++---
 src/t_stream.c                          | 12 ++++++------
 src/t_zset.c                            |  2 +-
 src/util.c                              |  2 +-
 src/ziplist.c                           |  4 ++--
 src/zmalloc.c                           |  2 +-
 tests/integration/replication-psync.tcl |  2 +-
 tests/unit/dump.tcl                     |  2 +-
 tests/unit/scripting.tcl                |  2 +-
 tests/unit/type/zset.tcl                |  2 +-
 utils/hashtable/README                  |  2 +-
 40 files changed, 99 insertions(+), 99 deletions(-)

diff --git a/deps/README.md b/deps/README.md
index 6b1f019dd..367ee1627 100644
--- a/deps/README.md
+++ b/deps/README.md
@@ -22,7 +22,7 @@ just following tose steps:
 
 1. Remove the jemalloc directory.
 2. Substitute it with the new jemalloc source tree.
-3. Edit the Makefile localted in the same directoy as the README you are
+3. Edit the Makefile localted in the same directory as the README you are
    reading, and change the --with-version in the Jemalloc configure script
    options with the version you are using. This is required because otherwise
    Jemalloc configuration script is broken and will not work nested in another
@@ -50,7 +50,7 @@ This is never upgraded since it's part of the Redis project. If there are change
 Hiredis
 ---
 
-Hiredis uses the SDS string library, that must be the same version used inside Redis itself. Hiredis is also very critical for Sentinel. Historically Redis often used forked versions of hiredis in a way or the other. In order to upgrade it is adviced to take a lot of care:
+Hiredis uses the SDS string library, that must be the same version used inside Redis itself. Hiredis is also very critical for Sentinel. Historically Redis often used forked versions of hiredis in a way or the other. In order to upgrade it is advised to take a lot of care:
 
 1. Check with diff if hiredis API changed and what impact it could have in Redis.
 2. Make sure thet the SDS library inside Hiredis and inside Redis are compatible.
@@ -83,6 +83,6 @@ and our version:
 
 1. Makefile is modified to allow a different compiler than GCC.
 2. We have the implementation source code, and directly link to the following external libraries: `lua_cjson.o`, `lua_struct.o`, `lua_cmsgpack.o` and `lua_bit.o`.
-3. There is a security fix in `ldo.c`, line 498: The check for `LUA_SIGNATURE[0]` is removed in order toa void direct bytecode exectuion.
+3. There is a security fix in `ldo.c`, line 498: The check for `LUA_SIGNATURE[0]` is removed in order toa void direct bytecode execution.
 
 
diff --git a/redis.conf b/redis.conf
index 7c550a532..42d24f26e 100644
--- a/redis.conf
+++ b/redis.conf
@@ -639,7 +639,7 @@ slave-priority 100
 #    it with the specified string.
 # 4) During replication, when a slave performs a full resynchronization with
 #    its master, the content of the whole database is removed in order to
-#    load the RDB file just transfered.
+#    load the RDB file just transferred.
 #
 # In all the above cases the default is to delete objects in a blocking way,
 # like if DEL was called. However you can configure each case specifically
diff --git a/src/aof.c b/src/aof.c
index 594c3f666..2d5f259fb 100644
--- a/src/aof.c
+++ b/src/aof.c
@@ -261,7 +261,7 @@ int startAppendOnly(void) {
         serverLog(LL_WARNING,"AOF was enabled but there is already a child process saving an RDB file on disk. An AOF background was scheduled to start when possible.");
     } else {
         /* If there is a pending AOF rewrite, we need to switch it off and
-         * start a new one: the old one cannot be reused becuase it is not
+         * start a new one: the old one cannot be reused because it is not
          * accumulating the AOF buffer. */
         if (server.aof_child_pid != -1) {
             serverLog(LL_WARNING,"AOF was enabled but there is already an AOF rewriting in background. Stopping background AOF and starting a rewrite now.");
@@ -683,7 +683,7 @@ int loadAppendOnlyFile(char *filename) {
         exit(1);
     }
 
-    /* Handle a zero-length AOF file as a special case. An emtpy AOF file
+    /* Handle a zero-length AOF file as a special case. An empty AOF file
      * is a valid AOF because an empty server with AOF enabled will create
      * a zero length file at startup, that will remain like that if no write
      * operation is received. */
@@ -1713,7 +1713,7 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
             "Background AOF rewrite signal handler took %lldus", ustime()-now);
     } else if (!bysignal && exitcode != 0) {
         /* SIGUSR1 is whitelisted, so we have a way to kill a child without
-         * tirggering an error conditon. */
+         * tirggering an error condition. */
         if (bysignal != SIGUSR1)
             server.aof_lastbgrewrite_status = C_ERR;
         serverLog(LL_WARNING,
diff --git a/src/atomicvar.h b/src/atomicvar.h
index 84a5bbc5c..173b045fc 100644
--- a/src/atomicvar.h
+++ b/src/atomicvar.h
@@ -16,7 +16,7 @@
  *  pthread_mutex_t myvar_mutex;
  *  atomicSet(myvar,12345);
  *
- * If atomic primitives are availble (tested in config.h) the mutex
+ * If atomic primitives are available (tested in config.h) the mutex
  * is not used.
  *
  * Never use return value from the macros, instead use the AtomicGetIncr()
diff --git a/src/bitops.c b/src/bitops.c
index 43450fca3..23f2266a7 100644
--- a/src/bitops.c
+++ b/src/bitops.c
@@ -918,7 +918,7 @@ void bitfieldCommand(client *c) {
     struct bitfieldOp *ops = NULL; /* Array of ops to execute at end. */
     int owtype = BFOVERFLOW_WRAP; /* Overflow type. */
     int readonly = 1;
-    size_t higest_write_offset = 0;
+    size_t highest_write_offset = 0;
 
     for (j = 2; j < c->argc; j++) {
         int remargs = c->argc-j-1; /* Remaining args other than current. */
@@ -968,8 +968,8 @@ void bitfieldCommand(client *c) {
 
         if (opcode != BITFIELDOP_GET) {
             readonly = 0;
-            if (higest_write_offset < bitoffset + bits - 1)
-                higest_write_offset = bitoffset + bits - 1;
+            if (highest_write_offset < bitoffset + bits - 1)
+                highest_write_offset = bitoffset + bits - 1;
             /* INCRBY and SET require another argument. */
             if (getLongLongFromObjectOrReply(c,c->argv[j+3],&i64,NULL) != C_OK){
                 zfree(ops);
@@ -999,7 +999,7 @@ void bitfieldCommand(client *c) {
         /* Lookup by making room up to the farest bit reached by
          * this operation. */
         if ((o = lookupStringForBitCommand(c,
-            higest_write_offset)) == NULL) return;
+            highest_write_offset)) == NULL) return;
     }
 
     addReplyMultiBulkLen(c,numops);
diff --git a/src/cluster.c b/src/cluster.c
index 0ee63a6cd..e568f68a6 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -3100,7 +3100,7 @@ void clusterHandleSlaveFailover(void) {
                 (unsigned long long) myself->configEpoch);
         }
 
-        /* Take responsability for the cluster slots. */
+        /* Take responsibility for the cluster slots. */
         clusterFailoverReplaceYourMaster();
     } else {
         clusterLogCantFailover(CLUSTER_CANT_FAILOVER_WAITING_VOTES);
@@ -3151,11 +3151,11 @@ void clusterHandleSlaveMigration(int max_slaves) {
             !nodeTimedOut(mymaster->slaves[j])) okslaves++;
     if (okslaves <= server.cluster_migration_barrier) return;
 
-    /* Step 3: Idenitfy a candidate for migration, and check if among the
+    /* Step 3: Identify a candidate for migration, and check if among the
      * masters with the greatest number of ok slaves, I'm the one with the
      * smallest node ID (the "candidate slave").
      *
-     * Note: this means that eventually a replica migration will occurr
+     * Note: this means that eventually a replica migration will occur
      * since slaves that are reachable again always have their FAIL flag
      * cleared, so eventually there must be a candidate. At the same time
      * this does not mean that there are no race conditions possible (two
@@ -3736,7 +3736,7 @@ void clusterCloseAllSlots(void) {
  * -------------------------------------------------------------------------- */
 
 /* The following are defines that are only used in the evaluation function
- * and are based on heuristics. Actaully the main point about the rejoin and
+ * and are based on heuristics. Actually the main point about the rejoin and
  * writable delay is that they should be a few orders of magnitude larger
  * than the network latency. */
 #define CLUSTER_MAX_REJOIN_DELAY 5000
@@ -5584,7 +5584,7 @@ void clusterRedirectClient(client *c, clusterNode *n, int hashslot, int error_co
     if (error_code == CLUSTER_REDIR_CROSS_SLOT) {
         addReplySds(c,sdsnew("-CROSSSLOT Keys in request don't hash to the same slot\r\n"));
     } else if (error_code == CLUSTER_REDIR_UNSTABLE) {
-        /* The request spawns mutliple keys in the same slot,
+        /* The request spawns multiple keys in the same slot,
          * but the slot is not "stable" currently as there is
          * a migration or import in progress. */
         addReplySds(c,sdsnew("-TRYAGAIN Multiple keys request during rehashing of slot\r\n"));
diff --git a/src/cluster.h b/src/cluster.h
index 4d4a4d60e..6f9954d24 100644
--- a/src/cluster.h
+++ b/src/cluster.h
@@ -243,7 +243,7 @@ union clusterMsgData {
 #define CLUSTER_PROTO_VER 1 /* Cluster bus protocol version. */
 
 typedef struct {
-    char sig[4];        /* Siganture "RCmb" (Redis Cluster message bus). */
+    char sig[4];        /* Signature "RCmb" (Redis Cluster message bus). */
     uint32_t totlen;    /* Total length of this message */
     uint16_t ver;       /* Protocol version, currently set to 1. */
     uint16_t port;      /* TCP base port number. */
diff --git a/src/db.c b/src/db.c
index 151e948c9..055af71be 100644
--- a/src/db.c
+++ b/src/db.c
@@ -113,7 +113,7 @@ robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
          * safety measure, the command invoked is a read-only command, we can
          * safely return NULL here, and provide a more consistent behavior
          * to clients accessign expired values in a read-only fashion, that
-         * will say the key as non exisitng.
+         * will say the key as non existing.
          *
          * Notably this covers GETs when slaves are used to scale reads. */
         if (server.current_client &&
@@ -318,7 +318,7 @@ robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
  * If callback is given the function is called from time to time to
  * signal that work is in progress.
  *
- * The dbnum can be -1 if all teh DBs should be flushed, or the specified
+ * The dbnum can be -1 if all the DBs should be flushed, or the specified
  * DB number if we want to flush only a single Redis database number.
  *
  * Flags are be EMPTYDB_NO_FLAGS if no special flags are specified or
@@ -1185,7 +1185,7 @@ int *getKeysUsingCommandTable(struct redisCommand *cmd,robj **argv, int argc, in
     for (j = cmd->firstkey; j <= last; j += cmd->keystep) {
         if (j >= argc) {
             /* Modules commands, and standard commands with a not fixed number
-             * of arugments (negative arity parameter) do not have dispatch
+             * of arguments (negative arity parameter) do not have dispatch
              * time arity checks, so we need to handle the case where the user
              * passed an invalid number of arguments here. In this case we
              * return no keys and expect the command implementation to report
diff --git a/src/dict.c b/src/dict.c
index c52f5bf8d..738b38c46 100644
--- a/src/dict.c
+++ b/src/dict.c
@@ -327,7 +327,7 @@ int dictReplace(dict *d, void *key, void *val)
     dictEntry *entry, *existing, auxentry;
 
     /* Try to add the element. If the key
-     * does not exists dictAdd will suceed. */
+     * does not exists dictAdd will succeed. */
     entry = dictAddRaw(d,key,&existing);
     if (entry) {
         dictSetVal(d, entry, val);
diff --git a/src/endianconv.h b/src/endianconv.h
index d0c8e5b38..475f72b08 100644
--- a/src/endianconv.h
+++ b/src/endianconv.h
@@ -43,7 +43,7 @@ uint16_t intrev16(uint16_t v);
 uint32_t intrev32(uint32_t v);
 uint64_t intrev64(uint64_t v);
 
-/* variants of the function doing the actual convertion only if the target
+/* variants of the function doing the actual conversion only if the target
  * host is big endian */
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 #define memrev16ifbe(p) ((void)(0))
diff --git a/src/geo.c b/src/geo.c
index 90216e7dd..c78fadfcf 100644
--- a/src/geo.c
+++ b/src/geo.c
@@ -145,7 +145,7 @@ double extractUnitOrReply(client *c, robj *unit) {
 /* Input Argument Helper.
  * Extract the dinstance from the specified two arguments starting at 'argv'
  * that shouldbe in the form: <number> <unit> and return the dinstance in the
- * specified unit on success. *conversino is populated with the coefficient
+ * specified unit on success. *conversions is populated with the coefficient
  * to use in order to convert meters to the unit.
  *
  * On error a value less than zero is returned. */
diff --git a/src/hyperloglog.c b/src/hyperloglog.c
index 01a409bb5..ba3a3ab60 100644
--- a/src/hyperloglog.c
+++ b/src/hyperloglog.c
@@ -673,7 +673,7 @@ int hllSparseSet(robj *o, long index, uint8_t count) {
     end = p + sdslen(o->ptr) - HLL_HDR_SIZE;
 
     first = 0;
-    prev = NULL; /* Points to previos opcode at the end of the loop. */
+    prev = NULL; /* Points to previous opcode at the end of the loop. */
     next = NULL; /* Points to the next opcode at the end of the loop. */
     span = 0;
     while(p < end) {
@@ -764,7 +764,7 @@ int hllSparseSet(robj *o, long index, uint8_t count) {
      * and is either currently represented by a VAL opcode with len > 1,
      * by a ZERO opcode with len > 1, or by an XZERO opcode.
      *
-     * In those cases the original opcode must be split into muliple
+     * In those cases the original opcode must be split into multiple
      * opcodes. The worst case is an XZERO split in the middle resuling into
      * XZERO - VAL - XZERO, so the resulting sequence max length is
      * 5 bytes.
@@ -887,7 +887,7 @@ promote: /* Promote to dense representation. */
      *
      * Note that this in turn means that PFADD will make sure the command
      * is propagated to slaves / AOF, so if there is a sparse -> dense
-     * convertion, it will be performed in all the slaves as well. */
+     * conversion, it will be performed in all the slaves as well. */
     int dense_retval = hllDenseSet(hdr->registers,index,count);
     serverAssert(dense_retval == 1);
     return dense_retval;
diff --git a/src/latency.c b/src/latency.c
index 292720aa0..87e926078 100644
--- a/src/latency.c
+++ b/src/latency.c
@@ -152,7 +152,7 @@ int latencyResetEvent(char *event_to_reset) {
 
 /* ------------------------ Latency reporting (doctor) ---------------------- */
 
-/* Analyze the samples avaialble for a given event and return a structure
+/* Analyze the samples available for a given event and return a structure
  * populate with different metrics, average, MAD, min, max, and so forth.
  * Check latency.h definition of struct latenctStat for more info.
  * If the specified event has no elements the structure is populate with
diff --git a/src/lazyfree.c b/src/lazyfree.c
index f1de0c898..ac8a6bee9 100644
--- a/src/lazyfree.c
+++ b/src/lazyfree.c
@@ -23,10 +23,10 @@ size_t lazyfreeGetPendingObjectsCount(void) {
  * the function just returns the number of elements the object is composed of.
  *
  * Objects composed of single allocations are always reported as having a
- * single item even if they are actaully logical composed of multiple
+ * single item even if they are actually logical composed of multiple
  * elements.
  *
- * For lists the funciton returns the number of elements in the quicklist
+ * For lists the function returns the number of elements in the quicklist
  * representing the list. */
 size_t lazyfreeGetFreeEffort(robj *obj) {
     if (obj->type == OBJ_LIST) {
diff --git a/src/listpack.c b/src/listpack.c
index 30ea34690..c3070db6d 100644
--- a/src/listpack.c
+++ b/src/listpack.c
@@ -291,7 +291,7 @@ int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, ui
 /* Store a reverse-encoded variable length field, representing the length
  * of the previous element of size 'l', in the target buffer 'buf'.
  * The function returns the number of bytes used to encode it, from
- * 1 to 5. If 'buf' is NULL the funciton just returns the number of bytes
+ * 1 to 5. If 'buf' is NULL the function just returns the number of bytes
  * needed in order to encode the backlen. */
 unsigned long lpEncodeBacklen(unsigned char *buf, uint64_t l) {
     if (l <= 127) {
@@ -568,7 +568,7 @@ unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf) {
     }
 }
 
-/* Insert, delete or replace the specified element 'ele' of lenght 'len' at
+/* Insert, delete or replace the specified element 'ele' of length 'len' at
  * the specified position 'p', with 'p' being a listpack element pointer
  * obtained with lpFirst(), lpLast(), lpIndex(), lpNext(), lpPrev() or
  * lpSeek().
@@ -710,7 +710,7 @@ unsigned char *lpInsert(unsigned char *lp, unsigned char *ele, uint32_t size, un
     return lp;
 }
 
-/* Append the specified element 'ele' of lenght 'len' at the end of the
+/* Append the specified element 'ele' of length 'len' at the end of the
  * listpack. It is implemented in terms of lpInsert(), so the return value is
  * the same as lpInsert(). */
 unsigned char *lpAppend(unsigned char *lp, unsigned char *ele, uint32_t size) {
diff --git a/src/module.c b/src/module.c
index fc88e6a28..a46b86a50 100644
--- a/src/module.c
+++ b/src/module.c
@@ -3830,7 +3830,7 @@ void moduleReleaseGIL(void) {
  *
  * Notification callback gets executed with a redis context that can not be
  * used to send anything to the client, and has the db number where the event
- * occured as its selected db number.
+ * occurred as its selected db number.
  *
  * Notice that it is not necessary to enable norifications in redis.conf for
  * module notifications to work.
@@ -3887,7 +3887,7 @@ void moduleNotifyKeyspaceEvent(int type, const char *event, robj *key, int dbid)
     }
 }
 
-/* Unsubscribe any notification subscirbers this module has upon unloading */
+/* Unsubscribe any notification subscribers this module has upon unloading */
 void moduleUnsubscribeNotifications(RedisModule *module) {
     listIter li;
     listNode *ln;
@@ -4365,7 +4365,7 @@ void moduleInitModulesSystem(void) {
  * because the server must be fully initialized before loading modules.
  *
  * The function aborts the server on errors, since to start with missing
- * modules is not considered sane: clients may rely on the existance of
+ * modules is not considered sane: clients may rely on the existence of
  * given commands, loading AOF also may need some modules to exist, and
  * if this instance is a slave, it must understand commands from master. */
 void moduleLoadFromQueue(void) {
diff --git a/src/modules/gendoc.rb b/src/modules/gendoc.rb
index 516f5d795..ee6572884 100644
--- a/src/modules/gendoc.rb
+++ b/src/modules/gendoc.rb
@@ -1,5 +1,5 @@
 # gendoc.rb -- Converts the top-comments inside module.c to modules API
-#              reference documentaiton in markdown format.
+#              reference documentation in markdown format.
 
 # Convert the C comment to markdown
 def markdown(s)
diff --git a/src/quicklist.c b/src/quicklist.c
index faa08c65f..7b5484116 100644
--- a/src/quicklist.c
+++ b/src/quicklist.c
@@ -1636,7 +1636,7 @@ int quicklistTest(int argc, char *argv[]) {
         TEST("add to tail of empty list") {
             quicklist *ql = quicklistNew(-2, options[_i]);
             quicklistPushTail(ql, "hello", 6);
-            /* 1 for head and 1 for tail beacuse 1 node = head = tail */
+            /* 1 for head and 1 for tail because 1 node = head = tail */
             ql_verify(ql, 1, 1, 1, 1);
             quicklistRelease(ql);
         }
@@ -1644,7 +1644,7 @@ int quicklistTest(int argc, char *argv[]) {
         TEST("add to head of empty list") {
             quicklist *ql = quicklistNew(-2, options[_i]);
             quicklistPushHead(ql, "hello", 6);
-            /* 1 for head and 1 for tail beacuse 1 node = head = tail */
+            /* 1 for head and 1 for tail because 1 node = head = tail */
             ql_verify(ql, 1, 1, 1, 1);
             quicklistRelease(ql);
         }
diff --git a/src/rax.c b/src/rax.c
index c2aa95c3d..92b367550 100644
--- a/src/rax.c
+++ b/src/rax.c
@@ -467,7 +467,7 @@ int raxGenericInsert(rax *rax, unsigned char *s, size_t len, void *data, void **
     /* If the node we stopped at is a compressed node, we need to
      * split it before to continue.
      *
-     * Splitting a compressed node have a few possibile cases.
+     * Splitting a compressed node have a few possible cases.
      * Imagine that the node 'h' we are currently at is a compressed
      * node contaning the string "ANNIBALE" (it means that it represents
      * nodes A -> N -> N -> I -> B -> A -> L -> E with the only child
@@ -749,7 +749,7 @@ int raxGenericInsert(rax *rax, unsigned char *s, size_t len, void *data, void **
         cp = raxNodeLastChildPtr(trimmed);
         memcpy(cp,&postfix,sizeof(postfix));
 
-        /* Finish! We don't need to contine with the insertion
+        /* Finish! We don't need to continue with the insertion
          * algorithm for ALGO 2. The key is already inserted. */
         rax->numele++;
         rax_free(h);
diff --git a/src/rax.h b/src/rax.h
index 226cd9b70..43fceea35 100644
--- a/src/rax.h
+++ b/src/rax.h
@@ -94,7 +94,7 @@ typedef struct raxNode {
      *
      * If the node has an associated key (iskey=1) and is not NULL
      * (isnull=0), then after the raxNode pointers poiting to the
-     * childen, an additional value pointer is present (as you can see
+     * children, an additional value pointer is present (as you can see
      * in the representation above as "value-ptr" field).
      */
     unsigned char data[];
diff --git a/src/rdb.c b/src/rdb.c
index 8836b9cb3..3e43cb4e4 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -1658,7 +1658,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
             if (first == NULL) {
                 /* Serialized listpacks should never be empty, since on
                  * deletion we should remove the radix tree key if the
-                 * resulting listpack is emtpy. */
+                 * resulting listpack is empty. */
                 rdbExitReportCorruptRDB("Empty listpack inside stream");
             }
 
@@ -2099,7 +2099,7 @@ void backgroundSaveDoneHandlerDisk(int exitcode, int bysignal) {
         latencyEndMonitor(latency);
         latencyAddSampleIfNeeded("rdb-unlink-temp-file",latency);
         /* SIGUSR1 is whitelisted, so we have a way to kill a child without
-         * tirggering an error conditon. */
+         * tirggering an error condition. */
         if (bysignal != SIGUSR1)
             server.lastbgsave_status = C_ERR;
     }
@@ -2136,7 +2136,7 @@ void backgroundSaveDoneHandlerSocket(int exitcode, int bysignal) {
      * in error state.
      *
      * If the process returned an error, consider the list of slaves that
-     * can continue to be emtpy, so that it's just a special case of the
+     * can continue to be empty, so that it's just a special case of the
      * normal code path. */
     ok_slaves = zmalloc(sizeof(uint64_t)); /* Make space for the count. */
     ok_slaves[0] = 0;
diff --git a/src/redis-cli.c b/src/redis-cli.c
index d178c7e41..283b991f5 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -2423,7 +2423,7 @@ static void clusterManagerOptimizeAntiAffinity(clusterManagerNodeArray *ipnodes,
                                                            ip_count, 
                                                            NULL, NULL);
         /* If the change actually makes thing worse, revert. Otherwise
-         * leave as it is becuase the best solution may need a few
+         * leave as it is because the best solution may need a few
          * combined swaps. */
         if (new_score > score) {
             first->replicate = first_master;
@@ -3539,7 +3539,7 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
                 if (!clusterManagerCheckRedisReply(n, r, NULL)) fixed = -1;
                 if (r) freeReplyObject(r);
                 if (fixed < 0) goto cleanup;
-                /* Since CLUSTER ADDSLOTS succeded, we also update the slot 
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
                  * info into the node struct, in order to keep it synced */
                 n->slots[atoi(slot)] = 1;
                 fixed++;
@@ -3570,7 +3570,7 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
                 if (!clusterManagerCheckRedisReply(n, r, NULL)) fixed = -1;
                 if (r) freeReplyObject(r);
                 if (fixed < 0) goto cleanup;
-                /* Since CLUSTER ADDSLOTS succeded, we also update the slot 
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
                  * info into the node struct, in order to keep it synced */
                 n->slots[atoi(slot)] = 1;
                 fixed++;
@@ -3580,7 +3580,7 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
 
     /* Handle case "3": keys in multiple nodes. */
     if (listLength(multi) > 0) {
-        printf("The folowing uncovered slots have keys in multiple nodes:\n");
+        printf("The following uncovered slots have keys in multiple nodes:\n");
         clusterManagerPrintSlotsList(multi);
         if (confirmWithYes("Fix these slots by moving keys "
                            "into a single node?")) {
@@ -3612,7 +3612,7 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
                 if (!clusterManagerCheckRedisReply(target, r, NULL)) fixed = -1;
                 if (r) freeReplyObject(r);
                 if (fixed < 0) goto cleanup;
-                /* Since CLUSTER ADDSLOTS succeded, we also update the slot 
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
                  * info into the node struct, in order to keep it synced */
                 target->slots[atoi(slot)] = 1;
                 listIter nli;
@@ -3735,7 +3735,7 @@ static int clusterManagerFixOpenSlot(int slot) {
         success = clusterManagerCheckRedisReply(owner, reply, NULL);
         if (reply) freeReplyObject(reply);
         if (!success) goto cleanup;
-        /* Since CLUSTER ADDSLOTS succeded, we also update the slot 
+        /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
          * info into the node struct, in order to keep it synced */
         owner->slots[slot] = 1;
         /* Make sure this information will propagate. Not strictly needed
@@ -4945,7 +4945,7 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
                                                             src->port, 
                                                             dst->ip, 
                                                             dst->port);
-            /* Actaully move the slots. */
+            /* Actually move the slots. */
             list *lsrc = listCreate(), *table = NULL;
             listAddNodeTail(lsrc, src); 
             table = clusterManagerComputeReshardTable(lsrc, numslots);
@@ -5894,15 +5894,15 @@ static void getKeySizes(redisReply *keys, int *types,
             keys->element[i]->str);
     }
 
-    /* Retreive sizes */
+    /* Retrieve sizes */
     for(i=0;i<keys->elements;i++) {
-        /* Skip keys that dissapeared between SCAN and TYPE */
+        /* Skip keys that disappeared between SCAN and TYPE */
         if(types[i] == TYPE_NONE) {
             sizes[i] = 0;
             continue;
         }
 
-        /* Retreive size */
+        /* Retrieve size */
         if(redisGetReply(context, (void**)&reply)!=REDIS_OK) {
             fprintf(stderr, "Error getting size for key '%s' (%d: %s)\n",
                 keys->element[i]->str, context->err, context->errstr);
@@ -5972,7 +5972,7 @@ static void findBigKeys(void) {
             arrsize = keys->elements;
         }
 
-        /* Retreive types and then sizes */
+        /* Retrieve types and then sizes */
         getKeyTypes(keys, types);
         getKeySizes(keys, types, sizes);
 
diff --git a/src/redis-trib.rb b/src/redis-trib.rb
index 47b398ba6..770fa68eb 100755
--- a/src/redis-trib.rb
+++ b/src/redis-trib.rb
@@ -454,7 +454,7 @@ class RedisTrib
 
         # Handle case "1": keys in no node.
         if none.length > 0
-            xputs "The folowing uncovered slots have no keys across the cluster:"
+            xputs "The following uncovered slots have no keys across the cluster:"
             xputs none.keys.join(",")
             yes_or_die "Fix these slots by covering with a random node?"
             none.each{|slot,nodes|
@@ -466,7 +466,7 @@ class RedisTrib
 
         # Handle case "2": keys only in one node.
         if single.length > 0
-            xputs "The folowing uncovered slots have keys in just one node:"
+            xputs "The following uncovered slots have keys in just one node:"
             puts single.keys.join(",")
             yes_or_die "Fix these slots by covering with those nodes?"
             single.each{|slot,nodes|
@@ -477,7 +477,7 @@ class RedisTrib
 
         # Handle case "3": keys in multiple nodes.
         if multi.length > 0
-            xputs "The folowing uncovered slots have keys in multiple nodes:"
+            xputs "The following uncovered slots have keys in multiple nodes:"
             xputs multi.keys.join(",")
             yes_or_die "Fix these slots by moving keys into a single node?"
             multi.each{|slot,nodes|
@@ -804,7 +804,7 @@ class RedisTrib
 
             new_score,aux = get_anti_affinity_score
             # If the change actually makes thing worse, revert. Otherwise
-            # leave as it is becuase the best solution may need a few
+            # leave as it is because the best solution may need a few
             # combined swaps.
             if new_score > score
                 first.set_as_replica(first_master)
@@ -1232,7 +1232,7 @@ class RedisTrib
             if numslots > 0
                 puts "Moving #{numslots} slots from #{src} to #{dst}"
 
-                # Actaully move the slots.
+                # Actually move the slots.
                 reshard_table = compute_reshard_table([src],numslots)
                 if reshard_table.length != numslots
                     xputs "*** Assertio failed: Reshard table != number of slots"
@@ -1752,7 +1752,7 @@ private
     ]
 end
 
-# Turn a key name into the corrisponding Redis Cluster slot.
+# Turn a key name into the corresponding Redis Cluster slot.
 def key_to_slot(key)
     # Only hash what is inside {...} if there is such a pattern in the key.
     # Note that the specification requires the content that is between
diff --git a/src/redisassert.h b/src/redisassert.h
index c9b78327c..61ab35a14 100644
--- a/src/redisassert.h
+++ b/src/redisassert.h
@@ -1,4 +1,4 @@
-/* redisassert.h -- Drop in replacemnet assert.h that prints the stack trace
+/* redisassert.h -- Drop in replacements assert.h that prints the stack trace
  *                  in the Redis logs.
  *
  * This file should be included instead of "assert.h" inside libraries used by
diff --git a/src/replication.c b/src/replication.c
index 487aa75f1..0adef8aec 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -553,7 +553,7 @@ need_full_resync:
  * Side effects, other than starting a BGSAVE:
  *
  * 1) Handle the slaves in WAIT_START state, by preparing them for a full
- *    sync if the BGSAVE was succesfully started, or sending them an error
+ *    sync if the BGSAVE was successfully started, or sending them an error
  *    and dropping them from the list of slaves.
  *
  * 2) Flush the Lua scripting script cache if the BGSAVE was actually
@@ -896,7 +896,7 @@ void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
         }
     }
 
-    /* If the preamble was already transfered, send the RDB bulk data. */
+    /* If the preamble was already transferred, send the RDB bulk data. */
     lseek(slave->repldbfd,slave->repldboff,SEEK_SET);
     buflen = read(slave->repldbfd,buf,PROTO_IOBUF_LEN);
     if (buflen <= 0) {
@@ -965,7 +965,7 @@ void updateSlavesWaitingBgsave(int bgsaveerr, int type) {
                         replicationGetSlaveName(slave));
                 /* Note: we wait for a REPLCONF ACK message from slave in
                  * order to really put it online (install the write handler
-                 * so that the accumulated data can be transfered). However
+                 * so that the accumulated data can be transferred). However
                  * we change the replication state ASAP, since our slave
                  * is technically online now. */
                 slave->replstate = SLAVE_STATE_ONLINE;
@@ -1048,7 +1048,7 @@ int slaveIsInHandshakeState(void) {
 
 /* Avoid the master to detect the slave is timing out while loading the
  * RDB file in initial synchronization. We send a single newline character
- * that is valid protocol but is guaranteed to either be sent entierly or
+ * that is valid protocol but is guaranteed to either be sent entirely or
  * not, since the byte is indivisible.
  *
  * The function is called in two contexts: while we flush the current
@@ -1397,7 +1397,7 @@ char *sendSynchronousCommand(int flags, int fd, ...) {
  *
  * The function returns:
  *
- * PSYNC_CONTINUE: If the PSYNC command succeded and we can continue.
+ * PSYNC_CONTINUE: If the PSYNC command succeeded and we can continue.
  * PSYNC_FULLRESYNC: If PSYNC is supported but a full resync is needed.
  *                   In this case the master run_id and global replication
  *                   offset is saved.
@@ -2120,7 +2120,7 @@ void replicationSendAck(void) {
  * functions. */
 
 /* This function is called by freeClient() in order to cache the master
- * client structure instead of destryoing it. freeClient() will return
+ * client structure instead of destroying it. freeClient() will return
  * ASAP after this function returns, so every action needed to avoid problems
  * with a client that is really "suspended" has to be done by this function.
  *
diff --git a/src/sds.c b/src/sds.c
index 1c977e450..c4f43603d 100644
--- a/src/sds.c
+++ b/src/sds.c
@@ -283,7 +283,7 @@ sds sdsRemoveFreeSpace(sds s) {
     return s;
 }
 
-/* Return the total size of the allocation of the specifed sds string,
+/* Return the total size of the allocation of the specified sds string,
  * including:
  * 1) The sds header before the pointer.
  * 2) The string.
diff --git a/src/sentinel.c b/src/sentinel.c
index be77f0616..76e0eb750 100644
--- a/src/sentinel.c
+++ b/src/sentinel.c
@@ -514,7 +514,7 @@ void sentinelIsRunning(void) {
         if (sentinel.myid[j] != 0) break;
 
     if (j == CONFIG_RUN_ID_SIZE) {
-        /* Pick ID and presist the config. */
+        /* Pick ID and persist the config. */
         getRandomHexChars(sentinel.myid,CONFIG_RUN_ID_SIZE);
         sentinelFlushConfig();
     }
@@ -2531,7 +2531,7 @@ void sentinelReceiveHelloMessages(redisAsyncContext *c, void *reply, void *privd
 }
 
 /* Send an "Hello" message via Pub/Sub to the specified 'ri' Redis
- * instance in order to broadcast the current configuraiton for this
+ * instance in order to broadcast the current configuration for this
  * master, and to advertise the existence of this Sentinel at the same time.
  *
  * The message has the following format:
@@ -3357,7 +3357,7 @@ void sentinelInfoCommand(client *c) {
     addReplyBulkSds(c, info);
 }
 
-/* Implements Sentinel verison of the ROLE command. The output is
+/* Implements Sentinel version of the ROLE command. The output is
  * "sentinel" and the list of currently monitored master names. */
 void sentinelRoleCommand(client *c) {
     dictIterator *di;
@@ -3568,7 +3568,7 @@ void sentinelCheckSubjectivelyDown(sentinelRedisInstance *ri) {
     if (ri->link->cc &&
         (mstime() - ri->link->cc_conn_time) >
         SENTINEL_MIN_LINK_RECONNECT_PERIOD &&
-        ri->link->act_ping_time != 0 && /* Ther is a pending ping... */
+        ri->link->act_ping_time != 0 && /* There is a pending ping... */
         /* The pending ping is delayed, and we did not received
          * error replies as well. */
         (mstime() - ri->link->act_ping_time) > (ri->down_after_period/2) &&
@@ -3757,7 +3757,7 @@ void sentinelSimFailureCrash(void) {
 }
 
 /* Vote for the sentinel with 'req_runid' or return the old vote if already
- * voted for the specifed 'req_epoch' or one greater.
+ * voted for the specified 'req_epoch' or one greater.
  *
  * If a vote is not available returns NULL, otherwise return the Sentinel
  * runid and populate the leader_epoch with the epoch of the vote. */
@@ -3908,7 +3908,7 @@ int sentinelSendSlaveOf(sentinelRedisInstance *ri, char *host, int port) {
     /* In order to send SLAVEOF in a safe way, we send a transaction performing
      * the following tasks:
      * 1) Reconfigure the instance according to the specified host/port params.
-     * 2) Rewrite the configuraiton.
+     * 2) Rewrite the configuration.
      * 3) Disconnect all clients (but this one sending the commnad) in order
      *    to trigger the ask-master-on-reconnection protocol for connected
      *    clients.
diff --git a/src/server.c b/src/server.c
index b7d1e5e82..347ebcefd 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2364,7 +2364,7 @@ void call(client *c, int flags) {
         if (c->flags & CLIENT_FORCE_AOF) propagate_flags |= PROPAGATE_AOF;
 
         /* However prevent AOF / replication propagation if the command
-         * implementatino called preventCommandPropagation() or similar,
+         * implementations called preventCommandPropagation() or similar,
          * or if we don't have the call() flags to do so. */
         if (c->flags & CLIENT_PREVENT_REPL_PROP ||
             !(flags & CMD_CALL_PROPAGATE_REPL))
@@ -3920,7 +3920,7 @@ int main(int argc, char **argv) {
             configfile = argv[j];
             server.configfile = getAbsolutePath(configfile);
             /* Replace the config file in server.exec_argv with
-             * its absoulte path. */
+             * its absolute path. */
             zfree(server.exec_argv[j]);
             server.exec_argv[j] = zstrdup(server.configfile);
             j++;
diff --git a/src/server.h b/src/server.h
index c60cadfc1..fc62710c6 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1601,11 +1601,11 @@ void receiveChildInfo(void);
 #define ZADD_NONE 0
 #define ZADD_INCR (1<<0)    /* Increment the score instead of setting it. */
 #define ZADD_NX (1<<1)      /* Don't touch elements not already existing. */
-#define ZADD_XX (1<<2)      /* Only touch elements already exisitng. */
+#define ZADD_XX (1<<2)      /* Only touch elements already existing. */
 
 /* Output flags. */
 #define ZADD_NOP (1<<3)     /* Operation not performed because of conditionals.*/
-#define ZADD_NAN (1<<4)     /* Only touch elements already exisitng. */
+#define ZADD_NAN (1<<4)     /* Only touch elements already existing. */
 #define ZADD_ADDED (1<<5)   /* The element was new and was added. */
 #define ZADD_UPDATED (1<<6) /* The element already existed, score updated. */
 
diff --git a/src/sort.c b/src/sort.c
index 7feae9206..4b300d868 100644
--- a/src/sort.c
+++ b/src/sort.c
@@ -193,7 +193,7 @@ void sortCommand(client *c) {
     long limit_start = 0, limit_count = -1, start, end;
     int j, dontsort = 0, vectorlen;
     int getop = 0; /* GET operation counter */
-    int int_convertion_error = 0;
+    int int_conversion_error = 0;
     int syntax_error = 0;
     robj *sortval, *sortby = NULL, *storekey = NULL;
     redisSortObject *vector; /* Resulting vector to sort */
@@ -469,7 +469,7 @@ void sortCommand(client *c) {
                     if (eptr[0] != '\0' || errno == ERANGE ||
                         isnan(vector[j].u.score))
                     {
-                        int_convertion_error = 1;
+                        int_conversion_error = 1;
                     }
                 } else if (byval->encoding == OBJ_ENCODING_INT) {
                     /* Don't need to decode the object if it's
@@ -501,7 +501,7 @@ void sortCommand(client *c) {
     /* Send command output to the output buffer, performing the specified
      * GET/DEL/INCR/DECR operations if any. */
     outputlen = getop ? getop*(end-start+1) : end-start+1;
-    if (int_convertion_error) {
+    if (int_conversion_error) {
         addReplyError(c,"One or more scores can't be converted into double");
     } else if (storekey == NULL) {
         /* STORE option not specified, sent the sorting result to client */
diff --git a/src/t_stream.c b/src/t_stream.c
index a5c2b8737..5c03c9727 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -207,7 +207,7 @@ int streamAppendItem(stream *s, robj **argv, int64_t numfields, streamID *added_
 
     /* Create a new listpack and radix tree node if needed. Note that when
      * a new listpack is created, we populate it with a "master entry". This
-     * is just a set of fields that is taken as refernce in order to compress
+     * is just a set of fields that is taken as references in order to compress
      * the stream entries that we'll add inside the listpack.
      *
      * Note that while we use the first added entry fields to create
@@ -469,7 +469,7 @@ int64_t streamTrimByLength(stream *s, size_t maxlen, int approx) {
  * iteration is from the start to the end element (inclusive), otherwise
  * if rev is non-zero, the iteration is reversed.
  *
- * Once the iterator is initalized, we iterate like this:
+ * Once the iterator is initialized, we iterate like this:
  *
  *  streamIterator myiterator;
  *  streamIteratorStart(&myiterator,...);
@@ -834,7 +834,7 @@ void streamPropagateXCLAIM(client *c, robj *key, robj *group, robj *id, streamNA
  * given, but currently such a feature is never used by the code base that
  * will always pass 'spi' and propagate when a group is passed.
  *
- * Note that this function is recursive in certian cases. When it's called
+ * Note that this function is recursive in certain cases. When it's called
  * with a non NULL group and consumer argument, it may call
  * streamReplyWithRangeFromConsumerPEL() in order to get entries from the
  * consumer pending entries list. However such a function will then call
@@ -2067,7 +2067,7 @@ void xclaimCommand(client *c) {
 /* XDEL <key> [<ID1> <ID2> ... <IDN>]
  *
  * Removes the specified entries from the stream. Returns the number
- * of items actaully deleted, that may be different from the number
+ * of items actually deleted, that may be different from the number
  * of IDs passed in case certain IDs do not exist. */
 void xdelCommand(client *c) {
     robj *o;
@@ -2078,13 +2078,13 @@ void xdelCommand(client *c) {
 
     /* We need to sanity check the IDs passed to start. Even if not
      * a big issue, it is not great that the command is only partially
-     * executed becuase at some point an invalid ID is parsed. */
+     * executed because at some point an invalid ID is parsed. */
     streamID id;
     for (int j = 2; j < c->argc; j++) {
         if (streamParseIDOrReply(c,c->argv[j],&id,0) != C_OK) return;
     }
 
-    /* Actaully apply the command. */
+    /* Actually apply the command. */
     int deleted = 0;
     for (int j = 2; j < c->argc; j++) {
         streamParseIDOrReply(c,c->argv[j],&id,0); /* Retval already checked. */
diff --git a/src/t_zset.c b/src/t_zset.c
index 1322e7d35..92abb49d5 100644
--- a/src/t_zset.c
+++ b/src/t_zset.c
@@ -507,7 +507,7 @@ static int zslParseRange(robj *min, robj *max, zrangespec *spec) {
   * + means the max string possible
   *
   * If the string is valid the *dest pointer is set to the redis object
-  * that will be used for the comparision, and ex will be set to 0 or 1
+  * that will be used for the comparison, and ex will be set to 0 or 1
   * respectively if the item is exclusive or inclusive. C_OK will be
   * returned.
   *
diff --git a/src/util.c b/src/util.c
index db5b018d5..ca5435026 100644
--- a/src/util.c
+++ b/src/util.c
@@ -451,7 +451,7 @@ int string2ld(const char *s, size_t slen, long double *dp) {
 /* Convert a double to a string representation. Returns the number of bytes
  * required. The representation should always be parsable by strtod(3).
  * This function does not support human-friendly formatting like ld2string
- * does. It is intented mainly to be used inside t_zset.c when writing scores
+ * does. It is intended mainly to be used inside t_zset.c when writing scores
  * into a ziplist representing a sorted set. */
 int d2string(char *buf, size_t len, double value) {
     if (isnan(value)) {
diff --git a/src/ziplist.c b/src/ziplist.c
index 90bb9c81e..1579d1109 100644
--- a/src/ziplist.c
+++ b/src/ziplist.c
@@ -269,7 +269,7 @@
  * Note that this is not how the data is actually encoded, is just what we
  * get filled by a function in order to operate more easily. */
 typedef struct zlentry {
-    unsigned int prevrawlensize; /* Bytes used to encode the previos entry len*/
+    unsigned int prevrawlensize; /* Bytes used to encode the previous entry len*/
     unsigned int prevrawlen;     /* Previous entry len. */
     unsigned int lensize;        /* Bytes used to encode this entry type/len.
                                     For example strings have a 1, 2 or 5 bytes
@@ -431,7 +431,7 @@ unsigned int zipStorePrevEntryLength(unsigned char *p, unsigned int len) {
 /* Return the length of the previous element, and the number of bytes that
  * are used in order to encode the previous element length.
  * 'ptr' must point to the prevlen prefix of an entry (that encodes the
- * length of the previos entry in order to navigate the elements backward).
+ * length of the previous entry in order to navigate the elements backward).
  * The length of the previous entry is stored in 'prevlen', the number of
  * bytes needed to encode the previous entry length are stored in
  * 'prevlensize'. */
diff --git a/src/zmalloc.c b/src/zmalloc.c
index 56fb0798d..4956f905f 100644
--- a/src/zmalloc.c
+++ b/src/zmalloc.c
@@ -380,7 +380,7 @@ size_t zmalloc_get_private_dirty(long pid) {
 }
 
 /* Returns the size of physical memory (RAM) in bytes.
- * It looks ugly, but this is the cleanest way to achive cross platform results.
+ * It looks ugly, but this is the cleanest way to achieve cross platform results.
  * Cleaned up from:
  *
  * http://nadeausoftware.com/articles/2012/09/c_c_tip_how_get_physical_memory_size_system
diff --git a/tests/integration/replication-psync.tcl b/tests/integration/replication-psync.tcl
index 2b9e13f50..10052f7c1 100644
--- a/tests/integration/replication-psync.tcl
+++ b/tests/integration/replication-psync.tcl
@@ -11,7 +11,7 @@ proc stop_bg_complex_data {handle} {
 # partial resyncs attempts, all this while flooding the master with
 # write queries.
 #
-# You can specifiy backlog size, ttl, delay before reconnection, test duration
+# You can specify backlog size, ttl, delay before reconnection, test duration
 # in seconds, and an additional condition to verify at the end.
 #
 # If reconnect is > 0, the test actually try to break the connection and
diff --git a/tests/unit/dump.tcl b/tests/unit/dump.tcl
index 3e6051fed..91a4df09e 100644
--- a/tests/unit/dump.tcl
+++ b/tests/unit/dump.tcl
@@ -279,7 +279,7 @@ start_server {tags {"dump"}} {
         set e
     } {*empty string*}
 
-    test {MIGRATE with mutliple keys migrate just existing ones} {
+    test {MIGRATE with multiple keys migrate just existing ones} {
         set first [srv 0 client]
         r set key1 "v1"
         r set key2 "v2"
diff --git a/tests/unit/scripting.tcl b/tests/unit/scripting.tcl
index 57afae537..bcde721c3 100644
--- a/tests/unit/scripting.tcl
+++ b/tests/unit/scripting.tcl
@@ -517,7 +517,7 @@ start_server {tags {"scripting"}} {
     # Note: keep this test at the end of this server stanza because it
     # kills the server.
     test {SHUTDOWN NOSAVE can kill a timedout script anyway} {
-        # The server sould be still unresponding to normal commands.
+        # The server could be still unresponding to normal commands.
         catch {r ping} e
         assert_match {BUSY*} $e
         catch {r shutdown nosave}
diff --git a/tests/unit/type/zset.tcl b/tests/unit/type/zset.tcl
index 45f024cc3..bebba96d9 100644
--- a/tests/unit/type/zset.tcl
+++ b/tests/unit/type/zset.tcl
@@ -84,7 +84,7 @@ start_server {tags {"zset"}} {
             set err
         } {ERR*}
 
-        test "ZADD NX with non exisitng key" {
+        test "ZADD NX with non existing key" {
             r del ztmp
             r zadd ztmp nx 10 x 20 y 30 z
             assert {[r zcard ztmp] == 3}
diff --git a/utils/hashtable/README b/utils/hashtable/README
index e2862f012..87a76c9a5 100644
--- a/utils/hashtable/README
+++ b/utils/hashtable/README
@@ -5,7 +5,7 @@ rehashing.c
 
 Visually show buckets in the two hash tables between rehashings. Also stress
 test getRandomKeys() implementation, that may actually disappear from
-Redis soon, however visualizaiton some code is reusable in new bugs
+Redis soon, however visualization some code is reusable in new bugs
 investigation.
 
 Compile with:

From 6a529067589d51faaa4d1642027516ab432ec6e3 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 12:56:12 +0200
Subject: [PATCH 152/219] Localtime function skeleton and file added.

---
 src/localtime.c | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 src/localtime.c

diff --git a/src/localtime.c b/src/localtime.c
new file mode 100644
index 000000000..f03d95639
--- /dev/null
+++ b/src/localtime.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018, Salvatore Sanfilippo <antirez at gmail dot com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <time.h>
+
+/* This is a safe version of localtime() which contains no locks and is
+ * fork() friendly. Even the _r version of localtime() cannot be used safely
+ * in Redis. Another thread may be calling localtime() while the main thread
+ * forks(). Later when the child process calls localtime() again, for instance
+ * in order to log something to the Redis log, it may deadlock: in the copy
+ * of the address space of the forked process the lock will never be released.
+ *
+ * This function takes the timezone 'tz' as argument, and the 'dst' flag is
+ * used to check if daylight saving time is currently in effect. The caller
+ * of this function should obtain such information calling tzset() ASAP in the
+ * main() function, and later accessing the globals 'timezone' and 'daylight'. */
+void nolocks_localtime(struct tm *tmptr, time_t t, time_t tz, int dst) {
+}

From 06ca400f95aca07a3807e16b061415d82c927c64 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 13:16:53 +0200
Subject: [PATCH 153/219] Localtime: basics initial calculations. Year missing.

---
 src/localtime.c | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/src/localtime.c b/src/localtime.c
index f03d95639..a92d7464c 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -39,6 +39,34 @@
  * This function takes the timezone 'tz' as argument, and the 'dst' flag is
  * used to check if daylight saving time is currently in effect. The caller
  * of this function should obtain such information calling tzset() ASAP in the
- * main() function, and later accessing the globals 'timezone' and 'daylight'. */
-void nolocks_localtime(struct tm *tmptr, time_t t, time_t tz, int dst) {
+ * main() function, and later accessing the globals 'timezone' and 'daylight'.
+ *
+ * Note that this function does not work for dates < 1/1/1970, it is solely
+ * designed to work with what time(NULL) may return, and to support Redis
+ * logging of the dates, it's not really a complete implementation. */
+static int is_leap_year(time_t year) {
+    if (year % 4) return 0;
+    else if (year % 100) return 1;
+    else if (year % 400) return 0;
+    else return 1;
+}
+
+void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
+    const time_t secs_min = 60;
+    const time_t secs_hour = 3600;
+    const time_t secs_day = 3600*24;
+
+    t += tz;                            /* Adjust for timezone. */
+    time_t days = t / secs_day;         /* Days passed since epoch. */
+    time_t seconds = t % secs_day;      /* Remaining seconds. */
+
+    tmp->tm_isdst = dst;
+    tmp->tm_hour = seconds / secs_hour;
+    tmp->tm_min = (seconds % secs_hour) / secs_min;
+    tmp->tm_sec = (seconds % secs_hour) % secs_min;
+
+    /* 1/1/1970 was a Thursday, that is, day 4 from the POV of the tm structure
+     * where sunday = 0, so to calculate the day of the week we have to add 4
+     * and take the modulo by 7. */
+    tmp->tm_wday = (days+4)%7;
 }

From 0c12cbedbb1626597acf2f43718c6b52fc42d08a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 13:25:55 +0200
Subject: [PATCH 154/219] Localtime: compute year, month and day of the month.

---
 src/localtime.c | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/localtime.c b/src/localtime.c
index a92d7464c..d4090e63c 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -69,4 +69,30 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
      * where sunday = 0, so to calculate the day of the week we have to add 4
      * and take the modulo by 7. */
     tmp->tm_wday = (days+4)%7;
+
+    /* Calculate the current year. */
+    tmp->tm_year = 1970;
+    while(1) {
+        /* Leap years have one year more. */
+        time_t days_this_year = 365 + is_leap_year(tmp->tm_year);
+        if (days_this_year > days) break;
+        days -= days_this_year;
+        tmp->tm_year++;
+    }
+    tmp->tm_yday = days;  /* Number of day of the current year. */
+
+    /* We need to calculate in which month and day of the month we are. To do
+     * so we need to skip days according to how many days there are in each
+     * month, and adjust for the leap year that has one more day in February. */
+    int mdays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    mdays[1] += is_leap_year(tmp->tm_year);
+
+    tmp->tm_mon = 0;
+    while(days >= mdays[tmp->tm_mon]) {
+        days -= mdays[tmp->tm_mon];
+        tmp->tm_mon++;
+    }
+
+    tmp->tm_mday = days;
+    tmp->tm_year -= 1900; /* Surprisingly tm_year is year-1900. */
 }

From b9f33830295a78f8c5bb82f6caa033445d35e56e Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 13:35:15 +0200
Subject: [PATCH 155/219] Localtime: fix timezone adjustment.

---
 src/localtime.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/localtime.c b/src/localtime.c
index d4090e63c..536cb69e8 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -56,7 +56,8 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
     const time_t secs_hour = 3600;
     const time_t secs_day = 3600*24;
 
-    t += tz;                            /* Adjust for timezone. */
+    t -= tz;                            /* Adjust for timezone. */
+    t += 3600+dst;                      /* Adjust for daylight time.  */
     time_t days = t / secs_day;         /* Days passed since epoch. */
     time_t seconds = t % secs_day;      /* Remaining seconds. */
 

From c25ee35a8b6bcabab615e7babe486b08eebc9a47 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 13:35:40 +0200
Subject: [PATCH 156/219] Localtime: day of month is 1 based. Convert from 0
 based "days".

---
 src/localtime.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/localtime.c b/src/localtime.c
index 536cb69e8..a92248ecb 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -94,6 +94,6 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
         tmp->tm_mon++;
     }
 
-    tmp->tm_mday = days;
-    tmp->tm_year -= 1900; /* Surprisingly tm_year is year-1900. */
+    tmp->tm_mday = days+1;  /* Add 1 since our 'days' is zero-based. */
+    tmp->tm_year -= 1900;   /* Surprisingly tm_year is year-1900. */
 }

From 243c5a7a305eaf7a7cf936eb6805f44f9802b3a5 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 13:46:27 +0200
Subject: [PATCH 157/219] Localtime: add a test main() function to check the
 output.

---
 src/localtime.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/localtime.c b/src/localtime.c
index a92248ecb..c3564d1b0 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -57,7 +57,6 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
     const time_t secs_day = 3600*24;
 
     t -= tz;                            /* Adjust for timezone. */
-    t += 3600+dst;                      /* Adjust for daylight time.  */
     time_t days = t / secs_day;         /* Days passed since epoch. */
     time_t seconds = t % secs_day;      /* Remaining seconds. */
 
@@ -97,3 +96,18 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
     tmp->tm_mday = days+1;  /* Add 1 since our 'days' is zero-based. */
     tmp->tm_year -= 1900;   /* Surprisingly tm_year is year-1900. */
 }
+
+#ifdef LOCALTIME_TEST_MAIN
+#include <stdio.h>
+
+int main(void) {
+    tzset();
+    time_t t = time(NULL);
+    struct tm tm;
+    char buf[1024];
+
+    nolocks_localtime(&tm,t,timezone,daylight);
+    strftime(buf,sizeof(buf),"%d %b %H:%M:%S",&tm);
+    printf("[timezone: %d, dl: %d] %s\n", (int)timezone, (int)daylight, buf);
+}
+#endif

From 46f5a2ca077dbc9c4edab1f68feaa2c68244e0fc Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Wed, 4 Jul 2018 20:04:06 +0800
Subject: [PATCH 158/219] Fix indentation.

---
 src/ae.c     |  4 ++--
 src/server.c | 22 +++++++++++-----------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/ae.c b/src/ae.c
index 65adb2ab8..1ea671569 100644
--- a/src/ae.c
+++ b/src/ae.c
@@ -433,7 +433,7 @@ int aeProcessEvents(aeEventLoop *eventLoop, int flags)
              * before replying to a client. */
             int invert = fe->mask & AE_BARRIER;
 
-	    /* Note the "fe->mask & mask & ..." code: maybe an already
+            /* Note the "fe->mask & mask & ..." code: maybe an already
              * processed event removed an element that fired and we still
              * didn't processed, so we check if the event is still valid.
              *
@@ -485,7 +485,7 @@ int aeWait(int fd, int mask, long long milliseconds) {
     if ((retval = poll(&pfd, 1, milliseconds))== 1) {
         if (pfd.revents & POLLIN) retmask |= AE_READABLE;
         if (pfd.revents & POLLOUT) retmask |= AE_WRITABLE;
-	if (pfd.revents & POLLERR) retmask |= AE_WRITABLE;
+        if (pfd.revents & POLLERR) retmask |= AE_WRITABLE;
         if (pfd.revents & POLLHUP) retmask |= AE_WRITABLE;
         return retmask;
     } else {
diff --git a/src/server.c b/src/server.c
index 347ebcefd..f7fab5fd0 100644
--- a/src/server.c
+++ b/src/server.c
@@ -1151,7 +1151,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     } else {
         /* If there is not a background saving/rewrite in progress check if
          * we have to save/rewrite now. */
-         for (j = 0; j < server.saveparamslen; j++) {
+        for (j = 0; j < server.saveparamslen; j++) {
             struct saveparam *sp = server.saveparams+j;
 
             /* Save if we reached the given amount of changes,
@@ -1171,23 +1171,23 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
                 rdbSaveBackground(server.rdb_filename,rsiptr);
                 break;
             }
-         }
+        }
 
-         /* Trigger an AOF rewrite if needed. */
-         if (server.aof_state == AOF_ON &&
-             server.rdb_child_pid == -1 &&
-             server.aof_child_pid == -1 &&
-             server.aof_rewrite_perc &&
-             server.aof_current_size > server.aof_rewrite_min_size)
-         {
+        /* Trigger an AOF rewrite if needed. */
+        if (server.aof_state == AOF_ON &&
+            server.rdb_child_pid == -1 &&
+            server.aof_child_pid == -1 &&
+            server.aof_rewrite_perc &&
+            server.aof_current_size > server.aof_rewrite_min_size)
+        {
             long long base = server.aof_rewrite_base_size ?
-                            server.aof_rewrite_base_size : 1;
+                server.aof_rewrite_base_size : 1;
             long long growth = (server.aof_current_size*100/base) - 100;
             if (growth >= server.aof_rewrite_perc) {
                 serverLog(LL_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
                 rewriteAppendOnlyFileBackground();
             }
-         }
+        }
     }
 
 

From 6614d30599ddbfdb643fe7080173729636af27ad Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 14:09:07 +0200
Subject: [PATCH 159/219] Localtime: fix daylight time documentation and
 computation.

---
 src/localtime.c | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/localtime.c b/src/localtime.c
index c3564d1b0..ed6ff2cd3 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -39,7 +39,12 @@
  * This function takes the timezone 'tz' as argument, and the 'dst' flag is
  * used to check if daylight saving time is currently in effect. The caller
  * of this function should obtain such information calling tzset() ASAP in the
- * main() function, and later accessing the globals 'timezone' and 'daylight'.
+ * main() function to obtain the timezone offset from the 'timezone' global
+ * variable. To obtain the daylight information, if it is currently active or not,
+ * one trick is to call localtime() in main() ASAP as well, and get the
+ * information from the tm_isdst field of the tm structure. However the daylight
+ * time may switch in the future for long running processes, so this information
+ * should be refreshed at safe times.
  *
  * Note that this function does not work for dates < 1/1/1970, it is solely
  * designed to work with what time(NULL) may return, and to support Redis
@@ -57,6 +62,7 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
     const time_t secs_day = 3600*24;
 
     t -= tz;                            /* Adjust for timezone. */
+    t += 3600+dst;                      /* Adjust for daylight time. */
     time_t days = t / secs_day;         /* Days passed since epoch. */
     time_t seconds = t % secs_day;      /* Remaining seconds. */
 
@@ -101,13 +107,17 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
 #include <stdio.h>
 
 int main(void) {
-    tzset();
+    /* Obtain timezone and daylight info. */
+    tzset(); /* Now 'timezome' global is populated. */
     time_t t = time(NULL);
+    struct tm *aux = localtime(&t);
+    int daylight_active = aux->tm_isdst;
+
     struct tm tm;
     char buf[1024];
 
-    nolocks_localtime(&tm,t,timezone,daylight);
+    nolocks_localtime(&tm,t,timezone,daylight_active);
     strftime(buf,sizeof(buf),"%d %b %H:%M:%S",&tm);
-    printf("[timezone: %d, dl: %d] %s\n", (int)timezone, (int)daylight, buf);
+    printf("[timezone: %d, dl: %d] %s\n", (int)timezone, (int)daylight_active, buf);
 }
 #endif

From 0ea39aa404ea9243838dcd8cb5f246ec895136cf Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 15:16:20 +0200
Subject: [PATCH 160/219] Localtime: fix daylight saving adjustment. Use * not
 +.

---
 src/localtime.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/localtime.c b/src/localtime.c
index ed6ff2cd3..2021325b4 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -62,7 +62,7 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
     const time_t secs_day = 3600*24;
 
     t -= tz;                            /* Adjust for timezone. */
-    t += 3600+dst;                      /* Adjust for daylight time. */
+    t += 3600*dst;                      /* Adjust for daylight time. */
     time_t days = t / secs_day;         /* Days passed since epoch. */
     time_t seconds = t % secs_day;      /* Remaining seconds. */
 

From 296441445068762a138b31eb20433d2cd9d17d4b Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 15:16:54 +0200
Subject: [PATCH 161/219] Localtime: fix comment about leap year.

---
 src/localtime.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/localtime.c b/src/localtime.c
index 2021325b4..8c1ff4955 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -79,7 +79,7 @@ void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
     /* Calculate the current year. */
     tmp->tm_year = 1970;
     while(1) {
-        /* Leap years have one year more. */
+        /* Leap years have one day more. */
         time_t days_this_year = 365 + is_leap_year(tmp->tm_year);
         if (days_this_year > days) break;
         days -= days_this_year;

From 18d8205bbde7bd7bf007784c391fb7fdb1d0a7e4 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 15:50:41 +0200
Subject: [PATCH 162/219] Localtime: clarify is_leap_year() working with
 comments.

---
 src/localtime.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/localtime.c b/src/localtime.c
index 8c1ff4955..186c8e3c6 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -50,10 +50,10 @@
  * designed to work with what time(NULL) may return, and to support Redis
  * logging of the dates, it's not really a complete implementation. */
 static int is_leap_year(time_t year) {
-    if (year % 4) return 0;
-    else if (year % 100) return 1;
-    else if (year % 400) return 0;
-    else return 1;
+    if (year % 4) return 0;         /* A year divisible by 4 is not leap. */
+    else if (year % 100) return 1;  /* If div by 4 and not 100 is surely leap. */
+    else if (year % 400) return 0;  /* If div by 100 *and* 400 is not leap. */
+    else return 1;                  /* If div by 100 and not by 400 is leap. */
 }
 
 void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {

From 81778d91bf5a0007dc44293e983c7e36dfd7cc51 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 16:44:57 +0200
Subject: [PATCH 163/219] Cache timezone and daylight active flag for safer
 logging.

With such information will be able to use a private localtime()
implementation serverLog(), which does not use any locking and is both
thread and fork() safe.
---
 src/server.c | 13 ++++++++++++-
 src/server.h |  2 ++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/server.c b/src/server.c
index 347ebcefd..2c9324006 100644
--- a/src/server.c
+++ b/src/server.c
@@ -977,6 +977,14 @@ void updateCachedTime(void) {
     time_t unixtime = time(NULL);
     atomicSet(server.unixtime,unixtime);
     server.mstime = mstime();
+
+    /* To get information about daylight saving time, we need to call localtime_r
+     * and cache the result. However calling localtime_r in this context is safe
+     * since we will never fork() while here, in the main thread. The logging
+     * function will call a thread safe version of localtime that has no locks. */
+    struct tm tm;
+    localtime_r(&server.unixtime,&tm);
+    server.daylight_active = tm.tm_isdst;
 }
 
 /* This is our timer interrupt, called server.hz times per second.
@@ -1419,10 +1427,12 @@ void initServerConfig(void) {
     pthread_mutex_init(&server.lruclock_mutex,NULL);
     pthread_mutex_init(&server.unixtime_mutex,NULL);
 
+    updateCachedTime();
     getRandomHexChars(server.runid,CONFIG_RUN_ID_SIZE);
     server.runid[CONFIG_RUN_ID_SIZE] = '\0';
     changeReplicationId();
     clearReplicationId2();
+    server.timezone = timezone; /* Initialized by tzset(). */
     server.configfile = NULL;
     server.executable = NULL;
     server.hz = CONFIG_DEFAULT_HZ;
@@ -2000,7 +2010,6 @@ void initServer(void) {
     server.aof_last_write_status = C_OK;
     server.aof_last_write_errno = 0;
     server.repl_good_slaves_count = 0;
-    updateCachedTime();
 
     /* Create the timer callback, this is our way to process many background
      * operations incrementally, like clients timeout, eviction of unaccessed
@@ -3861,9 +3870,11 @@ int main(int argc, char **argv) {
     spt_init(argc, argv);
 #endif
     setlocale(LC_COLLATE,"");
+    tzset(); /* Populates 'timezone' global. */
     zmalloc_set_oom_handler(redisOutOfMemoryHandler);
     srand(time(NULL)^getpid());
     gettimeofday(&tv,NULL);
+
     char hashseed[16];
     getRandomHexChars(hashseed,sizeof(hashseed));
     dictSetHashFunctionSeed((uint8_t*)hashseed);
diff --git a/src/server.h b/src/server.h
index fc62710c6..47efd0336 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1192,6 +1192,8 @@ struct redisServer {
     int list_compress_depth;
     /* time cache */
     time_t unixtime;    /* Unix time sampled every cron cycle. */
+    time_t timezone;    /* Cached timezone. As set by tzset(). */
+    int daylight_active;    /* Currently in daylight saving time. */
     long long mstime;   /* Like 'unixtime' but with milliseconds resolution. */
     /* Pubsub */
     dict *pubsub_channels;  /* Map channels to list of subscribed clients */

From cb78c84235ab50f03a83b0ad4c3ce168b7e48020 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 4 Jul 2018 16:50:22 +0200
Subject: [PATCH 164/219] Use nolocks_localtime() for safer logging.

---
 src/Makefile | 2 +-
 src/server.c | 8 +++++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/Makefile b/src/Makefile
index 8cd7afe5e..f5525bd6d 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -144,7 +144,7 @@ endif
 
 REDIS_SERVER_NAME=redis-server
 REDIS_SENTINEL_NAME=redis-sentinel
-REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o
+REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o
 REDIS_CLI_NAME=redis-cli
 REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o zmalloc.o release.o anet.o ae.o crc64.o siphash.o crc16.o
 REDIS_BENCHMARK_NAME=redis-benchmark
diff --git a/src/server.c b/src/server.c
index 2c9324006..41edab91d 100644
--- a/src/server.c
+++ b/src/server.c
@@ -326,6 +326,10 @@ struct redisCommand redisCommandTable[] = {
 
 /*============================ Utility functions ============================ */
 
+/* We use a private localtime implementation which is fork-safe. The logging
+ * function of Redis may be called from other threads. */
+void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst);
+
 /* Low level logging. To use only for very big messages, otherwise
  * serverLog() is to prefer. */
 void serverLogRaw(int level, const char *msg) {
@@ -351,7 +355,9 @@ void serverLogRaw(int level, const char *msg) {
         pid_t pid = getpid();
 
         gettimeofday(&tv,NULL);
-        off = strftime(buf,sizeof(buf),"%d %b %H:%M:%S.",localtime(&tv.tv_sec));
+        struct tm tm;
+        nolocks_localtime(&tm,tv.tv_sec,server.timezone,server.daylight_active);
+        off = strftime(buf,sizeof(buf),"%d %b %H:%M:%S.",&tm);
         snprintf(buf+off,sizeof(buf)-off,"%03d",(int)tv.tv_usec/1000);
         if (server.sentinel_mode) {
             role_char = 'X'; /* Sentinel. */

From 0a5805d7f1db3dc8cc932942399879cffd079fc6 Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Sat, 7 Jul 2018 08:44:41 +0800
Subject: [PATCH 165/219] fix compile warning in addReplySubcommandSyntaxError

---
 src/networking.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/networking.c b/src/networking.c
index 8aec27280..cefeba45e 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -570,7 +570,7 @@ void addReplySubcommandSyntaxError(client *c) {
     sdstoupper(cmd);
     addReplyErrorFormat(c,
         "Unknown subcommand or wrong number of arguments for '%s'. Try %s HELP.",
-        c->argv[1]->ptr,cmd);
+        (char*)c->argv[1]->ptr,cmd);
     sdsfree(cmd);
 }
 

From 62a4a8c1d58308fa67978352376db2f2aede449a Mon Sep 17 00:00:00 2001
From: minkikim89 <minkikim89@gmail.com>
Date: Sat, 7 Jul 2018 09:18:22 +0200
Subject: [PATCH 166/219] fix whitespace in redis-cli.c

---
 src/redis-cli.c | 724 ++++++++++++++++++++++++------------------------
 1 file changed, 362 insertions(+), 362 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 283b991f5..115323720 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -41,14 +41,14 @@
 #include <errno.h>
 #include <sys/stat.h>
 #include <sys/time.h>
-#include <assert.h> 
+#include <assert.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <math.h>
 
 #include <hiredis.h>
 #include <sds.h> /* use sds.h from hiredis, so that only one set of sds functions will be present in the binary */
-#include "dict.h" 
+#include "dict.h"
 #include "adlist.h"
 #include "zmalloc.h"
 #include "linenoise.h"
@@ -125,7 +125,7 @@
 #define CLUSTER_MANAGER_OPT_QUIET       1 << 6
 #define CLUSTER_MANAGER_OPT_VERBOSE     1 << 7
 
-#define CLUSTER_MANAGER_LOG_LVL_INFO    1 
+#define CLUSTER_MANAGER_LOG_LVL_INFO    1
 #define CLUSTER_MANAGER_LOG_LVL_WARN    2
 #define CLUSTER_MANAGER_LOG_LVL_ERR     3
 #define CLUSTER_MANAGER_LOG_LVL_SUCCESS 4
@@ -150,7 +150,7 @@ int spectrum_palette_size;
 /* Dict Helpers */
 
 static uint64_t dictSdsHash(const void *key);
-static int dictSdsKeyCompare(void *privdata, const void *key1, 
+static int dictSdsKeyCompare(void *privdata, const void *key1,
     const void *key2);
 static void dictSdsDestructor(void *privdata, void *val);
 static void dictListDestructor(void *privdata, void *val);
@@ -1310,13 +1310,13 @@ static int parseOptions(int argc, char **argv) {
         } else if (!strcmp(argv[i],"--cluster") && lastarg) {
             usage();
         } else if (!strcmp(argv[i],"--cluster-replicas") && !lastarg) {
-            config.cluster_manager_command.replicas = atoi(argv[++i]);  
+            config.cluster_manager_command.replicas = atoi(argv[++i]);
         } else if (!strcmp(argv[i],"--cluster-master-id") && !lastarg) {
-            config.cluster_manager_command.master_id = argv[++i];  
+            config.cluster_manager_command.master_id = argv[++i];
         } else if (!strcmp(argv[i],"--cluster-from") && !lastarg) {
-            config.cluster_manager_command.from = argv[++i];  
+            config.cluster_manager_command.from = argv[++i];
         } else if (!strcmp(argv[i],"--cluster-to") && !lastarg) {
-            config.cluster_manager_command.to = argv[++i];  
+            config.cluster_manager_command.to = argv[++i];
         } else if (!strcmp(argv[i],"--cluster-weight") && !lastarg) {
             int widx = i + 1;
             char **weight = argv + widx;
@@ -1326,36 +1326,36 @@ static int parseOptions(int argc, char **argv) {
                 wargc++;
             }
             if (wargc > 0) {
-                config.cluster_manager_command.weight = weight;  
+                config.cluster_manager_command.weight = weight;
                 config.cluster_manager_command.weight_argc = wargc;
                 i += wargc;
             }
         } else if (!strcmp(argv[i],"--cluster-slots") && !lastarg) {
-            config.cluster_manager_command.slots = atoi(argv[++i]);  
+            config.cluster_manager_command.slots = atoi(argv[++i]);
         } else if (!strcmp(argv[i],"--cluster-timeout") && !lastarg) {
-            config.cluster_manager_command.timeout = atoi(argv[++i]);  
+            config.cluster_manager_command.timeout = atoi(argv[++i]);
         } else if (!strcmp(argv[i],"--cluster-pipeline") && !lastarg) {
-            config.cluster_manager_command.pipeline = atoi(argv[++i]);  
+            config.cluster_manager_command.pipeline = atoi(argv[++i]);
         } else if (!strcmp(argv[i],"--cluster-threshold") && !lastarg) {
-            config.cluster_manager_command.threshold = atof(argv[++i]);  
+            config.cluster_manager_command.threshold = atof(argv[++i]);
         } else if (!strcmp(argv[i],"--cluster-yes")) {
-            config.cluster_manager_command.flags |= 
-                CLUSTER_MANAGER_CMD_FLAG_YES;  
+            config.cluster_manager_command.flags |=
+                CLUSTER_MANAGER_CMD_FLAG_YES;
         } else if (!strcmp(argv[i],"--cluster-simulate")) {
-            config.cluster_manager_command.flags |= 
-                CLUSTER_MANAGER_CMD_FLAG_SIMULATE;  
+            config.cluster_manager_command.flags |=
+                CLUSTER_MANAGER_CMD_FLAG_SIMULATE;
         } else if (!strcmp(argv[i],"--cluster-replace")) {
-            config.cluster_manager_command.flags |= 
-                CLUSTER_MANAGER_CMD_FLAG_REPLACE;  
+            config.cluster_manager_command.flags |=
+                CLUSTER_MANAGER_CMD_FLAG_REPLACE;
         } else if (!strcmp(argv[i],"--cluster-copy")) {
-            config.cluster_manager_command.flags |= 
-                CLUSTER_MANAGER_CMD_FLAG_COPY;  
+            config.cluster_manager_command.flags |=
+                CLUSTER_MANAGER_CMD_FLAG_COPY;
         } else if (!strcmp(argv[i],"--cluster-slave")) {
-            config.cluster_manager_command.flags |= 
-                CLUSTER_MANAGER_CMD_FLAG_SLAVE;  
+            config.cluster_manager_command.flags |=
+                CLUSTER_MANAGER_CMD_FLAG_SLAVE;
         } else if (!strcmp(argv[i],"--cluster-use-empty-masters")) {
-            config.cluster_manager_command.flags |= 
-                CLUSTER_MANAGER_CMD_FLAG_EMPTYMASTER;  
+            config.cluster_manager_command.flags |=
+                CLUSTER_MANAGER_CMD_FLAG_EMPTYMASTER;
         } else if (!strcmp(argv[i],"-v") || !strcmp(argv[i], "--version")) {
             sds version = cliVersion();
             printf("redis-cli %s\n", version);
@@ -1905,7 +1905,7 @@ static clusterManagerNode *clusterManagerNodeByAbbreviatedName(const char *n);
 static void clusterManagerNodeResetSlots(clusterManagerNode *node);
 static int clusterManagerNodeIsCluster(clusterManagerNode *node, char **err);
 static void clusterManagerPrintNotClusterNodeError(clusterManagerNode *node,
-                                                   char *err); 
+                                                   char *err);
 static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
                                       char **err);
 static int clusterManagerLoadInfoFromNode(clusterManagerNode *node, int opts);
@@ -1923,12 +1923,12 @@ static int clusterManagerCheckCluster(int quiet);
 static void clusterManagerLog(int level, const char* fmt, ...);
 static int clusterManagerIsConfigConsistent(void);
 static void clusterManagerOnError(sds err);
-static void clusterManagerNodeArrayInit(clusterManagerNodeArray *array, 
+static void clusterManagerNodeArrayInit(clusterManagerNodeArray *array,
                                         int len);
 static void clusterManagerNodeArrayReset(clusterManagerNodeArray *array);
-static void clusterManagerNodeArrayShift(clusterManagerNodeArray *array, 
+static void clusterManagerNodeArrayShift(clusterManagerNodeArray *array,
                                          clusterManagerNode **nodeptr);
-static void clusterManagerNodeArrayAdd(clusterManagerNodeArray *array, 
+static void clusterManagerNodeArrayAdd(clusterManagerNodeArray *array,
                                        clusterManagerNode *node);
 
 /* Cluster Manager commands. */
@@ -1955,24 +1955,24 @@ typedef struct clusterManagerCommandDef {
 } clusterManagerCommandDef;
 
 clusterManagerCommandDef clusterManagerCommands[] = {
-    {"create", clusterManagerCommandCreate, -2, "host1:port1 ... hostN:portN", 
+    {"create", clusterManagerCommandCreate, -2, "host1:port1 ... hostN:portN",
      "replicas <arg>"},
     {"check", clusterManagerCommandCheck, -1, "host:port", NULL},
     {"info", clusterManagerCommandInfo, -1, "host:port", NULL},
     {"fix", clusterManagerCommandFix, -1, "host:port", NULL},
-    {"reshard", clusterManagerCommandReshard, -1, "host:port", 
+    {"reshard", clusterManagerCommandReshard, -1, "host:port",
      "from <arg>,to <arg>,slots <arg>,yes,timeout <arg>,pipeline <arg>"},
-    {"rebalance", clusterManagerCommandRebalance, -1, "host:port", 
+    {"rebalance", clusterManagerCommandRebalance, -1, "host:port",
      "weight <node1=w1...nodeN=wN>,use-empty-masters,"
-     "timeout <arg>,simulate,pipeline <arg>,threshold <arg>"}, 
-    {"add-node", clusterManagerCommandAddNode, 2, 
+     "timeout <arg>,simulate,pipeline <arg>,threshold <arg>"},
+    {"add-node", clusterManagerCommandAddNode, 2,
      "new_host:new_port existing_host:existing_port", "slave,master-id <arg>"},
     {"del-node", clusterManagerCommandDeleteNode, 2, "host:port node_id",NULL},
-    {"call", clusterManagerCommandCall, -2, 
+    {"call", clusterManagerCommandCall, -2,
         "host:port command arg arg .. arg", NULL},
-    {"set-timeout", clusterManagerCommandSetTimeout, 2, 
+    {"set-timeout", clusterManagerCommandSetTimeout, 2,
      "host:port milliseconds", NULL},
-    {"import", clusterManagerCommandImport, 1, "host:port", 
+    {"import", clusterManagerCommandImport, 1, "host:port",
      "from <arg>,copy,replace"},
     {"help", clusterManagerCommandHelp, 0, NULL, NULL}
 };
@@ -1988,19 +1988,19 @@ static void createClusterManagerCommand(char *cmdname, int argc, char **argv) {
 
 
 static clusterManagerCommandProc *validateClusterManagerCommand(void) {
-    int i, commands_count = sizeof(clusterManagerCommands) / 
+    int i, commands_count = sizeof(clusterManagerCommands) /
                             sizeof(clusterManagerCommandDef);
     clusterManagerCommandProc *proc = NULL;
     char *cmdname = config.cluster_manager_command.name;
     int argc = config.cluster_manager_command.argc;
     for (i = 0; i < commands_count; i++) {
-        clusterManagerCommandDef cmddef = clusterManagerCommands[i]; 
+        clusterManagerCommandDef cmddef = clusterManagerCommands[i];
         if (!strcmp(cmddef.name, cmdname)) {
-            if ((cmddef.arity > 0 && argc != cmddef.arity) || 
+            if ((cmddef.arity > 0 && argc != cmddef.arity) ||
                 (cmddef.arity < 0 && argc < (cmddef.arity * -1))) {
                 fprintf(stderr, "[ERR] Wrong number of arguments for "
                                 "specified --cluster sub command\n");
-                return NULL;    
+                return NULL;
             }
             proc = cmddef.proc;
         }
@@ -2009,13 +2009,13 @@ static clusterManagerCommandProc *validateClusterManagerCommand(void) {
     return proc;
 }
 
-/* Get host ip and port from command arguments. If only one argument has 
- * been provided it must be in the form of 'ip:port', elsewhere 
+/* Get host ip and port from command arguments. If only one argument has
+ * been provided it must be in the form of 'ip:port', elsewhere
  * the first argument must be the ip and the second one the port.
- * If host and port can be detected, it returns 1 and it stores host and 
- * port into variables referenced by'ip_ptr' and 'port_ptr' pointers, 
+ * If host and port can be detected, it returns 1 and it stores host and
+ * port into variables referenced by'ip_ptr' and 'port_ptr' pointers,
  * elsewhere it returns 0. */
-static int getClusterHostFromCmdArgs(int argc, char **argv, 
+static int getClusterHostFromCmdArgs(int argc, char **argv,
                                      char **ip_ptr, int *port_ptr) {
     int port = 0;
     char *ip = NULL;
@@ -2053,13 +2053,13 @@ static void freeClusterManagerNodeFlags(list *flags) {
 }
 
 static void freeClusterManagerNode(clusterManagerNode *node) {
-    if (node->context != NULL) redisFree(node->context); 
+    if (node->context != NULL) redisFree(node->context);
     if (node->friends != NULL) {
-        listIter li; 
+        listIter li;
         listNode *ln;
         listRewind(node->friends,&li);
         while ((ln = listNext(&li)) != NULL) {
-            clusterManagerNode *fn = ln->value; 
+            clusterManagerNode *fn = ln->value;
             freeClusterManagerNode(fn);
         }
         listRelease(node->friends);
@@ -2086,12 +2086,12 @@ static void freeClusterManagerNode(clusterManagerNode *node) {
 }
 
 static void freeClusterManager(void) {
-    listIter li; 
+    listIter li;
     listNode *ln;
     if (cluster_manager.nodes != NULL) {
         listRewind(cluster_manager.nodes,&li);
         while ((ln = listNext(&li)) != NULL) {
-            clusterManagerNode *n = ln->value; 
+            clusterManagerNode *n = ln->value;
             freeClusterManagerNode(n);
         }
         listRelease(cluster_manager.nodes);
@@ -2100,13 +2100,13 @@ static void freeClusterManager(void) {
     if (cluster_manager.errors != NULL) {
         listRewind(cluster_manager.errors,&li);
         while ((ln = listNext(&li)) != NULL) {
-            sds err = ln->value; 
+            sds err = ln->value;
             sdsfree(err);
         }
         listRelease(cluster_manager.errors);
         cluster_manager.errors = NULL;
     }
-    if (clusterManagerUncoveredSlots != NULL) 
+    if (clusterManagerUncoveredSlots != NULL)
         dictRelease(clusterManagerUncoveredSlots);
 }
 
@@ -2135,27 +2135,27 @@ static clusterManagerNode *clusterManagerNewNode(char *ip, int port) {
     return node;
 }
 
-/* Check whether reply is NULL or its type is REDIS_REPLY_ERROR. In the 
- * latest case, if the 'err' arg is not NULL, it gets allocated with a copy 
- * of reply error (it's up to the caller function to free it), elsewhere 
+/* Check whether reply is NULL or its type is REDIS_REPLY_ERROR. In the
+ * latest case, if the 'err' arg is not NULL, it gets allocated with a copy
+ * of reply error (it's up to the caller function to free it), elsewhere
  * the error is directly printed. */
-static int clusterManagerCheckRedisReply(clusterManagerNode *n, 
-                                         redisReply *r, char **err) 
+static int clusterManagerCheckRedisReply(clusterManagerNode *n,
+                                         redisReply *r, char **err)
 {
     int is_err = 0;
     if (!r || (is_err = (r->type == REDIS_REPLY_ERROR))) {
         if (is_err) {
             if (err != NULL) {
-                *err = zmalloc((r->len + 1) * sizeof(char));  
-                strcpy(*err, r->str); 
-            } else CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, r->str); 
+                *err = zmalloc((r->len + 1) * sizeof(char));
+                strcpy(*err, r->str);
+            } else CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, r->str);
         }
         return 0;
     }
-    return 1; 
-} 
+    return 1;
+}
 
-static void clusterManagerRemoveNodeFromList(list *nodelist, 
+static void clusterManagerRemoveNodeFromList(list *nodelist,
                                              clusterManagerNode *node) {
     listIter li;
     listNode *ln;
@@ -2179,7 +2179,7 @@ static clusterManagerNode *clusterManagerNodeByName(const char *name) {
     listNode *ln;
     listRewind(cluster_manager.nodes, &li);
     while ((ln = listNext(&li)) != NULL) {
-        clusterManagerNode *n = ln->value; 
+        clusterManagerNode *n = ln->value;
         if (n->name && !sdscmp(n->name, lcname)) {
             found = n;
             break;
@@ -2204,8 +2204,8 @@ static clusterManagerNode *clusterManagerNodeByAbbreviatedName(const char*name)
     listNode *ln;
     listRewind(cluster_manager.nodes, &li);
     while ((ln = listNext(&li)) != NULL) {
-        clusterManagerNode *n = ln->value; 
-        if (n->name && 
+        clusterManagerNode *n = ln->value;
+        if (n->name &&
             strstr(n->name, lcname) == n->name) {
             found = n;
             break;
@@ -2221,17 +2221,17 @@ static void clusterManagerNodeResetSlots(clusterManagerNode *node) {
 }
 
 /* Call "INFO" redis command on the specified node and return the reply. */
-static redisReply *clusterManagerGetNodeRedisInfo(clusterManagerNode *node, 
-                                                  char **err) 
+static redisReply *clusterManagerGetNodeRedisInfo(clusterManagerNode *node,
+                                                  char **err)
 {
     redisReply *info = CLUSTER_MANAGER_COMMAND(node, "INFO");
     if (err != NULL) *err = NULL;
     if (info == NULL) return NULL;
     if (info->type == REDIS_REPLY_ERROR) {
         if (err != NULL) {
-            *err = zmalloc((info->len + 1) * sizeof(char));  
-            strcpy(*err, info->str); 
-        } 
+            *err = zmalloc((info->len + 1) * sizeof(char));
+            strcpy(*err, info->str);
+        }
         freeReplyObject(info);
         return  NULL;
     }
@@ -2246,7 +2246,7 @@ static int clusterManagerNodeIsCluster(clusterManagerNode *node, char **err) {
     return is_cluster;
 }
 
-/* Checks whether the node is empty. Node is considered not-empty if it has 
+/* Checks whether the node is empty. Node is considered not-empty if it has
  * some key or if it already knows other nodes */
 static int clusterManagerNodeIsEmpty(clusterManagerNode *node, char **err) {
     redisReply *info = clusterManagerGetNodeRedisInfo(node, err);
@@ -2292,12 +2292,12 @@ result:
  * to this violation, so that we'll optimize for the second factor only
  * if it does not impact the first one.
  *
- * The ipnodes argument is an array of clusterManagerNodeArray, one for 
+ * The ipnodes argument is an array of clusterManagerNodeArray, one for
  * each IP, while ip_count is the total number of IPs in the configuration.
  *
  * The function returns the above score, and the list of
- * offending slaves can be stored into the 'offending' argument, 
- * so that the optimizer can try changing the configuration of the 
+ * offending slaves can be stored into the 'offending' argument,
+ * so that the optimizer can try changing the configuration of the
  * slaves violating the anti-affinity goals. */
 static int clusterManagerGetAntiAffinityScore(clusterManagerNodeArray *ipnodes,
     int ip_count, clusterManagerNode ***offending, int *offending_len)
@@ -2309,7 +2309,7 @@ static int clusterManagerGetAntiAffinityScore(clusterManagerNodeArray *ipnodes,
         *offending = zcalloc(node_len * sizeof(clusterManagerNode*));
         offending_p = *offending;
     }
-    /* For each set of nodes in the same host, split by 
+    /* For each set of nodes in the same host, split by
      * related nodes (masters and slaves which are involved in
      * replication of each other) */
     for (i = 0; i < ip_count; i++) {
@@ -2330,13 +2330,13 @@ static int clusterManagerGetAntiAffinityScore(clusterManagerNodeArray *ipnodes,
                 otypes = sdsempty();
                 dictAdd(related, key, otypes);
             }
-            // Master type 'm' is always set as the first character of the 
+            // Master type 'm' is always set as the first character of the
             // types string.
             if (!node->replicate) types = sdscatprintf(otypes, "m%s", otypes);
-            else types = sdscat(otypes, "s"); 
+            else types = sdscat(otypes, "s");
             if (types != otypes) dictReplace(related, key, types);
         }
-        /* Now it's trivial to check, for each related group having the 
+        /* Now it's trivial to check, for each related group having the
          * same host, what is their local score. */
         dictIterator *iter = dictGetIterator(related);
         dictEntry *entry;
@@ -2356,7 +2356,7 @@ static int clusterManagerGetAntiAffinityScore(clusterManagerNodeArray *ipnodes,
                 clusterManagerNode *n = ln->value;
                 if (n->replicate == NULL) continue;
                 if (!strcmp(n->replicate, name) && !strcmp(n->ip, ip)) {
-                    *(offending_p++) = n;               
+                    *(offending_p++) = n;
                     if (offending_len != NULL) (*offending_len)++;
                     break;
                 }
@@ -2373,7 +2373,7 @@ static void clusterManagerOptimizeAntiAffinity(clusterManagerNodeArray *ipnodes,
     int ip_count)
 {
     clusterManagerNode **offenders = NULL;
-    int score = clusterManagerGetAntiAffinityScore(ipnodes, ip_count, 
+    int score = clusterManagerGetAntiAffinityScore(ipnodes, ip_count,
                                                    NULL, NULL);
     if (score == 0) goto cleanup;
     clusterManagerLogInfo(">>> Trying to optimize slaves allocation "
@@ -2387,18 +2387,18 @@ static void clusterManagerOptimizeAntiAffinity(clusterManagerNodeArray *ipnodes,
             zfree(offenders);
             offenders = NULL;
         }
-        score = clusterManagerGetAntiAffinityScore(ipnodes, 
-                                                   ip_count, 
-                                                   &offenders, 
+        score = clusterManagerGetAntiAffinityScore(ipnodes,
+                                                   ip_count,
+                                                   &offenders,
                                                    &offending_len);
         if (score == 0) break; // Optimal anti affinity reached
         /* We'll try to randomly swap a slave's assigned master causing
          * an affinity problem with another random slave, to see if we
          * can improve the affinity. */
         int rand_idx = rand() % offending_len;
-        clusterManagerNode *first = offenders[rand_idx], 
+        clusterManagerNode *first = offenders[rand_idx],
                            *second = NULL;
-        clusterManagerNode **other_replicas = zcalloc((node_len - 1) * 
+        clusterManagerNode **other_replicas = zcalloc((node_len - 1) *
                                                       sizeof(*other_replicas));
         int other_replicas_count = 0;
         listIter li;
@@ -2415,12 +2415,12 @@ static void clusterManagerOptimizeAntiAffinity(clusterManagerNodeArray *ipnodes,
         }
         rand_idx = rand() % other_replicas_count;
         second = other_replicas[rand_idx];
-        char *first_master = first->replicate, 
+        char *first_master = first->replicate,
              *second_master = second->replicate;
         first->replicate = second_master, first->dirty = 1;
         second->replicate = first_master, second->dirty = 1;
-        int new_score = clusterManagerGetAntiAffinityScore(ipnodes, 
-                                                           ip_count, 
+        int new_score = clusterManagerGetAntiAffinityScore(ipnodes,
+                                                           ip_count,
                                                            NULL, NULL);
         /* If the change actually makes thing worse, revert. Otherwise
          * leave as it is because the best solution may need a few
@@ -2435,10 +2435,10 @@ static void clusterManagerOptimizeAntiAffinity(clusterManagerNodeArray *ipnodes,
     score = clusterManagerGetAntiAffinityScore(ipnodes, ip_count, NULL, NULL);
     char *msg;
     int perfect = (score == 0);
-    int log_level = (perfect ? CLUSTER_MANAGER_LOG_LVL_SUCCESS : 
+    int log_level = (perfect ? CLUSTER_MANAGER_LOG_LVL_SUCCESS :
                                CLUSTER_MANAGER_LOG_LVL_WARN);
-    if (perfect) msg = "[OK] Perfect anti-affinity obtained!"; 
-    else if (score >= 10000) 
+    if (perfect) msg = "[OK] Perfect anti-affinity obtained!";
+    else if (score >= 10000)
         msg = ("[WARNING] Some slaves are in the same host as their master");
     else
         msg=("[WARNING] Some slaves of the same master are in the same host");
@@ -2480,10 +2480,10 @@ static sds clusterManagerNodeSlotsString(clusterManagerNode *node) {
             last_slot_idx = i;
         } else {
             if (last_slot_idx >= 0) {
-                if (first_range_idx == last_slot_idx) 
+                if (first_range_idx == last_slot_idx)
                     slots = sdscat(slots, "]");
                 else slots = sdscatfmt(slots, "-%u]", last_slot_idx);
-            } 
+            }
             last_slot_idx = -1;
             first_range_idx = -1;
         }
@@ -2543,16 +2543,16 @@ static sds clusterManagerNodeInfo(clusterManagerNode *node, int indent) {
         sds flags = clusterManagerNodeFlagString(node);
         info = sdscatfmt(info, "%s: %S %s:%u\n"
                                "%s   slots:%S (%u slots) "
-                               "%S", 
-                               role, node->name, node->ip, node->port, spaces, 
+                               "%S",
+                               role, node->name, node->ip, node->port, spaces,
                                slots, node->slots_count, flags);
         sdsfree(slots);
         sdsfree(flags);
     }
-    if (node->replicate != NULL) 
+    if (node->replicate != NULL)
         info = sdscatfmt(info, "\n%s   replicates %S", spaces, node->replicate);
     else if (node->replicas_count)
-        info = sdscatfmt(info, "\n%s   %U additional replica(s)", 
+        info = sdscatfmt(info, "\n%s   %U additional replica(s)",
                          spaces, node->replicas_count);
     sdsfree(spaces);
     return info;
@@ -2607,8 +2607,8 @@ static void clusterManagerShowClusterInfo(void) {
                 return;
             };
             if (reply != NULL) freeReplyObject(reply);
-            printf("%s:%d (%s...) -> %d keys | %d slots | %d slaves.\n", 
-                   node->ip, node->port, name, dbsize, 
+            printf("%s:%d (%s...) -> %d keys | %d slots | %d slaves.\n",
+                   node->ip, node->port, name, dbsize,
                    node->slots_count, replicas);
             masters++;
             keys += dbsize;
@@ -2626,7 +2626,7 @@ static int clusterManagerAddSlots(clusterManagerNode *node, char**err)
     void *_reply = NULL;
     int success = 1;
     /* First two args are used for the command itself. */
-    int argc = node->slots_count + 2; 
+    int argc = node->slots_count + 2;
     sds *argv = zmalloc(argc * sizeof(*argv));
     size_t *argvlen = zmalloc(argc * sizeof(*argvlen));
     argv[0] = "CLUSTER";
@@ -2665,12 +2665,12 @@ cleanup:
 }
 
 /* Set slot status to "importing" or "migrating" */
-static int clusterManagerSetSlot(clusterManagerNode *node1, 
-                                 clusterManagerNode *node2, 
+static int clusterManagerSetSlot(clusterManagerNode *node1,
+                                 clusterManagerNode *node2,
                                  int slot, const char *status, char **err) {
     redisReply *reply = CLUSTER_MANAGER_COMMAND(node1, "CLUSTER "
-                                                "SETSLOT %d %s %s", 
-                                                slot, status, 
+                                                "SETSLOT %d %s %s",
+                                                slot, status,
                                                 (char *) node2->name);
     if (err != NULL) *err = NULL;
     if (!reply) return 0;
@@ -2678,8 +2678,8 @@ static int clusterManagerSetSlot(clusterManagerNode *node1,
     if (reply->type == REDIS_REPLY_ERROR) {
         success = 0;
         if (err != NULL) {
-            *err = zmalloc((reply->len + 1) * sizeof(char));  
-            strcpy(*err, reply->str); 
+            *err = zmalloc((reply->len + 1) * sizeof(char));
+            strcpy(*err, reply->str);
             CLUSTER_MANAGER_PRINT_REPLY_ERROR(node1, err);
         }
         goto cleanup;
@@ -2689,14 +2689,14 @@ cleanup:
     return success;
 }
 
-/* Migrate keys taken from reply->elements. It returns the reply from the 
- * MIGRATE command, or NULL if something goes wrong. If the argument 'dots' 
+/* Migrate keys taken from reply->elements. It returns the reply from the
+ * MIGRATE command, or NULL if something goes wrong. If the argument 'dots'
  * is not NULL, a dot will be printed for every migrated key. */
-static redisReply *clusterManagerMigrateKeysInReply(clusterManagerNode *source, 
-                                                    clusterManagerNode *target, 
-                                                    redisReply *reply, 
-                                                    int replace, int timeout, 
-                                                    char *dots) 
+static redisReply *clusterManagerMigrateKeysInReply(clusterManagerNode *source,
+                                                    clusterManagerNode *target,
+                                                    redisReply *reply,
+                                                    int replace, int timeout,
+                                                    char *dots)
 {
     redisReply *migrate_reply = NULL;
     char **argv = NULL;
@@ -2753,28 +2753,28 @@ cleanup:
 }
 
 /* Migrate all keys in the given slot from source to target.*/
-static int clusterManagerMigrateKeysInSlot(clusterManagerNode *source, 
-                                           clusterManagerNode *target, 
-                                           int slot, int timeout, 
+static int clusterManagerMigrateKeysInSlot(clusterManagerNode *source,
+                                           clusterManagerNode *target,
+                                           int slot, int timeout,
                                            int pipeline, int verbose,
-                                           char **err) 
+                                           char **err)
 {
     int success = 1;
-    int do_fix = (config.cluster_manager_command.flags & 
+    int do_fix = (config.cluster_manager_command.flags &
                   CLUSTER_MANAGER_CMD_FLAG_FIX);
     while (1) {
         char *dots = NULL;
         redisReply *reply = NULL, *migrate_reply = NULL;
         reply = CLUSTER_MANAGER_COMMAND(source, "CLUSTER "
-                                        "GETKEYSINSLOT %d %d", slot, 
+                                        "GETKEYSINSLOT %d %d", slot,
                                         pipeline);
         success = (reply != NULL);
         if (!success) return 0;
         if (reply->type == REDIS_REPLY_ERROR) {
             success = 0;
             if (err != NULL) {
-                *err = zmalloc((reply->len + 1) * sizeof(char));  
-                strcpy(*err, reply->str); 
+                *err = zmalloc((reply->len + 1) * sizeof(char));
+                strcpy(*err, reply->str);
                 CLUSTER_MANAGER_PRINT_REPLY_ERROR(source, err);
             }
             goto next;
@@ -2787,8 +2787,8 @@ static int clusterManagerMigrateKeysInSlot(clusterManagerNode *source,
         }
         if (verbose) dots = zmalloc((count+1) * sizeof(char));
         /* Calling MIGRATE command. */
-        migrate_reply = clusterManagerMigrateKeysInReply(source, target, 
-                                                         reply, 0, timeout, 
+        migrate_reply = clusterManagerMigrateKeysInReply(source, target,
+                                                         reply, 0, timeout,
                                                          dots);
         if (migrate_reply == NULL) goto next;
         if (migrate_reply->type == REDIS_REPLY_ERROR) {
@@ -2797,22 +2797,22 @@ static int clusterManagerMigrateKeysInSlot(clusterManagerNode *source,
                                       "Replacing it for FIX.\n");
                 freeReplyObject(migrate_reply);
                 /* Try to migrate keys adding REPLACE option. */
-                migrate_reply = clusterManagerMigrateKeysInReply(source, 
-                                                                 target, 
-                                                                 reply, 
+                migrate_reply = clusterManagerMigrateKeysInReply(source,
+                                                                 target,
+                                                                 reply,
                                                                  1, timeout,
                                                                  NULL);
-                success = (migrate_reply != NULL && 
+                success = (migrate_reply != NULL &&
                            migrate_reply->type != REDIS_REPLY_ERROR);
             } else success = 0;
             if (!success) {
                 if (migrate_reply != NULL) {
                     if (err) {
                         *err = zmalloc((migrate_reply->len + 1) * sizeof(char));
-                        strcpy(*err, migrate_reply->str); 
+                        strcpy(*err, migrate_reply->str);
                     }
                     printf("\n");
-                    CLUSTER_MANAGER_PRINT_REPLY_ERROR(source, 
+                    CLUSTER_MANAGER_PRINT_REPLY_ERROR(source,
                                                       migrate_reply->str);
                 }
                 goto next;
@@ -2832,34 +2832,34 @@ next:
 }
 
 /* Move slots between source and target nodes using MIGRATE.
- * 
+ *
  * Options:
  * CLUSTER_MANAGER_OPT_VERBOSE -- Print a dot for every moved key.
- * CLUSTER_MANAGER_OPT_COLD    -- Move keys without opening slots / 
+ * CLUSTER_MANAGER_OPT_COLD    -- Move keys without opening slots /
  *                                reconfiguring the nodes.
  * CLUSTER_MANAGER_OPT_UPDATE  -- Update node->slots for source/target nodes.
  * CLUSTER_MANAGER_OPT_QUIET   -- Don't print info messages.
 */
-static int clusterManagerMoveSlot(clusterManagerNode *source, 
-                                  clusterManagerNode *target, 
-                                  int slot, int opts,  char**err) 
+static int clusterManagerMoveSlot(clusterManagerNode *source,
+                                  clusterManagerNode *target,
+                                  int slot, int opts,  char**err)
 {
     if (!(opts & CLUSTER_MANAGER_OPT_QUIET)) {
-        printf("Moving slot %d from %s:%d to %s:%d: ", slot, source->ip, 
+        printf("Moving slot %d from %s:%d to %s:%d: ", slot, source->ip,
                source->port, target->ip, target->port);
         fflush(stdout);
     }
     if (err != NULL) *err = NULL;
-    int pipeline = config.cluster_manager_command.pipeline, 
+    int pipeline = config.cluster_manager_command.pipeline,
         timeout = config.cluster_manager_command.timeout,
         print_dots = (opts & CLUSTER_MANAGER_OPT_VERBOSE),
         option_cold = (opts & CLUSTER_MANAGER_OPT_COLD),
         success = 1;
     if (!option_cold) {
-        success = clusterManagerSetSlot(target, source, slot, 
+        success = clusterManagerSetSlot(target, source, slot,
                                         "importing", err);
         if (!success) return 0;
-        success = clusterManagerSetSlot(source, target, slot, 
+        success = clusterManagerSetSlot(source, target, slot,
                                         "migrating", err);
         if (!success) return 0;
     }
@@ -2876,16 +2876,16 @@ static int clusterManagerMoveSlot(clusterManagerNode *source,
             clusterManagerNode *n = ln->value;
             if (n->flags & CLUSTER_MANAGER_FLAG_SLAVE) continue;
             redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER "
-                                                    "SETSLOT %d %s %s", 
-                                                    slot, "node", 
-                                                    target->name);  
+                                                    "SETSLOT %d %s %s",
+                                                    slot, "node",
+                                                    target->name);
             success = (r != NULL);
             if (!success) return 0;
             if (r->type == REDIS_REPLY_ERROR) {
                 success = 0;
                 if (err != NULL) {
-                    *err = zmalloc((r->len + 1) * sizeof(char));  
-                    strcpy(*err, r->str); 
+                    *err = zmalloc((r->len + 1) * sizeof(char));
+                    strcpy(*err, r->str);
                     CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, err);
                 }
             }
@@ -2901,7 +2901,7 @@ static int clusterManagerMoveSlot(clusterManagerNode *source,
     return 1;
 }
 
-/* Flush the dirty node configuration by calling replicate for slaves or 
+/* Flush the dirty node configuration by calling replicate for slaves or
  * adding the slots defined in the masters. */
 static int clusterManagerFlushNodeConfig(clusterManagerNode *node, char **err) {
     if (!node->dirty) return 0;
@@ -2909,13 +2909,13 @@ static int clusterManagerFlushNodeConfig(clusterManagerNode *node, char **err) {
     int is_err = 0, success = 1;
     if (err != NULL) *err = NULL;
     if (node->replicate != NULL) {
-        reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER REPLICATE %s", 
-                                        node->replicate); 
+        reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER REPLICATE %s",
+                                        node->replicate);
         if (reply == NULL || (is_err = (reply->type == REDIS_REPLY_ERROR))) {
             if (is_err && err != NULL) {
-                *err = zmalloc((reply->len + 1) * sizeof(char));  
-                strcpy(*err, reply->str); 
-            } 
+                *err = zmalloc((reply->len + 1) * sizeof(char));
+                strcpy(*err, reply->str);
+            }
             success = 0;
             /* If the cluster did not already joined it is possible that
              * the slave does not know the master node yet. So on errors
@@ -2947,12 +2947,12 @@ static void clusterManagerWaitForClusterJoin(void) {
 /* Load node's cluster configuration by calling "CLUSTER NODES" command.
  * Node's configuration (name, replicate, slots, ...) is then updated.
  * If CLUSTER_MANAGER_OPT_GETFRIENDS flag is set into 'opts' argument,
- * and node already knows other nodes, the node's friends list is populated 
+ * and node already knows other nodes, the node's friends list is populated
  * with the other nodes info. */
-static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts, 
-                                      char **err) 
+static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
+                                      char **err)
 {
-    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER NODES"); 
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER NODES");
     int success = 1;
     *err = NULL;
     if (!clusterManagerCheckRedisReply(node, reply, err)) {
@@ -2962,16 +2962,16 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
     int getfriends = (opts & CLUSTER_MANAGER_OPT_GETFRIENDS);
     char *lines = reply->str, *p, *line;
     while ((p = strstr(lines, "\n")) != NULL) {
-        *p = '\0'; 
+        *p = '\0';
         line = lines;
         lines = p + 1;
-        char *name = NULL, *addr = NULL, *flags = NULL, *master_id = NULL, 
-             *ping_sent = NULL, *ping_recv = NULL, *config_epoch = NULL, 
+        char *name = NULL, *addr = NULL, *flags = NULL, *master_id = NULL,
+             *ping_sent = NULL, *ping_recv = NULL, *config_epoch = NULL,
              *link_status = NULL;
         UNUSED(link_status);
         int i = 0;
         while ((p = strchr(line, ' ')) != NULL) {
-            *p = '\0'; 
+            *p = '\0';
             char *token = line;
             line = p + 1;
             switch(i++){
@@ -2985,7 +2985,7 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
             case 7: link_status = token; break;
             }
             if (i == 8) break; // Slots
-        }         
+        }
         if (!flags) {
             success = 0;
             goto cleanup;
@@ -3004,7 +3004,7 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
                     remaining -= (p - line);
 
                     char *slotsdef = line;
-                    *p = '\0'; 
+                    *p = '\0';
                     if (remaining) {
                         line = p + 1;
                         remaining--;
@@ -3020,11 +3020,11 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
                             sds slot = sdsnew(slotsdef);
                             sds dst = sdsnew(p);
                             node->migrating_count += 2;
-                            node->migrating = zrealloc(node->migrating, 
+                            node->migrating = zrealloc(node->migrating,
                                 (node->migrating_count * sizeof(sds)));
-                            node->migrating[node->migrating_count - 2] = 
+                            node->migrating[node->migrating_count - 2] =
                                 slot;
-                            node->migrating[node->migrating_count - 1] = 
+                            node->migrating[node->migrating_count - 1] =
                                 dst;
                         }  else if ((p = strstr(slotsdef, "-<-"))) {//Importing
                             *p = '\0';
@@ -3034,13 +3034,13 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
                             sds slot = sdsnew(slotsdef);
                             sds src = sdsnew(p);
                             node->importing_count += 2;
-                            node->importing = zrealloc(node->importing, 
+                            node->importing = zrealloc(node->importing,
                                 (node->importing_count * sizeof(sds)));
-                            node->importing[node->importing_count - 2] = 
+                            node->importing[node->importing_count - 2] =
                                 slot;
-                            node->importing[node->importing_count - 1] = 
+                            node->importing[node->importing_count - 1] =
                                 src;
-                        } 
+                        }
                     } else if ((dash = strchr(slotsdef, '-')) != NULL) {
                         p = dash;
                         int start, stop;
@@ -3092,7 +3092,7 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
             sds flag = NULL;
             char *fp = strchr(flags, ',');
             if (fp) {
-                *fp = '\0'; 
+                *fp = '\0';
                 flag = sdsnew(flags);
                 flags = fp + 1;
             } else {
@@ -3114,7 +3114,7 @@ static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts,
             }
             listAddNodeTail(currentNode->flags_str, flag);
         }
-        if (config_epoch != NULL) 
+        if (config_epoch != NULL)
             currentNode->current_epoch = atoll(config_epoch);
         if (ping_sent != NULL) currentNode->ping_sent = atoll(ping_sent);
         if (ping_recv != NULL) currentNode->ping_recv = atoll(ping_recv);
@@ -3125,16 +3125,16 @@ cleanup:
     return success;
 }
 
-/* Retrieves info about the cluster using argument 'node' as the starting 
+/* Retrieves info about the cluster using argument 'node' as the starting
  * point. All nodes will be loaded inside the cluster_manager.nodes list.
- * Warning: if something goes wrong, it will free the starting node before 
+ * Warning: if something goes wrong, it will free the starting node before
  * returning 0. */
 static int clusterManagerLoadInfoFromNode(clusterManagerNode *node, int opts) {
-    if (node->context == NULL) 
+    if (node->context == NULL)
         CLUSTER_MANAGER_NODE_CONNECT(node);
     if (node->context->err) {
         fprintf(stderr,"Could not connect to Redis at ");
-        fprintf(stderr,"%s:%d: %s\n", node->ip, node->port, 
+        fprintf(stderr,"%s:%d: %s\n", node->ip, node->port,
                 node->context->errstr);
         freeClusterManagerNode(node);
         return 0;
@@ -3160,7 +3160,7 @@ static int clusterManagerLoadInfoFromNode(clusterManagerNode *node, int opts) {
     listNode *ln;
     if (cluster_manager.nodes != NULL) {
         listRewind(cluster_manager.nodes, &li);
-        while ((ln = listNext(&li)) != NULL) 
+        while ((ln = listNext(&li)) != NULL)
             freeClusterManagerNode((clusterManagerNode *) ln->value);
         listRelease(cluster_manager.nodes);
     }
@@ -3176,8 +3176,8 @@ static int clusterManagerLoadInfoFromNode(clusterManagerNode *node, int opts) {
             if (friend->context->err) goto invalid_friend;
             e = NULL;
             if (clusterManagerNodeLoadInfo(friend, 0, &e)) {
-                if (friend->flags & (CLUSTER_MANAGER_FLAG_NOADDR | 
-                                     CLUSTER_MANAGER_FLAG_DISCONNECT | 
+                if (friend->flags & (CLUSTER_MANAGER_FLAG_NOADDR |
+                                     CLUSTER_MANAGER_FLAG_DISCONNECT |
                                      CLUSTER_MANAGER_FLAG_FAIL))
                     goto invalid_friend;
                 listAddNodeTail(cluster_manager.nodes, friend);
@@ -3197,25 +3197,25 @@ invalid_friend:
     // Count replicas for each node
     listRewind(cluster_manager.nodes, &li);
     while ((ln = listNext(&li)) != NULL) {
-        clusterManagerNode *n = ln->value; 
+        clusterManagerNode *n = ln->value;
         if (n->replicate != NULL) {
             clusterManagerNode *master = clusterManagerNodeByName(n->replicate);
             if (master == NULL) {
                 clusterManagerLogWarn("*** WARNING: %s:%d claims to be "
-                                      "slave of unknown node ID %s.\n", 
+                                      "slave of unknown node ID %s.\n",
                                       n->ip, n->port, n->replicate);
             } else master->replicas_count++;
         }
     }
-    return 1;                                          
+    return 1;
 }
 
 /* Compare functions used by various sorting operations. */
-int clusterManagerSlotCompare(const void *slot1, const void *slot2) { 
+int clusterManagerSlotCompare(const void *slot1, const void *slot2) {
     const char **i1 = (const char **)slot1;
     const char **i2 = (const char **)slot2;
     return strcmp(*i1, *i2);
-} 
+}
 
 int clusterManagerSlotCountCompareDesc(const void *n1, const void *n2) {
     clusterManagerNode *node1 = *((clusterManagerNode **) n1);
@@ -3233,19 +3233,19 @@ static sds clusterManagerGetConfigSignature(clusterManagerNode *node) {
     sds signature = NULL;
     int node_count = 0, i = 0, name_len = 0;
     char **node_configs = NULL;
-    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER NODES"); 
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER NODES");
     if (reply == NULL || reply->type == REDIS_REPLY_ERROR)
         goto cleanup;
     char *lines = reply->str, *p, *line;
     while ((p = strstr(lines, "\n")) != NULL) {
         i = 0;
-        *p = '\0'; 
+        *p = '\0';
         line = lines;
         lines = p + 1;
         char *nodename = NULL;
         int tot_size = 0;
         while ((p = strchr(line, ' ')) != NULL) {
-            *p = '\0'; 
+            *p = '\0';
             char *token = line;
             line = p + 1;
             if (i == 0) {
@@ -3268,7 +3268,7 @@ static sds clusterManagerGetConfigSignature(clusterManagerNode *node) {
             remaining -= size;
             tot_size += size;
             char *slotsdef = line;
-            *p = '\0'; 
+            *p = '\0';
             if (remaining) {
                 line = p + 1;
                 remaining--;
@@ -3281,9 +3281,9 @@ static sds clusterManagerGetConfigSignature(clusterManagerNode *node) {
         }
         if (c > 0) {
             if (c > 1)
-                qsort(slots, c, sizeof(char *), clusterManagerSlotCompare); 
+                qsort(slots, c, sizeof(char *), clusterManagerSlotCompare);
             node_count++;
-            node_configs = 
+            node_configs =
                 zrealloc(node_configs, (node_count * sizeof(char *)));
             /* Make room for '|' separators. */
             tot_size += (sizeof(char) * (c - 1));
@@ -3304,12 +3304,12 @@ static sds clusterManagerGetConfigSignature(clusterManagerNode *node) {
     }
     if (node_count > 0) {
         if (node_count > 1) {
-            qsort(node_configs, node_count, sizeof(char *), 
+            qsort(node_configs, node_count, sizeof(char *),
                   clusterManagerSlotCompare);
         }
         signature = sdsempty();
         for (i = 0; i < node_count; i++) {
-            if (i > 0) signature = sdscatprintf(signature, "%c", '|'); 
+            if (i > 0) signature = sdscatprintf(signature, "%c", '|');
             signature = sdscatfmt(signature, "%s", node_configs[i]);
         }
     }
@@ -3357,8 +3357,8 @@ static void clusterManagerOnError(sds err) {
     clusterManagerLogErr("%s\n", (char *) err);
 }
 
-/* Check the slots coverage of the cluster. The 'all_slots' argument must be 
- * and array of 16384 bytes. Every covered slot will be set to 1 in the 
+/* Check the slots coverage of the cluster. The 'all_slots' argument must be
+ * and array of 16384 bytes. Every covered slot will be set to 1 in the
  * 'all_slots' array. The function returns the total number if covered slots.*/
 static int clusterManagerGetCoveredSlots(char *all_slots) {
     if (cluster_manager.nodes == NULL) return 0;
@@ -3384,7 +3384,7 @@ static void clusterManagerPrintSlotsList(list *slots) {
     listRewind(slots, &li);
     sds first = NULL;
     while ((ln = listNext(&li)) != NULL) {
-        sds slot = ln->value; 
+        sds slot = ln->value;
         if (!first) first = slot;
         else printf(", ");
         printf("%s", slot);
@@ -3395,8 +3395,8 @@ static void clusterManagerPrintSlotsList(list *slots) {
 /* Return the node, among 'nodes' with the greatest number of keys
  * in the specified slot. */
 static clusterManagerNode * clusterManagerGetNodeWithMostKeysInSlot(list *nodes,
-                                                                    int slot, 
-                                                                    char **err) 
+                                                                    int slot,
+                                                                    char **err)
 {
     clusterManagerNode *node = NULL;
     int numkeys = 0;
@@ -3408,19 +3408,19 @@ static clusterManagerNode * clusterManagerGetNodeWithMostKeysInSlot(list *nodes,
         clusterManagerNode *n = ln->value;
         if (n->flags & CLUSTER_MANAGER_FLAG_SLAVE || n->replicate)
             continue;
-        redisReply *r = 
-            CLUSTER_MANAGER_COMMAND(n, "CLUSTER COUNTKEYSINSLOT %d", slot); 
+        redisReply *r =
+            CLUSTER_MANAGER_COMMAND(n, "CLUSTER COUNTKEYSINSLOT %d", slot);
         int success = clusterManagerCheckRedisReply(n, r, err);
         if (success) {
             if (r->integer > numkeys || node == NULL) {
                 numkeys = r->integer;
                 node = n;
-            } 
+            }
         }
         if (r != NULL) freeReplyObject(r);
         /* If the reply contains errors */
         if (!success) {
-            if (err != NULL && *err != NULL) 
+            if (err != NULL && *err != NULL)
                 CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, err);
             node = NULL;
             break;
@@ -3458,7 +3458,7 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
     int uncovered_count = 0;
     sds log = sdsempty();
     for (i = 0; i < CLUSTER_MANAGER_SLOTS; i++) {
-        int covered = all_slots[i]; 
+        int covered = all_slots[i];
         if (!covered) {
             sds key = sdsfromlonglong((long long) i);
             if (uncovered_count++ > 0) printf(",");
@@ -3469,10 +3469,10 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
             listNode *ln;
             listRewind(cluster_manager.nodes, &li);
             while ((ln = listNext(&li)) != NULL) {
-                clusterManagerNode *n = ln->value; 
+                clusterManagerNode *n = ln->value;
                 if (n->flags & CLUSTER_MANAGER_FLAG_SLAVE || n->replicate)
                     continue;
-                redisReply *reply = CLUSTER_MANAGER_COMMAND(n, 
+                redisReply *reply = CLUSTER_MANAGER_COMMAND(n,
                     "CLUSTER GETKEYSINSLOT %d %d", i, 1);
                 if (!clusterManagerCheckRedisReply(n, reply, NULL)) {
                     fixed = -1;
@@ -3484,12 +3484,12 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
                     listAddNodeTail(slot_nodes, n);
                     if (listLength(slot_nodes) > 1)
                         slot_nodes_str = sdscat(slot_nodes_str, ", ");
-                    slot_nodes_str = sdscatfmt(slot_nodes_str, 
+                    slot_nodes_str = sdscatfmt(slot_nodes_str,
                                                "%s:%u", n->ip, n->port);
                 }
                 freeReplyObject(reply);
             }
-            log = sdscatfmt(log, "\nSlot %S has keys in %u nodes: %S", 
+            log = sdscatfmt(log, "\nSlot %S has keys in %u nodes: %S",
                             key, listLength(slot_nodes), slot_nodes_str);
             sdsfree(slot_nodes_str);
             dictAdd(clusterManagerUncoveredSlots, key, slot_nodes);
@@ -3512,7 +3512,7 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
         case 0: listAddNodeTail(none, slot); break;
         case 1: listAddNodeTail(single, slot); break;
         default: listAddNodeTail(multi, slot); break;
-        } 
+        }
     }
     dictReleaseIterator(iter);
 
@@ -3527,19 +3527,19 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
             listNode *ln;
             listRewind(none, &li);
             while ((ln = listNext(&li)) != NULL) {
-                sds slot = ln->value; 
+                sds slot = ln->value;
                 long idx = (long) (rand() % listLength(cluster_manager.nodes));
                 listNode *node_n = listIndex(cluster_manager.nodes, idx);
                 assert(node_n != NULL);
                 clusterManagerNode *n = node_n->value;
-                clusterManagerLogInfo(">>> Covering slot %s with %s:%d\n", 
+                clusterManagerLogInfo(">>> Covering slot %s with %s:%d\n",
                                       slot, n->ip, n->port);
-                redisReply *r = CLUSTER_MANAGER_COMMAND(n, 
+                redisReply *r = CLUSTER_MANAGER_COMMAND(n,
                     "CLUSTER ADDSLOTS %s", slot);
                 if (!clusterManagerCheckRedisReply(n, r, NULL)) fixed = -1;
                 if (r) freeReplyObject(r);
                 if (fixed < 0) goto cleanup;
-                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
                  * info into the node struct, in order to keep it synced */
                 n->slots[atoi(slot)] = 1;
                 fixed++;
@@ -3556,21 +3556,21 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
             listNode *ln;
             listRewind(single, &li);
             while ((ln = listNext(&li)) != NULL) {
-                sds slot = ln->value; 
+                sds slot = ln->value;
                 dictEntry *entry = dictFind(clusterManagerUncoveredSlots, slot);
                 assert(entry != NULL);
                 list *nodes = (list *) dictGetVal(entry);
                 listNode *fn = listFirst(nodes);
                 assert(fn != NULL);
                 clusterManagerNode *n = fn->value;
-                clusterManagerLogInfo(">>> Covering slot %s with %s:%d\n", 
+                clusterManagerLogInfo(">>> Covering slot %s with %s:%d\n",
                                       slot, n->ip, n->port);
-                redisReply *r = CLUSTER_MANAGER_COMMAND(n, 
+                redisReply *r = CLUSTER_MANAGER_COMMAND(n,
                     "CLUSTER ADDSLOTS %s", slot);
                 if (!clusterManagerCheckRedisReply(n, r, NULL)) fixed = -1;
                 if (r) freeReplyObject(r);
                 if (fixed < 0) goto cleanup;
-                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
                  * info into the node struct, in order to keep it synced */
                 n->slots[atoi(slot)] = 1;
                 fixed++;
@@ -3588,21 +3588,21 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
             listNode *ln;
             listRewind(multi, &li);
             while ((ln = listNext(&li)) != NULL) {
-                sds slot = ln->value; 
+                sds slot = ln->value;
                 dictEntry *entry = dictFind(clusterManagerUncoveredSlots, slot);
                 assert(entry != NULL);
                 list *nodes = (list *) dictGetVal(entry);
                 int s = atoi(slot);
-                clusterManagerNode *target = 
+                clusterManagerNode *target =
                     clusterManagerGetNodeWithMostKeysInSlot(nodes, s, NULL);
                 if (target == NULL) {
                     fixed = -1;
                     goto cleanup;
                 }
                 clusterManagerLogInfo(">>> Covering slot %s moving keys "
-                                      "to %s:%d\n", slot, 
+                                      "to %s:%d\n", slot,
                                       target->ip, target->port);
-                redisReply *r = CLUSTER_MANAGER_COMMAND(target, 
+                redisReply *r = CLUSTER_MANAGER_COMMAND(target,
                     "CLUSTER ADDSLOTS %s", slot);
                 if (!clusterManagerCheckRedisReply(target, r, NULL)) fixed = -1;
                 if (r) freeReplyObject(r);
@@ -3612,7 +3612,7 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
                 if (!clusterManagerCheckRedisReply(target, r, NULL)) fixed = -1;
                 if (r) freeReplyObject(r);
                 if (fixed < 0) goto cleanup;
-                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
                  * info into the node struct, in order to keep it synced */
                 target->slots[atoi(slot)] = 1;
                 listIter nli;
@@ -3621,18 +3621,18 @@ static int clusterManagerFixSlotsCoverage(char *all_slots) {
                 while ((nln = listNext(&nli)) != NULL) {
                     clusterManagerNode *src = nln->value;
                     if (src == target) continue;
-                    /* Set the source node in 'importing' state 
-                     * (even if we will actually migrate keys away) 
-                     * in order to avoid receiving redirections 
+                    /* Set the source node in 'importing' state
+                     * (even if we will actually migrate keys away)
+                     * in order to avoid receiving redirections
                      * for MIGRATE. */
-                    redisReply *r = CLUSTER_MANAGER_COMMAND(src, 
-                        "CLUSTER SETSLOT %s %s %s", slot, 
+                    redisReply *r = CLUSTER_MANAGER_COMMAND(src,
+                        "CLUSTER SETSLOT %s %s %s", slot,
                         "IMPORTING", target->name);
-                    if (!clusterManagerCheckRedisReply(target, r, NULL)) 
+                    if (!clusterManagerCheckRedisReply(target, r, NULL))
                         fixed = -1;
                     if (r) freeReplyObject(r);
                     if (fixed < 0) goto cleanup;
-                    int opts = CLUSTER_MANAGER_OPT_VERBOSE | 
+                    int opts = CLUSTER_MANAGER_OPT_VERBOSE |
                                CLUSTER_MANAGER_OPT_COLD;
                     if (!clusterManagerMoveSlot(src, target, s, opts, NULL)) {
                         fixed = -1;
@@ -3673,7 +3673,7 @@ static int clusterManagerFixOpenSlot(int slot) {
         if (n->flags & CLUSTER_MANAGER_FLAG_SLAVE) continue;
         if (n->slots[slot]) {
             if (owner == NULL) owner = n;
-            listAddNodeTail(owners, n); 
+            listAddNodeTail(owners, n);
         }
     }
     listRewind(cluster_manager.nodes, &li);
@@ -3682,10 +3682,10 @@ static int clusterManagerFixOpenSlot(int slot) {
         if (n->flags & CLUSTER_MANAGER_FLAG_SLAVE) continue;
         if (n->migrating) {
             for (int i = 0; i < n->migrating_count; i += 2) {
-                sds migrating_slot = n->migrating[i]; 
+                sds migrating_slot = n->migrating[i];
                 if (atoi(migrating_slot) == slot) {
                     char *sep = (listLength(migrating) == 0 ? "" : ",");
-                    migrating_str = sdscatfmt(migrating_str, "%s%S:%u", 
+                    migrating_str = sdscatfmt(migrating_str, "%s%S:%u",
                                               sep, n->ip, n->port);
                     listAddNodeTail(migrating, n);
                     break;
@@ -3694,10 +3694,10 @@ static int clusterManagerFixOpenSlot(int slot) {
         }
         if (n->importing) {
             for (int i = 0; i < n->importing_count; i += 2) {
-                sds importing_slot = n->importing[i]; 
+                sds importing_slot = n->importing[i];
                 if (atoi(importing_slot) == slot) {
                     char *sep = (listLength(importing) == 0 ? "" : ",");
-                    importing_str = sdscatfmt(importing_str, "%s%S:%u", 
+                    importing_str = sdscatfmt(importing_str, "%s%S:%u",
                                               sep, n->ip, n->port);
                     listAddNodeTail(importing, n);
                     break;
@@ -3712,7 +3712,7 @@ static int clusterManagerFixOpenSlot(int slot) {
     if (owner == NULL) {
         clusterManagerLogInfo(">>> Nobody claims ownership, "
                               "selecting an owner...\n");
-        owner = clusterManagerGetNodeWithMostKeysInSlot(cluster_manager.nodes, 
+        owner = clusterManagerGetNodeWithMostKeysInSlot(cluster_manager.nodes,
                                                         slot, NULL);
         // If we still don't have an owner, we can't fix it.
         if (owner == NULL) {
@@ -3723,10 +3723,10 @@ static int clusterManagerFixOpenSlot(int slot) {
         }
 
         // Use ADDSLOTS to assign the slot.
-        clusterManagerLogWarn("*** Configuring %s:%d as the slot owner\n", 
+        clusterManagerLogWarn("*** Configuring %s:%d as the slot owner\n",
                               owner->ip, owner->port);
         redisReply *reply = CLUSTER_MANAGER_COMMAND(owner, "CLUSTER "
-                                                    "SETSLOT %d %s", 
+                                                    "SETSLOT %d %s",
                                                     slot, "STABLE");
         success = clusterManagerCheckRedisReply(owner, reply, NULL);
         if (reply) freeReplyObject(reply);
@@ -3735,7 +3735,7 @@ static int clusterManagerFixOpenSlot(int slot) {
         success = clusterManagerCheckRedisReply(owner, reply, NULL);
         if (reply) freeReplyObject(reply);
         if (!success) goto cleanup;
-        /* Since CLUSTER ADDSLOTS succeeded, we also update the slot 
+        /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
          * info into the node struct, in order to keep it synced */
         owner->slots[slot] = 1;
         /* Make sure this information will propagate. Not strictly needed
@@ -3769,7 +3769,7 @@ static int clusterManagerFixOpenSlot(int slot) {
             success = clusterManagerCheckRedisReply(n, reply, NULL);
             if (reply) freeReplyObject(reply);
             if (!success) goto cleanup;
-            success = clusterManagerSetSlot(n, owner, slot, "importing", NULL); 
+            success = clusterManagerSetSlot(n, owner, slot, "importing", NULL);
             if (!success) goto cleanup;
             clusterManagerRemoveNodeFromList(importing, n); //Avoid duplicates
             listAddNodeTail(importing, n);
@@ -3786,7 +3786,7 @@ static int clusterManagerFixOpenSlot(int slot) {
         clusterManagerNode *src = listFirst(migrating)->value;
         clusterManagerNode *dst = listFirst(importing)->value;
         success = clusterManagerMoveSlot(src, dst, slot, move_opts, NULL);
-    } 
+    }
     /* Case 2: There are multiple nodes that claim the slot as importing,
      * they probably got keys about the slot after a restart so opened
      * the slot. In this case we just move all the keys to the owner
@@ -3804,18 +3804,18 @@ static int clusterManagerFixOpenSlot(int slot) {
             clusterManagerLogInfo(">>> Setting %d as STABLE in "
                                   "%s:%d\n", slot, n->ip, n->port);
 
-            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER SETSLOT %d %s", 
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER SETSLOT %d %s",
                                                     slot, "STABLE");
             success = clusterManagerCheckRedisReply(n, r, NULL);
             if (r) freeReplyObject(r);
             if (!success) goto cleanup;
         }
     } else {
-        int try_to_close_slot = (listLength(importing) == 0 && 
-                                 listLength(migrating) == 1); 
+        int try_to_close_slot = (listLength(importing) == 0 &&
+                                 listLength(migrating) == 1);
         if (try_to_close_slot) {
             clusterManagerNode *n = listFirst(migrating)->value;
-            redisReply *r = CLUSTER_MANAGER_COMMAND(n, 
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n,
                 "CLUSTER GETKEYSINSLOT %d %d", slot, 10);
             success = clusterManagerCheckRedisReply(n, r, NULL);
             if (r) {
@@ -3829,7 +3829,7 @@ static int clusterManagerFixOpenSlot(int slot) {
      * can just close the slot, probably a reshard interrupted in the middle. */
         if (try_to_close_slot) {
             clusterManagerNode *n = listFirst(migrating)->value;
-            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER SETSLOT %d %s", 
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER SETSLOT %d %s",
                                                     slot, "STABLE");
             success = clusterManagerCheckRedisReply(n, r, NULL);
             if (r) freeReplyObject(r);
@@ -3839,7 +3839,7 @@ static int clusterManagerFixOpenSlot(int slot) {
             clusterManagerLogErr("[ERR] Sorry, redis-cli can't fix this slot "
                                  "yet (work in progress). Slot is set as "
                                  "migrating in %s, as importing in %s, "
-                                 "owner is %s:%d\n", migrating_str, 
+                                 "owner is %s:%d\n", migrating_str,
                                  importing_str, owner->ip, owner->port);
         }
     }
@@ -3856,10 +3856,10 @@ static int clusterManagerCheckCluster(int quiet) {
     listNode *ln = listFirst(cluster_manager.nodes);
     if (!ln) return 0;
     int result = 1;
-    int do_fix = config.cluster_manager_command.flags & 
+    int do_fix = config.cluster_manager_command.flags &
                  CLUSTER_MANAGER_CMD_FLAG_FIX;
     clusterManagerNode *node = ln->value;
-    clusterManagerLogInfo(">>> Performing Cluster Check (using node %s:%d)\n", 
+    clusterManagerLogInfo(">>> Performing Cluster Check (using node %s:%d)\n",
                           node->ip, node->port);
     if (!quiet) clusterManagerShowNodes();
     if (!clusterManagerIsConfigConsistent()) {
@@ -3877,12 +3877,12 @@ static int clusterManagerCheckCluster(int quiet) {
     int i;
     dict *open_slots = NULL;
     while ((ln = listNext(&li)) != NULL) {
-        clusterManagerNode *n = ln->value; 
+        clusterManagerNode *n = ln->value;
         if (n->migrating != NULL) {
-            if (open_slots == NULL) 
+            if (open_slots == NULL)
                 open_slots = dictCreate(&clusterManagerDictType, NULL);
             sds errstr = sdsempty();
-            errstr = sdscatprintf(errstr, 
+            errstr = sdscatprintf(errstr,
                                 "[WARNING] Node %s:%d has slots in "
                                 "migrating state ",
                                 n->ip,
@@ -3892,15 +3892,15 @@ static int clusterManagerCheckCluster(int quiet) {
                 dictAdd(open_slots, slot, sdsdup(n->migrating[i + 1]));
                 char *fmt = (i > 0 ? ",%S" : "%S");
                 errstr = sdscatfmt(errstr, fmt, slot);
-            } 
+            }
             errstr = sdscat(errstr, ".");
             clusterManagerOnError(errstr);
         }
         if (n->importing != NULL) {
-            if (open_slots == NULL) 
+            if (open_slots == NULL)
                 open_slots = dictCreate(&clusterManagerDictType, NULL);
             sds errstr = sdsempty();
-            errstr = sdscatprintf(errstr, 
+            errstr = sdscatprintf(errstr,
                                 "[WARNING] Node %s:%d has slots in "
                                 "importing state ",
                                 n->ip,
@@ -3910,7 +3910,7 @@ static int clusterManagerCheckCluster(int quiet) {
                 dictAdd(open_slots, slot, sdsdup(n->importing[i + 1]));
                 char *fmt = (i > 0 ? ",%S" : "%S");
                 errstr = sdscatfmt(errstr, fmt, slot);
-            } 
+            }
             errstr = sdscat(errstr, ".");
             clusterManagerOnError(errstr);
         }
@@ -3946,12 +3946,12 @@ static int clusterManagerCheckCluster(int quiet) {
     memset(slots, 0, CLUSTER_MANAGER_SLOTS);
     int coverage = clusterManagerGetCoveredSlots(slots);
     if (coverage == CLUSTER_MANAGER_SLOTS) {
-        clusterManagerLogOk("[OK] All %d slots covered.\n", 
+        clusterManagerLogOk("[OK] All %d slots covered.\n",
                             CLUSTER_MANAGER_SLOTS);
     } else {
         sds err = sdsempty();
         err = sdscatprintf(err, "[ERR] Not all %d slots are "
-                                "covered by nodes.\n", 
+                                "covered by nodes.\n",
                                 CLUSTER_MANAGER_SLOTS);
         clusterManagerOnError(err);
         result = 0;
@@ -3966,11 +3966,11 @@ static int clusterManagerCheckCluster(int quiet) {
     return result;
 }
 
-static clusterManagerNode *clusterNodeForResharding(char *id, 
+static clusterManagerNode *clusterNodeForResharding(char *id,
                                                     clusterManagerNode *target,
-                                                    int *raise_err) 
+                                                    int *raise_err)
 {
-    clusterManagerNode *node = NULL; 
+    clusterManagerNode *node = NULL;
     const char *invalid_node_msg = "*** The specified node (%s) is not known "
                                    "or not a master, please retry.\n";
     node = clusterManagerNodeByName(id);
@@ -3985,7 +3985,7 @@ static clusterManagerNode *clusterNodeForResharding(char *id,
                                   "the target node as "
                                   "source node.\n");
             return NULL;
-        } 
+        }
     }
     return node;
 }
@@ -4002,10 +4002,10 @@ static list *clusterManagerComputeReshardTable(list *sources, int numslots) {
         tot_slots += node->slots_count;
         sorted[i++] = node;
     }
-    qsort(sorted, src_count, sizeof(clusterManagerNode *), 
+    qsort(sorted, src_count, sizeof(clusterManagerNode *),
           clusterManagerSlotCountCompareDesc);
     for (i = 0; i < src_count; i++) {
-        clusterManagerNode *node = sorted[i]; 
+        clusterManagerNode *node = sorted[i];
         float n = ((float) numslots / tot_slots * node->slots_count);
         if (i == 0) n = ceil(n);
         else n = floor(n);
@@ -4050,10 +4050,10 @@ static void clusterManagerReleaseReshardTable(list *table) {
 }
 
 static void clusterManagerLog(int level, const char* fmt, ...) {
-    int use_colors = 
+    int use_colors =
         (config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_COLOR);
     if (use_colors) {
-        printf("\033["); 
+        printf("\033[");
         switch (level) {
         case CLUSTER_MANAGER_LOG_LVL_INFO: printf(LOG_COLOR_BOLD); break;
         case CLUSTER_MANAGER_LOG_LVL_WARN: printf(LOG_COLOR_YELLOW); break;
@@ -4069,8 +4069,8 @@ static void clusterManagerLog(int level, const char* fmt, ...) {
     if (use_colors) printf("\033[" LOG_COLOR_RESET);
 }
 
-static void clusterManagerNodeArrayInit(clusterManagerNodeArray *array, 
-                                        int alloc_len) 
+static void clusterManagerNodeArrayInit(clusterManagerNodeArray *array,
+                                        int alloc_len)
 {
     array->nodes = zcalloc(alloc_len * sizeof(clusterManagerNode*));
     array->alloc = array->nodes;
@@ -4093,8 +4093,8 @@ static void clusterManagerNodeArrayReset(clusterManagerNodeArray *array) {
 }
 
 /* Shift array->nodes and store the shifted node into 'nodeptr'. */
-static void clusterManagerNodeArrayShift(clusterManagerNodeArray *array, 
-                                         clusterManagerNode **nodeptr) 
+static void clusterManagerNodeArrayShift(clusterManagerNodeArray *array,
+                                         clusterManagerNode **nodeptr)
 {
     assert(array->nodes < (array->nodes + array->len));
     /* If the first node to be shifted is not NULL, decrement count. */
@@ -4107,7 +4107,7 @@ static void clusterManagerNodeArrayShift(clusterManagerNodeArray *array,
 }
 
 static void clusterManagerNodeArrayAdd(clusterManagerNodeArray *array,
-                                       clusterManagerNode *node) 
+                                       clusterManagerNode *node)
 {
     assert(array->nodes < (array->nodes + array->len));
     assert(node != NULL);
@@ -4115,10 +4115,10 @@ static void clusterManagerNodeArrayAdd(clusterManagerNodeArray *array,
     array->nodes[array->count++] = node;
 }
 
-static void clusterManagerPrintNotEmptyNodeError(clusterManagerNode *node, 
-                                                 char *err) 
+static void clusterManagerPrintNotEmptyNodeError(clusterManagerNode *node,
+                                                 char *err)
 {
-    char *msg; 
+    char *msg;
     if (err) msg = err;
     else {
         msg = "is not empty. Either the node already knows other "
@@ -4128,8 +4128,8 @@ static void clusterManagerPrintNotEmptyNodeError(clusterManagerNode *node,
     clusterManagerLogErr("[ERR] Node %s:%d %s\n", node->ip, node->port, msg);
 }
 
-static void clusterManagerPrintNotClusterNodeError(clusterManagerNode *node, 
-                                                   char *err) 
+static void clusterManagerPrintNotClusterNodeError(clusterManagerNode *node,
+                                                   char *err)
 {
     char *msg = (err ? err : "is not configured as a cluster node.");
     clusterManagerLogErr("[ERR] Node %s:%d %s\n", node->ip, node->port, msg);
@@ -4206,17 +4206,17 @@ static int clusterManagerCommandCreate(int argc, char **argv) {
     if (masters_count < 3) {
         clusterManagerLogErr(
             "*** ERROR: Invalid configuration for cluster creation.\n"
-            "*** Redis Cluster requires at least 3 master nodes.\n" 
-            "*** This is not possible with %d nodes and %d replicas per node.", 
+            "*** Redis Cluster requires at least 3 master nodes.\n"
+            "*** This is not possible with %d nodes and %d replicas per node.",
             node_len, replicas);
-        clusterManagerLogErr("\n*** At least %d nodes are required.\n", 
+        clusterManagerLogErr("\n*** At least %d nodes are required.\n",
                              3 * (replicas + 1));
         return 0;
     }
     clusterManagerLogInfo(">>> Performing hash slots allocation "
                           "on %d nodes...\n", node_len);
     int interleaved_len = 0, ip_count = 0;
-    clusterManagerNode **interleaved = zcalloc(node_len*sizeof(**interleaved)); 
+    clusterManagerNode **interleaved = zcalloc(node_len*sizeof(**interleaved));
     char **ips = zcalloc(node_len * sizeof(char*));
     clusterManagerNodeArray *ip_nodes = zcalloc(node_len * sizeof(*ip_nodes));
     listIter li;
@@ -4248,7 +4248,7 @@ static int clusterManagerCommandCreate(int argc, char **argv) {
                 clusterManagerNodeArrayShift(node_array, &n);
                 interleaved[interleaved_len++] = n;
             }
-        }    
+        }
     }
     clusterManagerNode **masters = interleaved;
     interleaved += masters_count;
@@ -4258,7 +4258,7 @@ static int clusterManagerCommandCreate(int argc, char **argv) {
     float cursor = 0.0f;
     for (i = 0; i < masters_count; i++) {
         clusterManagerNode *master = masters[i];
-        long last = lround(cursor + slots_per_node - 1); 
+        long last = lround(cursor + slots_per_node - 1);
         if (last > CLUSTER_MANAGER_SLOTS || i == (masters_count - 1))
             last = CLUSTER_MANAGER_SLOTS - 1;
         if (last < first) last = first;
@@ -4279,7 +4279,7 @@ assign_replicas:
         clusterManagerNode *master = masters[i];
         int assigned_replicas = 0;
         while (assigned_replicas < replicas) {
-            if (available_count == 0) break; 
+            if (available_count == 0) break;
             clusterManagerNode *found = NULL, *slave = NULL;
             int firstNodeIdx = -1;
             for (j = 0; j < interleaved_len; j++) {
@@ -4294,7 +4294,7 @@ assign_replicas:
             }
             if (found) slave = found;
             else if (firstNodeIdx >= 0) {
-                slave = interleaved[firstNodeIdx]; 
+                slave = interleaved[firstNodeIdx];
                 interleaved_len -= (interleaved - (interleaved + firstNodeIdx));
                 interleaved += (firstNodeIdx + 1);
             }
@@ -4302,10 +4302,10 @@ assign_replicas:
                 assigned_replicas++;
                 available_count--;
                 if (slave->replicate) sdsfree(slave->replicate);
-                slave->replicate = sdsnew(master->name); 
+                slave->replicate = sdsnew(master->name);
                 slave->dirty = 1;
             } else break;
-            printf("Adding replica %s:%d to %s:%d\n", slave->ip, slave->port, 
+            printf("Adding replica %s:%d to %s:%d\n", slave->ip, slave->port,
                    master->ip, master->port);
             if (assign_unused) break;
         }
@@ -4344,8 +4344,8 @@ assign_replicas:
         while ((ln = listNext(&li)) != NULL) {
             clusterManagerNode *node = ln->value;
             redisReply *reply = NULL;
-            reply = CLUSTER_MANAGER_COMMAND(node, 
-                                            "cluster set-config-epoch %d", 
+            reply = CLUSTER_MANAGER_COMMAND(node,
+                                            "cluster set-config-epoch %d",
                                             config_epoch++);
             if (reply != NULL) freeReplyObject(reply);
         }
@@ -4360,7 +4360,7 @@ assign_replicas:
                 continue;
             }
             redisReply *reply = NULL;
-            reply = CLUSTER_MANAGER_COMMAND(node, "cluster meet %s %d", 
+            reply = CLUSTER_MANAGER_COMMAND(node, "cluster meet %s %d",
                                             first->ip, first->port);
             int is_err = 0;
             if (reply != NULL) {
@@ -4377,7 +4377,7 @@ assign_replicas:
             }
         }
         /* Give one second for the join to start, in order to avoid that
-         * waiting for cluster join will find all the nodes agree about 
+         * waiting for cluster join will find all the nodes agree about
          * the config as they are still empty with unassigned slots. */
         sleep(1);
         clusterManagerWaitForClusterJoin();
@@ -4408,7 +4408,7 @@ assign_replicas:
         listEmpty(cluster_manager.nodes);
         if (!clusterManagerLoadInfoFromNode(first_node, 0)) {
             success = 0;
-            goto cleanup; 
+            goto cleanup;
         }
         clusterManagerCheckCluster(0);
     }
@@ -4429,11 +4429,11 @@ static int clusterManagerCommandAddNode(int argc, char **argv) {
     redisReply *reply = NULL;
     char *ref_ip = NULL, *ip = NULL;
     int ref_port = 0, port = 0;
-    if (!getClusterHostFromCmdArgs(argc - 1, argv + 1, &ref_ip, &ref_port)) 
+    if (!getClusterHostFromCmdArgs(argc - 1, argv + 1, &ref_ip, &ref_port))
         goto invalid_args;
     if (!getClusterHostFromCmdArgs(1, argv, &ip, &port))
         goto invalid_args;
-    clusterManagerLogInfo(">>> Adding node %s:%d to cluster %s:%d\n", ip, port, 
+    clusterManagerLogInfo(">>> Adding node %s:%d to cluster %s:%d\n", ip, port,
                           ref_ip, ref_port);
     // Check the existing cluster
     clusterManagerNode *refnode = clusterManagerNewNode(ref_ip, ref_port);
@@ -4454,17 +4454,17 @@ static int clusterManagerCommandAddNode(int argc, char **argv) {
         } else {
             master_node = clusterManagerNodeWithLeastReplicas();
             assert(master_node != NULL);
-            printf("Automatically selected master %s:%d\n", master_node->ip, 
+            printf("Automatically selected master %s:%d\n", master_node->ip,
                    master_node->port);
-        } 
-    } 
+        }
+    }
 
     // Add the new node
     clusterManagerNode *new_node = clusterManagerNewNode(ip, port);
     int added = 0;
     CLUSTER_MANAGER_NODE_CONNECT(new_node);
     if (new_node->context->err) {
-        clusterManagerLogErr("[ERR] Sorry, can't connect to node %s:%d\n", 
+        clusterManagerLogErr("[ERR] Sorry, can't connect to node %s:%d\n",
                              ip, port);
         success = 0;
         goto cleanup;
@@ -4495,23 +4495,23 @@ static int clusterManagerCommandAddNode(int argc, char **argv) {
     // Send CLUSTER MEET command to the new node
     clusterManagerLogInfo(">>> Send CLUSTER MEET to node %s:%d to make it "
                           "join the cluster.\n", ip, port);
-    reply = CLUSTER_MANAGER_COMMAND(new_node, "CLUSTER MEET %s %d", 
+    reply = CLUSTER_MANAGER_COMMAND(new_node, "CLUSTER MEET %s %d",
                                     first->ip, first->port);
     if (!(success = clusterManagerCheckRedisReply(new_node, reply, NULL)))
         goto cleanup;
-    
+
     /* Additional configuration is needed if the node is added as a slave. */
     if (master_node) {
         sleep(1);
         clusterManagerWaitForClusterJoin();
-        clusterManagerLogInfo(">>> Configure node as replica of %s:%d.\n", 
+        clusterManagerLogInfo(">>> Configure node as replica of %s:%d.\n",
                               master_node->ip, master_node->port);
         freeReplyObject(reply);
-        reply = CLUSTER_MANAGER_COMMAND(new_node, "CLUSTER REPLICATE %s", 
+        reply = CLUSTER_MANAGER_COMMAND(new_node, "CLUSTER REPLICATE %s",
                                         master_node->name);
         if (!(success = clusterManagerCheckRedisReply(new_node, reply, NULL)))
             goto cleanup;
-    } 
+    }
     clusterManagerLogOk("[OK] New node added correctly.\n");
 cleanup:
     if (!added && new_node) freeClusterManagerNode(new_node);
@@ -4529,14 +4529,14 @@ static int clusterManagerCommandDeleteNode(int argc, char **argv) {
     char *ip = NULL;
     if (!getClusterHostFromCmdArgs(1, argv, &ip, &port)) goto invalid_args;
     char *node_id = argv[1];
-    clusterManagerLogInfo(">>> Removing node %s from cluster %s:%d\n", 
+    clusterManagerLogInfo(">>> Removing node %s from cluster %s:%d\n",
                           node_id, ip, port);
     clusterManagerNode *ref_node = clusterManagerNewNode(ip, port);
     clusterManagerNode *node = NULL;
-    
+
     // Load cluster information
     if (!clusterManagerLoadInfoFromNode(ref_node, 0)) return 0;
-    
+
     // Check if the node exists and is not empty
     node = clusterManagerNodeByName(node_id);
     if (node == NULL) {
@@ -4548,7 +4548,7 @@ static int clusterManagerCommandDeleteNode(int argc, char **argv) {
                              "away and try again.\n", node->ip, node->port);
         return 0;
     }
-    
+
     // Send CLUSTER FORGET to all the nodes but the node to remove
     clusterManagerLogInfo(">>> Sending CLUSTER FORGET messages to the "
                           "cluster...\n");
@@ -4562,16 +4562,16 @@ static int clusterManagerCommandDeleteNode(int argc, char **argv) {
             // Reconfigure the slave to replicate with some other node
             clusterManagerNode *master = clusterManagerNodeWithLeastReplicas();
             assert(master != NULL);
-            clusterManagerLogInfo(">>> %s:%d as replica of %s:%d\n", 
+            clusterManagerLogInfo(">>> %s:%d as replica of %s:%d\n",
                                   n->ip, n->port, master->ip, master->port);
-            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER REPLICATE %s", 
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER REPLICATE %s",
                                                     master->name);
             success = clusterManagerCheckRedisReply(n, r, NULL);
             if (r) freeReplyObject(r);
             if (!success) return 0;
         }
-        redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER FORGET %s", 
-                                                node_id); 
+        redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER FORGET %s",
+                                                node_id);
         success = clusterManagerCheckRedisReply(n, r, NULL);
         if (r) freeReplyObject(r);
         if (!success) return 0;
@@ -4628,14 +4628,14 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
     clusterManagerCheckCluster(0);
     if (cluster_manager.errors && listLength(cluster_manager.errors) > 0) {
         fflush(stdout);
-        fprintf(stderr, 
+        fprintf(stderr,
                 "*** Please fix your cluster problems before resharding\n");
         return 0;
     }
     int slots = config.cluster_manager_command.slots;
     if (!slots) {
         while (slots <= 0 || slots > CLUSTER_MANAGER_SLOTS) {
-            printf("How many slots do you want to move (from 1 to %d)? ", 
+            printf("How many slots do you want to move (from 1 to %d)? ",
                    CLUSTER_MANAGER_SLOTS);
             fflush(stdout);
             char buf[6];
@@ -4643,7 +4643,7 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
             if (nread <= 0) continue;
             int last_idx = nread - 1;
             if (buf[last_idx] != '\n') {
-                int ch; 
+                int ch;
                 while ((ch = getchar()) != '\n' && ch != EOF) {}
             }
             buf[last_idx] = '\0';
@@ -4651,16 +4651,16 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
         }
     }
     char buf[255];
-    char *to = config.cluster_manager_command.to, 
+    char *to = config.cluster_manager_command.to,
          *from = config.cluster_manager_command.from;
     while (to == NULL) {
-        printf("What is the receiving node ID? "); 
+        printf("What is the receiving node ID? ");
         fflush(stdout);
         int nread = read(fileno(stdin),buf,255);
         if (nread <= 0) continue;
         int last_idx = nread - 1;
         if (buf[last_idx] != '\n') {
-            int ch; 
+            int ch;
             while ((ch = getchar()) != '\n' && ch != EOF) {}
         }
         buf[last_idx] = '\0';
@@ -4678,13 +4678,13 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
                "the hash slots.\n");
         printf("  Type 'done' once you entered all the source nodes IDs.\n");
         while (1) {
-            printf("Source node #%lu: ", listLength(sources) + 1); 
+            printf("Source node #%lu: ", listLength(sources) + 1);
             fflush(stdout);
             int nread = read(fileno(stdin),buf,255);
             if (nread <= 0) continue;
             int last_idx = nread - 1;
             if (buf[last_idx] != '\n') {
-                int ch; 
+                int ch;
                 while ((ch = getchar()) != '\n' && ch != EOF) {}
             }
             buf[last_idx] = '\0';
@@ -4693,7 +4693,7 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
                 all = 1;
                 break;
             } else {
-                clusterManagerNode *src = 
+                clusterManagerNode *src =
                     clusterNodeForResharding(buf, target, &raise_err);
                 if (src != NULL) listAddNodeTail(sources, src);
                 else if (raise_err) {
@@ -4703,14 +4703,14 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
             }
         }
     } else {
-        char *p; 
+        char *p;
         while((p = strchr(from, ',')) != NULL) {
             *p = '\0';
             if (!strcmp(from, "all")) {
                 all = 1;
                 break;
             } else {
-                clusterManagerNode *src = 
+                clusterManagerNode *src =
                     clusterNodeForResharding(from, target, &raise_err);
                 if (src != NULL) listAddNodeTail(sources, src);
                 else if (raise_err) {
@@ -4724,7 +4724,7 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
         if (!all && strlen(from) > 0) {
             if (!strcmp(from, "all")) all = 1;
             if (!all) {
-                clusterManagerNode *src = 
+                clusterManagerNode *src =
                     clusterNodeForResharding(from, target, &raise_err);
                 if (src != NULL) listAddNodeTail(sources, src);
                 else if (raise_err) {
@@ -4737,7 +4737,7 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
     listIter li;
     listNode *ln;
     if (all) {
-        listEmpty(sources); 
+        listEmpty(sources);
         listRewind(cluster_manager.nodes, &li);
         while ((ln = listNext(&li)) != NULL) {
             clusterManagerNode *n = ln->value;
@@ -4768,8 +4768,8 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
     table = clusterManagerComputeReshardTable(sources, slots);
     printf("  Resharding plan:\n");
     clusterManagerShowReshardTable(table);
-    if (!(config.cluster_manager_command.flags & 
-          CLUSTER_MANAGER_CMD_FLAG_YES)) 
+    if (!(config.cluster_manager_command.flags &
+          CLUSTER_MANAGER_CMD_FLAG_YES))
     {
         printf("Do you want to proceed with the proposed "
                "reshard plan (yes/no)? ");
@@ -4787,7 +4787,7 @@ static int clusterManagerCommandReshard(int argc, char **argv) {
     while ((ln = listNext(&li)) != NULL) {
         clusterManagerReshardTableItem *item = ln->value;
         char *err = NULL;
-        result = clusterManagerMoveSlot(item->source, target, item->slot, 
+        result = clusterManagerMoveSlot(item->source, target, item->slot,
                                         opts, &err);
         if (!result) {
             if (err != NULL) {
@@ -4827,18 +4827,18 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
             float w = atof(++p);
             clusterManagerNode *n = clusterManagerNodeByAbbreviatedName(name);
             if (n == NULL) {
-                clusterManagerLogErr("*** No such master node %s\n", name); 
+                clusterManagerLogErr("*** No such master node %s\n", name);
                 result = 0;
                 goto cleanup;
             }
             n->weight = w;
-        } 
+        }
     }
-    float total_weight = 0; 
+    float total_weight = 0;
     int nodes_involved = 0;
-    int use_empty = config.cluster_manager_command.flags & 
+    int use_empty = config.cluster_manager_command.flags &
                     CLUSTER_MANAGER_CMD_FLAG_EMPTYMASTER;
-    involved = listCreate(); 
+    involved = listCreate();
     listIter li;
     listNode *ln;
     listRewind(cluster_manager.nodes, &li);
@@ -4851,7 +4851,7 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
             n->weight = 0;
             continue;
         }
-        total_weight += n->weight; 
+        total_weight += n->weight;
         nodes_involved++;
         listAddNodeTail(involved, n);
     }
@@ -4913,10 +4913,10 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
         }
     }
     /* Sort nodes by their slots balance. */
-    qsort(weightedNodes, nodes_involved, sizeof(clusterManagerNode *), 
+    qsort(weightedNodes, nodes_involved, sizeof(clusterManagerNode *),
           clusterManagerCompareNodeBalance);
     clusterManagerLogInfo(">>> Rebalancing across %d nodes. "
-                          "Total weight = %.2f\n", 
+                          "Total weight = %.2f\n",
                           nodes_involved, total_weight);
     if (config.verbose) {
         for (i = 0; i < nodes_involved; i++) {
@@ -4931,7 +4931,7 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
      * find nodes that need to get/provide slots. */
     int dst_idx = 0;
     int src_idx = nodes_involved - 1;
-    int simulate = config.cluster_manager_command.flags & 
+    int simulate = config.cluster_manager_command.flags &
                    CLUSTER_MANAGER_CMD_FLAG_SIMULATE;
     while (dst_idx < src_idx) {
         clusterManagerNode *dst = weightedNodes[dst_idx];
@@ -4940,14 +4940,14 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
         int sb = abs(src->balance);
         int numslots = (db < sb ? db : sb);
         if (numslots > 0) {
-            printf("Moving %d slots from %s:%d to %s:%d\n", numslots, 
-                                                            src->ip, 
-                                                            src->port, 
-                                                            dst->ip, 
+            printf("Moving %d slots from %s:%d to %s:%d\n", numslots,
+                                                            src->ip,
+                                                            src->port,
+                                                            dst->ip,
                                                             dst->port);
             /* Actually move the slots. */
             list *lsrc = listCreate(), *table = NULL;
-            listAddNodeTail(lsrc, src); 
+            listAddNodeTail(lsrc, src);
             table = clusterManagerComputeReshardTable(lsrc, numslots);
             listRelease(lsrc);
             int table_len = (int) listLength(table);
@@ -4960,14 +4960,14 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
             if (simulate) {
                 for (i = 0; i < table_len; i++) printf("#");
             } else {
-                int opts = CLUSTER_MANAGER_OPT_QUIET | 
+                int opts = CLUSTER_MANAGER_OPT_QUIET |
                            CLUSTER_MANAGER_OPT_UPDATE;
                 listRewind(table, &li);
                 while ((ln = listNext(&li)) != NULL) {
-                    clusterManagerReshardTableItem *item = ln->value; 
-                    result = clusterManagerMoveSlot(item->source, 
-                                                    dst, 
-                                                    item->slot, 
+                    clusterManagerReshardTableItem *item = ln->value;
+                    result = clusterManagerMoveSlot(item->source,
+                                                    dst,
+                                                    item->slot,
                                                     opts, NULL);
                     if (!result) goto end_move;
                     printf("#");
@@ -5019,8 +5019,8 @@ static int clusterManagerCommandSetTimeout(int argc, char **argv) {
     while ((ln = listNext(&li)) != NULL) {
         clusterManagerNode *n = ln->value;
         char *err = NULL;
-        redisReply *reply = CLUSTER_MANAGER_COMMAND(n, "CONFIG %s %s %d", 
-                                                    "SET", 
+        redisReply *reply = CLUSTER_MANAGER_COMMAND(n, "CONFIG %s %s %d",
+                                                    "SET",
                                                     "cluster-node-timeout",
                                                     timeout);
         if (reply == NULL) goto reply_err;
@@ -5032,17 +5032,17 @@ static int clusterManagerCommandSetTimeout(int argc, char **argv) {
         ok = clusterManagerCheckRedisReply(n, reply, &err);
         freeReplyObject(reply);
         if (!ok) goto reply_err;
-        clusterManagerLogWarn("*** New timeout set for %s:%d\n", n->ip, 
+        clusterManagerLogWarn("*** New timeout set for %s:%d\n", n->ip,
                               n->port);
         ok_count++;
         continue;
 reply_err:
         if (err == NULL) err = "";
-        clusterManagerLogErr("ERR setting node-timeot for %s:%d: %s\n", n->ip, 
+        clusterManagerLogErr("ERR setting node-timeot for %s:%d: %s\n", n->ip,
                              n->port, err);
         err_count++;
     }
-    clusterManagerLogInfo(">>> New node timeout set. %d OK, %d ERR.\n", 
+    clusterManagerLogInfo(">>> New node timeout set. %d OK, %d ERR.\n",
                           ok_count, err_count);
     return 1;
 invalid_args:
@@ -5070,7 +5070,7 @@ static int clusterManagerCommandImport(int argc, char **argv) {
                            "pass a valid address (ie. 120.0.0.1:7000).\n";
         goto invalid_args;
     }
-    clusterManagerLogInfo(">>> Importing data from %s:%d to cluster %s:%d\n", 
+    clusterManagerLogInfo(">>> Importing data from %s:%d to cluster %s:%d\n",
                           src_ip, src_port, ip, port);
 
     clusterManagerNode *refnode = clusterManagerNewNode(ip, port);
@@ -5082,7 +5082,7 @@ static int clusterManagerCommandImport(int argc, char **argv) {
     redisContext *src_ctx = redisConnect(src_ip, src_port);
     if (src_ctx->err) {
         success = 0;
-        fprintf(stderr,"Could not connect to Redis at %s:%d: %s.\n", src_ip, 
+        fprintf(stderr,"Could not connect to Redis at %s:%d: %s.\n", src_ip,
                 src_port, src_ctx->errstr);
         goto cleanup;
     }
@@ -5094,7 +5094,7 @@ static int clusterManagerCommandImport(int argc, char **argv) {
     }
     if (getLongInfoField(src_reply->str, "cluster_enabled")) {
         clusterManagerLogErr("[ERR] The source node should not be a "
-                             "cluster node.\n"); 
+                             "cluster node.\n");
         success = 0;
         goto cleanup;
     }
@@ -5123,7 +5123,7 @@ static int clusterManagerCommandImport(int argc, char **argv) {
                 slots_map[i] = n;
                 break;
             }
-        } 
+        }
     }
 
     char cmdfmt[50] = "MIGRATE %s %d %s %d %d";
@@ -5138,7 +5138,7 @@ static int clusterManagerCommandImport(int argc, char **argv) {
     while (cursor != 0) {
         if (cursor < 0) cursor = 0;
         freeReplyObject(src_reply);
-        src_reply = reconnectingRedisCommand(src_ctx, "SCAN %d COUNT %d", 
+        src_reply = reconnectingRedisCommand(src_ctx, "SCAN %d COUNT %d",
                                              cursor, 1000);
         if (!src_reply || src_reply->type == REDIS_REPLY_ERROR) {
             if (src_reply && src_reply->str) reply_err = src_reply->str;
@@ -5148,7 +5148,7 @@ static int clusterManagerCommandImport(int argc, char **argv) {
         assert(src_reply->type == REDIS_REPLY_ARRAY);
         assert(src_reply->elements >= 2);
         assert(src_reply->element[1]->type == REDIS_REPLY_ARRAY);
-        if (src_reply->element[0]->type == REDIS_REPLY_STRING) 
+        if (src_reply->element[0]->type == REDIS_REPLY_STRING)
             cursor = atoi(src_reply->element[0]->str);
         else if (src_reply->element[0]->type == REDIS_REPLY_INTEGER)
             cursor = src_reply->element[0]->integer;
@@ -5160,14 +5160,14 @@ static int clusterManagerCommandImport(int argc, char **argv) {
             uint16_t slot = clusterManagerKeyHashSlot(key, kr->len);
             clusterManagerNode *target = slots_map[slot];
             printf("Migrating %s to %s:%d: ", key, target->ip, target->port);
-            redisReply *r = reconnectingRedisCommand(src_ctx, cmdfmt, 
-                                                     target->ip, target->port, 
-                                                     key, 0, timeout, 
+            redisReply *r = reconnectingRedisCommand(src_ctx, cmdfmt,
+                                                     target->ip, target->port,
+                                                     key, 0, timeout,
                                                      "COPY", "REPLACE");
             if (!r || r->type == REDIS_REPLY_ERROR) {
                 if (r && r->str) {
                     clusterManagerLogErr("Source %s:%d replied with "
-                                         "error:\n%s\n", src_ip, src_port, 
+                                         "error:\n%s\n", src_ip, src_port,
                                          r->str);
                 }
                 success = 0;
@@ -5178,8 +5178,8 @@ static int clusterManagerCommandImport(int argc, char **argv) {
         }
     }
 cleanup:
-    if (reply_err) 
-        clusterManagerLogErr("Source %s:%d replied with error:\n%s\n", 
+    if (reply_err)
+        clusterManagerLogErr("Source %s:%d replied with error:\n%s\n",
                              src_ip, src_port, reply_err);
     if (src_ctx) redisFree(src_ctx);
     if (src_reply) freeReplyObject(src_reply);
@@ -5208,13 +5208,13 @@ static int clusterManagerCommandCall(int argc, char **argv) {
     listNode *ln;
     listRewind(cluster_manager.nodes, &li);
     while ((ln = listNext(&li)) != NULL) {
-        clusterManagerNode *n = ln->value; 
+        clusterManagerNode *n = ln->value;
         if (!n->context) CLUSTER_MANAGER_NODE_CONNECT(n);
         redisReply *reply = NULL;
         redisAppendCommandArgv(n->context, argc, (const char **) argv, argvlen);
         int status = redisGetReply(n->context, (void **)(&reply));
-        if (status != REDIS_OK || reply == NULL ) 
-            printf("%s:%d: Failed!\n", n->ip, n->port); 
+        if (status != REDIS_OK || reply == NULL )
+            printf("%s:%d: Failed!\n", n->ip, n->port);
         else {
             sds formatted_reply = cliFormatReplyTTY(reply, "");
             printf("%s:%d: %s\n", n->ip, n->port, (char *) formatted_reply);
@@ -5232,7 +5232,7 @@ invalid_args:
 static int clusterManagerCommandHelp(int argc, char **argv) {
     UNUSED(argc);
     UNUSED(argv);
-    int commands_count = sizeof(clusterManagerCommands) / 
+    int commands_count = sizeof(clusterManagerCommands) /
                          sizeof(clusterManagerCommandDef);
     int i = 0, j;
     fprintf(stderr, "Cluster Manager Commands:\n");
@@ -6575,7 +6575,7 @@ int main(int argc, char **argv) {
     config.cluster_manager_command.slots = 0;
     config.cluster_manager_command.timeout = CLUSTER_MANAGER_MIGRATE_TIMEOUT;
     config.cluster_manager_command.pipeline = CLUSTER_MANAGER_MIGRATE_PIPELINE;
-    config.cluster_manager_command.threshold = 
+    config.cluster_manager_command.threshold =
         CLUSTER_MANAGER_REBALANCE_THRESHOLD;
     pref.hints = 1;
 

From 289d8d9c2cb618a3099e3bf1d548087e4c6954cd Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Thu, 5 Jul 2018 15:25:32 +0800
Subject: [PATCH 167/219] CLIENT UNBLOCK: fix client unblock help message.

---
 src/networking.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/networking.c b/src/networking.c
index cefeba45e..5e0d783fc 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -1592,7 +1592,7 @@ void clientCommand(client *c) {
 "pause <timeout>        -- Suspend all Redis clients for <timout> milliseconds.",
 "reply (on|off|skip)    -- Control the replies sent to the current connection.",
 "setname <name>         -- Assign the name <name> to the current connection.",
-"unblock                -- Unblock the specified blocked client.",
+"unblock <clientid> [TIMEOUT|ERROR] -- Unblock the specified blocked client.",
 NULL
         };
         addReplyHelp(c, help);

From a3a5a25fa03a591b84c4d88f313c510dcec989cf Mon Sep 17 00:00:00 2001
From: Amit Dey <35510446+amitdey1987@users.noreply.github.com>
Date: Wed, 4 Jul 2018 08:36:09 -0700
Subject: [PATCH 168/219] fixing broken link in CONTRIBUTING

http://help.github.com/send-pull-requests/
is no longer supported

this change modifies the link to the working one
https://help.github.com/articles/creating-a-pull-request/
---
 CONTRIBUTING | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CONTRIBUTING b/CONTRIBUTING
index 5b0f02953..7dee24c74 100644
--- a/CONTRIBUTING
+++ b/CONTRIBUTING
@@ -32,7 +32,7 @@ each source file that you contribute.
     a. Fork Redis on github ( http://help.github.com/fork-a-repo/ )
     b. Create a topic branch (git checkout -b my_branch)
     c. Push to your branch (git push origin my_branch)
-    d. Initiate a pull request on github ( http://help.github.com/send-pull-requests/ )
+    d. Initiate a pull request on github ( https://help.github.com/articles/creating-a-pull-request/ )
     e. Done :)
 
 For minor fixes just open a pull request on Github.

From 846203279c06d5bb3dc99c61f3f040439645de08 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 9 Jul 2018 13:24:30 +0200
Subject: [PATCH 169/219] redis-cli: cliConnect() flags CC_FORCE and CC_QUIET.

We need CC_QUIET in order to fix #5096 by silently failing if needed.
---
 src/redis-cli.c | 36 +++++++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 13 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 115323720..2fa86ffbf 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -136,6 +136,10 @@
 #define LOG_COLOR_YELLOW    "33;1m"
 #define LOG_COLOR_RESET     "0m"
 
+/* cliConnect() flags. */
+#define CC_FORCE (1<<0)         /* Re-connect if already connected. */
+#define CC_QUIET (1<<1)         /* Don't log connecting errors. */
+
 /* --latency-dist palettes. */
 int spectrum_palette_color_size = 19;
 int spectrum_palette_color[] = {0,233,234,235,237,239,241,243,245,247,144,143,142,184,226,214,208,202,196};
@@ -741,10 +745,12 @@ static int cliSelect(void) {
     return REDIS_ERR;
 }
 
-/* Connect to the server. If force is not zero the connection is performed
- * even if there is already a connected socket. */
-static int cliConnect(int force) {
-    if (context == NULL || force) {
+/* Connect to the server. It is possible to pass certain flags to the function:
+ *      CC_FORCE: The connection is performed even if there is already
+ *                a connected socket.
+ *      CC_QUIET: Don't print errors if connection fails. */
+static int cliConnect(int flags) {
+    if (context == NULL || flags & CC_FORCE) {
         if (context != NULL) {
             redisFree(context);
         }
@@ -756,11 +762,15 @@ static int cliConnect(int force) {
         }
 
         if (context->err) {
-            fprintf(stderr,"Could not connect to Redis at ");
-            if (config.hostsocket == NULL)
-                fprintf(stderr,"%s:%d: %s\n",config.hostip,config.hostport,context->errstr);
-            else
-                fprintf(stderr,"%s: %s\n",config.hostsocket,context->errstr);
+            if (!(flags & CC_QUIET)) {
+                fprintf(stderr,"Could not connect to Redis at ");
+                if (config.hostsocket == NULL)
+                    fprintf(stderr,"%s:%d: %s\n",
+                        config.hostip,config.hostport,context->errstr);
+                else
+                    fprintf(stderr,"%s: %s\n",
+                        config.hostsocket,context->errstr);
+            }
             redisFree(context);
             context = NULL;
             return REDIS_ERR;
@@ -1524,7 +1534,7 @@ static int issueCommandRepeat(int argc, char **argv, long repeat) {
     while (1) {
         config.cluster_reissue_command = 0;
         if (cliSendCommand(argc,argv,repeat) != REDIS_OK) {
-            cliConnect(1);
+            cliConnect(CC_FORCE);
 
             /* If we still cannot send the command print error.
              * We'll try to reconnect the next time. */
@@ -1535,7 +1545,7 @@ static int issueCommandRepeat(int argc, char **argv, long repeat) {
          }
          /* Issue the command again if we got redirected in cluster mode */
          if (config.cluster_mode && config.cluster_reissue_command) {
-            cliConnect(1);
+            cliConnect(CC_FORCE);
          } else {
              break;
         }
@@ -1698,7 +1708,7 @@ static void repl(void) {
                     config.hostip = sdsnew(argv[1]);
                     config.hostport = atoi(argv[2]);
                     cliRefreshPrompt();
-                    cliConnect(1);
+                    cliConnect(CC_FORCE);
                 } else if (argc == 1 && !strcasecmp(argv[0],"clear")) {
                     linenoiseClearScreen();
                 } else {
@@ -1822,7 +1832,7 @@ static int evalMode(int argc, char **argv) {
                 strncpy(config.prompt,"lua debugger> ",sizeof(config.prompt));
                 repl();
                 /* Restart the session if repl() returned. */
-                cliConnect(1);
+                cliConnect(CC_FORCE);
                 printf("\n");
             }
         } else {

From 18d65849fd40639d752d3f7409f2fd23d6321662 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 9 Jul 2018 13:25:48 +0200
Subject: [PATCH 170/219] redis-cli: fix #5096 double error message.

---
 src/redis-cli.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 2fa86ffbf..437cc8e9c 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -504,7 +504,7 @@ static void cliInitHelp(void) {
  * entries with additional entries obtained using the COMMAND command
  * available in recent versions of Redis. */
 static void cliIntegrateHelp(void) {
-    if (cliConnect(0) == REDIS_ERR) return;
+    if (cliConnect(CC_QUIET) == REDIS_ERR) return;
 
     redisReply *reply = redisCommand(context, "COMMAND");
     if(reply == NULL || reply->type != REDIS_REPLY_ARRAY) return;

From b67f027699e8fc293e0bcf167cf296b380af5a5a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 9 Jul 2018 13:36:47 +0200
Subject: [PATCH 171/219] redis-cli: fix #4990 additional argument in help.

---
 src/redis-cli.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 437cc8e9c..299d46174 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -542,6 +542,7 @@ static void cliIntegrateHelp(void) {
         ch->name = new->argv[0];
         ch->params = sdsempty();
         int args = llabs(entry->element[1]->integer);
+        args--; /* Remove the command name itself. */
         if (entry->element[3]->integer == 1) {
             ch->params = sdscat(ch->params,"key ");
             args--;

From 61f12973f763b1af4e4737a0985df8991451070e Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Mon, 9 Jul 2018 19:26:40 +0800
Subject: [PATCH 172/219] Bugfix: PEL is incorrect when consumer is blocked
 using xreadgroup with NOACK option.

Save NOACK option into client.blockingState structure.
---
 src/blocked.c    | 4 +++-
 src/networking.c | 1 +
 src/server.h     | 1 +
 src/t_stream.c   | 1 +
 4 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/blocked.c b/src/blocked.c
index e0dd56724..58772f1eb 100644
--- a/src/blocked.c
+++ b/src/blocked.c
@@ -382,6 +382,7 @@ void handleClientsBlockedOnKeys(void) {
                              * consumer here. */
                             streamCG *group = NULL;
                             streamConsumer *consumer = NULL;
+                            int noack = 0;
                             if (receiver->bpop.xread_group) {
                                 group = streamLookupCG(s,
                                         receiver->bpop.xread_group->ptr);
@@ -396,6 +397,7 @@ void handleClientsBlockedOnKeys(void) {
                                 consumer = streamLookupConsumer(group,
                                            receiver->bpop.xread_consumer->ptr,
                                            1);
+                                noack = receiver->bpop.xread_group_noack;
                             }
 
                             /* Emit the two elements sub-array consisting of
@@ -412,7 +414,7 @@ void handleClientsBlockedOnKeys(void) {
                             };
                             streamReplyWithRange(receiver,s,&start,NULL,
                                                  receiver->bpop.xread_count,
-                                                 0, group, consumer, 0, &pi);
+                                                 0, group, consumer, noack, &pi);
 
                             /* Note that after we unblock the client, 'gt'
                              * and other receiver->bpop stuff are no longer
diff --git a/src/networking.c b/src/networking.c
index 5e0d783fc..58b553fe6 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -140,6 +140,7 @@ client *createClient(int fd) {
     c->bpop.target = NULL;
     c->bpop.xread_group = NULL;
     c->bpop.xread_consumer = NULL;
+    c->bpop.xread_group_noack = 0;
     c->bpop.numreplicas = 0;
     c->bpop.reploffset = 0;
     c->woff = 0;
diff --git a/src/server.h b/src/server.h
index 47efd0336..f3df6b46b 100644
--- a/src/server.h
+++ b/src/server.h
@@ -665,6 +665,7 @@ typedef struct blockingState {
     robj *xread_group;      /* XREADGROUP group name. */
     robj *xread_consumer;   /* XREADGROUP consumer name. */
     mstime_t xread_retry_time, xread_retry_ttl;
+    int xread_group_noack;
 
     /* BLOCKED_WAIT */
     int numreplicas;        /* Number of replicas we are waiting for ACK. */
diff --git a/src/t_stream.c b/src/t_stream.c
index 5c03c9727..db0b4fb96 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1426,6 +1426,7 @@ void xreadCommand(client *c) {
             incrRefCount(consumername);
             c->bpop.xread_group = groupname;
             c->bpop.xread_consumer = consumername;
+            c->bpop.xread_group_noack = noack;
         } else {
             c->bpop.xread_group = NULL;
             c->bpop.xread_consumer = NULL;

From 3f8a3efe5fd968d064337276f052de187bd339b2 Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Tue, 10 Jul 2018 16:26:13 +0800
Subject: [PATCH 173/219] Streams: fix xreadgroup crash after xgroup SETID is
 sent.

For issue #5111.
---
 src/t_stream.c | 35 ++++++++++++++++++++---------------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index db0b4fb96..75adba6ab 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -905,24 +905,29 @@ size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end
              * will not require extra lookups. We'll fix the problem later
              * if we find that there is already a entry for this ID. */
             streamNACK *nack = streamCreateNACK(consumer);
-            int retval = 0;
-            retval += raxTryInsert(group->pel,buf,sizeof(buf),nack,NULL);
-            retval += raxTryInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
+            int retval_group_tryins = 0, retval_consumer_tryins = 0;
+            retval_group_tryins = raxTryInsert(group->pel,buf,sizeof(buf),nack,NULL);
+            retval_consumer_tryins = raxTryInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
 
             /* Now we can check if the entry was already busy, and
              * in that case reassign the entry to the new consumer. */
-            if (retval == 0) {
-                streamFreeNACK(nack);
-                nack = raxFind(group->pel,buf,sizeof(buf));
-                serverAssert(nack != raxNotFound);
-                raxRemove(nack->consumer->pel,buf,sizeof(buf),NULL);
-                /* Update the consumer and idle time. */
-                nack->consumer = consumer;
-                nack->delivery_time = mstime();
-                nack->delivery_count++;
-                /* Add the entry in the new consumer local PEL. */
-                raxInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
-            } else if (retval == 1) {
+            if (retval_group_tryins == 0) {
+                streamNACK *oldnack = raxFind(group->pel,buf,sizeof(buf));
+                serverAssert(oldnack != raxNotFound);
+                if (retval_consumer_tryins == 0) {
+                    /* In this case, only need to update old nack
+                     * delivery_time and delivery_count. */
+                    oldnack->delivery_time = mstime();
+                    oldnack->delivery_count++;
+                    streamFreeNACK(nack);
+                } else {
+                    /* remove the old nack from original consumer */
+                    raxRemove(oldnack->consumer->pel,buf,sizeof(buf),NULL);
+                    /* Overwrite nack in group pel. */
+                    raxInsert(group->pel,buf,sizeof(buf),nack,NULL);
+                    streamFreeNACK(oldnack);
+                }
+            } else if (retval_group_tryins == 1 && retval_consumer_tryins == 0) {
                 serverPanic("NACK half-created. Should not be possible.");
             }
 

From 09327f11dd718461b3a1d577729c1e9969f37080 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 10 Jul 2018 11:11:39 +0200
Subject: [PATCH 174/219] Streams: fix unblocking logic into a consumer group.

When a client blocks for a consumer group, we don't know the actual ID
we want to be served: other clients blocked in the same consumer group
may be served first, so the consumer group latest delivered ID changes.
This was not handled correctly, all the clients in the consumer group
were unblocked without data but the first.
---
 src/blocked.c | 38 ++++++++++++++++++++++++--------------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/src/blocked.c b/src/blocked.c
index e0dd56724..e62d75485 100644
--- a/src/blocked.c
+++ b/src/blocked.c
@@ -370,6 +370,29 @@ void handleClientsBlockedOnKeys(void) {
                         if (receiver->btype != BLOCKED_STREAM) continue;
                         streamID *gt = dictFetchValue(receiver->bpop.keys,
                                                       rl->key);
+
+                        /* If we blocked in the context of a consumer
+                         * group, we need to resolve the group and update the
+                         * last ID the client is blocked for: this is needed
+                         * because serving other clients in the same consumer
+                         * group will alter the "last ID" of the consumer
+                         * group, and clients blocked in a consumer group are
+                         * always blocked for the ">" ID: we need to deliver
+                         * only new messages and avoid unblocking the client
+                         * otherwise. */
+                        streamCG *group = NULL;
+                        if (receiver->bpop.xread_group) {
+                            group = streamLookupCG(s,
+                                    receiver->bpop.xread_group->ptr);
+                            /* If the group was not found, send an error
+                             * to the consumer. */
+                            if (!group) {
+                                /* XXX: Fixme, send the error. */
+                            } else {
+                                *gt = group->last_id;
+                            }
+                        }
+
                         if (s->last_id.ms > gt->ms ||
                             (s->last_id.ms == gt->ms &&
                              s->last_id.seq > gt->seq))
@@ -377,21 +400,8 @@ void handleClientsBlockedOnKeys(void) {
                             streamID start = *gt;
                             start.seq++; /* Can't overflow, it's an uint64_t */
 
-                            /* If we blocked in the context of a consumer
-                             * group, we need to resolve the group and
-                             * consumer here. */
-                            streamCG *group = NULL;
+                            /* Lookup the consuemr for the group, if any. */
                             streamConsumer *consumer = NULL;
-                            if (receiver->bpop.xread_group) {
-                                group = streamLookupCG(s,
-                                        receiver->bpop.xread_group->ptr);
-                                /* In theory if the group is not found we
-                                 * just perform the read without the group,
-                                 * but actually when the group, or the key
-                                 * itself is deleted (triggering the removal
-                                 * of the group), we check for blocked clients
-                                 * and send them an error. */
-                            }
                             if (group) {
                                 consumer = streamLookupConsumer(group,
                                            receiver->bpop.xread_consumer->ptr,

From a71e8148533449097b12233fbebafef135fd4a80 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 10 Jul 2018 11:19:06 +0200
Subject: [PATCH 175/219] Streams: send an error to consumers blocked on
 non-existing group.

To detect when the group (or the whole key) is destroyed to send an
error to the consumers blocked in such group is a problem, so we leave
the consumers listening, the sysadmin is free to create or destroy
groups assuming she/he knows what to do. However a client may be blocked
in a given consumer group, that is later destroyed. Then the stream
receives new elements. In that case there is no sane behavior to serve
the consumer... but to report an error about the group no longer
existing.

More about detecting this synchronously and why it is not done:

1. Normally we don't do that, we leave clients blocked for other data
types such as lists.

2. When we free a stream object there is no longer information about
what was the key it was associated with, so while destroying the
consumer groups we miss the info to unblock the clients in that moment.

3. Objects can be reclaimed in other threads where it is no longer safe
to do client operations.
---
 src/blocked.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/blocked.c b/src/blocked.c
index e62d75485..2a349f0a4 100644
--- a/src/blocked.c
+++ b/src/blocked.c
@@ -387,7 +387,11 @@ void handleClientsBlockedOnKeys(void) {
                             /* If the group was not found, send an error
                              * to the consumer. */
                             if (!group) {
-                                /* XXX: Fixme, send the error. */
+                                addReplyError(receiver,
+                                    "-NOGROUP the consumer group this client "
+                                    "was blocked on no longer exists");
+                                unblockClient(receiver);
+                                continue;
                             } else {
                                 *gt = group->last_id;
                             }

From 1a02b5f6eea523d8020b189ef6e96a515bd3f23d Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 10 Jul 2018 11:34:17 +0200
Subject: [PATCH 176/219] Streams: make blocking for > a truly special case.

To simplify the semantics of blocking for a group, this commit changes
the implementation to better match the description we provide of
conusmer groups: blocking for > will make the consumer waiting for new
elements in the group. However blocking for any other ID will always
serve the local history of the consumer.

However it must be noted that the > ID is actually an alias for the
special ID ms/seq of UINT64_MAX,UINT64_MAX.
---
 src/t_stream.c | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 5c03c9727..a4702b0c2 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1355,7 +1355,11 @@ void xreadCommand(client *c) {
                                 "<consumer> option.");
                 goto cleanup;
             }
-            ids[id_idx] = group->last_id;
+            /* We use just the maximum ID to signal this is a ">" ID, anyway
+             * the code handling the blocking clients will have to update the
+             * ID later in order to match the changing consumer group last ID. */
+            ids[id_idx].ms = UINT64_MAX;
+            ids[id_idx].seq = UINT64_MAX;
             continue;
         }
         if (streamParseIDOrReply(c,c->argv[i],ids+id_idx,0) != C_OK)
@@ -1370,9 +1374,30 @@ void xreadCommand(client *c) {
         if (o == NULL) continue;
         stream *s = o->ptr;
         streamID *gt = ids+i; /* ID must be greater than this. */
-        if (s->last_id.ms > gt->ms ||
-            (s->last_id.ms == gt->ms && s->last_id.seq > gt->seq))
-        {
+        int serve_synchronously = 0;
+
+        /* Check if there are the conditions to serve the client synchronously. */
+        if (groups) {
+            /* If the consumer is blocked on a group, we always serve it
+             * synchronously (serving its local history) if the ID specified
+             * was not the special ">" ID. */
+            if (gt->ms != UINT64_MAX ||
+                gt->seq != UINT64_MAX)
+            {
+                serve_synchronously = 1;
+            }
+        } else {
+            /* For clients without a consumer group specified, we serve the
+             * client synchronously only if we can actually provide at least
+             * one item from the stream. */
+            if (s->last_id.ms > gt->ms ||
+                (s->last_id.ms == gt->ms && s->last_id.seq > gt->seq))
+            {
+                serve_synchronously = 1;
+            }
+        }
+
+        if (serve_synchronously) {
             arraylen++;
             if (arraylen == 1) arraylen_ptr = addDeferredMultiBulkLength(c);
             /* streamReplyWithRange() handles the 'start' ID as inclusive,

From a8c1bb310e13ae273cf47e09f42953bf38a26b1e Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 10 Jul 2018 12:01:52 +0200
Subject: [PATCH 177/219] Streams: fix new XREADGROUP sync logic.

---
 src/t_stream.c | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index a4702b0c2..526877787 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1385,11 +1385,21 @@ void xreadCommand(client *c) {
                 gt->seq != UINT64_MAX)
             {
                 serve_synchronously = 1;
+            } else {
+                /* We also want to serve a consumer in a consumer group
+                 * synchronously in case the group top item delivered is smaller
+                 * than what the stream has inside. */
+                streamID *last = &groups[i]->last_id;
+                if (s->last_id.ms > last->ms ||
+                    (s->last_id.ms == last->ms && s->last_id.seq > last->seq))
+                {
+                    serve_synchronously = 1;
+                    *gt = *last;
+                }
             }
         } else {
-            /* For clients without a consumer group specified, we serve the
-             * client synchronously only if we can actually provide at least
-             * one item from the stream. */
+            /* For consumers without a group, we serve synchronously if we can
+             * actually provide at least one item from the stream. */
             if (s->last_id.ms > gt->ms ||
                 (s->last_id.ms == gt->ms && s->last_id.seq > gt->seq))
             {

From 28e95c7c523258ea43b5fe9b42aeb4f9305da5f7 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 10 Jul 2018 12:04:31 +0200
Subject: [PATCH 178/219] Streams: fix typo "consumer".

---
 src/blocked.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/blocked.c b/src/blocked.c
index 2a349f0a4..e722a4e83 100644
--- a/src/blocked.c
+++ b/src/blocked.c
@@ -404,7 +404,7 @@ void handleClientsBlockedOnKeys(void) {
                             streamID start = *gt;
                             start.seq++; /* Can't overflow, it's an uint64_t */
 
-                            /* Lookup the consuemr for the group, if any. */
+                            /* Lookup the consumer for the group, if any. */
                             streamConsumer *consumer = NULL;
                             if (group) {
                                 consumer = streamLookupConsumer(group,

From 9505dd2011ef7143670b68247ff1818ffbad9768 Mon Sep 17 00:00:00 2001
From: tengfeng <jingcheng.ljc@alibaba-inc.com>
Date: Tue, 10 Jul 2018 20:58:01 +0800
Subject: [PATCH 179/219] fix repeat argument issue and reduce unnessary loop
 times for redis-cli.

---
 src/redis-cli.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 299d46174..9459f8c31 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -1174,6 +1174,16 @@ static int cliSendCommand(int argc, char **argv, long repeat) {
             } else if (!strcasecmp(command,"auth") && argc == 2) {
                 cliSelect();
             }
+
+
+            /*  Issue the command again if we got redirected in cluster mode  */
+            if  (config.cluster_mode  &&  config.cluster_reissue_command)  {
+                cliConnect(CC_FORCE);
+                config.cluster_reissue_command  =  0;
+                /* for a '-MOVED' or '-ASK' response, we need to issue the command again, so
+                 * add repeat by 1. */
+                repeat++;
+            }
         }
         if (config.interval) usleep(config.interval);
         fflush(stdout); /* Make it grep friendly */
@@ -1543,13 +1553,8 @@ static int issueCommandRepeat(int argc, char **argv, long repeat) {
                 cliPrintContextError();
                 return REDIS_ERR;
             }
-         }
-         /* Issue the command again if we got redirected in cluster mode */
-         if (config.cluster_mode && config.cluster_reissue_command) {
-            cliConnect(CC_FORCE);
-         } else {
-             break;
-        }
+        } else
+            break;
     }
     return REDIS_OK;
 }

From 920158ec812dde184200232cc347f589123b715d Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Wed, 11 Jul 2018 16:09:00 +0300
Subject: [PATCH 180/219] Active defrag fixes for 32bit builds (again)

* overflow in jemalloc fragmentation hint to the defragger
---
 .../include/jemalloc/internal/jemalloc_internal_inlines_c.h   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h b/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
index 540c168e5..290e5cf99 100644
--- a/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
+++ b/deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
@@ -234,8 +234,8 @@ iget_defrag_hint(tsdn_t *tsdn, void* ptr, int *bin_util, int *run_util) {
 		if (slab != bin->slabcur) {
 			const bin_info_t *bin_info = &bin_infos[binind];
 			size_t availregs = bin_info->nregs * bin->stats.curslabs;
-			*bin_util = (bin->stats.curregs<<16) / availregs;
-			*run_util = ((bin_info->nregs - extent_nfree_get(slab))<<16) / bin_info->nregs;
+			*bin_util = ((long long)bin->stats.curregs<<16) / availregs;
+			*run_util = ((long long)(bin_info->nregs - extent_nfree_get(slab))<<16) / bin_info->nregs;
 			defrag = 1;
 		}
 		malloc_mutex_unlock(tsdn, &bin->lock);

From a7c180e559d687022e85bee88f28d11db571e90c Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 12 Jul 2018 13:15:54 +0200
Subject: [PATCH 181/219] Simplify duplicated NACK #5112 fix.

We don't really need to distinguish between the case the consumer is the
same or is a different one.
---
 src/t_stream.c | 39 ++++++++++++++++++---------------------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 572e09669..5c1b7d4c4 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -905,29 +905,26 @@ size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end
              * will not require extra lookups. We'll fix the problem later
              * if we find that there is already a entry for this ID. */
             streamNACK *nack = streamCreateNACK(consumer);
-            int retval_group_tryins = 0, retval_consumer_tryins = 0;
-            retval_group_tryins = raxTryInsert(group->pel,buf,sizeof(buf),nack,NULL);
-            retval_consumer_tryins = raxTryInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
+            int group_inserted =
+                raxTryInsert(group->pel,buf,sizeof(buf),nack,NULL);
+            int consumer_inserted =
+                raxTryInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
 
             /* Now we can check if the entry was already busy, and
-             * in that case reassign the entry to the new consumer. */
-            if (retval_group_tryins == 0) {
-                streamNACK *oldnack = raxFind(group->pel,buf,sizeof(buf));
-                serverAssert(oldnack != raxNotFound);
-                if (retval_consumer_tryins == 0) {
-                    /* In this case, only need to update old nack
-                     * delivery_time and delivery_count. */
-                    oldnack->delivery_time = mstime();
-                    oldnack->delivery_count++;
-                    streamFreeNACK(nack);
-                } else {
-                    /* remove the old nack from original consumer */
-                    raxRemove(oldnack->consumer->pel,buf,sizeof(buf),NULL);
-                    /* Overwrite nack in group pel. */
-                    raxInsert(group->pel,buf,sizeof(buf),nack,NULL);
-                    streamFreeNACK(oldnack);
-                }
-            } else if (retval_group_tryins == 1 && retval_consumer_tryins == 0) {
+             * in that case reassign the entry to the new consumer,
+             * or update it if the consumer is the same as before. */
+            if (group_inserted == 0) {
+                streamFreeNACK(nack);
+                nack = raxFind(group->pel,buf,sizeof(buf));
+                serverAssert(nack != raxNotFound);
+                raxRemove(nack->consumer->pel,buf,sizeof(buf),NULL);
+                /* Update the consumer and idle time. */
+                nack->consumer = consumer;
+                nack->delivery_time = mstime();
+                nack->delivery_count++;
+                /* Add the entry in the new consumer local PEL. */
+                raxInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
+            } else if (group_inserted == 1 && consumer_inserted == 0) {
                 serverPanic("NACK half-created. Should not be possible.");
             }
 

From b6260a027026d1a5a6fa4fa0d8527de86066de8e Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 12 Jul 2018 13:19:39 +0200
Subject: [PATCH 182/219] Streams: when re-delivering because of SETID, reset
 deliveries counter.

We don't want to increment the deliveries here, because the sysadmin
reset the consumer group so the desire is likely to restart processing,
and having the PEL polluted with old information is not useful but
probably confusing.

Related to #5111.
---
 src/t_stream.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 5c1b7d4c4..54d6b0d1f 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -918,10 +918,10 @@ size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end
                 nack = raxFind(group->pel,buf,sizeof(buf));
                 serverAssert(nack != raxNotFound);
                 raxRemove(nack->consumer->pel,buf,sizeof(buf),NULL);
-                /* Update the consumer and idle time. */
+                /* Update the consumer and NACK metadata. */
                 nack->consumer = consumer;
                 nack->delivery_time = mstime();
-                nack->delivery_count++;
+                nack->delivery_count = 1;
                 /* Add the entry in the new consumer local PEL. */
                 raxInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
             } else if (group_inserted == 1 && consumer_inserted == 0) {

From 8d6b7861a702b9f8fb2eceb76750c393a79e4c40 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 12 Jul 2018 13:35:17 +0200
Subject: [PATCH 183/219] Add regression test for #5111.

---
 tests/unit/type/stream-cgroups.tcl | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/unit/type/stream-cgroups.tcl b/tests/unit/type/stream-cgroups.tcl
index 3f72b3dbb..7c991a5da 100644
--- a/tests/unit/type/stream-cgroups.tcl
+++ b/tests/unit/type/stream-cgroups.tcl
@@ -81,4 +81,19 @@ start_server {
         # just ID2.
         assert {[r XACK mystream mygroup $id1 $id2] eq 1}
     }
+
+    test {PEL NACK reassignment after XGROUP SETID event} {
+        r del events
+        r xadd events * f1 v1
+        r xadd events * f1 v1
+        r xadd events * f1 v1
+        r xadd events * f1 v1
+        r xgroup create events g1 $
+        r xadd events * f1 v1
+        set c [llength [lindex [r xreadgroup group g1 c1 streams events >] 0 1]]
+        assert {$c == 1}
+        r xgroup setid events g1 -
+        set c [llength [lindex [r xreadgroup group g1 c2 streams events >] 0 1]]
+        assert {$c == 5}
+    }
 }

From c2a85fb3c5291c9f0ebe776117fe4d77222eebb7 Mon Sep 17 00:00:00 2001
From: Shen Longxing <shenlongxing2012@gmail.com>
Date: Thu, 12 Jul 2018 21:21:37 +0800
Subject: [PATCH 184/219] Delete unused role checking.

When check rdb file, it is unnecessary to check role.
---
 src/redis-check-rdb.c | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/redis-check-rdb.c b/src/redis-check-rdb.c
index 50854be0c..8de1d8f48 100644
--- a/src/redis-check-rdb.c
+++ b/src/redis-check-rdb.c
@@ -286,12 +286,8 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
         /* Read value */
         rdbstate.doing = RDB_CHECK_DOING_READ_OBJECT_VALUE;
         if ((val = rdbLoadObject(type,&rdb)) == NULL) goto eoferr;
-        /* Check if the key already expired. This function is used when loading
-         * an RDB file from disk, either at startup, or when an RDB was
-         * received from the master. In the latter case, the master is
-         * responsible for key expiry. If we would expire keys here, the
-         * snapshot taken by the master may not be reflected on the slave. */
-        if (server.masterhost == NULL && expiretime != -1 && expiretime < now)
+        /* Check if the key already expired. */
+        if (expiretime != -1 && expiretime < now)
             rdbstate.already_expired++;
         if (expiretime != -1) rdbstate.expires++;
         rdbstate.key = NULL;

From 513eb5728cbe364721f3258b6964566d28b18136 Mon Sep 17 00:00:00 2001
From: artix <artix2@gmail.com>
Date: Fri, 22 Jun 2018 18:27:03 +0200
Subject: [PATCH 185/219] Cluster Manager: auth support (-a argument).

---
 src/redis-cli.c | 60 +++++++++++++++++++++++++++++++++----------------
 1 file changed, 41 insertions(+), 19 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 9459f8c31..8a7b18fbb 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -79,10 +79,8 @@
     "and port (ie. 120.0.0.1 7000)\n"
 #define CLUSTER_MANAGER_MODE() (config.cluster_manager_command.name != NULL)
 #define CLUSTER_MANAGER_MASTERS_COUNT(nodes, replicas) (nodes/(replicas + 1))
-#define CLUSTER_MANAGER_NODE_CONNECT(n) \
-    (n->context = redisConnect(n->ip, n->port));
 #define CLUSTER_MANAGER_COMMAND(n,...) \
-        (reconnectingRedisCommand(n->context, __VA_ARGS__))
+        (redisCommand(n->context, __VA_ARGS__))
 
 #define CLUSTER_MANAGER_NODE_ARRAY_FREE(array) zfree(array->alloc)
 
@@ -2171,6 +2169,31 @@ static int clusterManagerCheckRedisReply(clusterManagerNode *n,
     return 1;
 }
 
+static int clusterManagerNodeConnect(clusterManagerNode *node) {
+    if (node->context) redisFree(node->context);
+    node->context = redisConnect(node->ip, node->port);
+    if (node->context->err) {
+        fprintf(stderr,"Could not connect to Redis at ");
+        fprintf(stderr,"%s:%d: %s\n", node->ip, node->port,
+                node->context->errstr);
+        redisFree(node->context);
+        node->context = NULL;
+        return 0;
+    }
+    /* Set aggressive KEEP_ALIVE socket option in the Redis context socket
+     * in order to prevent timeouts caused by the execution of long
+     * commands. At the same time this improves the detection of real
+     * errors. */
+    anetKeepAlive(NULL, node->context->fd, REDIS_CLI_KEEPALIVE_INTERVAL);
+    if (config.auth) {
+        redisReply *reply = redisCommand(node->context,"AUTH %s",config.auth);
+        int ok = clusterManagerCheckRedisReply(node, reply, NULL);
+        if (reply != NULL) freeReplyObject(reply);
+        if (!ok) return 0;
+    }
+    return 1;
+}
+
 static void clusterManagerRemoveNodeFromList(list *nodelist,
                                              clusterManagerNode *node) {
     listIter li;
@@ -2718,6 +2741,7 @@ static redisReply *clusterManagerMigrateKeysInReply(clusterManagerNode *source,
     char **argv = NULL;
     size_t *argv_len = NULL;
     int c = (replace ? 8 : 7);
+    if (config.auth) c += 2;
     size_t argc = c + reply->elements;
     size_t i, offset = 6; // Keys Offset
     argv = zcalloc(argc * sizeof(char *));
@@ -2743,6 +2767,14 @@ static redisReply *clusterManagerMigrateKeysInReply(clusterManagerNode *source,
         argv_len[offset] = 7;
         offset++;
     }
+    if (config.auth) {
+        argv[offset] = "AUTH";
+        argv_len[offset] = 4;
+        offset++;
+        argv[offset] = config.auth;
+        argv_len[offset] = strlen(config.auth);
+        offset++;
+    }
     argv[offset] = "KEYS";
     argv_len[offset] = 4;
     offset++;
@@ -3146,12 +3178,7 @@ cleanup:
  * Warning: if something goes wrong, it will free the starting node before
  * returning 0. */
 static int clusterManagerLoadInfoFromNode(clusterManagerNode *node, int opts) {
-    if (node->context == NULL)
-        CLUSTER_MANAGER_NODE_CONNECT(node);
-    if (node->context->err) {
-        fprintf(stderr,"Could not connect to Redis at ");
-        fprintf(stderr,"%s:%d: %s\n", node->ip, node->port,
-                node->context->errstr);
+    if (node->context == NULL && !clusterManagerNodeConnect(node)) {
         freeClusterManagerNode(node);
         return 0;
     }
@@ -3187,9 +3214,8 @@ static int clusterManagerLoadInfoFromNode(clusterManagerNode *node, int opts) {
         while ((ln = listNext(&li)) != NULL) {
             clusterManagerNode *friend = ln->value;
             if (!friend->ip || !friend->port) goto invalid_friend;
-            if (!friend->context)
-                CLUSTER_MANAGER_NODE_CONNECT(friend);
-            if (friend->context->err) goto invalid_friend;
+            if (!friend->context && !clusterManagerNodeConnect(friend))
+                goto invalid_friend;
             e = NULL;
             if (clusterManagerNodeLoadInfo(friend, 0, &e)) {
                 if (friend->flags & (CLUSTER_MANAGER_FLAG_NOADDR |
@@ -4184,10 +4210,7 @@ static int clusterManagerCommandCreate(int argc, char **argv) {
         char *ip = addr;
         int port = atoi(++c);
         clusterManagerNode *node = clusterManagerNewNode(ip, port);
-        CLUSTER_MANAGER_NODE_CONNECT(node);
-        if (node->context->err) {
-            fprintf(stderr,"Could not connect to Redis at ");
-            fprintf(stderr,"%s:%d: %s\n", ip, port, node->context->errstr);
+        if (!clusterManagerNodeConnect(node)) {
             freeClusterManagerNode(node);
             return 0;
         }
@@ -4478,8 +4501,7 @@ static int clusterManagerCommandAddNode(int argc, char **argv) {
     // Add the new node
     clusterManagerNode *new_node = clusterManagerNewNode(ip, port);
     int added = 0;
-    CLUSTER_MANAGER_NODE_CONNECT(new_node);
-    if (new_node->context->err) {
+    if (!clusterManagerNodeConnect(new_node)) {
         clusterManagerLogErr("[ERR] Sorry, can't connect to node %s:%d\n",
                              ip, port);
         success = 0;
@@ -5225,7 +5247,7 @@ static int clusterManagerCommandCall(int argc, char **argv) {
     listRewind(cluster_manager.nodes, &li);
     while ((ln = listNext(&li)) != NULL) {
         clusterManagerNode *n = ln->value;
-        if (!n->context) CLUSTER_MANAGER_NODE_CONNECT(n);
+        if (!n->context && !clusterManagerNodeConnect(n)) continue;
         redisReply *reply = NULL;
         redisAppendCommandArgv(n->context, argc, (const char **) argv, argvlen);
         int status = redisGetReply(n->context, (void **)(&reply));

From d222eda9f089f6605d755777c32132cb8cad76c9 Mon Sep 17 00:00:00 2001
From: artix <artix2@gmail.com>
Date: Wed, 27 Jun 2018 16:42:22 +0200
Subject: [PATCH 186/219] Redis-trib deprecated: it no longer works and it
 outputs a warning to the user.

---
 src/redis-trib.rb | 1913 +++------------------------------------------
 1 file changed, 106 insertions(+), 1807 deletions(-)

diff --git a/src/redis-trib.rb b/src/redis-trib.rb
index 770fa68eb..b1af83069 100755
--- a/src/redis-trib.rb
+++ b/src/redis-trib.rb
@@ -1,1791 +1,36 @@
 #!/usr/bin/env ruby
 
-# TODO (temporary here, we'll move this into the Github issues once
-#       redis-trib initial implementation is completed).
-#
-# - Make sure that if the rehashing fails in the middle redis-trib will try
-#   to recover.
-# - When redis-trib performs a cluster check, if it detects a slot move in
-#   progress it should prompt the user to continue the move from where it
-#   stopped.
-# - Gracefully handle Ctrl+C in move_slot to prompt the user if really stop
-#   while rehashing, and performing the best cleanup possible if the user
-#   forces the quit.
-# - When doing "fix" set a global Fix to true, and prompt the user to
-#   fix the problem if automatically fixable every time there is something
-#   to fix. For instance:
-#   1) If there is a node that pretend to receive a slot, or to migrate a
-#      slot, but has no entries in that slot, fix it.
-#   2) If there is a node having keys in slots that are not owned by it
-#      fix this condition moving the entries in the same node.
-#   3) Perform more possibly slow tests about the state of the cluster.
-#   4) When aborted slot migration is detected, fix it.
-
-require 'rubygems'
-require 'redis'
-
-ClusterHashSlots = 16384
-MigrateDefaultTimeout = 60000
-MigrateDefaultPipeline = 10
-RebalanceDefaultThreshold = 2
-
-$verbose = false
-
-def xputs(s)
-    case s[0..2]
-    when ">>>"
-        color="29;1"
-    when "[ER"
-        color="31;1"
-    when "[WA"
-        color="31;1"
-    when "[OK"
-        color="32"
-    when "[FA","***"
-        color="33"
-    else
-        color=nil
-    end
-
-    color = nil if ENV['TERM'] != "xterm"
-    print "\033[#{color}m" if color
-    print s
-    print "\033[0m" if color
-    print "\n"
+def colorized(str, color)
+    return str if !(ENV['TERM'] || '')["xterm"]
+    color_code = {
+        white: 29,
+        bold: '29;1',
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        gray: 37
+    }[color]
+    return str if !color_code
+    "\033[#{color_code}m#{str}\033[0m"
 end
 
-class ClusterNode
-    def initialize(addr)
-        s = addr.split("@")[0].split(":")
-        if s.length < 2
-           puts "Invalid IP or Port (given as #{addr}) - use IP:Port format"
-           exit 1
-        end
-        port = s.pop # removes port from split array
-        ip = s.join(":") # if s.length > 1 here, it's IPv6, so restore address
-        @r = nil
-        @info = {}
-        @info[:host] = ip
-        @info[:port] = port
-        @info[:slots] = {}
-        @info[:migrating] = {}
-        @info[:importing] = {}
-        @info[:replicate] = false
-        @dirty = false # True if we need to flush slots info into node.
-        @friends = []
-    end
+class String
 
-    def friends
-        @friends
-    end
-
-    def slots
-        @info[:slots]
-    end
-
-    def has_flag?(flag)
-        @info[:flags].index(flag)
-    end
-
-    def to_s
-        "#{@info[:host]}:#{@info[:port]}"
-    end
-
-    def connect(o={})
-        return if @r
-        print "Connecting to node #{self}: " if $verbose
-        STDOUT.flush
-        begin
-            @r = Redis.new(:host => @info[:host], :port => @info[:port], :timeout => 60)
-            @r.ping
-        rescue
-            xputs "[ERR] Sorry, can't connect to node #{self}"
-            exit 1 if o[:abort]
-            @r = nil
-        end
-        xputs "OK" if $verbose
-    end
-
-    def assert_cluster
-        info = @r.info
-        if !info["cluster_enabled"] || info["cluster_enabled"].to_i == 0
-            xputs "[ERR] Node #{self} is not configured as a cluster node."
-            exit 1
-        end
-    end
-
-    def assert_empty
-        if !(@r.cluster("info").split("\r\n").index("cluster_known_nodes:1")) ||
-            (@r.info['db0'])
-            xputs "[ERR] Node #{self} is not empty. Either the node already knows other nodes (check with CLUSTER NODES) or contains some key in database 0."
-            exit 1
-        end
-    end
-
-    def load_info(o={})
-        self.connect
-        nodes = @r.cluster("nodes").split("\n")
-        nodes.each{|n|
-            # name addr flags role ping_sent ping_recv link_status slots
-            split = n.split
-            name,addr,flags,master_id,ping_sent,ping_recv,config_epoch,link_status = split[0..6]
-            slots = split[8..-1]
-            info = {
-                :name => name,
-                :addr => addr,
-                :flags => flags.split(","),
-                :replicate => master_id,
-                :ping_sent => ping_sent.to_i,
-                :ping_recv => ping_recv.to_i,
-                :link_status => link_status
-            }
-            info[:replicate] = false if master_id == "-"
-
-            if info[:flags].index("myself")
-                @info = @info.merge(info)
-                @info[:slots] = {}
-                slots.each{|s|
-                    if s[0..0] == '['
-                        if s.index("->-") # Migrating
-                            slot,dst = s[1..-1].split("->-")
-                            @info[:migrating][slot.to_i] = dst
-                        elsif s.index("-<-") # Importing
-                            slot,src = s[1..-1].split("-<-")
-                            @info[:importing][slot.to_i] = src
-                        end
-                    elsif s.index("-")
-                        start,stop = s.split("-")
-                        self.add_slots((start.to_i)..(stop.to_i))
-                    else
-                        self.add_slots((s.to_i)..(s.to_i))
-                    end
-                } if slots
-                @dirty = false
-                @r.cluster("info").split("\n").each{|e|
-                    k,v=e.split(":")
-                    k = k.to_sym
-                    v.chop!
-                    if k != :cluster_state
-                        @info[k] = v.to_i
-                    else
-                        @info[k] = v
-                    end
-                }
-            elsif o[:getfriends]
-                @friends << info
-            end
+    %w(white bold black red green yellow blue magenta cyan gray).each{|color|
+        color = :"#{color}"
+        define_method(color){
+            colorized(self, color)
         }
-    end
+    }
 
-    def add_slots(slots)
-        slots.each{|s|
-            @info[:slots][s] = :new
-        }
-        @dirty = true
-    end
-
-    def set_as_replica(node_id)
-        @info[:replicate] = node_id
-        @dirty = true
-    end
-
-    def flush_node_config
-        return if !@dirty
-        if @info[:replicate]
-            begin
-                @r.cluster("replicate",@info[:replicate])
-            rescue
-                # If the cluster did not already joined it is possible that
-                # the slave does not know the master node yet. So on errors
-                # we return ASAP leaving the dirty flag set, to flush the
-                # config later.
-                return
-            end
-        else
-            new = []
-            @info[:slots].each{|s,val|
-                if val == :new
-                    new << s
-                    @info[:slots][s] = true
-                end
-            }
-            @r.cluster("addslots",*new)
-        end
-        @dirty = false
-    end
-
-    def info_string
-        # We want to display the hash slots assigned to this node
-        # as ranges, like in: "1-5,8-9,20-25,30"
-        #
-        # Note: this could be easily written without side effects,
-        # we use 'slots' just to split the computation into steps.
-
-        # First step: we want an increasing array of integers
-        # for instance: [1,2,3,4,5,8,9,20,21,22,23,24,25,30]
-        slots = @info[:slots].keys.sort
-
-        # As we want to aggregate adjacent slots we convert all the
-        # slot integers into ranges (with just one element)
-        # So we have something like [1..1,2..2, ... and so forth.
-        slots.map!{|x| x..x}
-
-        # Finally we group ranges with adjacent elements.
-        slots = slots.reduce([]) {|a,b|
-            if !a.empty? && b.first == (a[-1].last)+1
-                a[0..-2] + [(a[-1].first)..(b.last)]
-            else
-                a + [b]
-            end
-        }
-
-        # Now our task is easy, we just convert ranges with just one
-        # element into a number, and a real range into a start-end format.
-        # Finally we join the array using the comma as separator.
-        slots = slots.map{|x|
-            x.count == 1 ? x.first.to_s : "#{x.first}-#{x.last}"
-        }.join(",")
-
-        role = self.has_flag?("master") ? "M" : "S"
-
-        if self.info[:replicate] and @dirty
-            is = "S: #{self.info[:name]} #{self.to_s}"
-        else
-            is = "#{role}: #{self.info[:name]} #{self.to_s}\n"+
-            "   slots:#{slots} (#{self.slots.length} slots) "+
-            "#{(self.info[:flags]-["myself"]).join(",")}"
-        end
-        if self.info[:replicate]
-            is += "\n   replicates #{info[:replicate]}"
-        elsif self.has_flag?("master") && self.info[:replicas]
-            is += "\n   #{info[:replicas].length} additional replica(s)"
-        end
-        is
-    end
-
-    # Return a single string representing nodes and associated slots.
-    # TODO: remove slaves from config when slaves will be handled
-    # by Redis Cluster.
-    def get_config_signature
-        config = []
-        @r.cluster("nodes").each_line{|l|
-            s = l.split
-            slots = s[8..-1].select {|x| x[0..0] != "["}
-            next if slots.length == 0
-            config << s[0]+":"+(slots.sort.join(","))
-        }
-        config.sort.join("|")
-    end
-
-    def info
-        @info
-    end
-
-    def is_dirty?
-        @dirty
-    end
-
-    def r
-        @r
-    end
 end
 
-class RedisTrib
-    def initialize
-        @nodes = []
-        @fix = false
-        @errors = []
-        @timeout = MigrateDefaultTimeout
-    end
-
-    def check_arity(req_args, num_args)
-        if ((req_args > 0 and num_args != req_args) ||
-           (req_args < 0 and num_args < req_args.abs))
-           xputs "[ERR] Wrong number of arguments for specified sub command"
-           exit 1
-        end
-    end
-
-    def add_node(node)
-        @nodes << node
-    end
-
-    def reset_nodes
-        @nodes = []
-    end
-
-    def cluster_error(msg)
-        @errors << msg
-        xputs msg
-    end
-
-    # Return the node with the specified ID or Nil.
-    def get_node_by_name(name)
-        @nodes.each{|n|
-            return n if n.info[:name] == name.downcase
-        }
-        return nil
-    end
-
-    # Like get_node_by_name but the specified name can be just the first
-    # part of the node ID as long as the prefix in unique across the
-    # cluster.
-    def get_node_by_abbreviated_name(name)
-        l = name.length
-        candidates = []
-        @nodes.each{|n|
-            if n.info[:name][0...l] == name.downcase
-                candidates << n
-            end
-        }
-        return nil if candidates.length != 1
-        candidates[0]
-    end
-
-    # This function returns the master that has the least number of replicas
-    # in the cluster. If there are multiple masters with the same smaller
-    # number of replicas, one at random is returned.
-    def get_master_with_least_replicas
-        masters = @nodes.select{|n| n.has_flag? "master"}
-        sorted = masters.sort{|a,b|
-            a.info[:replicas].length <=> b.info[:replicas].length
-        }
-        sorted[0]
-    end
-
-    def check_cluster(opt={})
-        xputs ">>> Performing Cluster Check (using node #{@nodes[0]})"
-        show_nodes if !opt[:quiet]
-        check_config_consistency
-        check_open_slots
-        check_slots_coverage
-    end
-
-    def show_cluster_info
-        masters = 0
-        keys = 0
-        @nodes.each{|n|
-            if n.has_flag?("master")
-                puts "#{n} (#{n.info[:name][0...8]}...) -> #{n.r.dbsize} keys | #{n.slots.length} slots | "+
-                     "#{n.info[:replicas].length} slaves."
-                masters += 1
-                keys += n.r.dbsize
-            end
-        }
-        xputs "[OK] #{keys} keys in #{masters} masters."
-        keys_per_slot = sprintf("%.2f",keys/16384.0)
-        puts "#{keys_per_slot} keys per slot on average."
-    end
-
-    # Merge slots of every known node. If the resulting slots are equal
-    # to ClusterHashSlots, then all slots are served.
-    def covered_slots
-        slots = {}
-        @nodes.each{|n|
-            slots = slots.merge(n.slots)
-        }
-        slots
-    end
-
-    def check_slots_coverage
-        xputs ">>> Check slots coverage..."
-        slots = covered_slots
-        if slots.length == ClusterHashSlots
-            xputs "[OK] All #{ClusterHashSlots} slots covered."
-        else
-            cluster_error \
-                "[ERR] Not all #{ClusterHashSlots} slots are covered by nodes."
-            fix_slots_coverage if @fix
-        end
-    end
-
-    def check_open_slots
-        xputs ">>> Check for open slots..."
-        open_slots = []
-        @nodes.each{|n|
-            if n.info[:migrating].size > 0
-                cluster_error \
-                    "[WARNING] Node #{n} has slots in migrating state (#{n.info[:migrating].keys.join(",")})."
-                open_slots += n.info[:migrating].keys
-            end
-            if n.info[:importing].size > 0
-                cluster_error \
-                    "[WARNING] Node #{n} has slots in importing state (#{n.info[:importing].keys.join(",")})."
-                open_slots += n.info[:importing].keys
-            end
-        }
-        open_slots.uniq!
-        if open_slots.length > 0
-            xputs "[WARNING] The following slots are open: #{open_slots.join(",")}"
-        end
-        if @fix
-            open_slots.each{|slot| fix_open_slot slot}
-        end
-    end
-
-    def nodes_with_keys_in_slot(slot)
-        nodes = []
-        @nodes.each{|n|
-            next if n.has_flag?("slave")
-            nodes << n if n.r.cluster("getkeysinslot",slot,1).length > 0
-        }
-        nodes
-    end
-
-    def fix_slots_coverage
-        not_covered = (0...ClusterHashSlots).to_a - covered_slots.keys
-        xputs ">>> Fixing slots coverage..."
-        xputs "List of not covered slots: " + not_covered.join(",")
-
-        # For every slot, take action depending on the actual condition:
-        # 1) No node has keys for this slot.
-        # 2) A single node has keys for this slot.
-        # 3) Multiple nodes have keys for this slot.
-        slots = {}
-        not_covered.each{|slot|
-            nodes = nodes_with_keys_in_slot(slot)
-            slots[slot] = nodes
-            xputs "Slot #{slot} has keys in #{nodes.length} nodes: #{nodes.join(", ")}"
-        }
-
-        none = slots.select {|k,v| v.length == 0}
-        single = slots.select {|k,v| v.length == 1}
-        multi = slots.select {|k,v| v.length > 1}
-
-        # Handle case "1": keys in no node.
-        if none.length > 0
-            xputs "The following uncovered slots have no keys across the cluster:"
-            xputs none.keys.join(",")
-            yes_or_die "Fix these slots by covering with a random node?"
-            none.each{|slot,nodes|
-                node = @nodes.sample
-                xputs ">>> Covering slot #{slot} with #{node}"
-                node.r.cluster("addslots",slot)
-            }
-        end
-
-        # Handle case "2": keys only in one node.
-        if single.length > 0
-            xputs "The following uncovered slots have keys in just one node:"
-            puts single.keys.join(",")
-            yes_or_die "Fix these slots by covering with those nodes?"
-            single.each{|slot,nodes|
-                xputs ">>> Covering slot #{slot} with #{nodes[0]}"
-                nodes[0].r.cluster("addslots",slot)
-            }
-        end
-
-        # Handle case "3": keys in multiple nodes.
-        if multi.length > 0
-            xputs "The following uncovered slots have keys in multiple nodes:"
-            xputs multi.keys.join(",")
-            yes_or_die "Fix these slots by moving keys into a single node?"
-            multi.each{|slot,nodes|
-                target = get_node_with_most_keys_in_slot(nodes,slot)
-                xputs ">>> Covering slot #{slot} moving keys to #{target}"
-
-                target.r.cluster('addslots',slot)
-                target.r.cluster('setslot',slot,'stable')
-                nodes.each{|src|
-                    next if src == target
-                    # Set the source node in 'importing' state (even if we will
-                    # actually migrate keys away) in order to avoid receiving
-                    # redirections for MIGRATE.
-                    src.r.cluster('setslot',slot,'importing',target.info[:name])
-                    move_slot(src,target,slot,:dots=>true,:fix=>true,:cold=>true)
-                    src.r.cluster('setslot',slot,'stable')
-                }
-            }
-        end
-    end
-
-    # Return the owner of the specified slot
-    def get_slot_owners(slot)
-        owners = []
-        @nodes.each{|n|
-            next if n.has_flag?("slave")
-            n.slots.each{|s,_|
-                owners << n if s == slot
-            }
-        }
-        owners
-    end
-
-    # Return the node, among 'nodes' with the greatest number of keys
-    # in the specified slot.
-    def get_node_with_most_keys_in_slot(nodes,slot)
-        best = nil
-        best_numkeys = 0
-        @nodes.each{|n|
-            next if n.has_flag?("slave")
-            numkeys = n.r.cluster("countkeysinslot",slot)
-            if numkeys > best_numkeys || best == nil
-                best = n
-                best_numkeys = numkeys
-            end
-        }
-        return best
-    end
-
-    # Slot 'slot' was found to be in importing or migrating state in one or
-    # more nodes. This function fixes this condition by migrating keys where
-    # it seems more sensible.
-    def fix_open_slot(slot)
-        puts ">>> Fixing open slot #{slot}"
-
-        # Try to obtain the current slot owner, according to the current
-        # nodes configuration.
-        owners = get_slot_owners(slot)
-        owner = owners[0] if owners.length == 1
-
-        migrating = []
-        importing = []
-        @nodes.each{|n|
-            next if n.has_flag? "slave"
-            if n.info[:migrating][slot]
-                migrating << n
-            elsif n.info[:importing][slot]
-                importing << n
-            elsif n.r.cluster("countkeysinslot",slot) > 0 && n != owner
-                xputs "*** Found keys about slot #{slot} in node #{n}!"
-                importing << n
-            end
-        }
-        puts "Set as migrating in: #{migrating.join(",")}"
-        puts "Set as importing in: #{importing.join(",")}"
-
-        # If there is no slot owner, set as owner the slot with the biggest
-        # number of keys, among the set of migrating / importing nodes.
-        if !owner
-            xputs ">>> Nobody claims ownership, selecting an owner..."
-            owner = get_node_with_most_keys_in_slot(@nodes,slot)
-
-            # If we still don't have an owner, we can't fix it.
-            if !owner
-                xputs "[ERR] Can't select a slot owner. Impossible to fix."
-                exit 1
-            end
-
-            # Use ADDSLOTS to assign the slot.
-            puts "*** Configuring #{owner} as the slot owner"
-            owner.r.cluster("setslot",slot,"stable")
-            owner.r.cluster("addslots",slot)
-            # Make sure this information will propagate. Not strictly needed
-            # since there is no past owner, so all the other nodes will accept
-            # whatever epoch this node will claim the slot with.
-            owner.r.cluster("bumpepoch")
-
-            # Remove the owner from the list of migrating/importing
-            # nodes.
-            migrating.delete(owner)
-            importing.delete(owner)
-        end
-
-        # If there are multiple owners of the slot, we need to fix it
-        # so that a single node is the owner and all the other nodes
-        # are in importing state. Later the fix can be handled by one
-        # of the base cases above.
-        #
-        # Note that this case also covers multiple nodes having the slot
-        # in migrating state, since migrating is a valid state only for
-        # slot owners.
-        if owners.length > 1
-            owner = get_node_with_most_keys_in_slot(owners,slot)
-            owners.each{|n|
-                next if n == owner
-                n.r.cluster('delslots',slot)
-                n.r.cluster('setslot',slot,'importing',owner.info[:name])
-                importing.delete(n) # Avoid duplciates
-                importing << n
-            }
-            owner.r.cluster('bumpepoch')
-        end
-
-        # Case 1: The slot is in migrating state in one slot, and in
-        #         importing state in 1 slot. That's trivial to address.
-        if migrating.length == 1 && importing.length == 1
-            move_slot(migrating[0],importing[0],slot,:dots=>true,:fix=>true)
-        # Case 2: There are multiple nodes that claim the slot as importing,
-        # they probably got keys about the slot after a restart so opened
-        # the slot. In this case we just move all the keys to the owner
-        # according to the configuration.
-        elsif migrating.length == 0 && importing.length > 0
-            xputs ">>> Moving all the #{slot} slot keys to its owner #{owner}"
-            importing.each {|node|
-                next if node == owner
-                move_slot(node,owner,slot,:dots=>true,:fix=>true,:cold=>true)
-                xputs ">>> Setting #{slot} as STABLE in #{node}"
-                node.r.cluster("setslot",slot,"stable")
-            }
-        # Case 3: There are no slots claiming to be in importing state, but
-        # there is a migrating node that actually don't have any key. We
-        # can just close the slot, probably a reshard interrupted in the middle.
-        elsif importing.length == 0 && migrating.length == 1 &&
-              migrating[0].r.cluster("getkeysinslot",slot,10).length == 0
-            migrating[0].r.cluster("setslot",slot,"stable")
-        else
-            xputs "[ERR] Sorry, Redis-trib can't fix this slot yet (work in progress). Slot is set as migrating in #{migrating.join(",")}, as importing in #{importing.join(",")}, owner is #{owner}"
-        end
-    end
-
-    # Check if all the nodes agree about the cluster configuration
-    def check_config_consistency
-        if !is_config_consistent?
-            cluster_error "[ERR] Nodes don't agree about configuration!"
-        else
-            xputs "[OK] All nodes agree about slots configuration."
-        end
-    end
-
-    def is_config_consistent?
-        signatures=[]
-        @nodes.each{|n|
-            signatures << n.get_config_signature
-        }
-        return signatures.uniq.length == 1
-    end
-
-    def wait_cluster_join
-        print "Waiting for the cluster to join"
-        while !is_config_consistent?
-            print "."
-            STDOUT.flush
-            sleep 1
-        end
-        print "\n"
-    end
-
-    def alloc_slots
-        nodes_count = @nodes.length
-        masters_count = @nodes.length / (@replicas+1)
-        masters = []
-
-        # The first step is to split instances by IP. This is useful as
-        # we'll try to allocate master nodes in different physical machines
-        # (as much as possible) and to allocate slaves of a given master in
-        # different physical machines as well.
-        #
-        # This code assumes just that if the IP is different, than it is more
-        # likely that the instance is running in a different physical host
-        # or at least a different virtual machine.
-        ips = {}
-        @nodes.each{|n|
-            ips[n.info[:host]] = [] if !ips[n.info[:host]]
-            ips[n.info[:host]] << n
-        }
-
-        # Select master instances
-        puts "Using #{masters_count} masters:"
-        interleaved = []
-        stop = false
-        while not stop do
-            # Take one node from each IP until we run out of nodes
-            # across every IP.
-            ips.each do |ip,nodes|
-                if nodes.empty?
-                    # if this IP has no remaining nodes, check for termination
-                    if interleaved.length == nodes_count
-                        # stop when 'interleaved' has accumulated all nodes
-                        stop = true
-                        next
-                    end
-                else
-                    # else, move one node from this IP to 'interleaved'
-                    interleaved.push nodes.shift
-                end
-            end
-        end
-
-        masters = interleaved.slice!(0, masters_count)
-        nodes_count -= masters.length
-
-        masters.each{|m| puts m}
-
-        # Rotating the list sometimes helps to get better initial
-        # anti-affinity before the optimizer runs.
-        interleaved.push interleaved.shift
-
-        # Alloc slots on masters. After interleaving to get just the first N
-        # should be optimal. With slaves is more complex, see later...
-        slots_per_node = ClusterHashSlots.to_f / masters_count
-        first = 0
-        cursor = 0.0
-        masters.each_with_index{|n,masternum|
-            last = (cursor+slots_per_node-1).round
-            if last > ClusterHashSlots || masternum == masters.length-1
-                last = ClusterHashSlots-1
-            end
-            last = first if last < first # Min step is 1.
-            n.add_slots first..last
-            first = last+1
-            cursor += slots_per_node
-        }
-
-        # Select N replicas for every master.
-        # We try to split the replicas among all the IPs with spare nodes
-        # trying to avoid the host where the master is running, if possible.
-        #
-        # Note we loop two times.  The first loop assigns the requested
-        # number of replicas to each master.  The second loop assigns any
-        # remaining instances as extra replicas to masters.  Some masters
-        # may end up with more than their requested number of replicas, but
-        # all nodes will be used.
-        assignment_verbose = false
-
-        [:requested,:unused].each do |assign|
-            masters.each do |m|
-                assigned_replicas = 0
-                while assigned_replicas < @replicas
-                    break if nodes_count == 0
-                    if assignment_verbose
-                        if assign == :requested
-                            puts "Requesting total of #{@replicas} replicas " \
-                                 "(#{assigned_replicas} replicas assigned " \
-                                 "so far with #{nodes_count} total remaining)."
-                        elsif assign == :unused
-                            puts "Assigning extra instance to replication " \
-                                 "role too (#{nodes_count} remaining)."
-                        end
-                    end
-
-                    # Return the first node not matching our current master
-                    node = interleaved.find{|n| n.info[:host] != m.info[:host]}
-
-                    # If we found a node, use it as a best-first match.
-                    # Otherwise, we didn't find a node on a different IP, so we
-                    # go ahead and use a same-IP replica.
-                    if node
-                        slave = node
-                        interleaved.delete node
-                    else
-                        slave = interleaved.shift
-                    end
-                    slave.set_as_replica(m.info[:name])
-                    nodes_count -= 1
-                    assigned_replicas += 1
-                    puts "Adding replica #{slave} to #{m}"
-
-                    # If we are in the "assign extra nodes" loop,
-                    # we want to assign one extra replica to each
-                    # master before repeating masters.
-                    # This break lets us assign extra replicas to masters
-                    # in a round-robin way.
-                    break if assign == :unused
-                end
-            end
-        end
-
-        optimize_anti_affinity
-    end
-
-    def optimize_anti_affinity
-        score,aux = get_anti_affinity_score
-        return if score == 0
-
-        xputs ">>> Trying to optimize slaves allocation for anti-affinity"
-
-        maxiter = 500*@nodes.length # Effort is proportional to cluster size...
-        while maxiter > 0
-            score,offenders = get_anti_affinity_score
-            break if score == 0 # Optimal anti affinity reached
-
-            # We'll try to randomly swap a slave's assigned master causing
-            # an affinity problem with another random slave, to see if we
-            # can improve the affinity.
-            first = offenders.shuffle.first
-            nodes = @nodes.select{|n| n != first && n.info[:replicate]}
-            break if nodes.length == 0
-            second = nodes.shuffle.first
-
-            first_master = first.info[:replicate]
-            second_master = second.info[:replicate]
-            first.set_as_replica(second_master)
-            second.set_as_replica(first_master)
-
-            new_score,aux = get_anti_affinity_score
-            # If the change actually makes thing worse, revert. Otherwise
-            # leave as it is because the best solution may need a few
-            # combined swaps.
-            if new_score > score
-                first.set_as_replica(first_master)
-                second.set_as_replica(second_master)
-            end
-
-            maxiter -= 1
-        end
-
-        score,aux = get_anti_affinity_score
-        if score == 0
-            xputs "[OK] Perfect anti-affinity obtained!"
-        elsif score >= 10000
-            puts "[WARNING] Some slaves are in the same host as their master"
-        else
-            puts "[WARNING] Some slaves of the same master are in the same host"
-        end
-    end
-
-    # Return the anti-affinity score, which is a measure of the amount of
-    # violations of anti-affinity in the current cluster layout, that is, how
-    # badly the masters and slaves are distributed in the different IP
-    # addresses so that slaves of the same master are not in the master
-    # host and are also in different hosts.
-    #
-    # The score is calculated as follows:
-    #
-    # SAME_AS_MASTER = 10000 * each slave in the same IP of its master.
-    # SAME_AS_SLAVE  = 1 * each slave having the same IP as another slave
-    #                      of the same master.
-    # FINAL_SCORE = SAME_AS_MASTER + SAME_AS_SLAVE
-    #
-    # So a greater score means a worse anti-affinity level, while zero
-    # means perfect anti-affinity.
-    #
-    # The anti affinity optimizator will try to get a score as low as
-    # possible. Since we do not want to sacrifice the fact that slaves should
-    # not be in the same host as the master, we assign 10000 times the score
-    # to this violation, so that we'll optimize for the second factor only
-    # if it does not impact the first one.
-    #
-    # The function returns two things: the above score, and the list of
-    # offending slaves, so that the optimizer can try changing the
-    # configuration of the slaves violating the anti-affinity goals.
-    def get_anti_affinity_score
-        score = 0
-        offending = [] # List of offending slaves to return to the caller
-
-        # First, split nodes by host
-        host_to_node = {}
-        @nodes.each{|n|
-            host = n.info[:host]
-            host_to_node[host] = [] if host_to_node[host] == nil
-            host_to_node[host] << n
-        }
-
-        # Then, for each set of nodes in the same host, split by
-        # related nodes (masters and slaves which are involved in
-        # replication of each other)
-        host_to_node.each{|host,nodes|
-            related = {}
-            nodes.each{|n|
-                if !n.info[:replicate]
-                    name = n.info[:name]
-                    related[name] = [] if related[name] == nil
-                    related[name] << :m
-                else
-                    name = n.info[:replicate]
-                    related[name] = [] if related[name] == nil
-                    related[name] << :s
-                end
-            }
-
-            # Now it's trivial to check, for each related group having the
-            # same host, what is their local score.
-            related.each{|id,types|
-                next if types.length < 2
-                types.sort! # Make sure :m if the first if any
-                if types[0] == :m
-                    score += 10000 * (types.length-1)
-                else
-                    score += 1 * types.length
-                end
-
-                # Populate the list of offending nodes
-                @nodes.each{|n|
-                    if n.info[:replicate] == id &&
-                       n.info[:host] == host
-                       offending << n
-                    end
-                }
-            }
-        }
-        return score,offending
-    end
-
-    def flush_nodes_config
-        @nodes.each{|n|
-            n.flush_node_config
-        }
-    end
-
-    def show_nodes
-        @nodes.each{|n|
-            xputs n.info_string
-        }
-    end
-
-    # Redis Cluster config epoch collision resolution code is able to eventually
-    # set a different epoch to each node after a new cluster is created, but
-    # it is slow compared to assign a progressive config epoch to each node
-    # before joining the cluster. However we do just a best-effort try here
-    # since if we fail is not a problem.
-    def assign_config_epoch
-        config_epoch = 1
-        @nodes.each{|n|
-            begin
-                n.r.cluster("set-config-epoch",config_epoch)
-            rescue
-            end
-            config_epoch += 1
-        }
-    end
-
-    def join_cluster
-        # We use a brute force approach to make sure the node will meet
-        # each other, that is, sending CLUSTER MEET messages to all the nodes
-        # about the very same node.
-        # Thanks to gossip this information should propagate across all the
-        # cluster in a matter of seconds.
-        first = false
-        @nodes.each{|n|
-            if !first then first = n.info; next; end # Skip the first node
-            n.r.cluster("meet",first[:host],first[:port])
-        }
-    end
-
-    def yes_or_die(msg)
-        print "#{msg} (type 'yes' to accept): "
-        STDOUT.flush
-        if !(STDIN.gets.chomp.downcase == "yes")
-            xputs "*** Aborting..."
-            exit 1
-        end
-    end
-
-    def load_cluster_info_from_node(nodeaddr)
-        node = ClusterNode.new(nodeaddr)
-        node.connect(:abort => true)
-        node.assert_cluster
-        node.load_info(:getfriends => true)
-        add_node(node)
-        node.friends.each{|f|
-            next if f[:flags].index("noaddr") ||
-                    f[:flags].index("disconnected") ||
-                    f[:flags].index("fail")
-            fnode = ClusterNode.new(f[:addr])
-            fnode.connect()
-            next if !fnode.r
-            begin
-                fnode.load_info()
-                add_node(fnode)
-            rescue => e
-                xputs "[ERR] Unable to load info for node #{fnode}"
-            end
-        }
-        populate_nodes_replicas_info
-    end
-
-    # This function is called by load_cluster_info_from_node in order to
-    # add additional information to every node as a list of replicas.
-    def populate_nodes_replicas_info
-        # Start adding the new field to every node.
-        @nodes.each{|n|
-            n.info[:replicas] = []
-        }
-
-        # Populate the replicas field using the replicate field of slave
-        # nodes.
-        @nodes.each{|n|
-            if n.info[:replicate]
-                master = get_node_by_name(n.info[:replicate])
-                if !master
-                    xputs "*** WARNING: #{n} claims to be slave of unknown node ID #{n.info[:replicate]}."
-                else
-                    master.info[:replicas] << n
-                end
-            end
-        }
-    end
-
-    # Given a list of source nodes return a "resharding plan"
-    # with what slots to move in order to move "numslots" slots to another
-    # instance.
-    def compute_reshard_table(sources,numslots)
-        moved = []
-        # Sort from bigger to smaller instance, for two reasons:
-        # 1) If we take less slots than instances it is better to start
-        #    getting from the biggest instances.
-        # 2) We take one slot more from the first instance in the case of not
-        #    perfect divisibility. Like we have 3 nodes and need to get 10
-        #    slots, we take 4 from the first, and 3 from the rest. So the
-        #    biggest is always the first.
-        sources = sources.sort{|a,b| b.slots.length <=> a.slots.length}
-        source_tot_slots = sources.inject(0) {|sum,source|
-            sum+source.slots.length
-        }
-        sources.each_with_index{|s,i|
-            # Every node will provide a number of slots proportional to the
-            # slots it has assigned.
-            n = (numslots.to_f/source_tot_slots*s.slots.length)
-            if i == 0
-                n = n.ceil
-            else
-                n = n.floor
-            end
-            s.slots.keys.sort[(0...n)].each{|slot|
-                if moved.length < numslots
-                    moved << {:source => s, :slot => slot}
-                end
-            }
-        }
-        return moved
-    end
-
-    def show_reshard_table(table)
-        table.each{|e|
-            puts "    Moving slot #{e[:slot]} from #{e[:source].info[:name]}"
-        }
-    end
-
-    # Move slots between source and target nodes using MIGRATE.
-    #
-    # Options:
-    # :verbose -- Print a dot for every moved key.
-    # :fix     -- We are moving in the context of a fix. Use REPLACE.
-    # :cold    -- Move keys without opening slots / reconfiguring the nodes.
-    # :update  -- Update nodes.info[:slots] for source/target nodes.
-    # :quiet   -- Don't print info messages.
-    def move_slot(source,target,slot,o={})
-        o = {:pipeline => MigrateDefaultPipeline}.merge(o)
-
-        # We start marking the slot as importing in the destination node,
-        # and the slot as migrating in the target host. Note that the order of
-        # the operations is important, as otherwise a client may be redirected
-        # to the target node that does not yet know it is importing this slot.
-        if !o[:quiet]
-            print "Moving slot #{slot} from #{source} to #{target}: "
-            STDOUT.flush
-        end
-
-        if !o[:cold]
-            target.r.cluster("setslot",slot,"importing",source.info[:name])
-            source.r.cluster("setslot",slot,"migrating",target.info[:name])
-        end
-        # Migrate all the keys from source to target using the MIGRATE command
-        while true
-            keys = source.r.cluster("getkeysinslot",slot,o[:pipeline])
-            break if keys.length == 0
-            begin
-                source.r.client.call(["migrate",target.info[:host],target.info[:port],"",0,@timeout,:keys,*keys])
-            rescue => e
-                if o[:fix] && e.to_s =~ /BUSYKEY/
-                    xputs "*** Target key exists. Replacing it for FIX."
-                    source.r.client.call(["migrate",target.info[:host],target.info[:port],"",0,@timeout,:replace,:keys,*keys])
-                else
-                    puts ""
-                    xputs "[ERR] Calling MIGRATE: #{e}"
-                    exit 1
-                end
-            end
-            print "."*keys.length if o[:dots]
-            STDOUT.flush
-        end
-
-        puts if !o[:quiet]
-        # Set the new node as the owner of the slot in all the known nodes.
-        if !o[:cold]
-            @nodes.each{|n|
-                next if n.has_flag?("slave")
-                n.r.cluster("setslot",slot,"node",target.info[:name])
-            }
-        end
-
-        # Update the node logical config
-        if o[:update] then
-            source.info[:slots].delete(slot)
-            target.info[:slots][slot] = true
-        end
-    end
-
-    # redis-trib subcommands implementations.
-
-    def check_cluster_cmd(argv,opt)
-        load_cluster_info_from_node(argv[0])
-        check_cluster
-    end
-
-    def info_cluster_cmd(argv,opt)
-        load_cluster_info_from_node(argv[0])
-        show_cluster_info
-    end
-
-    def rebalance_cluster_cmd(argv,opt)
-        opt = {
-            'pipeline' => MigrateDefaultPipeline,
-            'threshold' => RebalanceDefaultThreshold
-        }.merge(opt)
-
-        # Load nodes info before parsing options, otherwise we can't
-        # handle --weight.
-        load_cluster_info_from_node(argv[0])
-
-        # Options parsing
-        threshold = opt['threshold'].to_i
-        autoweights = opt['auto-weights']
-        weights = {}
-        opt['weight'].each{|w|
-            fields = w.split("=")
-            node = get_node_by_abbreviated_name(fields[0])
-            if !node || !node.has_flag?("master")
-                puts "*** No such master node #{fields[0]}"
-                exit 1
-            end
-            weights[node.info[:name]] = fields[1].to_f
-        } if opt['weight']
-        useempty = opt['use-empty-masters']
-
-       # Assign a weight to each node, and compute the total cluster weight.
-        total_weight = 0
-        nodes_involved = 0
-        @nodes.each{|n|
-            if n.has_flag?("master")
-                next if !useempty && n.slots.length == 0
-                n.info[:w] = weights[n.info[:name]] ? weights[n.info[:name]] : 1
-                total_weight += n.info[:w]
-                nodes_involved += 1
-            end
-        }
-
-        # Check cluster, only proceed if it looks sane.
-        check_cluster(:quiet => true)
-        if @errors.length != 0
-            puts "*** Please fix your cluster problems before rebalancing"
-            exit 1
-        end
-
-        # Calculate the slots balance for each node. It's the number of
-        # slots the node should lose (if positive) or gain (if negative)
-        # in order to be balanced.
-        threshold = opt['threshold'].to_f
-        threshold_reached = false
-        @nodes.each{|n|
-            if n.has_flag?("master")
-                next if !n.info[:w]
-                expected = ((ClusterHashSlots.to_f / total_weight) *
-                            n.info[:w]).to_i
-                n.info[:balance] = n.slots.length - expected
-                # Compute the percentage of difference between the
-                # expected number of slots and the real one, to see
-                # if it's over the threshold specified by the user.
-                over_threshold = false
-                if threshold > 0
-                    if n.slots.length > 0
-                        err_perc = (100-(100.0*expected/n.slots.length)).abs
-                        over_threshold = true if err_perc > threshold
-                    elsif expected > 0
-                        over_threshold = true
-                    end
-                end
-                threshold_reached = true if over_threshold
-            end
-        }
-        if !threshold_reached
-            xputs "*** No rebalancing needed! All nodes are within the #{threshold}% threshold."
-            return
-        end
-
-        # Only consider nodes we want to change
-        sn = @nodes.select{|n|
-            n.has_flag?("master") && n.info[:w]
-        }
-
-        # Because of rounding, it is possible that the balance of all nodes
-        # summed does not give 0. Make sure that nodes that have to provide
-        # slots are always matched by nodes receiving slots.
-        total_balance = sn.map{|x| x.info[:balance]}.reduce{|a,b| a+b}
-        while total_balance > 0
-            sn.each{|n|
-                if n.info[:balance] < 0 && total_balance > 0
-                    n.info[:balance] -= 1
-                    total_balance -= 1
-                end
-            }
-        end
-
-        # Sort nodes by their slots balance.
-        sn = sn.sort{|a,b|
-            a.info[:balance] <=> b.info[:balance]
-        }
-
-        xputs ">>> Rebalancing across #{nodes_involved} nodes. Total weight = #{total_weight}"
-
-        if $verbose
-            sn.each{|n|
-                puts "#{n} balance is #{n.info[:balance]} slots"
-            }
-        end
-
-        # Now we have at the start of the 'sn' array nodes that should get
-        # slots, at the end nodes that must give slots.
-        # We take two indexes, one at the start, and one at the end,
-        # incrementing or decrementing the indexes accordingly til we
-        # find nodes that need to get/provide slots.
-        dst_idx = 0
-        src_idx = sn.length - 1
-
-        while dst_idx < src_idx
-            dst = sn[dst_idx]
-            src = sn[src_idx]
-            numslots = [dst.info[:balance],src.info[:balance]].map{|n|
-                n.abs
-            }.min
-
-            if numslots > 0
-                puts "Moving #{numslots} slots from #{src} to #{dst}"
-
-                # Actually move the slots.
-                reshard_table = compute_reshard_table([src],numslots)
-                if reshard_table.length != numslots
-                    xputs "*** Assertio failed: Reshard table != number of slots"
-                    exit 1
-                end
-                if opt['simulate']
-                    print "#"*reshard_table.length
-                else
-                    reshard_table.each{|e|
-                        move_slot(e[:source],dst,e[:slot],
-                            :quiet=>true,
-                            :dots=>false,
-                            :update=>true,
-                            :pipeline=>opt['pipeline'])
-                        print "#"
-                        STDOUT.flush
-                    }
-                end
-                puts
-            end
-
-            # Update nodes balance.
-            dst.info[:balance] += numslots
-            src.info[:balance] -= numslots
-            dst_idx += 1 if dst.info[:balance] == 0
-            src_idx -= 1 if src.info[:balance] == 0
-        end
-    end
-
-    def fix_cluster_cmd(argv,opt)
-        @fix = true
-        @timeout = opt['timeout'].to_i if opt['timeout']
-
-        load_cluster_info_from_node(argv[0])
-        check_cluster
-    end
-
-    def reshard_cluster_cmd(argv,opt)
-        opt = {'pipeline' => MigrateDefaultPipeline}.merge(opt)
-
-        load_cluster_info_from_node(argv[0])
-        check_cluster
-        if @errors.length != 0
-            puts "*** Please fix your cluster problems before resharding"
-            exit 1
-        end
-
-        @timeout = opt['timeout'].to_i if opt['timeout'].to_i
-
-        # Get number of slots
-        if opt['slots']
-            numslots = opt['slots'].to_i
-        else
-            numslots = 0
-            while numslots <= 0 or numslots > ClusterHashSlots
-                print "How many slots do you want to move (from 1 to #{ClusterHashSlots})? "
-                numslots = STDIN.gets.to_i
-            end
-        end
-
-        # Get the target instance
-        if opt['to']
-            target = get_node_by_name(opt['to'])
-            if !target || target.has_flag?("slave")
-                xputs "*** The specified node is not known or not a master, please retry."
-                exit 1
-            end
-        else
-            target = nil
-            while not target
-                print "What is the receiving node ID? "
-                target = get_node_by_name(STDIN.gets.chop)
-                if !target || target.has_flag?("slave")
-                    xputs "*** The specified node is not known or not a master, please retry."
-                    target = nil
-                end
-            end
-        end
-
-        # Get the source instances
-        sources = []
-        if opt['from']
-            opt['from'].split(',').each{|node_id|
-                if node_id == "all"
-                    sources = "all"
-                    break
-                end
-                src = get_node_by_name(node_id)
-                if !src || src.has_flag?("slave")
-                    xputs "*** The specified node is not known or is not a master, please retry."
-                    exit 1
-                end
-                sources << src
-            }
-        else
-            xputs "Please enter all the source node IDs."
-            xputs "  Type 'all' to use all the nodes as source nodes for the hash slots."
-            xputs "  Type 'done' once you entered all the source nodes IDs."
-            while true
-                print "Source node ##{sources.length+1}:"
-                line = STDIN.gets.chop
-                src = get_node_by_name(line)
-                if line == "done"
-                    break
-                elsif line == "all"
-                    sources = "all"
-                    break
-                elsif !src || src.has_flag?("slave")
-                    xputs "*** The specified node is not known or is not a master, please retry."
-                elsif src.info[:name] == target.info[:name]
-                    xputs "*** It is not possible to use the target node as source node."
-                else
-                    sources << src
-                end
-            end
-        end
-
-        if sources.length == 0
-            puts "*** No source nodes given, operation aborted"
-            exit 1
-        end
-
-        # Handle soures == all.
-        if sources == "all"
-            sources = []
-            @nodes.each{|n|
-                next if n.info[:name] == target.info[:name]
-                next if n.has_flag?("slave")
-                sources << n
-            }
-        end
-
-        # Check if the destination node is the same of any source nodes.
-        if sources.index(target)
-            xputs "*** Target node is also listed among the source nodes!"
-            exit 1
-        end
-
-        puts "\nReady to move #{numslots} slots."
-        puts "  Source nodes:"
-        sources.each{|s| puts "    "+s.info_string}
-        puts "  Destination node:"
-        puts "    #{target.info_string}"
-        reshard_table = compute_reshard_table(sources,numslots)
-        puts "  Resharding plan:"
-        show_reshard_table(reshard_table)
-        if !opt['yes']
-            print "Do you want to proceed with the proposed reshard plan (yes/no)? "
-            yesno = STDIN.gets.chop
-            exit(1) if (yesno != "yes")
-        end
-        reshard_table.each{|e|
-            move_slot(e[:source],target,e[:slot],
-                :dots=>true,
-                :pipeline=>opt['pipeline'])
-        }
-    end
-
-    # This is an helper function for create_cluster_cmd that verifies if
-    # the number of nodes and the specified replicas have a valid configuration
-    # where there are at least three master nodes and enough replicas per node.
-    def check_create_parameters
-        masters = @nodes.length/(@replicas+1)
-        if masters < 3
-            puts "*** ERROR: Invalid configuration for cluster creation."
-            puts "*** Redis Cluster requires at least 3 master nodes."
-            puts "*** This is not possible with #{@nodes.length} nodes and #{@replicas} replicas per node."
-            puts "*** At least #{3*(@replicas+1)} nodes are required."
-            exit 1
-        end
-    end
-
-    def create_cluster_cmd(argv,opt)
-        opt = {'replicas' => 0}.merge(opt)
-        @replicas = opt['replicas'].to_i
-
-        xputs ">>> Creating cluster"
-        argv[0..-1].each{|n|
-            node = ClusterNode.new(n)
-            node.connect(:abort => true)
-            node.assert_cluster
-            node.load_info
-            node.assert_empty
-            add_node(node)
-        }
-        check_create_parameters
-        xputs ">>> Performing hash slots allocation on #{@nodes.length} nodes..."
-        alloc_slots
-        show_nodes
-        yes_or_die "Can I set the above configuration?"
-        flush_nodes_config
-        xputs ">>> Nodes configuration updated"
-        xputs ">>> Assign a different config epoch to each node"
-        assign_config_epoch
-        xputs ">>> Sending CLUSTER MEET messages to join the cluster"
-        join_cluster
-        # Give one second for the join to start, in order to avoid that
-        # wait_cluster_join will find all the nodes agree about the config as
-        # they are still empty with unassigned slots.
-        sleep 1
-        wait_cluster_join
-        flush_nodes_config # Useful for the replicas
-        # Reset the node information, so that when the
-        # final summary is listed in check_cluster about the newly created cluster
-        # all the nodes would get properly listed as slaves or masters
-        reset_nodes
-        load_cluster_info_from_node(argv[0])
-        check_cluster
-    end
-
-    def addnode_cluster_cmd(argv,opt)
-        xputs ">>> Adding node #{argv[0]} to cluster #{argv[1]}"
-
-        # Check the existing cluster
-        load_cluster_info_from_node(argv[1])
-        check_cluster
-
-        # If --master-id was specified, try to resolve it now so that we
-        # abort before starting with the node configuration.
-        if opt['slave']
-            if opt['master-id']
-                master = get_node_by_name(opt['master-id'])
-                if !master
-                    xputs "[ERR] No such master ID #{opt['master-id']}"
-                end
-            else
-                master = get_master_with_least_replicas
-                xputs "Automatically selected master #{master}"
-            end
-        end
-
-        # Add the new node
-        new = ClusterNode.new(argv[0])
-        new.connect(:abort => true)
-        new.assert_cluster
-        new.load_info
-        new.assert_empty
-        first = @nodes.first.info
-        add_node(new)
-
-        # Send CLUSTER MEET command to the new node
-        xputs ">>> Send CLUSTER MEET to node #{new} to make it join the cluster."
-        new.r.cluster("meet",first[:host],first[:port])
-
-        # Additional configuration is needed if the node is added as
-        # a slave.
-        if opt['slave']
-            wait_cluster_join
-            xputs ">>> Configure node as replica of #{master}."
-            new.r.cluster("replicate",master.info[:name])
-        end
-        xputs "[OK] New node added correctly."
-    end
-
-    def delnode_cluster_cmd(argv,opt)
-        id = argv[1].downcase
-        xputs ">>> Removing node #{id} from cluster #{argv[0]}"
-
-        # Load cluster information
-        load_cluster_info_from_node(argv[0])
-
-        # Check if the node exists and is not empty
-        node = get_node_by_name(id)
-
-        if !node
-            xputs "[ERR] No such node ID #{id}"
-            exit 1
-        end
-
-        if node.slots.length != 0
-            xputs "[ERR] Node #{node} is not empty! Reshard data away and try again."
-            exit 1
-        end
-
-        # Send CLUSTER FORGET to all the nodes but the node to remove
-        xputs ">>> Sending CLUSTER FORGET messages to the cluster..."
-        @nodes.each{|n|
-            next if n == node
-            if n.info[:replicate] && n.info[:replicate].downcase == id
-                # Reconfigure the slave to replicate with some other node
-                master = get_master_with_least_replicas
-                xputs ">>> #{n} as replica of #{master}"
-                n.r.cluster("replicate",master.info[:name])
-            end
-            n.r.cluster("forget",argv[1])
-        }
-
-        # Finally shutdown the node
-        xputs ">>> SHUTDOWN the node."
-        node.r.shutdown
-    end
-
-    def set_timeout_cluster_cmd(argv,opt)
-        timeout = argv[1].to_i
-        if timeout < 100
-            puts "Setting a node timeout of less than 100 milliseconds is a bad idea."
-            exit 1
-        end
-
-        # Load cluster information
-        load_cluster_info_from_node(argv[0])
-        ok_count = 0
-        err_count = 0
-
-        # Send CLUSTER FORGET to all the nodes but the node to remove
-        xputs ">>> Reconfiguring node timeout in every cluster node..."
-        @nodes.each{|n|
-            begin
-                n.r.config("set","cluster-node-timeout",timeout)
-                n.r.config("rewrite")
-                ok_count += 1
-                xputs "*** New timeout set for #{n}"
-            rescue => e
-                puts "ERR setting node-timeot for #{n}: #{e}"
-                err_count += 1
-            end
-        }
-        xputs ">>> New node timeout set. #{ok_count} OK, #{err_count} ERR."
-    end
-
-    def call_cluster_cmd(argv,opt)
-        cmd = argv[1..-1]
-        cmd[0] = cmd[0].upcase
-
-        # Load cluster information
-        load_cluster_info_from_node(argv[0])
-        xputs ">>> Calling #{cmd.join(" ")}"
-        @nodes.each{|n|
-            begin
-                res = n.r.send(*cmd)
-                puts "#{n}: #{res}"
-            rescue => e
-                puts "#{n}: #{e}"
-            end
-        }
-    end
-
-    def import_cluster_cmd(argv,opt)
-        source_addr = opt['from']
-        xputs ">>> Importing data from #{source_addr} to cluster #{argv[1]}"
-        use_copy = opt['copy']
-        use_replace = opt['replace']
-
-        # Check the existing cluster.
-        load_cluster_info_from_node(argv[0])
-        check_cluster
-
-        # Connect to the source node.
-        xputs ">>> Connecting to the source Redis instance"
-        src_host,src_port = source_addr.split(":")
-        source = Redis.new(:host =>src_host, :port =>src_port)
-        if source.info['cluster_enabled'].to_i == 1
-            xputs "[ERR] The source node should not be a cluster node."
-        end
-        xputs "*** Importing #{source.dbsize} keys from DB 0"
-
-        # Build a slot -> node map
-        slots = {}
-        @nodes.each{|n|
-            n.slots.each{|s,_|
-                slots[s] = n
-            }
-        }
-
-        # Use SCAN to iterate over the keys, migrating to the
-        # right node as needed.
-        cursor = nil
-        while cursor != 0
-            cursor,keys = source.scan(cursor, :count => 1000)
-            cursor = cursor.to_i
-            keys.each{|k|
-                # Migrate keys using the MIGRATE command.
-                slot = key_to_slot(k)
-                target = slots[slot]
-                print "Migrating #{k} to #{target}: "
-                STDOUT.flush
-                begin
-                    cmd = ["migrate",target.info[:host],target.info[:port],k,0,@timeout]
-                    cmd << :copy if use_copy
-                    cmd << :replace if use_replace
-                    source.client.call(cmd)
-                rescue => e
-                    puts e
-                else
-                    puts "OK"
-                end
-            }
-        end
-    end
-
-    def help_cluster_cmd(argv,opt)
-        show_help
-        exit 0
-    end
-
-    # Parse the options for the specific command "cmd".
-    # Returns an hash populate with option => value pairs, and the index of
-    # the first non-option argument in ARGV.
-    def parse_options(cmd)
-        idx = 1 ; # Current index into ARGV
-        options={}
-        while idx < ARGV.length && ARGV[idx][0..1] == '--'
-            if ARGV[idx][0..1] == "--"
-                option = ARGV[idx][2..-1]
-                idx += 1
-
-                # --verbose is a global option
-                if option == "verbose"
-                    $verbose = true
-                    next
-                end
-
-                if ALLOWED_OPTIONS[cmd] == nil || ALLOWED_OPTIONS[cmd][option] == nil
-                    puts "Unknown option '#{option}' for command '#{cmd}'"
-                    exit 1
-                end
-                if ALLOWED_OPTIONS[cmd][option] != false
-                    value = ARGV[idx]
-                    idx += 1
-                else
-                    value = true
-                end
-
-                # If the option is set to [], it's a multiple arguments
-                # option. We just queue every new value into an array.
-                if ALLOWED_OPTIONS[cmd][option] == []
-                    options[option] = [] if !options[option]
-                    options[option] << value
-                else
-                    options[option] = value
-                end
-            else
-                # Remaining arguments are not options.
-                break
-            end
-        end
-
-        # Enforce mandatory options
-        if ALLOWED_OPTIONS[cmd]
-            ALLOWED_OPTIONS[cmd].each {|option,val|
-                if !options[option] && val == :required
-                    puts "Option '--#{option}' is required "+ \
-                         "for subcommand '#{cmd}'"
-                    exit 1
-                end
-            }
-        end
-        return options,idx
-    end
-end
-
-#################################################################################
-# Libraries
-#
-# We try to don't depend on external libs since this is a critical part
-# of Redis Cluster.
-#################################################################################
-
-# This is the CRC16 algorithm used by Redis Cluster to hash keys.
-# Implementation according to CCITT standards.
-#
-# This is actually the XMODEM CRC 16 algorithm, using the
-# following parameters:
-#
-# Name                       : "XMODEM", also known as "ZMODEM", "CRC-16/ACORN"
-# Width                      : 16 bit
-# Poly                       : 1021 (That is actually x^16 + x^12 + x^5 + 1)
-# Initialization             : 0000
-# Reflect Input byte         : False
-# Reflect Output CRC         : False
-# Xor constant to output CRC : 0000
-# Output for "123456789"     : 31C3
-
-module RedisClusterCRC16
-    def RedisClusterCRC16.crc16(bytes)
-        crc = 0
-        bytes.each_byte{|b|
-            crc = ((crc<<8) & 0xffff) ^ XMODEMCRC16Lookup[((crc>>8)^b) & 0xff]
-        }
-        crc
-    end
-
-private
-    XMODEMCRC16Lookup = [
-        0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
-        0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
-        0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
-        0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
-        0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
-        0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
-        0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
-        0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
-        0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
-        0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
-        0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
-        0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
-        0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
-        0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
-        0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
-        0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
-        0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
-        0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
-        0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
-        0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
-        0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
-        0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
-        0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
-        0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
-        0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
-        0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
-        0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
-        0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
-        0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
-        0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
-        0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
-        0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
-    ]
-end
-
-# Turn a key name into the corresponding Redis Cluster slot.
-def key_to_slot(key)
-    # Only hash what is inside {...} if there is such a pattern in the key.
-    # Note that the specification requires the content that is between
-    # the first { and the first } after the first {. If we found {} without
-    # nothing in the middle, the whole key is hashed as usually.
-    s = key.index "{"
-    if s
-        e = key.index "}",s+1
-        if e && e != s+1
-            key = key[s+1..e-1]
-        end
-    end
-    RedisClusterCRC16.crc16(key) % 16384
-end
-
-#################################################################################
-# Definition of commands
-#################################################################################
-
-COMMANDS={
-    "create"  => ["create_cluster_cmd", -2, "host1:port1 ... hostN:portN"],
-    "check"   => ["check_cluster_cmd", 2, "host:port"],
-    "info"    => ["info_cluster_cmd", 2, "host:port"],
-    "fix"     => ["fix_cluster_cmd", 2, "host:port"],
-    "reshard" => ["reshard_cluster_cmd", 2, "host:port"],
-    "rebalance" => ["rebalance_cluster_cmd", -2, "host:port"],
-    "add-node" => ["addnode_cluster_cmd", 3, "new_host:new_port existing_host:existing_port"],
-    "del-node" => ["delnode_cluster_cmd", 3, "host:port node_id"],
-    "set-timeout" => ["set_timeout_cluster_cmd", 3, "host:port milliseconds"],
-    "call" =>    ["call_cluster_cmd", -3, "host:port command arg arg .. arg"],
-    "import" =>  ["import_cluster_cmd", 2, "host:port"],
-    "help"    => ["help_cluster_cmd", 1, "(show this help)"]
-}
+COMMANDS = %w(create check info fix reshard rebalance add-node 
+              del-node set-timeout call import help)
 
 ALLOWED_OPTIONS={
     "create" => {"replicas" => true},
@@ -1793,38 +38,92 @@ ALLOWED_OPTIONS={
     "import" => {"from" => :required, "copy" => false, "replace" => false},
     "reshard" => {"from" => true, "to" => true, "slots" => true, "yes" => false, "timeout" => true, "pipeline" => true},
     "rebalance" => {"weight" => [], "auto-weights" => false, "use-empty-masters" => false, "timeout" => true, "simulate" => false, "pipeline" => true, "threshold" => true},
-    "fix" => {"timeout" => MigrateDefaultTimeout},
+    "fix" => {"timeout" => 0},
 }
 
-def show_help
-    puts "Usage: redis-trib <command> <options> <arguments ...>\n\n"
-    COMMANDS.each{|k,v|
-        puts "  #{k.ljust(15)} #{v[2]}"
-        if ALLOWED_OPTIONS[k]
-            ALLOWED_OPTIONS[k].each{|optname,has_arg|
-                puts "                  --#{optname}" + (has_arg ? " <arg>" : "")
-            }
+def parse_options(cmd)
+    cmd = cmd.downcase
+    idx = 0
+    options = {}
+    args = []
+    while (arg = ARGV.shift)
+        if arg[0..1] == "--"
+            option = arg[2..-1]
+
+            # --verbose is a global option
+            if option == "--verbose"
+                options['verbose'] = true
+                next
+            end
+            if ALLOWED_OPTIONS[cmd] == nil || 
+               ALLOWED_OPTIONS[cmd][option] == nil
+                next
+            end
+            if ALLOWED_OPTIONS[cmd][option] != false
+                value = ARGV.shift
+                next if !value
+            else
+                value = true
+            end
+
+            # If the option is set to [], it's a multiple arguments
+            # option. We just queue every new value into an array.
+            if ALLOWED_OPTIONS[cmd][option] == []
+                options[option] = [] if !options[option]
+                options[option] << value
+            else
+                options[option] = value
+            end
+        else
+            next if arg[0,1] == '-'
+            args << arg
         end
+    end
+
+    return options,args
+end
+
+def command_example(cmd, args, opts)
+    cmd = "redis-cli --cluster #{cmd}"
+    args.each{|a| 
+        a = a.to_s
+        a = a.inspect if a[' ']
+        cmd << " #{a}"
     }
-    puts "\nFor check, fix, reshard, del-node, set-timeout you can specify the host and port of any working node in the cluster.\n"
+    opts.each{|opt, val|
+        opt = " --cluster-#{opt.downcase}"
+        if val != true
+            val = val.join(' ') if val.is_a? Array
+            opt << " #{val}"
+        end
+        cmd << opt
+    }
+    cmd
 end
 
-# Sanity check
-if ARGV.length == 0
-    show_help
-    exit 1
+$command = ARGV.shift
+$opts, $args = parse_options($command) if $command
+
+puts "WARNING: redis-trib.rb is not longer available!".yellow
+puts "You should use #{'redis-cli'.bold} instead."
+puts ''
+puts "All commands and features belonging to redis-trib.rb "+
+     "have been moved\nto redis-cli."
+puts "In order to use them you should call redis-cli with the #{'--cluster'.bold}"
+puts "option followed by the subcommand name, arguments and options."
+puts ''
+puts "Use the following syntax:"
+puts "redis-cli --cluster SUBCOMMAND [ARGUMENTS] [OPTIONS]".bold
+puts ''
+puts "Example:"
+if $command
+    example = command_example $command, $args, $opts
+else
+    example = "redis-cli --cluster info 127.0.0.1:7000"
 end
-
-rt = RedisTrib.new
-cmd_spec = COMMANDS[ARGV[0].downcase]
-if !cmd_spec
-    puts "Unknown redis-trib subcommand '#{ARGV[0]}'"
-    exit 1
-end
-
-# Parse options
-cmd_options,first_non_option = rt.parse_options(ARGV[0].downcase)
-rt.check_arity(cmd_spec[1],ARGV.length-(first_non_option-1))
-
-# Dispatch
-rt.send(cmd_spec[0],ARGV[first_non_option..-1],cmd_options)
+puts example.bold
+puts ''
+puts "To get help about all subcommands, type:"
+puts "redis-cli --cluster help".bold
+puts ''
+exit 1

From d4182a0a0d36c97c42603fdd8ff6db750ec26580 Mon Sep 17 00:00:00 2001
From: artix <artix2@gmail.com>
Date: Wed, 27 Jun 2018 17:29:11 +0200
Subject: [PATCH 187/219] Cluster Manager: more checks on --cluster-weight
 option.

---
 src/redis-cli.c | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/redis-cli.c b/src/redis-cli.c
index 8a7b18fbb..0e8777bd2 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -167,8 +167,8 @@ typedef struct clusterManagerCommand {
     char *from;
     char *to;
     char **weight;
-    char *master_id;
     int weight_argc;
+    char *master_id;
     int slots;
     int timeout;
     int pipeline;
@@ -1337,11 +1337,20 @@ static int parseOptions(int argc, char **argv) {
         } else if (!strcmp(argv[i],"--cluster-to") && !lastarg) {
             config.cluster_manager_command.to = argv[++i];
         } else if (!strcmp(argv[i],"--cluster-weight") && !lastarg) {
+            if (config.cluster_manager_command.weight != NULL) {
+                fprintf(stderr, "WARNING: you cannot use --cluster-weight "
+                                "more than once.\n"
+                                "You can set more weights by adding them "
+                                "as a space-separated list, ie:\n"
+                                "--cluster-weight n1=w n2=w\n");
+                exit(1);
+            }
             int widx = i + 1;
             char **weight = argv + widx;
             int wargc = 0;
             for (; widx < argc; widx++) {
                 if (strstr(argv[widx], "--") == argv[widx]) break;
+                if (strchr(argv[widx], '=') == NULL) break;
                 wargc++;
             }
             if (wargc > 0) {
@@ -4899,7 +4908,7 @@ static int clusterManagerCommandRebalance(int argc, char **argv) {
     clusterManagerCheckCluster(1);
     if (cluster_manager.errors && listLength(cluster_manager.errors) > 0) {
         clusterManagerLogErr("*** Please fix your cluster problems "
-                             "before rebalancing" );
+                             "before rebalancing\n");
         result = 0;
         goto cleanup;
     }
@@ -6610,6 +6619,7 @@ int main(int argc, char **argv) {
     config.cluster_manager_command.from = NULL;
     config.cluster_manager_command.to = NULL;
     config.cluster_manager_command.weight = NULL;
+    config.cluster_manager_command.weight_argc = 0;
     config.cluster_manager_command.slots = 0;
     config.cluster_manager_command.timeout = CLUSTER_MANAGER_MIGRATE_TIMEOUT;
     config.cluster_manager_command.pipeline = CLUSTER_MANAGER_MIGRATE_PIPELINE;

From b3660be8f5fbf495b960407ff22d83f824161b74 Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Fri, 13 Jul 2018 17:51:06 +0800
Subject: [PATCH 188/219] Add test in slowlog.tcl

---
 tests/unit/slowlog.tcl | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/unit/slowlog.tcl b/tests/unit/slowlog.tcl
index fce02498b..dbd7a1547 100644
--- a/tests/unit/slowlog.tcl
+++ b/tests/unit/slowlog.tcl
@@ -78,4 +78,14 @@ start_server {tags {"slowlog"} overrides {slowlog-log-slower-than 1000000}} {
         set e [lindex [r slowlog get] 0]
         assert_equal {lastentry_client} [lindex $e 5]
     }
+
+    test {SLOWLOG - can be disabled} {
+        r config set slowlog-log-slower-than 1
+        r slowlog reset
+        assert_equal [r slowlog len] 1 
+        r config set slowlog-log-slower-than -1
+        r slowlog reset
+        r debug sleep 0.2
+        assert_equal [r slowlog len] 0
+    }
 }

From d6ba4fd56d9e386abaf6926fa47ead1525ff56cb Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Fri, 13 Jul 2018 17:53:55 +0800
Subject: [PATCH 189/219] Fix config set slowlog-log-slower-than and condition
 in createLatencyReport

---
 src/config.c  | 2 +-
 src/latency.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/config.c b/src/config.c
index aedef4888..54494c8e1 100644
--- a/src/config.c
+++ b/src/config.c
@@ -1122,7 +1122,7 @@ void configSetCommand(client *c) {
     } config_set_numerical_field(
       "lua-time-limit",server.lua_time_limit,0,LONG_MAX) {
     } config_set_numerical_field(
-      "slowlog-log-slower-than",server.slowlog_log_slower_than,0,LLONG_MAX) {
+      "slowlog-log-slower-than",server.slowlog_log_slower_than,-1,LLONG_MAX) {
     } config_set_numerical_field(
       "slowlog-max-len",ll,0,LONG_MAX) {
       /* Cast to unsigned. */
diff --git a/src/latency.c b/src/latency.c
index 87e926078..e8d2af306 100644
--- a/src/latency.c
+++ b/src/latency.c
@@ -294,7 +294,7 @@ sds createLatencyReport(void) {
 
         /* Potentially commands. */
         if (!strcasecmp(event,"command")) {
-            if (server.slowlog_log_slower_than == 0) {
+            if (server.slowlog_log_slower_than < 0) {
                 advise_slowlog_enabled = 1;
                 advices++;
             } else if (server.slowlog_log_slower_than/1000 >

From a93f8f09985ed832038b195e7f3e4b5cde220e94 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 13 Jul 2018 17:40:48 +0200
Subject: [PATCH 190/219] Test: XDEL basic test.

---
 tests/unit/type/stream.tcl | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/unit/type/stream.tcl b/tests/unit/type/stream.tcl
index d495c227b..c44b13168 100644
--- a/tests/unit/type/stream.tcl
+++ b/tests/unit/type/stream.tcl
@@ -234,6 +234,18 @@ start_server {
         assert {[lindex $res 0 1 1 1] eq {field two}}
     }
 
+    test {XDEL basic test} {
+        r del somestream
+        r xadd somestream * foo value0
+        set id [r xadd somestream * foo value1]
+        r xadd somestream * foo value2
+        r xdel somestream $id
+        assert {[r xlen somestream] == 2}
+        set result [r xrange somestream - +]
+        assert {[lindex $result 0 1 1] eq {value0}}
+        assert {[lindex $result 1 1 1] eq {value2}}
+    }
+
     test {XRANGE fuzzing} {
         set low_id [lindex $items 0 0]
         set high_id [lindex $items end 0]

From 8dc08ae2154a46757adb75ee091219baa2f0cb22 Mon Sep 17 00:00:00 2001
From: andrewsensus <7727721+andrewsensus@users.noreply.github.com>
Date: Fri, 13 Jul 2018 09:46:30 -0600
Subject: [PATCH 191/219] update leap year comment

---
 src/localtime.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/localtime.c b/src/localtime.c
index 186c8e3c6..3f59a3331 100644
--- a/src/localtime.c
+++ b/src/localtime.c
@@ -50,7 +50,7 @@
  * designed to work with what time(NULL) may return, and to support Redis
  * logging of the dates, it's not really a complete implementation. */
 static int is_leap_year(time_t year) {
-    if (year % 4) return 0;         /* A year divisible by 4 is not leap. */
+    if (year % 4) return 0;         /* A year not divisible by 4 is not leap. */
     else if (year % 100) return 1;  /* If div by 4 and not 100 is surely leap. */
     else if (year % 400) return 0;  /* If div by 100 *and* 400 is not leap. */
     else return 1;                  /* If div by 100 and not by 400 is leap. */

From d6efd5fc1d789496275c749b7a26a37ad90931e9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 13 Jul 2018 17:47:26 +0200
Subject: [PATCH 192/219] Test: XDEL fuzz testing, stream creation.

---
 tests/unit/type/stream.tcl | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/tests/unit/type/stream.tcl b/tests/unit/type/stream.tcl
index c44b13168..cf37ad38f 100644
--- a/tests/unit/type/stream.tcl
+++ b/tests/unit/type/stream.tcl
@@ -246,6 +246,26 @@ start_server {
         assert {[lindex $result 1 1 1] eq {value2}}
     }
 
+    # Here the idea is to check the consistency of the stream data structure
+    # as we remove all the elements down to zero elements.
+    test {XDEL fuzz test} {
+        r del somestream
+        set ids {}
+        set x 0; # Length of the stream
+        while 1 {
+            lappend ids [r xadd somestream * item $x]
+            incr x
+            # Add enough elements to have a few radix tree nodes inside the stream.
+            if {[dict get [r xinfo stream somestream] radix-tree-keys] > 20} break
+        }
+
+        # Now remove all the elements till we reach an empty stream
+        # and after every deletion, check that the stream is sane enough
+        # to report the right number of elements with XRANGE: this will also
+        # force accessing the whole data structure to check sanity.
+        assert {[r xlen somestream] == $x}
+    }
+
     test {XRANGE fuzzing} {
         set low_id [lindex $items 0 0]
         set high_id [lindex $items end 0]

From 967ad3643c540d3b40f64cc51b4aff6340662ffb Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 13 Jul 2018 17:51:03 +0200
Subject: [PATCH 193/219] Test: add lshuffle in the Tcl utility functions set.

---
 tests/support/util.tcl | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/tests/support/util.tcl b/tests/support/util.tcl
index 64c36b326..b3c3abca5 100644
--- a/tests/support/util.tcl
+++ b/tests/support/util.tcl
@@ -375,3 +375,17 @@ proc start_write_load {host port seconds} {
 proc stop_write_load {handle} {
     catch {exec /bin/kill -9 $handle}
 }
+
+# Shuffle a list. From Tcl wiki. Originally from Steve Cohen that improved
+# other versions. Code should be under public domain.
+proc lshuffle {list} {
+    set n [llength $list]
+    while {$n>0} {
+        set j [expr {int(rand()*$n)}]
+        lappend slist [lindex $list $j]
+        incr n -1
+        set temp [lindex $list $n]
+        set list [lreplace [K $list [set list {}]] $j $j $temp]
+    }
+    return $slist
+}

From 3d7d20b7f3fa186a6fd13f28a1382138b1b1b732 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 13 Jul 2018 17:52:39 +0200
Subject: [PATCH 194/219] Test: fix lshuffle by providing the "K" combinator.

---
 tests/support/util.tcl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/support/util.tcl b/tests/support/util.tcl
index b3c3abca5..181c865fc 100644
--- a/tests/support/util.tcl
+++ b/tests/support/util.tcl
@@ -376,6 +376,8 @@ proc stop_write_load {handle} {
     catch {exec /bin/kill -9 $handle}
 }
 
+proc K { x y } { set x } 
+
 # Shuffle a list. From Tcl wiki. Originally from Steve Cohen that improved
 # other versions. Code should be under public domain.
 proc lshuffle {list} {

From 2352a519928aa693d73d03c67898577a3bb2f56d Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 13 Jul 2018 17:58:17 +0200
Subject: [PATCH 195/219] Test: XDEL fuzz testing. Remove and check stage.

---
 tests/unit/type/stream.tcl | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/unit/type/stream.tcl b/tests/unit/type/stream.tcl
index cf37ad38f..5cf6805d7 100644
--- a/tests/unit/type/stream.tcl
+++ b/tests/unit/type/stream.tcl
@@ -264,6 +264,21 @@ start_server {
         # to report the right number of elements with XRANGE: this will also
         # force accessing the whole data structure to check sanity.
         assert {[r xlen somestream] == $x}
+
+        # We want to remove elements in random order to really test the
+        # implementation in a better way.
+        set ids [lshuffle $ids]
+        foreach id $ids {
+            assert {[r xdel somestream $id] == 1}
+            incr x -1
+            assert {[r xlen somestream] == $x}
+            # The test would be too slow calling XRANGE for every iteration.
+            # Do it every 100 removal.
+            if {$x % 100 == 0} {
+                set res [r xrange somestream - +]
+                assert {[llength $res] == $x}
+            }
+        }
     }
 
     test {XRANGE fuzzing} {

From 2d4366c5440ddd565e91142d59455232b6894dbd Mon Sep 17 00:00:00 2001
From: WuYunlong <xzsyeb@126.com>
Date: Sat, 14 Jul 2018 09:06:23 +0800
Subject: [PATCH 196/219] Accept write commands if persisting is disabled,
 event if we do have problems persisting on disk previously.

---
 src/server.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/server.c b/src/server.c
index 502589cf0..ea61d15ad 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2519,7 +2519,8 @@ int processCommand(client *c) {
     if (((server.stop_writes_on_bgsave_err &&
           server.saveparamslen > 0 &&
           server.lastbgsave_status == C_ERR) ||
-          server.aof_last_write_status == C_ERR) &&
+          (server.aof_state != AOF_OFF &&
+           server.aof_last_write_status == C_ERR)) &&
         server.masterhost == NULL &&
         (c->cmd->flags & CMD_WRITE ||
          c->cmd->proc == pingCommand))

From 0484dbcf68638149a8510537fd1a42c836f84020 Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Tue, 10 Jul 2018 16:46:48 +0800
Subject: [PATCH 197/219] Streams: using streamCompareID() instead of direct
 compare.

---
 src/t_stream.c | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 54d6b0d1f..6a4439d02 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1392,9 +1392,7 @@ void xreadCommand(client *c) {
                  * synchronously in case the group top item delivered is smaller
                  * than what the stream has inside. */
                 streamID *last = &groups[i]->last_id;
-                if (s->last_id.ms > last->ms ||
-                    (s->last_id.ms == last->ms && s->last_id.seq > last->seq))
-                {
+                if (streamCompareID(&s->last_id, last) > 0) {
                     serve_synchronously = 1;
                     *gt = *last;
                 }
@@ -1402,9 +1400,7 @@ void xreadCommand(client *c) {
         } else {
             /* For consumers without a group, we serve synchronously if we can
              * actually provide at least one item from the stream. */
-            if (s->last_id.ms > gt->ms ||
-                (s->last_id.ms == gt->ms && s->last_id.seq > gt->seq))
-            {
+            if (streamCompareID(&s->last_id, gt) > 0) {
                 serve_synchronously = 1;
             }
         }

From a2177cd2b6bcbacc376d9640727cd89c5ffed3fa Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Sat, 14 Jul 2018 15:02:24 +0800
Subject: [PATCH 198/219] Streams: add streamCompareID() declaration in
 stream.h.

---
 src/stream.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/stream.h b/src/stream.h
index 61210f952..ef08753b5 100644
--- a/src/stream.h
+++ b/src/stream.h
@@ -108,5 +108,6 @@ streamConsumer *streamLookupConsumer(streamCG *cg, sds name, int create);
 streamCG *streamCreateCG(stream *s, char *name, size_t namelen, streamID *id);
 streamNACK *streamCreateNACK(streamConsumer *consumer);
 void streamDecodeID(void *buf, streamID *id);
+int streamCompareID(streamID *a, streamID *b);
 
 #endif

From 491682a668dc5eeffdb6c989b819c1015c97b4f0 Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Sat, 14 Jul 2018 15:03:05 +0800
Subject: [PATCH 199/219] Streams: using streamCompareID() instead of direct
 compare in block.c.

---
 src/blocked.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/blocked.c b/src/blocked.c
index d8ae596d9..4a667501f 100644
--- a/src/blocked.c
+++ b/src/blocked.c
@@ -397,10 +397,7 @@ void handleClientsBlockedOnKeys(void) {
                             }
                         }
 
-                        if (s->last_id.ms > gt->ms ||
-                            (s->last_id.ms == gt->ms &&
-                             s->last_id.seq > gt->seq))
-                        {
+                        if (streamCompareID(&s->last_id, gt) > 0) {
                             streamID start = *gt;
                             start.seq++; /* Can't overflow, it's an uint64_t */
 

From b05a22e261bf2ed278d6b1a6afb3ade7ff4cacfc Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Sun, 15 Jul 2018 18:24:18 +0300
Subject: [PATCH 200/219] bugfix in sdsReqType creating 64bit sds headers on
 32bit systems

---
 src/sds.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/sds.c b/src/sds.c
index c4f43603d..39ad595ed 100644
--- a/src/sds.c
+++ b/src/sds.c
@@ -67,8 +67,10 @@ static inline char sdsReqType(size_t string_size) {
 #if (LONG_MAX == LLONG_MAX)
     if (string_size < 1ll<<32)
         return SDS_TYPE_32;
-#endif
     return SDS_TYPE_64;
+#else
+    return SDS_TYPE_32;
+#endif
 }
 
 /* Create a new sds string with the content specified by the 'init' pointer

From 816fc6cbc67957baae6c2fa8332222da8bf789b7 Mon Sep 17 00:00:00 2001
From: peterpaule <peterpaule@peterpauledeMacBook-Pro.local>
Date: Mon, 16 Jul 2018 11:28:22 +0800
Subject: [PATCH 201/219] remove one ineffective loop in dictGetSomeKeys.

---
 src/dict.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dict.c b/src/dict.c
index 97e636805..4db758618 100644
--- a/src/dict.c
+++ b/src/dict.c
@@ -706,7 +706,7 @@ unsigned int dictGetSomeKeys(dict *d, dictEntry **des, unsigned int count) {
                  * the current rehashing index, so we jump if possible.
                  * (this happens when going from big to small table). */
                 if (i >= d->ht[1].size) i = d->rehashidx;
-                continue;
+                else continue;
             }
             if (i >= d->ht[j].size) continue; /* Out of range for this table. */
             dictEntry *he = d->ht[j].table[i];

From b4ba5ac8408ef46c3a0b593a2d3cf6d74f33a1ce Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Mon, 16 Jul 2018 13:24:54 +0800
Subject: [PATCH 202/219] Streams: show last id for streams and groups

---
 src/t_stream.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 54d6b0d1f..c152bd678 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -2279,18 +2279,20 @@ NULL
         raxSeek(&ri,"^",NULL,0);
         while(raxNext(&ri)) {
             streamCG *cg = ri.data;
-            addReplyMultiBulkLen(c,6);
+            addReplyMultiBulkLen(c,8);
             addReplyStatus(c,"name");
             addReplyBulkCBuffer(c,ri.key,ri.key_len);
             addReplyStatus(c,"consumers");
             addReplyLongLong(c,raxSize(cg->consumers));
             addReplyStatus(c,"pending");
             addReplyLongLong(c,raxSize(cg->pel));
+            addReplyStatus(c,"last-delivered-id");
+            addReplyStreamID(c,&cg->last_id);
         }
         raxStop(&ri);
     } else if (!strcasecmp(opt,"STREAM") && c->argc == 3) {
         /* XINFO STREAM <key> (or the alias XINFO <key>). */
-        addReplyMultiBulkLen(c,12);
+        addReplyMultiBulkLen(c,14);
         addReplyStatus(c,"length");
         addReplyLongLong(c,s->length);
         addReplyStatus(c,"radix-tree-keys");
@@ -2299,6 +2301,8 @@ NULL
         addReplyLongLong(c,s->rax->numnodes);
         addReplyStatus(c,"groups");
         addReplyLongLong(c,s->cgroups ? raxSize(s->cgroups) : 0);
+        addReplyStatus(c,"last-id");
+        addReplyStreamID(c,&s->last_id);
 
         /* To emit the first/last entry we us the streamReplyWithRange()
          * API. */

From b6ce7d5ddce573f500b8770d9052e0c422c91500 Mon Sep 17 00:00:00 2001
From: paule <liangpan03021327@163.com>
Date: Mon, 16 Jul 2018 14:29:59 +0800
Subject: [PATCH 203/219] Update dict.c

change coding style.
---
 src/dict.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/dict.c b/src/dict.c
index 4db758618..4eeb26e0e 100644
--- a/src/dict.c
+++ b/src/dict.c
@@ -705,8 +705,10 @@ unsigned int dictGetSomeKeys(dict *d, dictEntry **des, unsigned int count) {
                  * table, there will be no elements in both tables up to
                  * the current rehashing index, so we jump if possible.
                  * (this happens when going from big to small table). */
-                if (i >= d->ht[1].size) i = d->rehashidx;
-                else continue;
+                if (i >= d->ht[1].size) 
+                    i = d->rehashidx;
+                else 
+                    continue;
             }
             if (i >= d->ht[j].size) continue; /* Out of range for this table. */
             dictEntry *he = d->ht[j].table[i];

From c9324f81a209c49c795d41ab2af8cb06b72d87c9 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Mon, 16 Jul 2018 15:57:41 +0800
Subject: [PATCH 204/219] Streams: free lp if all elements are deleted

---
 src/t_stream.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 54d6b0d1f..ea2cf5602 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -705,10 +705,15 @@ void streamIteratorRemoveEntry(streamIterator *si, streamID *current) {
     /* Change the valid/deleted entries count in the master entry. */
     unsigned char *p = lpFirst(lp);
     aux = lpGetInteger(p);
-    lp = lpReplaceInteger(lp,&p,aux-1);
-    p = lpNext(lp,p); /* Seek deleted field. */
-    aux = lpGetInteger(p);
-    lp = lpReplaceInteger(lp,&p,aux+1);
+    if (aux == 1) {
+        lpFree(lp);
+        raxRemove(si->stream->rax,si->ri.key,si->ri.key_len,NULL);
+    } else {
+        lp = lpReplaceInteger(lp,&p,aux-1);
+        p = lpNext(lp,p); /* Seek deleted field. */
+        aux = lpGetInteger(p);
+        lp = lpReplaceInteger(lp,&p,aux+1);
+    }
 
     /* Update the number of entries counter. */
     si->stream->length--;

From 185e0d9cd81435b32b62c39f131e2af6f6dcc92a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 16 Jul 2018 12:25:22 +0200
Subject: [PATCH 205/219] Modify XINFO field from last-id to last-generated-id.

Related to #5129.
---
 src/t_stream.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index c152bd678..6dd1280ec 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -2301,7 +2301,7 @@ NULL
         addReplyLongLong(c,s->rax->numnodes);
         addReplyStatus(c,"groups");
         addReplyLongLong(c,s->cgroups ? raxSize(s->cgroups) : 0);
-        addReplyStatus(c,"last-id");
+        addReplyStatus(c,"last-generated-id");
         addReplyStreamID(c,&s->last_id);
 
         /* To emit the first/last entry we us the streamReplyWithRange()

From 103c5a1a3cb9c306a8413820bdeb0132728cd47e Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 16 Jul 2018 12:41:55 +0200
Subject: [PATCH 206/219] Add a few comments to streamIteratorRemoveEntry().

---
 src/t_stream.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/t_stream.c b/src/t_stream.c
index 13ba02788..442515866 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -705,10 +705,14 @@ void streamIteratorRemoveEntry(streamIterator *si, streamID *current) {
     /* Change the valid/deleted entries count in the master entry. */
     unsigned char *p = lpFirst(lp);
     aux = lpGetInteger(p);
+
     if (aux == 1) {
+        /* If this is the last element in the listpack, we can remove the whole
+         * node. */
         lpFree(lp);
         raxRemove(si->stream->rax,si->ri.key,si->ri.key_len,NULL);
     } else {
+        /* In the base case we alter the counters of valid/deleted entries. */
         lp = lpReplaceInteger(lp,&p,aux-1);
         p = lpNext(lp,p); /* Seek deleted field. */
         aux = lpGetInteger(p);

From 73306c6fedd134e2d97f351c1bf1e657945771f7 Mon Sep 17 00:00:00 2001
From: "zhaozhao.zz" <zhaozhao.zz@alibaba-inc.com>
Date: Mon, 16 Jul 2018 20:48:07 +0800
Subject: [PATCH 207/219] Streams: correctly propagate xdel if needed

---
 src/t_stream.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 442515866..3b4ebea78 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -2137,9 +2137,13 @@ void xdelCommand(client *c) {
         streamParseIDOrReply(c,c->argv[j],&id,0); /* Retval already checked. */
         deleted += streamDeleteItem(s,&id);
     }
-    signalModifiedKey(c->db,c->argv[1]);
-    notifyKeyspaceEvent(NOTIFY_STREAM,"xdel",c->argv[1],c->db->id);
-    server.dirty += deleted;
+
+    /* Propagate the write if needed. */
+    if (deleted) {
+        signalModifiedKey(c->db,c->argv[1]);
+        notifyKeyspaceEvent(NOTIFY_STREAM,"xdel",c->argv[1],c->db->id);
+        server.dirty += deleted;
+    }
     addReplyLongLong(c,deleted);
 }
 

From bf680b6f8cdaee2c5588c5c8932a7f3b7fa70b15 Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Wed, 21 Feb 2018 20:18:34 +0200
Subject: [PATCH 208/219] slave buffers were wasteful and incorrectly counted
 causing eviction

A) slave buffers didn't count internal fragmentation and sds unused space,
   this caused them to induce eviction although we didn't mean for it.

B) slave buffers were consuming about twice the memory of what they actually needed.
- this was mainly due to sdsMakeRoomFor growing to twice as much as needed each time
  but networking.c not storing more than 16k (partially fixed recently in 237a38737).
- besides it wasn't able to store half of the new string into one buffer and the
  other half into the next (so the above mentioned fix helped mainly for small items).
- lastly, the sds buffers had up to 30% internal fragmentation that was wasted,
  consumed but not used.

C) inefficient performance due to starting from a small string and reallocing many times.

what i changed:
- creating dedicated buffers for reply list, counting their size with zmalloc_size
- when creating a new reply node from, preallocate it to at least 16k.
- when appending a new reply to the buffer, first fill all the unused space of the
  previous node before starting a new one.

other changes:
- expose mem_not_counted_for_evict info field for the benefit of the test suite
- add a test to make sure slave buffers are counted correctly and that they don't cause eviction
---
 src/aof.c                |   2 +-
 src/module.c             |   4 +-
 src/networking.c         | 102 ++++++++++++++++++++++-----------------
 src/replication.c        |   1 +
 src/scripting.c          |   4 +-
 src/server.c             |  10 ++++
 src/server.h             |   7 +++
 src/zmalloc.c            |   3 ++
 src/zmalloc.h            |   3 ++
 tests/unit/maxmemory.tcl |  92 +++++++++++++++++++++++++++++++++++
 10 files changed, 180 insertions(+), 48 deletions(-)

diff --git a/src/aof.c b/src/aof.c
index 2d5f259fb..be416ec4e 100644
--- a/src/aof.c
+++ b/src/aof.c
@@ -645,7 +645,7 @@ struct client *createFakeClient(void) {
     c->obuf_soft_limit_reached_time = 0;
     c->watched_keys = listCreate();
     c->peerid = NULL;
-    listSetFreeMethod(c->reply,decrRefCountVoid);
+    listSetFreeMethod(c->reply,freeClientReplyValue);
     listSetDupMethod(c->reply,dupClientReplyValue);
     initClientMultiState(c);
     return c;
diff --git a/src/module.c b/src/module.c
index a46b86a50..9809cd74e 100644
--- a/src/module.c
+++ b/src/module.c
@@ -2712,9 +2712,9 @@ RedisModuleCallReply *RM_Call(RedisModuleCtx *ctx, const char *cmdname, const ch
     sds proto = sdsnewlen(c->buf,c->bufpos);
     c->bufpos = 0;
     while(listLength(c->reply)) {
-        sds o = listNodeValue(listFirst(c->reply));
+        clientReplyBlock *o = listNodeValue(listFirst(c->reply));
 
-        proto = sdscatsds(proto,o);
+        proto = sdscatlen(proto,o->buf,o->used);
         listDelNode(c->reply,listFirst(c->reply));
     }
     reply = moduleCreateCallReplyFromProto(ctx,proto);
diff --git a/src/networking.c b/src/networking.c
index 58b553fe6..36ae26e0b 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -56,11 +56,14 @@ size_t getStringObjectSdsUsedMemory(robj *o) {
 
 /* Client.reply list dup and free methods. */
 void *dupClientReplyValue(void *o) {
-    return sdsdup(o);
+    clientReplyBlock *old = o;
+    clientReplyBlock *buf = zmalloc(sizeof(clientReplyBlock) + old->size);
+    memcpy(buf, o, sizeof(clientReplyBlock) + old->size);
+    return buf;
 }
 
 void freeClientReplyValue(void *o) {
-    sdsfree(o);
+    zfree(o);
 }
 
 int listMatchObjects(void *a, void *b) {
@@ -240,25 +243,31 @@ int _addReplyToBuffer(client *c, const char *s, size_t len) {
 void _addReplyStringToList(client *c, const char *s, size_t len) {
     if (c->flags & CLIENT_CLOSE_AFTER_REPLY) return;
 
-    if (listLength(c->reply) == 0) {
-        sds node = sdsnewlen(s,len);
-        listAddNodeTail(c->reply,node);
-        c->reply_bytes += len;
-    } else {
-        listNode *ln = listLast(c->reply);
-        sds tail = listNodeValue(ln);
+    listNode *ln = listLast(c->reply);
+    clientReplyBlock *tail = ln? listNodeValue(ln): NULL;
+    /* It is possible that we have a tail list node, but no tail buffer.
+     * if addDeferredMultiBulkLength() was used. */
 
-        /* Append to this object when possible. If tail == NULL it was
-         * set via addDeferredMultiBulkLength(). */
-        if (tail && (sdsavail(tail) >= len || sdslen(tail)+len <= PROTO_REPLY_CHUNK_BYTES)) {
-            tail = sdscatlen(tail,s,len);
-            listNodeValue(ln) = tail;
-            c->reply_bytes += len;
-        } else {
-            sds node = sdsnewlen(s,len);
-            listAddNodeTail(c->reply,node);
-            c->reply_bytes += len;
-        }
+    /* Append to tail string when possible. */
+    if (tail) {
+        /* Copy the part we can fit into the tail, and leave the rest for a new node */
+        size_t avail = tail->size - tail->used;
+        size_t copy = avail >= len? len: avail;
+        memcpy(tail->buf + tail->used, s, copy);
+        tail->used += copy;
+        s += copy;
+        len -= copy;
+    }
+    if (len) {
+        /* Create a new node, make sure it is allocated to at least PROTO_REPLY_CHUNK_BYTES */
+        size_t size = len < PROTO_REPLY_CHUNK_BYTES? PROTO_REPLY_CHUNK_BYTES: len;
+        tail = zmalloc(size + sizeof(clientReplyBlock));
+        /* take over the allocation's internal fragmentation */
+        tail->size = zmalloc_usable(tail) - sizeof(clientReplyBlock);
+        tail->used = len;
+        memcpy(tail->buf, s, len);
+        listAddNodeTail(c->reply, tail);
+        c->reply_bytes += tail->size;
     }
     asyncCloseClientOnOutputBufferLimitReached(c);
 }
@@ -390,26 +399,35 @@ void *addDeferredMultiBulkLength(client *c) {
 /* Populate the length object and try gluing it to the next chunk. */
 void setDeferredMultiBulkLength(client *c, void *node, long length) {
     listNode *ln = (listNode*)node;
-    sds len, next;
+    clientReplyBlock *next;
+    char lenstr[128];
+    size_t lenstr_len = sprintf(lenstr, "*%ld\r\n", length);
 
     /* Abort when *node is NULL: when the client should not accept writes
      * we return NULL in addDeferredMultiBulkLength() */
     if (node == NULL) return;
+    serverAssert(!listNodeValue(ln));
 
-    len = sdscatprintf(sdsnewlen("*",1),"%ld\r\n",length);
-    listNodeValue(ln) = len;
-    c->reply_bytes += sdslen(len);
-    if (ln->next != NULL) {
-        next = listNodeValue(ln->next);
-
-        /* Only glue when the next node is non-NULL (an sds in this case) */
-        if (next != NULL) {
-            len = sdscatsds(len,next);
-            listDelNode(c->reply,ln->next);
-            listNodeValue(ln) = len;
-            /* No need to update c->reply_bytes: we are just moving the same
-             * amount of bytes from one node to another. */
-        }
+    /* Glue into next node when:
+     * - the next node is non-NULL,
+     * - it has enough room already allocated
+     * - and not too large (avoid large memmove) */
+    if (ln->next != NULL && (next = listNodeValue(ln->next)) && 
+        next->size - next->used >= lenstr_len &&
+        next->used < PROTO_REPLY_CHUNK_BYTES * 4) {
+        memmove(next->buf + lenstr_len, next->buf, next->used);
+        memcpy(next->buf, lenstr, lenstr_len);
+        next->used += lenstr_len;
+        listDelNode(c->reply,ln);
+    } else {
+        /* Create a new node */
+        clientReplyBlock *buf = zmalloc(lenstr_len + sizeof(clientReplyBlock));
+        /* take over the allocation's internal fragmentation */
+        buf->size = zmalloc_usable(buf) - sizeof(clientReplyBlock);
+        buf->used = lenstr_len;
+        memcpy(buf->buf, lenstr, lenstr_len);
+        listNodeValue(ln) = buf;
+        c->reply_bytes += buf->size;
     }
     asyncCloseClientOnOutputBufferLimitReached(c);
 }
@@ -895,7 +913,7 @@ client *lookupClientByID(uint64_t id) {
 int writeToClient(int fd, client *c, int handler_installed) {
     ssize_t nwritten = 0, totwritten = 0;
     size_t objlen;
-    sds o;
+    clientReplyBlock *o;
 
     while(clientHasPendingReplies(c)) {
         if (c->bufpos > 0) {
@@ -912,23 +930,24 @@ int writeToClient(int fd, client *c, int handler_installed) {
             }
         } else {
             o = listNodeValue(listFirst(c->reply));
-            objlen = sdslen(o);
+            objlen = o->used;
 
             if (objlen == 0) {
+                c->reply_bytes -= o->size;
                 listDelNode(c->reply,listFirst(c->reply));
                 continue;
             }
 
-            nwritten = write(fd, o + c->sentlen, objlen - c->sentlen);
+            nwritten = write(fd, o->buf + c->sentlen, objlen - c->sentlen);
             if (nwritten <= 0) break;
             c->sentlen += nwritten;
             totwritten += nwritten;
 
             /* If we fully sent the object on head go to the next one */
             if (c->sentlen == objlen) {
+                c->reply_bytes -= o->size;
                 listDelNode(c->reply,listFirst(c->reply));
                 c->sentlen = 0;
-                c->reply_bytes -= objlen;
                 /* If there are no longer objects in the list, we expect
                  * the count of reply bytes to be exactly zero. */
                 if (listLength(c->reply) == 0)
@@ -1899,10 +1918,7 @@ void rewriteClientCommandArgument(client *c, int i, robj *newval) {
  * the caller wishes. The main usage of this function currently is
  * enforcing the client output length limits. */
 unsigned long getClientOutputBufferMemoryUsage(client *c) {
-    unsigned long list_item_size = sizeof(listNode)+5;
-    /* The +5 above means we assume an sds16 hdr, may not be true
-     * but is not going to be a problem. */
-
+    unsigned long list_item_size = sizeof(listNode) + sizeof(clientReplyBlock);
     return c->reply_bytes + (list_item_size*listLength(c->reply));
 }
 
diff --git a/src/replication.c b/src/replication.c
index 0adef8aec..bc3755398 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -2148,6 +2148,7 @@ void replicationCacheMaster(client *c) {
     server.master->read_reploff = server.master->reploff;
     if (c->flags & CLIENT_MULTI) discardTransaction(c);
     listEmpty(c->reply);
+    c->reply_bytes = 0;
     c->bufpos = 0;
     resetClient(c);
 
diff --git a/src/scripting.c b/src/scripting.c
index 857859e70..328e3d681 100644
--- a/src/scripting.c
+++ b/src/scripting.c
@@ -575,9 +575,9 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error) {
         reply = sdsnewlen(c->buf,c->bufpos);
         c->bufpos = 0;
         while(listLength(c->reply)) {
-            sds o = listNodeValue(listFirst(c->reply));
+            clientReplyBlock *o = listNodeValue(listFirst(c->reply));
 
-            reply = sdscatsds(reply,o);
+            reply = sdscatlen(reply,o->buf,o->used);
             listDelNode(c->reply,listFirst(c->reply));
         }
     }
diff --git a/src/server.c b/src/server.c
index 502589cf0..971595872 100644
--- a/src/server.c
+++ b/src/server.c
@@ -3101,6 +3101,11 @@ sds genRedisInfoString(char *section) {
             "rss_overhead_bytes:%zu\r\n"
             "mem_fragmentation_ratio:%.2f\r\n"
             "mem_fragmentation_bytes:%zu\r\n"
+            "mem_not_counted_for_evict:%zu\r\n"
+            "mem_replication_backlog:%zu\r\n"
+            "mem_clients_slaves:%zu\r\n"
+            "mem_clients_normal:%zu\r\n"
+            "mem_aof_buffer:%zu\r\n"
             "mem_allocator:%s\r\n"
             "active_defrag_running:%d\r\n"
             "lazyfree_pending_objects:%zu\r\n",
@@ -3133,6 +3138,11 @@ sds genRedisInfoString(char *section) {
             mh->rss_extra_bytes,
             mh->total_frag, /* this is the total RSS overhead, including fragmentation, */
             mh->total_frag_bytes, /* named so for backwards compatibility */
+            freeMemoryGetNotCountedMemory(),
+            mh->repl_backlog,
+            mh->clients_slaves,
+            mh->clients_normal,
+            mh->aof_buffer,
             ZMALLOC_LIB,
             server.active_defrag_running,
             lazyfreeGetPendingObjectsCount()
diff --git a/src/server.h b/src/server.h
index f3df6b46b..c35333bd3 100644
--- a/src/server.h
+++ b/src/server.h
@@ -619,6 +619,11 @@ typedef struct redisObject {
 
 struct evictionPoolEntry; /* Defined in evict.c */
 
+typedef struct clientReplyBlock {
+    size_t size, used;
+    char buf[];
+} clientReplyBlock;
+
 /* Redis database representation. There are multiple databases identified
  * by integers from 0 (the default database) up to the max configured
  * database. The database number is the 'id' field in the structure. */
@@ -1423,6 +1428,7 @@ void addReplySubcommandSyntaxError(client *c);
 void copyClientOutputBuffer(client *dst, client *src);
 size_t sdsZmallocSize(sds s);
 size_t getStringObjectSdsUsedMemory(robj *o);
+void freeClientReplyValue(void *o);
 void *dupClientReplyValue(void *o);
 void getClientsMaxBuffers(unsigned long *longest_output_list,
                           unsigned long *biggest_input_buffer);
@@ -1664,6 +1670,7 @@ int zslLexValueLteMax(sds value, zlexrangespec *spec);
 
 /* Core functions */
 int getMaxmemoryState(size_t *total, size_t *logical, size_t *tofree, float *level);
+size_t freeMemoryGetNotCountedMemory();
 int freeMemoryIfNeeded(void);
 int processCommand(client *c);
 void setupSignalHandlers(void);
diff --git a/src/zmalloc.c b/src/zmalloc.c
index 4956f905f..0d9917510 100644
--- a/src/zmalloc.c
+++ b/src/zmalloc.c
@@ -182,6 +182,9 @@ size_t zmalloc_size(void *ptr) {
     if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1));
     return size+PREFIX_SIZE;
 }
+size_t zmalloc_usable(void *ptr) {
+    return zmalloc_usable(ptr)-PREFIX_SIZE;
+}
 #endif
 
 void zfree(void *ptr) {
diff --git a/src/zmalloc.h b/src/zmalloc.h
index 49b33b883..9c9229907 100644
--- a/src/zmalloc.h
+++ b/src/zmalloc.h
@@ -98,6 +98,9 @@ void *zmalloc_no_tcache(size_t size);
 
 #ifndef HAVE_MALLOC_SIZE
 size_t zmalloc_size(void *ptr);
+size_t zmalloc_usable(void *ptr);
+#else
+#define zmalloc_usable(p) zmalloc_size(p)
 #endif
 
 #endif /* __ZMALLOC_H */
diff --git a/tests/unit/maxmemory.tcl b/tests/unit/maxmemory.tcl
index 0c3f6b32c..e3cd11114 100644
--- a/tests/unit/maxmemory.tcl
+++ b/tests/unit/maxmemory.tcl
@@ -142,3 +142,95 @@ start_server {tags {"maxmemory"}} {
         }
     }
 }
+
+proc test_slave_buffers {cmd_count payload_len limit_memory pipeline} {
+    start_server {tags {"maxmemory"}} {
+        start_server {} {
+            set slave [srv 0 client]
+            set slave_host [srv 0 host]
+            set slave_port [srv 0 port]
+            set master [srv -1 client]
+            set master_host [srv -1 host]
+            set master_port [srv -1 port]
+
+            # add 100 keys of 100k (10MB total)
+            for {set j 0} {$j < 100} {incr j} {
+                $master setrange "key:$j" 100000 asdf
+            }
+
+            $master config set maxmemory-policy allkeys-random
+            $master config set client-output-buffer-limit "slave 100000000 100000000 60"
+            $master config set repl-backlog-size [expr {10*1024}]
+
+            $slave slaveof $master_host $master_port
+            wait_for_condition 50 100 {
+                [s 0 master_link_status] eq {up}
+            } else {
+                fail "Replication not started."
+            }
+
+            # measure used memory after the slave connected and set maxmemory
+            set orig_used [s -1 used_memory]
+            set orig_client_buf [s -1 mem_clients_normal]
+            set orig_mem_not_counted_for_evict [s -1 mem_not_counted_for_evict]
+            set orig_used_no_repl [expr {$orig_used - $orig_mem_not_counted_for_evict}]
+            set limit [expr {$orig_used - $orig_mem_not_counted_for_evict + 20*1024}]
+
+            if {$limit_memory==1} {
+                $master config set maxmemory $limit
+            }
+
+            # put the slave to sleep
+            set rd_slave [redis_deferring_client]
+            $rd_slave debug sleep 60
+
+            # send some 10mb woth of commands that don't increase the memory usage
+            if {$pipeline == 1} {
+                set rd_master [redis_deferring_client -1]
+                for {set k 0} {$k < $cmd_count} {incr k} {
+                    $rd_master setrange key:0 0 [string repeat A $payload_len]
+                }
+                for {set k 0} {$k < $cmd_count} {incr k} {
+                    #$rd_master read
+                }
+            } else {
+                for {set k 0} {$k < $cmd_count} {incr k} {
+                    $master setrange key:0 0 [string repeat A $payload_len]
+                }
+            }
+
+            set new_used [s -1 used_memory]
+            set slave_buf [s -1 mem_clients_slaves]
+            set client_buf [s -1 mem_clients_normal]
+            set mem_not_counted_for_evict [s -1 mem_not_counted_for_evict]
+            set used_no_repl [expr {$new_used - $mem_not_counted_for_evict}]
+            set delta [expr {($used_no_repl - $client_buf) - ($orig_used_no_repl - $orig_client_buf)}]
+
+            assert {[$master dbsize] == 100}
+            assert {$slave_buf > 2*1024*1024} ;# some of the data may have been pushed to the OS buffers
+            assert {$delta < 50*1024 && $delta > -50*1024} ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
+
+            $master client kill type slave
+            set killed_used [s -1 used_memory]
+            set killed_slave_buf [s -1 mem_clients_slaves]
+            set killed_mem_not_counted_for_evict [s -1 mem_not_counted_for_evict]
+            set killed_used_no_repl [expr {$killed_used - $killed_mem_not_counted_for_evict}]
+            set delta_no_repl [expr {$killed_used_no_repl - $used_no_repl}]
+            assert {$killed_slave_buf == 0}
+            assert {$delta_no_repl > -50*1024 && $delta_no_repl < 50*1024} ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
+        }
+    }
+}
+
+test {slave buffer are counted correctly} {
+    # we wanna use many small commands, and we don't wanna wait long
+    # so we need to use a pipeline (redis_deferring_client)
+    # that may cause query buffer to fill and induce eviction, so we disable it
+    test_slave_buffers 1000000 10 0 1
+}
+
+test {slave buffer don't induce eviction} {
+    # test again with fewer (and bigger) commands without pipeline, but with eviction
+    test_slave_buffers 100000 100 1 0
+}
+

From f9c84d6d39411d25bb29d3a03b29ec257e2b66e7 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 16 Jul 2018 17:56:54 +0200
Subject: [PATCH 209/219] Hopefully improve commenting of #5126.

Reading the PR gave me the opportunity to better specify what the code
was doing in places where I was not immediately sure about what was
going on. Moreover I documented the structure in server.h so that people
reading the header file will immediately understand what the structure
is useful for.
---
 src/networking.c | 30 ++++++++++++++++++++----------
 src/server.h     |  2 ++
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/src/networking.c b/src/networking.c
index 36ae26e0b..d23185ffa 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -245,12 +245,15 @@ void _addReplyStringToList(client *c, const char *s, size_t len) {
 
     listNode *ln = listLast(c->reply);
     clientReplyBlock *tail = ln? listNodeValue(ln): NULL;
-    /* It is possible that we have a tail list node, but no tail buffer.
-     * if addDeferredMultiBulkLength() was used. */
+
+    /* Note that 'tail' may be NULL even if we have a tail node, becuase when
+     * addDeferredMultiBulkLength() is used, it sets a dummy node to NULL just
+     * fo fill it later, when the size of the bulk length is set. */
 
     /* Append to tail string when possible. */
     if (tail) {
-        /* Copy the part we can fit into the tail, and leave the rest for a new node */
+        /* Copy the part we can fit into the tail, and leave the rest for a
+         * new node */
         size_t avail = tail->size - tail->used;
         size_t copy = avail >= len? len: avail;
         memcpy(tail->buf + tail->used, s, copy);
@@ -259,7 +262,8 @@ void _addReplyStringToList(client *c, const char *s, size_t len) {
         len -= copy;
     }
     if (len) {
-        /* Create a new node, make sure it is allocated to at least PROTO_REPLY_CHUNK_BYTES */
+        /* Create a new node, make sure it is allocated to at
+         * least PROTO_REPLY_CHUNK_BYTES */
         size_t size = len < PROTO_REPLY_CHUNK_BYTES? PROTO_REPLY_CHUNK_BYTES: len;
         tail = zmalloc(size + sizeof(clientReplyBlock));
         /* take over the allocation's internal fragmentation */
@@ -408,11 +412,17 @@ void setDeferredMultiBulkLength(client *c, void *node, long length) {
     if (node == NULL) return;
     serverAssert(!listNodeValue(ln));
 
-    /* Glue into next node when:
-     * - the next node is non-NULL,
-     * - it has enough room already allocated
-     * - and not too large (avoid large memmove) */
-    if (ln->next != NULL && (next = listNodeValue(ln->next)) && 
+    /* Normally we fill this dummy NULL node, added by addDeferredMultiBulkLength(),
+     * with a new buffer structure containing the protocol needed to specify
+     * the length of the array following. However sometimes when there is
+     * little memory to move, we may instead remove this NULL node, and prefix
+     * our protocol in the node immediately after to it, in order to save a
+     * write(2) syscall later. Conditions needed to do it:
+     *
+     * - The next node is non-NULL,
+     * - It has enough room already allocated
+     * - And not too large (avoid large memmove) */
+    if (ln->next != NULL && (next = listNodeValue(ln->next)) &&
         next->size - next->used >= lenstr_len &&
         next->used < PROTO_REPLY_CHUNK_BYTES * 4) {
         memmove(next->buf + lenstr_len, next->buf, next->used);
@@ -422,7 +432,7 @@ void setDeferredMultiBulkLength(client *c, void *node, long length) {
     } else {
         /* Create a new node */
         clientReplyBlock *buf = zmalloc(lenstr_len + sizeof(clientReplyBlock));
-        /* take over the allocation's internal fragmentation */
+        /* Take over the allocation's internal fragmentation */
         buf->size = zmalloc_usable(buf) - sizeof(clientReplyBlock);
         buf->used = lenstr_len;
         memcpy(buf->buf, lenstr, lenstr_len);
diff --git a/src/server.h b/src/server.h
index c35333bd3..dae7561d8 100644
--- a/src/server.h
+++ b/src/server.h
@@ -619,6 +619,8 @@ typedef struct redisObject {
 
 struct evictionPoolEntry; /* Defined in evict.c */
 
+/* This structure is used in order to represent the output buffer of a client,
+ * which is actually a linked list of blocks like that, that is: client->reply. */
 typedef struct clientReplyBlock {
     size_t size, used;
     char buf[];

From cefe21d28a75f4fdbf24823ce42e777c2b9d5c6f Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 17 Jul 2018 10:39:47 +0200
Subject: [PATCH 210/219] dict.c: remove a few trailing spaces.

---
 src/dict.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dict.c b/src/dict.c
index 95a141d0d..2cf9d4839 100644
--- a/src/dict.c
+++ b/src/dict.c
@@ -705,9 +705,9 @@ unsigned int dictGetSomeKeys(dict *d, dictEntry **des, unsigned int count) {
                  * table, there will be no elements in both tables up to
                  * the current rehashing index, so we jump if possible.
                  * (this happens when going from big to small table). */
-                if (i >= d->ht[1].size) 
+                if (i >= d->ht[1].size)
                     i = d->rehashidx;
-                else 
+                else
                     continue;
             }
             if (i >= d->ht[j].size) continue; /* Out of range for this table. */

From d55598988b3381afff87bc974f5cfda0e8ae77e0 Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Sat, 14 Jul 2018 16:49:15 +0300
Subject: [PATCH 211/219] fix rare replication stream corruption with
 disk-based replication

The slave sends \n keepalive messages to the master while parsing the rdb,
and later sends REPLCONF ACK once a second. rarely, the master recives both
a linefeed char and a REPLCONF in the same read, \n*3\r\n$8\r\nREPLCONF\r\n...
and it tries to trim two chars (\r\n) from the query buffer,
trimming the '*' from *3\r\n$8\r\nREPLCONF\r\n...

then the master tries to process a command starting with '3' and replies to
the slave a bunch of -ERR and one +OK.
although the slave silently ignores these (prints a log message), this corrupts
the replication offset at the slave since the slave increases the replication
offset, and the master did not.

other than the fix in processInlineBuffer, i did several other improvments
while hunting this very rare bug.

- when redis replies with "unknown command" it includes a portion of the
  arguments, not just the command name. so it would be easier to understand
  what was recived, in my case, on the slave side,  it was -ERR, but
  the "arguments" were the interesting part (containing info on the error).
- about a year ago i added code in addReplyErrorLength to print the error to
  the log in case of a reply to master (since this string isn't actually
  trasmitted to the master), now changed that block to print a similar log
  message to indicate an error being sent from the master to the slave.
  note that the slave is marked as CLIENT_SLAVE only after PSYNC was received,
  so this will not cause any harm for REPLCONF, and will only indicate problems
  that are gonna corrupt the replication stream anyway.
- two places were c->reply was emptied, and i wanted to reset sentlen
  this is a precaution (i did not actually see such a problem), since a
  non-zero sentlen will cause corruption to be transmitted on the socket.
---
 src/networking.c  | 17 ++++++++++-------
 src/replication.c |  1 +
 src/server.c      |  9 +++++++--
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/networking.c b/src/networking.c
index d23185ffa..f6882f697 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -342,11 +342,13 @@ void addReplyErrorLength(client *c, const char *s, size_t len) {
     if (!len || s[0] != '-') addReplyString(c,"-ERR ",5);
     addReplyString(c,s,len);
     addReplyString(c,"\r\n",2);
-    if (c->flags & CLIENT_MASTER) {
+    if (c->flags & (CLIENT_MASTER|CLIENT_SLAVE)) {
+        char* to = c->flags & CLIENT_MASTER? "master": "slave";
+        char* from = c->flags & CLIENT_MASTER? "slave": "master";
         char *cmdname = c->lastcmd ? c->lastcmd->name : "<unknown>";
-        serverLog(LL_WARNING,"== CRITICAL == This slave is sending an error "
-                             "to its master: '%s' after processing the command "
-                             "'%s'", s, cmdname);
+        serverLog(LL_WARNING,"== CRITICAL == This %s is sending an error "
+                             "to its %s: '%s' after processing the command "
+                             "'%s'", from, to, s, cmdname);
     }
 }
 
@@ -608,6 +610,7 @@ void addReplySubcommandSyntaxError(client *c) {
  * destination client. */
 void copyClientOutputBuffer(client *dst, client *src) {
     listRelease(dst->reply);
+    dst->sentlen = 0;
     dst->reply = listDup(src->reply);
     memcpy(dst->buf,src->buf,src->bufpos);
     dst->bufpos = src->bufpos;
@@ -1094,7 +1097,7 @@ void resetClient(client *c) {
  * with the error and close the connection. */
 int processInlineBuffer(client *c) {
     char *newline;
-    int argc, j;
+    int argc, j, linefeed_chars = 1;
     sds *argv, aux;
     size_t querylen;
 
@@ -1112,7 +1115,7 @@ int processInlineBuffer(client *c) {
 
     /* Handle the \r\n case. */
     if (newline && newline != c->querybuf && *(newline-1) == '\r')
-        newline--;
+        newline--, linefeed_chars++;
 
     /* Split the input buffer up to the \r\n */
     querylen = newline-(c->querybuf);
@@ -1132,7 +1135,7 @@ int processInlineBuffer(client *c) {
         c->repl_ack_time = server.unixtime;
 
     /* Leave data after the first line of the query in the buffer */
-    sdsrange(c->querybuf,querylen+2,-1);
+    sdsrange(c->querybuf,querylen+linefeed_chars,-1);
 
     /* Setup argv array on client structure */
     if (argc) {
diff --git a/src/replication.c b/src/replication.c
index bc3755398..6d589c012 100644
--- a/src/replication.c
+++ b/src/replication.c
@@ -2148,6 +2148,7 @@ void replicationCacheMaster(client *c) {
     server.master->read_reploff = server.master->reploff;
     if (c->flags & CLIENT_MULTI) discardTransaction(c);
     listEmpty(c->reply);
+    c->sentlen = 0;
     c->reply_bytes = 0;
     c->bufpos = 0;
     resetClient(c);
diff --git a/src/server.c b/src/server.c
index 971595872..1e717b23c 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2449,8 +2449,13 @@ int processCommand(client *c) {
     c->cmd = c->lastcmd = lookupCommand(c->argv[0]->ptr);
     if (!c->cmd) {
         flagTransaction(c);
-        addReplyErrorFormat(c,"unknown command '%s'",
-            (char*)c->argv[0]->ptr);
+        sds args = sdsempty();
+        int i;
+        for (i=1; i < c->argc && sdslen(args) < 128; i++)
+            args = sdscatprintf(args, "`%.*s`, ", 128-(int)sdslen(args), (char*)c->argv[i]->ptr);
+        addReplyErrorFormat(c,"unknown command `%s`, with args beginning with: %s",
+            (char*)c->argv[0]->ptr, args);
+        sdsfree(args);
         return C_OK;
     } else if ((c->cmd->arity > 0 && c->cmd->arity != c->argc) ||
                (c->argc < -c->cmd->arity)) {

From 6501b6bb6d8d8243c47402e25e9d54e7309f727f Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Tue, 17 Jul 2018 18:19:10 +0800
Subject: [PATCH 212/219] Streams: return an error message if using xreadgroup
 with '$' ID.

Redis will always return an empty result when '$' ID is specified
with xreadgroup command, it's meaningless.
---
 src/t_stream.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/t_stream.c b/src/t_stream.c
index 442515866..8540cfc65 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1351,6 +1351,11 @@ void xreadCommand(client *c) {
         }
 
         if (strcmp(c->argv[i]->ptr,"$") == 0) {
+            if (xreadgroup) {
+                addReplyError(c,"The $ ID can be specified only when calling "
+                              "XREAD without GROUP option.");
+                goto cleanup;
+            }
             if (o) {
                 stream *s = o->ptr;
                 ids[id_idx] = s->last_id;

From 846cf12ae592b8a97c9e932f08b7533902733c17 Mon Sep 17 00:00:00 2001
From: "dejun.xdj" <dejun.xdj@alibaba-inc.com>
Date: Tue, 17 Jul 2018 18:23:47 +0800
Subject: [PATCH 213/219] Streams: remove meaningless if condition.

It's already checked if xreadgroup is set and groupname is NULL.
---
 src/t_stream.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 8540cfc65..ed0aa2141 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1365,7 +1365,7 @@ void xreadCommand(client *c) {
             }
             continue;
         } else if (strcmp(c->argv[i]->ptr,">") == 0) {
-            if (!xreadgroup || groupname == NULL) {
+            if (!xreadgroup) {
                 addReplyError(c,"The > ID can be specified only when calling "
                                 "XREADGROUP using the GROUP <group> "
                                 "<consumer> option.");

From afc7e08a20da95d6facf8357a82b7321cb64cfcf Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 17 Jul 2018 17:42:25 +0200
Subject: [PATCH 214/219] Panic when we are sending an error to our
 master/slave.

Related to #5135, see discussion there.
---
 src/networking.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/networking.c b/src/networking.c
index f6882f697..22850a4b6 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -349,6 +349,11 @@ void addReplyErrorLength(client *c, const char *s, size_t len) {
         serverLog(LL_WARNING,"== CRITICAL == This %s is sending an error "
                              "to its %s: '%s' after processing the command "
                              "'%s'", from, to, s, cmdname);
+        /* Here we want to panic because when an instance is sending an
+         * error to another instance in the context of replication, this can
+         * only create some kind of offset or data desynchronization. Better
+         * to catch it ASAP and crash instead of continuing. */
+        serverPanic("Continuing is unsafe: replication protocol violation.");
     }
 }
 

From 6201f7b4e0cb1ee96f54d6ec5b993d422581fbf9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 17 Jul 2018 17:54:10 +0200
Subject: [PATCH 215/219] Streams: better error when $ is given with
 XREADGROUP.

---
 src/t_stream.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/t_stream.c b/src/t_stream.c
index 05de288e0..201509c7e 100644
--- a/src/t_stream.c
+++ b/src/t_stream.c
@@ -1352,8 +1352,11 @@ void xreadCommand(client *c) {
 
         if (strcmp(c->argv[i]->ptr,"$") == 0) {
             if (xreadgroup) {
-                addReplyError(c,"The $ ID can be specified only when calling "
-                              "XREAD without GROUP option.");
+                addReplyError(c,"The $ ID is meaningless in the context of "
+                                "XREADGROUP: you want to read the history of "
+                                "this consumer by specifying a proper ID, or "
+                                "use the > ID to get new messages. The $ ID would "
+                                "just return an empty result set.");
                 goto cleanup;
             }
             if (o) {

From f89c93c8adf2dea395224c5c65d82e90aa323bfd Mon Sep 17 00:00:00 2001
From: Oran Agra <oran@redislabs.com>
Date: Wed, 18 Jul 2018 10:16:33 +0300
Subject: [PATCH 216/219] make active defrag test more stable

on slower machines, the active defrag test tended to fail.
although the fragmentation ratio was below the treshold, the defragger was
still in the middle of a scan cycle.

this commit changes:
- the defragger uses the current fragmentation state, rather than the cache one
  that is updated by server cron every 100ms. this actually fixes a bug of
  starting one excess scan cycle
- the test lets the defragger use more CPU cycles, in hope that the defrag
  will be faster, but also give it more time before we give up.
---
 src/defrag.c                 | 5 ++---
 tests/unit/memefficiency.tcl | 6 ++++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/defrag.c b/src/defrag.c
index b25fceb1e..d67b6e253 100644
--- a/src/defrag.c
+++ b/src/defrag.c
@@ -867,9 +867,8 @@ void defragDictBucketCallback(void *privdata, dictEntry **bucketref) {
  * or not, a false detection can cause the defragmenter to waste a lot of CPU
  * without the possibility of getting any results. */
 float getAllocatorFragmentation(size_t *out_frag_bytes) {
-    size_t resident = server.cron_malloc_stats.allocator_resident;
-    size_t active = server.cron_malloc_stats.allocator_active;
-    size_t allocated = server.cron_malloc_stats.allocator_allocated;
+    size_t resident, active, allocated;
+    zmalloc_get_allocator_info(&allocated, &active, &resident);
     float frag_pct = ((float)active / allocated)*100 - 100;
     size_t frag_bytes = active - allocated;
     float rss_pct = ((float)resident / allocated)*100 - 100;
diff --git a/tests/unit/memefficiency.tcl b/tests/unit/memefficiency.tcl
index c8e95de13..ec71a36b1 100644
--- a/tests/unit/memefficiency.tcl
+++ b/tests/unit/memefficiency.tcl
@@ -41,7 +41,7 @@ start_server {tags {"defrag"}} {
         test "Active defrag" {
             r config set activedefrag no
             r config set active-defrag-threshold-lower 5
-            r config set active-defrag-cycle-min 25
+            r config set active-defrag-cycle-min 65
             r config set active-defrag-cycle-max 75
             r config set active-defrag-ignore-bytes 2mb
             r config set maxmemory 100mb
@@ -66,9 +66,10 @@ start_server {tags {"defrag"}} {
                 }
 
                 # Wait for the active defrag to stop working.
-                wait_for_condition 100 100 {
+                wait_for_condition 150 100 {
                     [s active_defrag_running] eq 0
                 } else {
+                    after 120 ;# serverCron only updates the info once in 100ms
                     puts [r info memory]
                     puts [r memory malloc-stats]
                     fail "defrag didn't stop."
@@ -175,6 +176,7 @@ start_server {tags {"defrag"}} {
                 wait_for_condition 500 100 {
                     [s active_defrag_running] eq 0
                 } else {
+                    after 120 ;# serverCron only updates the info once in 100ms
                     puts [r info memory]
                     puts [r memory malloc-stats]
                     fail "defrag didn't stop."

From 6183f0590dede55ceeb9019899343170d38197d0 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 18 Jul 2018 17:40:07 +0200
Subject: [PATCH 217/219] Refine comment in addReplyErrorLength() about
 replying to masters/slaves.

See #5135 for some context.
---
 src/networking.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/networking.c b/src/networking.c
index 22850a4b6..c08d71998 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -342,6 +342,17 @@ void addReplyErrorLength(client *c, const char *s, size_t len) {
     if (!len || s[0] != '-') addReplyString(c,"-ERR ",5);
     addReplyString(c,s,len);
     addReplyString(c,"\r\n",2);
+
+    /* Sometimes it could be normal that a slave replies to a master with
+     * an error and this function gets called. Actually the error will never
+     * be sent because addReply*() against master clients has no effect...
+     * A notable example is:
+     *
+     *    EVAL 'redis.call("incr",KEYS[1]); redis.call("nonexisting")' 1 x
+     *
+     * Where the master must propagate the first change even if the second
+     * will produce an error. However it is useful to log such events since
+     * they are rare and may hint at errors in a script or a bug in Redis. */
     if (c->flags & (CLIENT_MASTER|CLIENT_SLAVE)) {
         char* to = c->flags & CLIENT_MASTER? "master": "slave";
         char* from = c->flags & CLIENT_MASTER? "slave": "master";

From 313b2240aec0447bb61453cf81f706120d826c30 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 18 Jul 2018 17:41:06 +0200
Subject: [PATCH 218/219] In addReplyErrorLength() only panic when replying to
 slave.

See #5135 for more context.
---
 src/networking.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/networking.c b/src/networking.c
index c08d71998..af7422178 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -360,11 +360,12 @@ void addReplyErrorLength(client *c, const char *s, size_t len) {
         serverLog(LL_WARNING,"== CRITICAL == This %s is sending an error "
                              "to its %s: '%s' after processing the command "
                              "'%s'", from, to, s, cmdname);
-        /* Here we want to panic because when an instance is sending an
-         * error to another instance in the context of replication, this can
+        /* Here we want to panic because when a master is sending an
+         * error to some slave in the context of replication, this can
          * only create some kind of offset or data desynchronization. Better
          * to catch it ASAP and crash instead of continuing. */
-        serverPanic("Continuing is unsafe: replication protocol violation.");
+        if (c->flags & CLIENT_SLAVE)
+            serverPanic("Continuing is unsafe: replication protocol violation.");
     }
 }
 

From 1c95c075966407729648fe676883a75be638824c Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 19 Jul 2018 12:22:42 +0200
Subject: [PATCH 219/219] Make vars used only by INFO CLIENTS local to the
 block.

Related to #4727.
---
 src/server.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/server.c b/src/server.c
index 251209b70..06826a356 100644
--- a/src/server.c
+++ b/src/server.c
@@ -2955,7 +2955,6 @@ sds genRedisInfoString(char *section) {
     time_t uptime = server.unixtime-server.stat_starttime;
     int j;
     struct rusage self_ru, c_ru;
-    unsigned long lol, bib;
     int allsections = 0, defsections = 0;
     int sections = 0;
 
@@ -3034,6 +3033,7 @@ sds genRedisInfoString(char *section) {
 
     /* Clients */
     if (allsections || defsections || !strcasecmp(section,"clients")) {
+        unsigned long lol, bib;
         getClientsMaxBuffers(&lol,&bib);
         if (sections++) info = sdscat(info,"\r\n");
         info = sdscatprintf(info,