Modules: fix for scripting replication of modules commands.

See issue #4466 / #4467.

README.md

@@ -1,4 +1,4 @@
-This README is just a fast *quick start* document. You can find more detailed documentation at [redis.io](https://redis.io).
+This README is just a fast *quick start* document. You can find more detailed documentation at http://redis.io.
 
 What is Redis?
 --------------

redis.conf

@@ -59,7 +59,7 @@
 # internet, binding to all the interfaces is dangerous and will expose the
 # instance to everybody on the internet. So by default we uncomment the
 # following bind directive, that will force Redis to listen only into
-# the IPv4 loopback interface address (this means Redis will be able to
+# the IPv4 lookback interface address (this means Redis will be able to
 # accept connections only from clients running into the same computer it
 # is running).
 #
@@ -296,9 +296,7 @@ dir ./
 #
 # 2) if slave-serve-stale-data is set to 'no' the slave will reply with
 #    an error "SYNC with master in progress" to all the kind of commands
-#    but to INFO, SLAVEOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG,
-#    SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB,
-#    COMMAND, POST, HOST: and LATENCY.
+#    but to INFO and SLAVEOF.
 #
 slave-serve-stale-data yes
 
@@ -608,7 +606,7 @@ slave-priority 100
 # deletion of the object. It means that the server stops processing new commands
 # in order to reclaim all the memory associated with an object in a synchronous
 # way. If the key deleted is associated with a small object, the time needed
-# in order to execute the DEL command is very small and comparable to most other
+# in order to execute th DEL command is very small and comparable to most other
 # O(1) or O(log_N) commands in Redis. However if the key is associated with an
 # aggregated value containing millions of elements, the server can block for
 # a long time (even seconds) in order to complete the operation.
@@ -623,7 +621,7 @@ slave-priority 100
 # It's up to the design of the application to understand when it is a good
 # idea to use one or the other. However the Redis server sometimes has to
 # delete keys or flush the whole database as a side effect of other operations.
-# Specifically Redis deletes objects independently of a user call in the
+# Specifically Redis deletes objects independently of an user call in the
 # following scenarios:
 #
 # 1) On eviction, because of the maxmemory and maxmemory policy configurations,
@@ -916,7 +914,7 @@ lua-time-limit 5000
 # Docker and other containers).
 #
 # In order to make Redis Cluster working in such environments, a static
-# configuration where each node knows its public address is needed. The
+# configuration where each node known its public address is needed. The
 # following two options are used for this scope, and are:
 #
 # * cluster-announce-ip
@@ -1156,20 +1154,6 @@ client-output-buffer-limit normal 0 0 0
 client-output-buffer-limit slave 256mb 64mb 60
 client-output-buffer-limit pubsub 32mb 8mb 60
 
-# Client query buffers accumulate new commands. They are limited to a fixed
-# amount by default in order to avoid that a protocol desynchronization (for
-# instance due to a bug in the client) will lead to unbound memory usage in
-# the query buffer. However you can configure it here if you have very special
-# needs, such us huge multi/exec requests or alike.
-#
-# client-query-buffer-limit 1gb
-
-# In the Redis protocol, bulk requests, that are, elements representing single
-# strings, are normally limited ot 512 mb. However you can change this limit
-# here.
-#
-# proto-max-bulk-len 512mb
-
 # Redis calls an internal function to perform many background tasks, like
 # closing connections of clients in timeout, purging expired keys that are
 # never requested, and so forth.

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.c
+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
 REDIS_CLI_NAME=redis-cli
 REDIS_CLI_OBJ=anet.o adlist.o redis-cli.o zmalloc.o release.o anet.o ae.o crc64.o
 REDIS_BENCHMARK_NAME=redis-benchmark

src/adlist.c

@@ -353,7 +353,7 @@ void listJoin(list *l, list *o) {
     else
         l->head = o->head;
 
-    if (o->tail) l->tail = o->tail;
+    l->tail = o->tail;
     l->len += o->len;
 
     /* Setup other as an empty list. */

src/ae.c

@@ -159,10 +159,6 @@ void aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask)
     aeFileEvent *fe = &eventLoop->events[fd];
     if (fe->mask == AE_NONE) return;
 
-    /* We want to always remove AE_BARRIER if set when AE_WRITABLE
-     * is removed. */
-    if (mask & AE_WRITABLE) mask |= AE_BARRIER;
-
     aeApiDelEvent(eventLoop, fd, mask);
     fe->mask = fe->mask & (~mask);
     if (fd == eventLoop->maxfd && fe->mask == AE_NONE) {
@@ -415,49 +411,19 @@ int aeProcessEvents(aeEventLoop *eventLoop, int flags)
             aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];
             int mask = eventLoop->fired[j].mask;
             int fd = eventLoop->fired[j].fd;
-            int fired = 0; /* Number of events fired for current fd. */
+            int rfired = 0;
 
-            /* Normally we execute the readable event first, and the writable
-             * event laster. This is useful as sometimes we may be able
-             * to serve the reply of a query immediately after processing the
-             * query.
-             *
-             * However if AE_BARRIER is set in the mask, our application is
-             * asking us to do the reverse: never fire the writable event
-             * after the readable. In such a case, we invert the calls.
-             * This is useful when, for instance, we want to do things
-             * in the beforeSleep() hook, like fsynching a file to disk,
-             * before replying to a client. */
-            int invert = fe->mask & AE_BARRIER;
-
-	    /* 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.
-             *
-             * Fire the readable event if the call sequence is not
-             * inverted. */
-            if (!invert && fe->mask & mask & AE_READABLE) {
+	    /* 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. */
+            if (fe->mask & mask & AE_READABLE) {
+                rfired = 1;
                 fe->rfileProc(eventLoop,fd,fe->clientData,mask);
-                fired++;
             }
-
-            /* Fire the writable event. */
             if (fe->mask & mask & AE_WRITABLE) {
-                if (!fired || fe->wfileProc != fe->rfileProc) {
+                if (!rfired || fe->wfileProc != fe->rfileProc)
                     fe->wfileProc(eventLoop,fd,fe->clientData,mask);
-                    fired++;
-                }
             }
-
-            /* If we have to invert the call, fire the readable event now
-             * after the writable one. */
-            if (invert && fe->mask & mask & AE_READABLE) {
-                if (!fired || fe->wfileProc != fe->rfileProc) {
-                    fe->rfileProc(eventLoop,fd,fe->clientData,mask);
-                    fired++;
-                }
-            }
-
             processed++;
         }
     }

src/ae.h

@@ -38,14 +38,9 @@
 #define AE_OK 0
 #define AE_ERR -1
 
-#define AE_NONE 0       /* No events registered. */
-#define AE_READABLE 1   /* Fire when descriptor is readable. */
-#define AE_WRITABLE 2   /* Fire when descriptor is writable. */
-#define AE_BARRIER 4    /* With WRITABLE, never fire the event if the
-                           READABLE event already fired in the same event
-                           loop iteration. Useful when you want to persist
-                           things to disk before sending replies, and want
-                           to do that in a group fashion. */
+#define AE_NONE 0
+#define AE_READABLE 1
+#define AE_WRITABLE 2
 
 #define AE_FILE_EVENTS 1
 #define AE_TIME_EVENTS 2
@@ -69,7 +64,7 @@ typedef void aeBeforeSleepProc(struct aeEventLoop *eventLoop);
 
 /* File event structure */
 typedef struct aeFileEvent {
-    int mask; /* one of AE_(READABLE|WRITABLE|BARRIER) */
+    int mask; /* one of AE_(READABLE|WRITABLE) */
     aeFileProc *rfileProc;
     aeFileProc *wfileProc;
     void *clientData;

src/anet.c

@@ -237,7 +237,7 @@ int anetResolveIP(char *err, char *host, char *ipbuf, size_t ipbuf_len) {
 
 static int anetSetReuseAddr(char *err, int fd) {
     int yes = 1;
-    /* Make sure connection-intensive things like the redis benchmark
+    /* Make sure connection-intensive things like the redis benckmark
      * will be able to close/open sockets a zillion of times */
     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {
         anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));

src/aof.c

@@ -197,60 +197,10 @@ ssize_t aofRewriteBufferWrite(int fd) {
  * AOF file implementation
  * ------------------------------------------------------------------------- */
 
-/* Return true if an AOf fsync is currently already in progress in a
- * BIO thread. */
-int aofFsyncInProgress(void) {
-    return bioPendingJobsOfType(BIO_AOF_FSYNC) != 0;
-}
-
 /* Starts a background task that performs fsync() against the specified
  * file descriptor (the one of the AOF file) in another thread. */
-void aofStartBackgroundFsync(void) {
-    if (aofFsyncInProgress()) {
-        /* We never want to start another fsync if one is in progress. */
-        return;
-    }
-
-    /* Before starting a new fsync, we need to flush the AOF buffer to
-     * disk if there are clients blocked in WAIT AOF, otherwise we are
-     * not going to sync their data. */
-    if (server.blocked_clients_by_type[BLOCKED_AOF])
-        flushAppendOnlyFile(0);
-
-    /* No fsync is in progress. If there was one, the new epoch is stored
-     * in server.aof_fsync_in_progress_epoch. So update the current fsync
-     * epoch with the one of the fsync in progress. */
-    server.aof_fsync_epoch = server.aof_fsync_in_progress_epoch;
-    bioCreateBackgroundJob(BIO_AOF_FSYNC,(void*)(long)server.aof_fd,NULL,NULL);
-    server.aof_fsync_in_progress_epoch++;
-}
-
-/* Returns an AOF epoch so that, when such epoch is reached by
- * server.aof_fsync_epoch, it means that everything that was written in the
- * AOF up to the moment this function returned the epoch, is now flushed
- * on disk. */
-uint64_t aofNextEpoch(void) {
-    return server.aof_fsync_in_progress_epoch + 1;
-}
-
-/* Kills an AOFRW child process if exists */
-static void killAppendOnlyChild(void) {
-    int statloc;
-    /* No AOFRW child? return. */
-    if (server.aof_child_pid == -1) return;
-    /* Kill AOFRW child, wait for child exit. */
-    serverLog(LL_NOTICE,"Killing running AOF rewrite child: %ld",
-        (long) server.aof_child_pid);
-    if (kill(server.aof_child_pid,SIGUSR1) != -1) {
-        while(wait3(&statloc,0,NULL) != server.aof_child_pid);
-    }
-    /* Reset the buffer accumulating changes while the child saves. */
-    aofRewriteBufferReset();
-    aofRemoveTempFile(server.aof_child_pid);
-    server.aof_child_pid = -1;
-    server.aof_rewrite_time_start = -1;
-    /* Close pipes used for IPC between the two processes. */
-    aofClosePipes();
+void aof_background_fsync(int fd) {
+    bioCreateBackgroundJob(BIO_AOF_FSYNC,(void*)(long)fd,NULL,NULL);
 }
 
 /* Called when the user switches from "appendonly yes" to "appendonly no"
@@ -264,18 +214,34 @@ void stopAppendOnly(void) {
     server.aof_fd = -1;
     server.aof_selected_db = -1;
     server.aof_state = AOF_OFF;
-    killAppendOnlyChild();
+    /* rewrite operation in progress? kill it, wait child exit */
+    if (server.aof_child_pid != -1) {
+        int statloc;
+
+        serverLog(LL_NOTICE,"Killing running AOF rewrite child: %ld",
+            (long) server.aof_child_pid);
+        if (kill(server.aof_child_pid,SIGUSR1) != -1) {
+            while(wait3(&statloc,0,NULL) != server.aof_child_pid);
+        }
+        /* reset the buffer accumulating changes while the child saves */
+        aofRewriteBufferReset();
+        aofRemoveTempFile(server.aof_child_pid);
+        server.aof_child_pid = -1;
+        server.aof_rewrite_time_start = -1;
+        /* close pipes used for IPC between the two processes. */
+        aofClosePipes();
+    }
 }
 
 /* Called when the user switches from "appendonly no" to "appendonly yes"
  * at runtime using the CONFIG command. */
 int startAppendOnly(void) {
     char cwd[MAXPATHLEN]; /* Current working dir path for error messages. */
-    int newfd;
 
-    newfd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644);
+    server.aof_last_fsync = server.unixtime;
+    server.aof_fd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644);
     serverAssert(server.aof_state == AOF_OFF);
-    if (newfd == -1) {
+    if (server.aof_fd == -1) {
         char *cwdp = getcwd(cwd,MAXPATHLEN);
 
         serverLog(LL_WARNING,
@@ -289,56 +255,17 @@ int startAppendOnly(void) {
     if (server.rdb_child_pid != -1) {
         server.aof_rewrite_scheduled = 1;
         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
-         * 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.");
-            killAppendOnlyChild();
-        }
-        if (rewriteAppendOnlyFileBackground() == C_ERR) {
-            close(newfd);
-            serverLog(LL_WARNING,"Redis needs to enable the AOF but can't trigger a background AOF rewrite operation. Check the above logs for more info about the error.");
-            return C_ERR;
-        }
+    } else if (rewriteAppendOnlyFileBackground() == C_ERR) {
+        close(server.aof_fd);
+        serverLog(LL_WARNING,"Redis needs to enable the AOF but can't trigger a background AOF rewrite operation. Check the above logs for more info about the error.");
+        return C_ERR;
     }
     /* We correctly switched on AOF, now wait for the rewrite to be complete
      * in order to append data on disk. */
     server.aof_state = AOF_WAIT_REWRITE;
-    server.aof_last_fsync = server.unixtime;
-    server.aof_fd = newfd;
     return C_OK;
 }
 
-/* This is a wrapper to the write syscall in order to retry on short writes
- * or if the syscall gets interrupted. It could look strange that we retry
- * on short writes given that we are writing to a block device: normally if
- * the first call is short, there is a end-of-space condition, so the next
- * is likely to fail. However apparently in modern systems this is no longer
- * true, and in general it looks just more resilient to retry the write. If
- * there is an actual error condition we'll get it at the next try. */
-ssize_t aofWrite(int fd, const char *buf, size_t len) {
-    ssize_t nwritten = 0, totwritten = 0;
-
-    while(len) {
-        nwritten = write(fd, buf, len);
-
-        if (nwritten < 0) {
-            if (errno == EINTR) {
-                continue;
-            }
-            return totwritten ? totwritten : -1;
-        }
-
-        len -= nwritten;
-        buf += nwritten;
-        totwritten += nwritten;
-    }
-
-    return totwritten;
-}
-
 /* Write the append only file buffer on disk.
  *
  * Since we are required to write the AOF before replying to the client,
@@ -366,7 +293,7 @@ void flushAppendOnlyFile(int force) {
     if (sdslen(server.aof_buf) == 0) return;
 
     if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
-        sync_in_progress = aofFsyncInProgress();
+        sync_in_progress = bioPendingJobsOfType(BIO_AOF_FSYNC) != 0;
 
     if (server.aof_fsync == AOF_FSYNC_EVERYSEC && !force) {
         /* With this append fsync policy we do background fsyncing.
@@ -396,7 +323,7 @@ void flushAppendOnlyFile(int force) {
      * or alike */
 
     latencyStartMonitor(latency);
-    nwritten = aofWrite(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));
+    nwritten = write(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));
     latencyEndMonitor(latency);
     /* We want to capture different events for delayed writes:
      * when the delay happens with a pending fsync, or with a saving child
@@ -415,7 +342,7 @@ void flushAppendOnlyFile(int force) {
     /* We performed the write so reset the postponed flush sentinel to zero. */
     server.aof_flush_postponed_start = 0;
 
-    if (nwritten != (ssize_t)sdslen(server.aof_buf)) {
+    if (nwritten != (signed)sdslen(server.aof_buf)) {
         static time_t last_write_error_log = 0;
         int can_log = 0;
 
@@ -515,11 +442,7 @@ void flushAppendOnlyFile(int force) {
         server.aof_last_fsync = server.unixtime;
     } else if ((server.aof_fsync == AOF_FSYNC_EVERYSEC &&
                 server.unixtime > server.aof_last_fsync)) {
-        aofStartBackgroundFsync();
-        /* Note that we update this time regardless of the fact fsync
-         * was actually started or nmot. server.aof_last_fsync is not
-         * used to really know when the latest fsync succeeded, but just
-         * as a timer to *try* to fsync once every second. */
+        if (!sync_in_progress) aof_background_fsync(server.aof_fd);
         server.aof_last_fsync = server.unixtime;
     }
 }
@@ -793,7 +716,7 @@ int loadAppendOnlyFile(char *filename) {
             }
             if (buf[0] != '$') goto fmterr;
             len = strtol(buf+1,NULL,10);
-            argsds = sdsnewlen(SDS_NOINIT,len);
+            argsds = sdsnewlen(NULL,len);
             if (len && fread(argsds,len,1,fp) == 0) {
                 sdsfree(argsds);
                 fakeClient->argc = j; /* Free up to j-1. */
@@ -1108,37 +1031,6 @@ int rewriteHashObject(rio *r, robj *key, robj *o) {
     return 1;
 }
 
-/* Emit the commands needed to rebuild a stream object.
- * The function returns 0 on error, 1 on success. */
-int rewriteStreamObject(rio *r, robj *key, robj *o) {
-    streamIterator si;
-    streamIteratorStart(&si,o->ptr,NULL,NULL,0);
-    streamID id;
-    int64_t numfields;
-
-    while(streamIteratorGetID(&si,&id,&numfields)) {
-        /* Emit a two elements array for each item. The first is
-         * the ID, the second is an array of field-value pairs. */
-
-        /* Emit the XADD <key> <id> ...fields... command. */
-        if (rioWriteBulkCount(r,'*',3+numfields*2) == 0) return 0;
-        if (rioWriteBulkString(r,"XADD",4) == 0) return 0;
-        if (rioWriteBulkObject(r,key) == 0) return 0;
-        sds replyid = sdscatfmt(sdsempty(),"%U.%U",id.ms,id.seq);
-        if (rioWriteBulkString(r,replyid,sdslen(replyid)) == 0) return 0;
-        sdsfree(replyid);
-        while(numfields--) {
-            unsigned char *field, *value;
-            int64_t field_len, value_len;
-            streamIteratorGetField(&si,&field,&value,&field_len,&value_len);
-            if (rioWriteBulkString(r,(char*)field,field_len) == 0) return 0;
-            if (rioWriteBulkString(r,(char*)value,value_len) == 0) return 0;
-        }
-    }
-    streamIteratorStop(&si);
-    return 1;
-}
-
 /* Call the module type callback in order to rewrite a data type
  * that is exported by a module and is not handled by Redis itself.
  * The function returns 0 on error, 1 on success. */
@@ -1219,8 +1111,6 @@ int rewriteAppendOnlyFileRio(rio *aof) {
                 if (rewriteSortedSetObject(aof,&key,o) == 0) goto werr;
             } else if (o->type == OBJ_HASH) {
                 if (rewriteHashObject(aof,&key,o) == 0) goto werr;
-            } else if (o->type == OBJ_STREAM) {
-                if (rewriteStreamObject(aof,&key,o) == 0) goto werr;
             } else if (o->type == OBJ_MODULE) {
                 if (rewriteModuleObject(aof,&key,o) == 0) goto werr;
             } else {
@@ -1395,7 +1285,7 @@ int aofCreatePipes(void) {
 
     if (pipe(fds) == -1) goto error; /* parent -> children data. */
     if (pipe(fds+2) == -1) goto error; /* children -> parent ack. */
-    if (pipe(fds+4) == -1) goto error; /* parent -> children ack. */
+    if (pipe(fds+4) == -1) goto error; /* children -> parent ack. */
     /* Parent -> children data is non blocking. */
     if (anetNonBlock(NULL,fds[0]) != ANET_OK) goto error;
     if (anetNonBlock(NULL,fds[1]) != ANET_OK) goto error;
@@ -1609,10 +1499,10 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
         if (server.aof_fd == -1) {
             /* AOF disabled */
 
-            /* Don't care if this fails: oldfd will be -1 and we handle that.
-             * One notable case of -1 return is if the old file does
-             * not exist. */
-            oldfd = open(server.aof_filename,O_RDONLY|O_NONBLOCK);
+             /* Don't care if this fails: oldfd will be -1 and we handle that.
+              * One notable case of -1 return is if the old file does
+              * not exist. */
+             oldfd = open(server.aof_filename,O_RDONLY|O_NONBLOCK);
         } else {
             /* AOF enabled */
             oldfd = -1; /* We'll set this to the current AOF filedes later. */
@@ -1642,11 +1532,10 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
             /* AOF enabled, replace the old fd with the new one. */
             oldfd = server.aof_fd;
             server.aof_fd = newfd;
-            if (server.aof_fsync == AOF_FSYNC_ALWAYS) {
+            if (server.aof_fsync == AOF_FSYNC_ALWAYS)
                 aof_fsync(newfd);
-            } else if (server.aof_fsync == AOF_FSYNC_EVERYSEC) {
-                aofStartBackgroundFsync();
-            }
+            else if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
+                aof_background_fsync(newfd);
             server.aof_selected_db = -1; /* Make sure SELECT is re-issued */
             aofUpdateCurrentSize();
             server.aof_rewrite_base_size = server.aof_current_size;

src/blocked.c

@@ -65,8 +65,6 @@
 
 #include "server.h"
 
-int serveClientBlockedOnList(client *receiver, robj *key, robj *dstkey, redisDb *db, robj *value, int where);
-
 /* Get a timeout value from an object and store it into 'timeout'.
  * The final timeout is always stored as milliseconds as a time where the
  * timeout will expire, however the parsing is performed according to
@@ -102,8 +100,7 @@ int getTimeoutFromObjectOrReply(client *c, robj *object, mstime_t *timeout, int
 void blockClient(client *c, int btype) {
     c->flags |= CLIENT_BLOCKED;
     c->btype = btype;
-    server.blocked_clients++;
-    server.blocked_clients_by_type[btype]++;
+    server.bpop_blocked_clients++;
 }
 
 /* This function is called in the beforeSleep() function of the event loop
@@ -135,12 +132,10 @@ void processUnblockedClients(void) {
 /* Unblock a client calling the right function depending on the kind
  * of operation the client is blocking for. */
 void unblockClient(client *c) {
-    if (c->btype == BLOCKED_LIST || c->btype == BLOCKED_STREAM) {
+    if (c->btype == BLOCKED_LIST) {
         unblockClientWaitingData(c);
     } else if (c->btype == BLOCKED_WAIT) {
         unblockClientWaitingReplicas(c);
-    } else if (c->btype == BLOCKED_AOF) {
-        unblockClientWaitingReplicas(c);
     } else if (c->btype == BLOCKED_MODULE) {
         unblockClientFromModule(c);
     } else {
@@ -148,10 +143,9 @@ void unblockClient(client *c) {
     }
     /* Clear the flags, and put the client in the unblocked list so that
      * we'll process new commands in its query buffer ASAP. */
-    server.blocked_clients--;
-    server.blocked_clients_by_type[c->btype]--;
     c->flags &= ~CLIENT_BLOCKED;
     c->btype = BLOCKED_NONE;
+    server.bpop_blocked_clients--;
     /* The client may already be into the unblocked list because of a previous
      * blocking operation, don't add back it into the list multiple times. */
     if (!(c->flags & CLIENT_UNBLOCKED)) {
@@ -164,12 +158,10 @@ void unblockClient(client *c) {
  * send it a reply of some kind. After this function is called,
  * unblockClient() will be called with the same client as argument. */
 void replyToBlockedClientTimedOut(client *c) {
-    if (c->btype == BLOCKED_LIST || c->btype == BLOCKED_STREAM) {
+    if (c->btype == BLOCKED_LIST) {
         addReply(c,shared.nullmultibulk);
     } else if (c->btype == BLOCKED_WAIT) {
         addReplyLongLong(c,replicationCountAcksByOffset(c->bpop.reploffset));
-    } else if (c->btype == BLOCKED_AOF) {
-        addReply(c,shared.czero);
     } else if (c->btype == BLOCKED_MODULE) {
         moduleBlockedClientTimedOut(c);
     } else {
@@ -201,283 +193,3 @@ void disconnectAllBlockedClients(void) {
         }
     }
 }
-
-/* This function should be called by Redis every time a single command,
- * a MULTI/EXEC block, or a Lua script, terminated its execution after
- * being called by a client.
- *
- * All the keys with at least one client blocked that received at least
- * one new element via some PUSH/XADD operation are accumulated into
- * the server.ready_keys list. This function will run the list and will
- * serve clients accordingly. Note that the function will iterate again and
- * again as a result of serving BRPOPLPUSH we can have new blocking clients
- * to serve because of the PUSH side of BRPOPLPUSH. */
-void handleClientsBlockedOnKeys(void) {
-    while(listLength(server.ready_keys) != 0) {
-        list *l;
-
-        /* Point server.ready_keys to a fresh list and save the current one
-         * locally. This way as we run the old list we are free to call
-         * signalKeyAsReady() that may push new elements in server.ready_keys
-         * when handling clients blocked into BRPOPLPUSH. */
-        l = server.ready_keys;
-        server.ready_keys = listCreate();
-
-        while(listLength(l) != 0) {
-            listNode *ln = listFirst(l);
-            readyList *rl = ln->value;
-
-            /* First of all remove this key from db->ready_keys so that
-             * we can safely call signalKeyAsReady() against this key. */
-            dictDelete(rl->db->ready_keys,rl->key);
-
-            /* Serve clients blocked on list key. */
-            robj *o = lookupKeyWrite(rl->db,rl->key);
-            if (o != NULL && o->type == OBJ_LIST) {
-                dictEntry *de;
-
-                /* We serve clients in the same order they blocked for
-                 * this key, from the first blocked to the last. */
-                de = dictFind(rl->db->blocking_keys,rl->key);
-                if (de) {
-                    list *clients = dictGetVal(de);
-                    int numclients = listLength(clients);
-
-                    while(numclients--) {
-                        listNode *clientnode = listFirst(clients);
-                        client *receiver = clientnode->value;
-
-                        if (receiver->btype != BLOCKED_LIST) {
-                            /* Put on the tail, so that at the next call
-                             * we'll not run into it again. */
-                            listDelNode(clients,clientnode);
-                            listAddNodeTail(clients,receiver);
-                            continue;
-                        }
-
-                        robj *dstkey = receiver->bpop.target;
-                        int where = (receiver->lastcmd &&
-                                     receiver->lastcmd->proc == blpopCommand) ?
-                                    LIST_HEAD : LIST_TAIL;
-                        robj *value = listTypePop(o,where);
-
-                        if (value) {
-                            /* Protect receiver->bpop.target, that will be
-                             * freed by the next unblockClient()
-                             * call. */
-                            if (dstkey) incrRefCount(dstkey);
-                            unblockClient(receiver);
-
-                            if (serveClientBlockedOnList(receiver,
-                                rl->key,dstkey,rl->db,value,
-                                where) == C_ERR)
-                            {
-                                /* If we failed serving the client we need
-                                 * to also undo the POP operation. */
-                                    listTypePush(o,value,where);
-                            }
-
-                            if (dstkey) decrRefCount(dstkey);
-                            decrRefCount(value);
-                        } else {
-                            break;
-                        }
-                    }
-                }
-
-                if (listTypeLength(o) == 0) {
-                    dbDelete(rl->db,rl->key);
-                }
-                /* We don't call signalModifiedKey() as it was already called
-                 * when an element was pushed on the list. */
-            }
-
-            /* Serve clients blocked on stream key. */
-            else if (o != NULL && o->type == OBJ_STREAM) {
-                dictEntry *de = dictFind(rl->db->blocking_keys,rl->key);
-                stream *s = o->ptr;
-
-                /* We need to provide the new data arrived on the stream
-                 * to all the clients that are waiting for an offset smaller
-                 * than the current top item. */
-                if (de) {
-                    list *clients = dictGetVal(de);
-                    listNode *ln;
-                    listIter li;
-                    listRewind(clients,&li);
-
-                    while((ln = listNext(&li))) {
-                        client *receiver = listNodeValue(ln);
-                        if (receiver->btype != BLOCKED_STREAM) continue;
-                        streamID *gt = dictFetchValue(receiver->bpop.keys,
-                                                      rl->key);
-                        if (s->last_id.ms > gt->ms ||
-                            (s->last_id.ms == gt->ms &&
-                             s->last_id.seq > gt->seq))
-                        {
-                            streamID start = *gt;
-                            start.seq++; /* Can't overflow, it's an uint64_t */
-                            /* Note that after we unblock the client, 'gt'
-                             * is no longer valid, so we must do it after
-                             * we copied the ID into the 'start' variable. */
-                            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
-                             * array, since we have just one key. */
-                            addReplyMultiBulkLen(receiver,1);
-                            addReplyMultiBulkLen(receiver,2);
-                            addReplyBulk(receiver,rl->key);
-                            streamReplyWithRange(receiver,s,&start,NULL,
-                                                 receiver->bpop.xread_count,0);
-                        }
-                    }
-                }
-            }
-
-            /* Free this item. */
-            decrRefCount(rl->key);
-            zfree(rl);
-            listDelNode(l,ln);
-        }
-        listRelease(l); /* We have the new list on place at this point. */
-    }
-}
-
-/* This is how the current blocking lists/streams work, we use BLPOP as
- * example, but the concept is the same for other list ops and XREAD.
- * - If the user calls BLPOP and the key exists and contains a non empty list
- *   then LPOP is called instead. So BLPOP is semantically the same as LPOP
- *   if blocking is not required.
- * - If instead BLPOP is called and the key does not exists or the list is
- *   empty we need to block. In order to do so we remove the notification for
- *   new data to read in the client socket (so that we'll not serve new
- *   requests if the blocking request is not served). Also we put the client
- *   in a dictionary (db->blocking_keys) mapping keys to a list of clients
- *   blocking for this keys.
- * - If a PUSH operation against a key with blocked clients waiting is
- *   performed, we mark this key as "ready", and after the current command,
- *   MULTI/EXEC block, or script, is executed, we serve all the clients waiting
- *   for this list, from the one that blocked first, to the last, accordingly
- *   to the number of elements we have in the ready list.
- */
-
-/* Set a client in blocking mode for the specified key (list or stream), with
- * the specified timeout. The 'type' argument is BLOCKED_LIST or BLOCKED_STREAM
- * depending on the kind of operation we are waiting for an empty key in
- * order to awake the client. The client is blocked for all the 'numkeys'
- * keys as in the 'keys' argument. When we block for stream keys, we also
- * provide an array of streamID structures: clients will be unblocked only
- * when items with an ID greater or equal to the specified one is appended
- * to the stream. */
-void blockForKeys(client *c, int btype, robj **keys, int numkeys, mstime_t timeout, robj *target, streamID *ids) {
-    dictEntry *de;
-    list *l;
-    int j;
-
-    c->bpop.timeout = timeout;
-    c->bpop.target = target;
-
-    if (target != NULL) incrRefCount(target);
-
-    for (j = 0; j < numkeys; j++) {
-        /* The value associated with the key name in the bpop.keys dictionary
-         * is NULL for lists, or the stream ID for streams. */
-        void *key_data = NULL;
-        if (btype == BLOCKED_STREAM) {
-            key_data = zmalloc(sizeof(streamID));
-            memcpy(key_data,ids+j,sizeof(streamID));
-        }
-
-        /* If the key already exists in the dictionary ignore it. */
-        if (dictAdd(c->bpop.keys,keys[j],key_data) != DICT_OK) {
-            zfree(key_data);
-            continue;
-        }
-        incrRefCount(keys[j]);
-
-        /* And in the other "side", to map keys -> clients */
-        de = dictFind(c->db->blocking_keys,keys[j]);
-        if (de == NULL) {
-            int retval;
-
-            /* For every key we take a list of clients blocked for it */
-            l = listCreate();
-            retval = dictAdd(c->db->blocking_keys,keys[j],l);
-            incrRefCount(keys[j]);
-            serverAssertWithInfo(c,keys[j],retval == DICT_OK);
-        } else {
-            l = dictGetVal(de);
-        }
-        listAddNodeTail(l,c);
-    }
-    blockClient(c,btype);
-}
-
-/* Unblock a client that's waiting in a blocking operation such as BLPOP.
- * You should never call this function directly, but unblockClient() instead. */
-void unblockClientWaitingData(client *c) {
-    dictEntry *de;
-    dictIterator *di;
-    list *l;
-
-    serverAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0);
-    di = dictGetIterator(c->bpop.keys);
-    /* The client may wait for multiple keys, so unblock it for every key. */
-    while((de = dictNext(di)) != NULL) {
-        robj *key = dictGetKey(de);
-
-        /* Remove this client from the list of clients waiting for this key. */
-        l = dictFetchValue(c->db->blocking_keys,key);
-        serverAssertWithInfo(c,key,l != NULL);
-        listDelNode(l,listSearchKey(l,c));
-        /* If the list is empty we need to remove it to avoid wasting memory */
-        if (listLength(l) == 0)
-            dictDelete(c->db->blocking_keys,key);
-    }
-    dictReleaseIterator(di);
-
-    /* Cleanup the client structure */
-    dictEmpty(c->bpop.keys,NULL);
-    if (c->bpop.target) {
-        decrRefCount(c->bpop.target);
-        c->bpop.target = NULL;
-    }
-    if (c->bpop.xread_group) {
-        decrRefCount(c->bpop.xread_group);
-        c->bpop.xread_group = NULL;
-    }
-}
-
-/* If the specified key has clients blocked waiting for list pushes, this
- * function will put the key reference into the server.ready_keys list.
- * Note that db->ready_keys is a hash table that allows us to avoid putting
- * the same key again and again in the list in case of multiple pushes
- * made by a script or in the context of MULTI/EXEC.
- *
- * The list will be finally processed by handleClientsBlockedOnLists() */
-void signalKeyAsReady(redisDb *db, robj *key) {
-    readyList *rl;
-
-    /* No clients blocking for this key? No need to queue it. */
-    if (dictFind(db->blocking_keys,key) == NULL) return;
-
-    /* Key was already signaled? No need to queue it again. */
-    if (dictFind(db->ready_keys,key) != NULL) return;
-
-    /* Ok, we need to queue this key into server.ready_keys. */
-    rl = zmalloc(sizeof(*rl));
-    rl->key = key;
-    rl->db = db;
-    incrRefCount(key);
-    listAddNodeTail(server.ready_keys,rl);
-
-    /* We also add the key in the db->ready_keys dictionary in order
-     * to avoid adding it multiple times into a list with a simple O(1)
-     * check. */
-    incrRefCount(key);
-    serverAssert(dictAdd(db->ready_keys,key,NULL) == DICT_OK);
-}
-
-

src/cluster.c

@@ -653,7 +653,7 @@ unsigned int keyHashSlot(char *key, int keylen) {
     for (e = s+1; e < keylen; e++)
         if (key[e] == '}') break;
 
-    /* No '}' or nothing between {} ? Hash the whole key. */
+    /* No '}' or nothing betweeen {} ? Hash the whole key. */
     if (e == keylen || e == s+1) return crc16(key,keylen) & 0x3FFF;
 
     /* If we are here there is both a { and a } on its right. Hash
@@ -2156,7 +2156,7 @@ void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
  * from event handlers that will do stuff with the same link later. */
 void clusterSendMessage(clusterLink *link, unsigned char *msg, size_t msglen) {
     if (sdslen(link->sndbuf) == 0 && msglen != 0)
-        aeCreateFileEvent(server.el,link->fd,AE_WRITABLE|AE_BARRIER,
+        aeCreateFileEvent(server.el,link->fd,AE_WRITABLE,
                     clusterWriteHandler,link);
 
     link->sndbuf = sdscatlen(link->sndbuf, msg, msglen);
@@ -2691,10 +2691,9 @@ void clusterSendFailoverAuthIfNeeded(clusterNode *node, clusterMsg *request) {
     }
 
     /* We can vote for this slave. */
+    clusterSendFailoverAuth(node);
     server.cluster->lastVoteEpoch = server.cluster->currentEpoch;
     node->slaveof->voted_time = mstime();
-    clusterDoBeforeSleep(CLUSTER_TODO_SAVE_CONFIG|CLUSTER_TODO_FSYNC_CONFIG);
-    clusterSendFailoverAuth(node);
     serverLog(LL_WARNING, "Failover auth granted to %.40s for epoch %llu",
         node->name, (unsigned long long) server.cluster->currentEpoch);
 }
@@ -4066,34 +4065,7 @@ void clusterCommand(client *c) {
         return;
     }
 
-    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:",
-"    <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:",
-"    start, end, master and replicas IP addresses, ports and ids",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (!strcasecmp(c->argv[1]->ptr,"meet") && (c->argc == 4 || c->argc == 5)) {
+    if (!strcasecmp(c->argv[1]->ptr,"meet") && (c->argc == 4 || c->argc == 5)) {
         /* CLUSTER MEET <ip> <port> [cport] */
         long long port, cport;
 
@@ -4286,7 +4258,7 @@ NULL
             clusterAddSlot(n,slot);
         } else {
             addReplyError(c,
-                "Invalid CLUSTER SETSLOT action or number of arguments. Try CLUSTER HELP");
+                "Invalid CLUSTER SETSLOT action or number of arguments");
             return;
         }
         clusterDoBeforeSleep(CLUSTER_TODO_SAVE_CONFIG|CLUSTER_TODO_UPDATE_STATE);
@@ -4636,9 +4608,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);
-        return;
+        addReplyError(c,"Wrong CLUSTER subcommand or number of arguments");
     }
 }
 
@@ -4897,16 +4867,14 @@ void migrateCloseTimedoutSockets(void) {
     dictReleaseIterator(di);
 }
 
-/* MIGRATE host port key dbid timeout [COPY | REPLACE | AUTH password]
+/* MIGRATE host port key dbid timeout [COPY | REPLACE]
  *
  * On in the multiple keys form:
  *
- * MIGRATE host port "" dbid timeout [COPY | REPLACE | AUTH password] KEYS key1
- * key2 ... keyN */
+ * MIGRATE host port "" dbid timeout [COPY | REPLACE] KEYS key1 key2 ... keyN */
 void migrateCommand(client *c) {
     migrateCachedSocket *cs;
-    int copy = 0, replace = 0, j;
-    char *password = NULL;
+    int copy, replace, j;
     long timeout;
     long dbid;
     robj **ov = NULL; /* Objects to migrate. */
@@ -4921,20 +4889,16 @@ void migrateCommand(client *c) {
     int first_key = 3; /* Argument index of the first key. */
     int num_keys = 1;  /* By default only migrate the 'key' argument. */
 
+    /* Initialization */
+    copy = 0;
+    replace = 0;
+
     /* Parse additional options */
     for (j = 6; j < c->argc; j++) {
-        int moreargs = j < c->argc-1;
         if (!strcasecmp(c->argv[j]->ptr,"copy")) {
             copy = 1;
         } else if (!strcasecmp(c->argv[j]->ptr,"replace")) {
             replace = 1;
-        } else if (!strcasecmp(c->argv[j]->ptr,"auth")) {
-            if (!moreargs) {
-                addReply(c,shared.syntaxerr);
-                return;
-            }
-            j++;
-            password = c->argv[j]->ptr;
         } else if (!strcasecmp(c->argv[j]->ptr,"keys")) {
             if (sdslen(c->argv[3]->ptr) != 0) {
                 addReplyError(c,
@@ -4993,14 +4957,6 @@ try_again:
 
     rioInitWithBuffer(&cmd,sdsempty());
 
-    /* Authentication */
-    if (password) {
-        serverAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',2));
-        serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"AUTH",4));
-        serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,password,
-            sdslen(password)));
-    }
-
     /* Send the SELECT command if the current DB is not already selected. */
     int select = cs->last_dbid != dbid; /* Should we emit SELECT? */
     if (select) {
@@ -5018,9 +4974,7 @@ try_again:
             ttl = expireat-mstime();
             if (ttl < 1) ttl = 1;
         }
-        serverAssertWithInfo(c,NULL,
-            rioWriteBulkCount(&cmd,'*',replace ? 5 : 4));
-
+        serverAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',replace ? 5 : 4));
         if (server.cluster_enabled)
             serverAssertWithInfo(c,NULL,
                 rioWriteBulkString(&cmd,"RESTORE-ASKING",14));
@@ -5063,14 +5017,9 @@ try_again:
         }
     }
 
-    char buf0[1024]; /* Auth reply. */
     char buf1[1024]; /* Select reply. */
     char buf2[1024]; /* Restore reply. */
 
-    /* Read the AUTH reply if needed. */
-    if (password && syncReadLine(cs->fd, buf0, sizeof(buf0), timeout) <= 0)
-        goto socket_err;
-
     /* Read the SELECT reply if needed. */
     if (select && syncReadLine(cs->fd, buf1, sizeof(buf1), timeout) <= 0)
         goto socket_err;
@@ -5087,21 +5036,13 @@ try_again:
             socket_error = 1;
             break;
         }
-        if ((password && buf0[0] == '-') ||
-            (select && buf1[0] == '-') ||
-            buf2[0] == '-')
-        {
+        if ((select && buf1[0] == '-') || buf2[0] == '-') {
             /* On error assume that last_dbid is no longer valid. */
             if (!error_from_target) {
                 cs->last_dbid = -1;
-                char *errbuf;
-                if (password && buf0[0] == '-') errbuf = buf0;
-                else if (select && buf1[0] == '-') errbuf = buf1;
-                else errbuf = buf2;
-
-                error_from_target = 1;
                 addReplyErrorFormat(c,"Target instance replied with error: %s",
-                    errbuf+1);
+                    (select && buf1[0] == '-') ? buf1+1 : buf2+1);
+                error_from_target = 1;
             }
         } else {
             if (!copy) {
@@ -5166,7 +5107,7 @@ try_again:
         addReply(c,shared.ok);
     } else {
         /* On error we already sent it in the for loop above, and set
-         * the currently selected socket to -1 to force SELECT the next time. */
+         * the curretly selected socket to -1 to force SELECT the next time. */
     }
 
     sdsfree(cmd.io.buffer.ptr);
@@ -5422,8 +5363,7 @@ clusterNode *getNodeByQuery(client *c, struct redisCommand *cmd, robj **argv, in
      * node is a slave and the request is about an hash slot our master
      * is serving, we can reply without redirection. */
     if (c->flags & CLIENT_READONLY &&
-        (cmd->flags & CMD_READONLY || cmd->proc == evalCommand ||
-         cmd->proc == evalShaCommand) &&
+        cmd->flags & CMD_READONLY &&
         nodeIsSlave(myself) &&
         myself->slaveof == n)
     {

src/config.c

@@ -328,19 +328,15 @@ void loadServerConfigFromString(char *config) {
                 err = "maxmemory-samples must be 1 or greater";
                 goto loaderr;
             }
-        } else if ((!strcasecmp(argv[0],"proto-max-bulk-len")) && argc == 2) {
-            server.proto_max_bulk_len = memtoll(argv[1],NULL);
-        } else if ((!strcasecmp(argv[0],"client-query-buffer-limit")) && argc == 2) {
-            server.client_max_querybuf_len = memtoll(argv[1],NULL);
         } else if (!strcasecmp(argv[0],"lfu-log-factor") && argc == 2) {
             server.lfu_log_factor = atoi(argv[1]);
-            if (server.lfu_log_factor < 0) {
+            if (server.maxmemory_samples < 0) {
                 err = "lfu-log-factor must be 0 or greater";
                 goto loaderr;
             }
         } else if (!strcasecmp(argv[0],"lfu-decay-time") && argc == 2) {
             server.lfu_decay_time = atoi(argv[1]);
-            if (server.lfu_decay_time < 0) {
+            if (server.maxmemory_samples < 1) {
                 err = "lfu-decay-time must be 0 or greater";
                 goto loaderr;
             }
@@ -1136,10 +1132,6 @@ void configSetCommand(client *c) {
             }
             freeMemoryIfNeeded();
         }
-    } config_set_memory_field(
-      "proto-max-bulk-len",server.proto_max_bulk_len) {
-    } config_set_memory_field(
-      "client-query-buffer-limit",server.client_max_querybuf_len) {
     } config_set_memory_field("repl-backlog-size",ll) {
         resizeReplicationBacklog(ll);
     } config_set_memory_field("auto-aof-rewrite-min-size",ll) {
@@ -1228,11 +1220,7 @@ void configGetCommand(client *c) {
 
     /* Numerical values */
     config_get_numerical_field("maxmemory",server.maxmemory);
-    config_get_numerical_field("proto-max-bulk-len",server.proto_max_bulk_len);
-    config_get_numerical_field("client-query-buffer-limit",server.client_max_querybuf_len);
     config_get_numerical_field("maxmemory-samples",server.maxmemory_samples);
-    config_get_numerical_field("lfu-log-factor",server.lfu_log_factor);
-    config_get_numerical_field("lfu-decay-time",server.lfu_decay_time);
     config_get_numerical_field("timeout",server.maxidletime);
     config_get_numerical_field("active-defrag-threshold-lower",server.active_defrag_threshold_lower);
     config_get_numerical_field("active-defrag-threshold-upper",server.active_defrag_threshold_upper);
@@ -2002,12 +1990,8 @@ int rewriteConfig(char *path) {
     rewriteConfigStringOption(state,"requirepass",server.requirepass,NULL);
     rewriteConfigNumericalOption(state,"maxclients",server.maxclients,CONFIG_DEFAULT_MAX_CLIENTS);
     rewriteConfigBytesOption(state,"maxmemory",server.maxmemory,CONFIG_DEFAULT_MAXMEMORY);
-    rewriteConfigBytesOption(state,"proto-max-bulk-len",server.proto_max_bulk_len,CONFIG_DEFAULT_PROTO_MAX_BULK_LEN);
-    rewriteConfigBytesOption(state,"client-query-buffer-limit",server.client_max_querybuf_len,PROTO_MAX_QUERYBUF_LEN);
     rewriteConfigEnumOption(state,"maxmemory-policy",server.maxmemory_policy,maxmemory_policy_enum,CONFIG_DEFAULT_MAXMEMORY_POLICY);
     rewriteConfigNumericalOption(state,"maxmemory-samples",server.maxmemory_samples,CONFIG_DEFAULT_MAXMEMORY_SAMPLES);
-    rewriteConfigNumericalOption(state,"lfu-log-factor",server.lfu_log_factor,CONFIG_DEFAULT_LFU_LOG_FACTOR);
-    rewriteConfigNumericalOption(state,"lfu-decay-time",server.lfu_decay_time,CONFIG_DEFAULT_LFU_DECAY_TIME);
     rewriteConfigNumericalOption(state,"active-defrag-threshold-lower",server.active_defrag_threshold_lower,CONFIG_DEFAULT_DEFRAG_THRESHOLD_LOWER);
     rewriteConfigNumericalOption(state,"active-defrag-threshold-upper",server.active_defrag_threshold_upper,CONFIG_DEFAULT_DEFRAG_THRESHOLD_UPPER);
     rewriteConfigBytesOption(state,"active-defrag-ignore-bytes",server.active_defrag_ignore_bytes,CONFIG_DEFAULT_DEFRAG_IGNORE_BYTES);
@@ -2081,24 +2065,19 @@ void configCommand(client *c) {
         return;
     }
 
-    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.",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (!strcasecmp(c->argv[1]->ptr,"set") && c->argc == 4) {
+    if (!strcasecmp(c->argv[1]->ptr,"set")) {
+        if (c->argc != 4) goto badarity;
         configSetCommand(c);
-    } else if (!strcasecmp(c->argv[1]->ptr,"get") && c->argc == 3) {
+    } else if (!strcasecmp(c->argv[1]->ptr,"get")) {
+        if (c->argc != 3) goto badarity;
         configGetCommand(c);
-    } else if (!strcasecmp(c->argv[1]->ptr,"resetstat") && c->argc == 2) {
+    } else if (!strcasecmp(c->argv[1]->ptr,"resetstat")) {
+        if (c->argc != 2) goto badarity;
         resetServerStats();
         resetCommandTableStats();
         addReply(c,shared.ok);
-    } else if (!strcasecmp(c->argv[1]->ptr,"rewrite") && c->argc == 2) {
+    } else if (!strcasecmp(c->argv[1]->ptr,"rewrite")) {
+        if (c->argc != 2) goto badarity;
         if (server.configfile == NULL) {
             addReplyError(c,"The server is running without a config file");
             return;
@@ -2111,8 +2090,12 @@ 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);
-        return;
+        addReplyError(c,
+            "CONFIG subcommand must be one of GET, SET, RESETSTAT, REWRITE");
     }
+    return;
+
+badarity:
+    addReplyErrorFormat(c,"Wrong number of arguments for CONFIG %s",
+        (char*) c->argv[1]->ptr);
 }

src/db.c

@@ -38,15 +38,6 @@
  * C-level DB API
  *----------------------------------------------------------------------------*/
 
-/* Update LFU when an object is accessed.
- * Firstly, decrement the counter if the decrement time is reached.
- * Then logarithmically increment the counter, and update the access time. */
-void updateLFU(robj *val) {
-    unsigned long counter = LFUDecrAndReturn(val);
-    counter = LFULogIncr(counter);
-    val->lru = (LFUGetTimeInMinutes()<<8) | counter;
-}
-
 /* Low level key lookup API, not actually called directly from commands
  * implementations that should instead rely on lookupKeyRead(),
  * lookupKeyWrite() and lookupKeyReadWithFlags(). */
@@ -63,7 +54,9 @@ robj *lookupKey(redisDb *db, robj *key, int flags) {
             !(flags & LOOKUP_NOTOUCH))
         {
             if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
-                updateLFU(val);
+                unsigned long ldt = val->lru >> 8;
+                unsigned long counter = LFULogIncr(val->lru & 255);
+                val->lru = (ldt << 8) | counter;
             } else {
                 val->lru = LRU_CLOCK();
             }
@@ -169,9 +162,9 @@ void dbAdd(redisDb *db, robj *key, robj *val) {
     int retval = dictAdd(db->dict, copy, val);
 
     serverAssertWithInfo(NULL,key,retval == DICT_OK);
-    if (val->type == OBJ_LIST) signalKeyAsReady(db, key);
+    if (val->type == OBJ_LIST) signalListAsReady(db, key);
     if (server.cluster_enabled) slotToKeyAdd(key);
-}
+ }
 
 /* Overwrite an existing key with a new value. Incrementing the reference
  * count of the new value is up to the caller.
@@ -187,9 +180,6 @@ void dbOverwrite(redisDb *db, robj *key, robj *val) {
         int saved_lru = old->lru;
         dictReplace(db->dict, key->ptr, val);
         val->lru = saved_lru;
-        /* LFU should be not only copied but also updated
-         * when a key is overwritten. */
-        updateLFU(val);
     } else {
         dictReplace(db->dict, key->ptr, val);
     }
@@ -798,7 +788,6 @@ void typeCommand(client *c) {
         case OBJ_SET: type = "set"; break;
         case OBJ_ZSET: type = "zset"; break;
         case OBJ_HASH: type = "hash"; break;
-        case OBJ_STREAM: type = "stream"; break;
         case OBJ_MODULE: {
             moduleValue *mv = o->ptr;
             type = mv->type->name;
@@ -952,8 +941,8 @@ void scanDatabaseForReadyLists(redisDb *db) {
     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))
-            signalKeyAsReady(db, key);
+        if (value && value->type == OBJ_LIST)
+            signalListAsReady(db, key);
     }
     dictReleaseIterator(di);
 }
@@ -1095,25 +1084,6 @@ void propagateExpire(redisDb *db, robj *key, int lazy) {
     decrRefCount(argv[1]);
 }
 
-/* This function is called when we are going to perform some operation
- * in a given key, but such key may be already logically expired even if
- * it still exists in the database. The main way this function is called
- * is via lookupKey*() family of functions.
- *
- * The behavior of the function depends on the replication role of the
- * instance, because slave instances do not expire keys, they wait
- * for DELs from the master for consistency matters. However even
- * slaves will try to have a coherent return value for the function,
- * so that read commands executed in the slave side will be able to
- * behave like if the key is expired even if still present (because the
- * master has yet to propagate the DEL).
- *
- * In masters as a side effect of finding a key which is expired, such
- * key will be evicted from the database. Also this may trigger the
- * propagation of a DEL/UNLINK command in AOF / replication stream.
- *
- * The return value of the function is 0 if the key is still valid,
- * otherwise the function returns 1 if the key is expired. */
 int expireIfNeeded(redisDb *db, robj *key) {
     mstime_t when = getExpire(db,key);
     mstime_t now;
@@ -1123,7 +1093,7 @@ int expireIfNeeded(redisDb *db, robj *key) {
     /* Don't expire anything while loading. It will be done later. */
     if (server.loading) return 0;
 
-    /* If we are in the context of a Lua script, we pretend that time is
+    /* If we are in the context of a Lua script, we claim that time is
      * blocked to when the Lua script started. This way a key can expire
      * only the first time it is accessed and not in the middle of the
      * script execution, making propagation to slaves / AOF consistent.
@@ -1171,13 +1141,11 @@ int *getKeysUsingCommandTable(struct redisCommand *cmd,robj **argv, int argc, in
     keys = zmalloc(sizeof(int)*((last - cmd->firstkey)+1));
     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
-             * 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
-             * an arity or syntax error. */
-            if (cmd->flags & CMD_MODULE || cmd->arity < 0) {
+            /* Modules command 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 module command to report an arity error. */
+            if (cmd->flags & CMD_MODULE) {
                 zfree(keys);
                 *numkeys = 0;
                 return NULL;
@@ -1384,36 +1352,6 @@ int *georadiusGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numk
     return keys;
 }
 
-/* XREAD [BLOCK <milliseconds>] [COUNT <count>] [GROUP <groupname> <ttl>]
- *       [RETRY <milliseconds> <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;
-    UNUSED(cmd);
-
-    /* We need to seek the last argument that contains "STREAMS", because other
-     * arguments before may contain it (for example the group name). */
-    int streams_pos = -1;
-    for (i = 1; i < argc; i++) {
-        char *arg = argv[i]->ptr;
-        if (!strcasecmp(arg, "streams")) streams_pos = i;
-    }
-    if (streams_pos != -1) num = argc - streams_pos - 1;
-
-    /* Syntax error. */
-    if (streams_pos == -1 || num % 2 != 0) {
-        *numkeys = 0;
-        return NULL;
-    }
-    num /= 2; /* We have half the keys as there are arguments because
-                 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;
-    *numkeys = num;
-    return keys;
-}
-
 /* Slot to Key API. This is used by Redis Cluster in order to obtain in
  * a fast way a key that belongs to a specified hash slot. This is useful
  * while rehashing the cluster and in other conditions when we need to

src/debug.c

@@ -239,27 +239,6 @@ void computeDatasetDigest(unsigned char *final) {
                     xorDigest(digest,eledigest,20);
                 }
                 hashTypeReleaseIterator(hi);
-            } else if (o->type == OBJ_STREAM) {
-                streamIterator si;
-                streamIteratorStart(&si,o->ptr,NULL,NULL,0);
-                streamID id;
-                int64_t numfields;
-
-                while(streamIteratorGetID(&si,&id,&numfields)) {
-                    sds itemid = sdscatfmt(sdsempty(),"%U.%U",id.ms,id.seq);
-                    mixDigest(digest,itemid,sdslen(itemid));
-                    sdsfree(itemid);
-
-                    while(numfields--) {
-                        unsigned char *field, *value;
-                        int64_t field_len, value_len;
-                        streamIteratorGetField(&si,&field,&value,
-                                                   &field_len,&value_len);
-                        mixDigest(digest,field,field_len);
-                        mixDigest(digest,value,value_len);
-                    }
-                }
-                streamIteratorStop(&si);
             } else if (o->type == OBJ_MODULE) {
                 RedisModuleDigest md;
                 moduleValue *mv = o->ptr;
@@ -283,30 +262,53 @@ 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-recovery <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.",
-NULL
-        };
-        addReplyHelp(c, help);
+    if (c->argc == 1) {
+        addReplyError(c,"You must specify a subcommand for DEBUG. Try DEBUG HELP for info.");
+        return;
+    }
+
+    if (!strcasecmp(c->argv[1]->ptr,"help")) {
+        void *blenp = addDeferredMultiBulkLength(c);
+        int blen = 0;
+        blen++; addReplyStatus(c,
+        "DEBUG <subcommand> arg arg ... arg. Subcommands:");
+        blen++; addReplyStatus(c,
+        "segfault -- Crash the server with sigsegv.");
+        blen++; addReplyStatus(c,
+        "panic -- Crash the server simulating a panic.");
+        blen++; addReplyStatus(c,
+        "restart  -- Graceful restart: save config, db, restart.");
+        blen++; addReplyStatus(c,
+        "crash-and-recovery <milliseconds> -- Hard crash and restart after <milliseconds> delay.");
+        blen++; addReplyStatus(c,
+        "assert   -- Crash by assertion failed.");
+        blen++; addReplyStatus(c,
+        "reload   -- Save the RDB on disk and reload it back in memory.");
+        blen++; addReplyStatus(c,
+        "loadaof  -- Flush the AOF buffers on disk and reload the AOF in memory.");
+        blen++; addReplyStatus(c,
+        "object <key> -- Show low level info about key and associated value.");
+        blen++; addReplyStatus(c,
+        "sdslen <key> -- Show low level SDS string info representing key and value.");
+        blen++; addReplyStatus(c,
+        "ziplist <key> -- Show low level info about the ziplist encoding.");
+        blen++; addReplyStatus(c,
+        "populate <count> [prefix] [size] -- Create <count> string keys named key:<num>. If a prefix is specified is used instead of the 'key' prefix.");
+        blen++; addReplyStatus(c,
+        "digest   -- Outputs an hex signature representing the current DB content.");
+        blen++; addReplyStatus(c,
+        "sleep <seconds> -- Stop the server for <seconds>. Decimals allowed.");
+        blen++; addReplyStatus(c,
+        "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.");
+        blen++; addReplyStatus(c,
+        "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.");
+        blen++; addReplyStatus(c,
+        "error <string> -- Return a Redis protocol error with <string> as message. Useful for clients unit tests to simulate Redis errors.");
+        blen++; addReplyStatus(c,
+        "structsize -- Return the size of different Redis core C structures.");
+        blen++; addReplyStatus(c,
+        "htstats <dbid> -- Return hash table statistics of the specified Redis database.");
+        setDeferredMultiBulkLength(c,blenp,blen);
     } else if (!strcasecmp(c->argv[1]->ptr,"segfault")) {
         *((char*)-1) = 'x';
     } else if (!strcasecmp(c->argv[1]->ptr,"panic")) {
@@ -368,13 +370,13 @@ NULL
         val = dictGetVal(de);
         strenc = strEncoding(val->encoding);
 
-        char extra[138] = {0};
+        char extra[128] = {0};
         if (val->encoding == OBJ_ENCODING_QUICKLIST) {
             char *nextra = extra;
             int remaining = sizeof(extra);
             quicklist *ql = val->ptr;
             /* Add number of quicklist nodes */
-            int used = snprintf(nextra, remaining, " ql_nodes:%lu", ql->len);
+            int used = snprintf(nextra, remaining, " ql_nodes:%u", ql->len);
             nextra += used;
             remaining -= used;
             /* Add average quicklist fill factor */
@@ -547,15 +549,9 @@ NULL
         stats = sdscat(stats,buf);
 
         addReplyBulkSds(c,stats);
-    } 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();
-        clearReplicationId2();
-        addReply(c,shared.ok);
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try DEBUG HELP",
+        addReplyErrorFormat(c, "Unknown DEBUG subcommand or wrong number of arguments for '%s'",
             (char*)c->argv[1]->ptr);
-        return;
     }
 }
 
@@ -1027,7 +1023,7 @@ void sigsegvHandler(int sig, siginfo_t *info, void *secret) {
         "Redis %s crashed by signal: %d", REDIS_VERSION, sig);
     if (eip != NULL) {
         serverLog(LL_WARNING,
-        "Crashed running the instruction at: %p", eip);
+        "Crashed running the instuction at: %p", eip);
     }
     if (sig == SIGSEGV || sig == SIGBUS) {
         serverLog(LL_WARNING,

src/defrag.c

@@ -289,7 +289,7 @@ int defragKey(redisDb *db, dictEntry *de) {
          /* Dirty code:
           * I can't search in db->expires for that key after i already released
           * the pointer it holds it won't be able to do the string compare */
-        uint64_t hash = dictGetHash(db->dict, de->key);
+        unsigned int hash = dictGetHash(db->dict, de->key);
         replaceSateliteDictKeyPtrAndOrDefragDictEntry(db->expires, keysds, newsds, hash, &defragged);
     }
 

src/dict.c

@@ -66,7 +66,7 @@ static unsigned int dict_force_resize_ratio = 5;
 
 static int _dictExpandIfNeeded(dict *ht);
 static unsigned long _dictNextPower(unsigned long size);
-static long _dictKeyIndex(dict *ht, const void *key, uint64_t hash, dictEntry **existing);
+static int _dictKeyIndex(dict *ht, const void *key, unsigned int hash, dictEntry **existing);
 static int _dictInit(dict *ht, dictType *type, void *privDataPtr);
 
 /* -------------------------- hash functions -------------------------------- */
@@ -202,7 +202,7 @@ int dictRehash(dict *d, int n) {
         de = d->ht[0].table[d->rehashidx];
         /* Move all the keys in this bucket from the old to the new hash HT */
         while(de) {
-            uint64_t h;
+            unsigned int h;
 
             nextde = de->next;
             /* Get the index in the new hash table */
@@ -291,7 +291,7 @@ int dictAdd(dict *d, void *key, void *val)
  */
 dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
 {
-    long index;
+    int index;
     dictEntry *entry;
     dictht *ht;
 
@@ -362,7 +362,7 @@ dictEntry *dictAddOrFind(dict *d, void *key) {
  * dictDelete() and dictUnlink(), please check the top comment
  * of those functions. */
 static dictEntry *dictGenericDelete(dict *d, const void *key, int nofree) {
-    uint64_t h, idx;
+    unsigned int h, idx;
     dictEntry *he, *prevHe;
     int table;
 
@@ -476,7 +476,7 @@ void dictRelease(dict *d)
 dictEntry *dictFind(dict *d, const void *key)
 {
     dictEntry *he;
-    uint64_t h, idx, table;
+    unsigned int h, idx, table;
 
     if (d->ht[0].used + d->ht[1].used == 0) return NULL; /* dict is empty */
     if (dictIsRehashing(d)) _dictRehashStep(d);
@@ -610,7 +610,7 @@ void dictReleaseIterator(dictIterator *iter)
 dictEntry *dictGetRandomKey(dict *d)
 {
     dictEntry *he, *orighe;
-    unsigned long h;
+    unsigned int h;
     int listlen, listele;
 
     if (dictSize(d) == 0) return NULL;
@@ -955,9 +955,9 @@ static unsigned long _dictNextPower(unsigned long size)
  *
  * Note that if we are in the process of rehashing the hash table, the
  * index is always returned in the context of the second (new) hash table. */
-static long _dictKeyIndex(dict *d, const void *key, uint64_t hash, dictEntry **existing)
+static int _dictKeyIndex(dict *d, const void *key, unsigned int hash, dictEntry **existing)
 {
-    unsigned long idx, table;
+    unsigned int idx, table;
     dictEntry *he;
     if (existing) *existing = NULL;
 
@@ -995,7 +995,7 @@ void dictDisableResize(void) {
     dict_can_resize = 0;
 }
 
-uint64_t dictGetHash(dict *d, const void *key) {
+unsigned int dictGetHash(dict *d, const void *key) {
     return dictHashKey(d, key);
 }
 
@@ -1004,9 +1004,9 @@ uint64_t dictGetHash(dict *d, const void *key) {
  * the hash value should be provided using dictGetHash.
  * no string / key comparison is performed.
  * return value is the reference to the dictEntry if found, or NULL if not found. */
-dictEntry **dictFindEntryRefByPtrAndHash(dict *d, const void *oldptr, uint64_t hash) {
+dictEntry **dictFindEntryRefByPtrAndHash(dict *d, const void *oldptr, unsigned int hash) {
     dictEntry *he, **heref;
-    unsigned long idx, table;
+    unsigned int idx, table;
 
     if (d->ht[0].used + d->ht[1].used == 0) return NULL; /* dict is empty */
     for (table = 0; table <= 1; table++) {

src/dict.h

@@ -178,8 +178,8 @@ int dictRehashMilliseconds(dict *d, int ms);
 void dictSetHashFunctionSeed(uint8_t *seed);
 uint8_t *dictGetHashFunctionSeed(void);
 unsigned long dictScan(dict *d, unsigned long v, dictScanFunction *fn, dictScanBucketFunction *bucketfn, void *privdata);
-uint64_t dictGetHash(dict *d, const void *key);
-dictEntry **dictFindEntryRefByPtrAndHash(dict *d, const void *oldptr, uint64_t hash);
+unsigned int dictGetHash(dict *d, const void *key);
+dictEntry **dictFindEntryRefByPtrAndHash(dict *d, const void *oldptr, unsigned int hash);
 
 /* Hash table types */
 extern dictType dictTypeHeapStringCopyKey;

src/evict.c

@@ -60,6 +60,8 @@ struct evictionPoolEntry {
 
 static struct evictionPoolEntry *EvictionPoolLRU;
 
+unsigned long LFUDecrAndReturn(robj *o);
+
 /* ----------------------------------------------------------------------------
  * Implementation of eviction, aging and LRU
  * --------------------------------------------------------------------------*/
@@ -300,8 +302,8 @@ unsigned long LFUGetTimeInMinutes(void) {
     return (server.unixtime/60) & 65535;
 }
 
-/* Given an object last access time, compute the minimum number of minutes
- * that elapsed since the last access. Handle overflow (ldt greater than
+/* Given an object last decrement time, compute the minimum number of minutes
+ * that elapsed since the last decrement. Handle overflow (ldt greater than
  * the current 16 bits minutes time) considering the time as wrapping
  * exactly once. */
 unsigned long LFUTimeElapsed(unsigned long ldt) {
@@ -322,22 +324,25 @@ uint8_t LFULogIncr(uint8_t counter) {
     return counter;
 }
 
-/* If the object decrement time is reached decrement the LFU counter but
- * do not update LFU fields of the object, we update the access time
- * and counter in an explicit way when the object is really accessed.
- * And we will times halve the counter according to the times of
- * elapsed time than server.lfu_decay_time.
- * Return the object frequency counter.
+/* If the object decrement time is reached, decrement the LFU counter and
+ * update the decrement time field. Return the object frequency counter.
  *
  * This function is used in order to scan the dataset for the best object
  * to fit: as we check for the candidate, we incrementally decrement the
  * counter of the scanned objects if needed. */
+#define LFU_DECR_INTERVAL 1
 unsigned long LFUDecrAndReturn(robj *o) {
     unsigned long ldt = o->lru >> 8;
     unsigned long counter = o->lru & 255;
-    unsigned long num_periods = server.lfu_decay_time ? LFUTimeElapsed(ldt) / server.lfu_decay_time : 0;
-    if (num_periods)
-        counter = (num_periods > counter) ? 0 : counter - num_periods;
+    if (LFUTimeElapsed(ldt) >= server.lfu_decay_time && counter) {
+        if (counter > LFU_INIT_VAL*2) {
+            counter /= 2;
+            if (counter < LFU_INIT_VAL*2) counter = LFU_INIT_VAL*2;
+        } else {
+            counter--;
+        }
+        o->lru = (LFUGetTimeInMinutes()<<8) | counter;
+    }
     return counter;
 }
 

src/expire.c

@@ -103,7 +103,7 @@ void activeExpireCycle(int type) {
 
     int j, iteration = 0;
     int dbs_per_call = CRON_DBS_PER_CALL;
-    long long start = ustime(), timelimit, elapsed;
+    long long start = ustime(), timelimit;
 
     /* When clients are paused the dataset should be static not just from the
      * POV of clients not being able to write, but also from the POV of
@@ -111,7 +111,7 @@ void activeExpireCycle(int type) {
     if (clientsArePaused()) return;
 
     if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
-        /* Don't start a fast cycle if the previous cycle did not exit
+        /* Don't start a fast cycle if the previous cycle did not exited
          * for time limt. Also don't repeat a fast cycle for the same period
          * as the fast cycle total duration itself. */
         if (!timelimit_exit) return;
@@ -140,13 +140,7 @@ void activeExpireCycle(int type) {
     if (type == ACTIVE_EXPIRE_CYCLE_FAST)
         timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */
 
-    /* Accumulate some global stats as we expire keys, to have some idea
-     * about the number of keys that are already logically expired, but still
-     * existing inside the database. */
-    long total_sampled = 0;
-    long total_expired = 0;
-
-    for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
+    for (j = 0; j < dbs_per_call; j++) {
         int expired;
         redisDb *db = server.db+(current_db % server.dbnum);
 
@@ -161,7 +155,6 @@ void activeExpireCycle(int type) {
             unsigned long num, slots;
             long long now, ttl_sum;
             int ttl_samples;
-            iteration++;
 
             /* If there is nothing to expire try next DB ASAP. */
             if ((num = dictSize(db->expires)) == 0) {
@@ -198,9 +191,7 @@ void activeExpireCycle(int type) {
                     ttl_sum += ttl;
                     ttl_samples++;
                 }
-                total_sampled++;
             }
-            total_expired += expired;
 
             /* Update the average TTL stats for this database. */
             if (ttl_samples) {
@@ -216,31 +207,18 @@ void activeExpireCycle(int type) {
             /* We can't block forever here even if there are many keys to
              * expire. So after a given amount of milliseconds return to the
              * caller waiting for the other active expire cycle. */
+            iteration++;
             if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
-                elapsed = ustime()-start;
-                if (elapsed > timelimit) {
-                    timelimit_exit = 1;
-                    server.stat_expired_time_cap_reached_count++;
-                    break;
-                }
+                long long elapsed = ustime()-start;
+
+                latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);
+                if (elapsed > timelimit) timelimit_exit = 1;
             }
+            if (timelimit_exit) return;
             /* We don't repeat the cycle if there are less than 25% of keys
              * found expired in the current DB. */
         } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
     }
-
-    elapsed = ustime()-start;
-    latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);
-
-    /* Update our estimate of keys existing but yet to be expired.
-     * Running average with this sample accounting for 5%. */
-    double current_perc;
-    if (total_sampled) {
-        current_perc = (double)total_expired/total_sampled;
-    } else
-        current_perc = 0;
-    server.stat_expired_stale_perc = (current_perc*0.05)+
-                                     (server.stat_expired_stale_perc*0.95);
 }
 
 /*-----------------------------------------------------------------------------

src/hyperloglog.c

@@ -475,8 +475,9 @@ int hllPatLen(unsigned char *ele, size_t elesize, long *regp) {
 
 /* ================== Dense representation implementation  ================== */
 
-/* Low level function to set the dense HLL register at 'index' to the
- * specified value if the current value is smaller than 'count'.
+/* "Add" the element in the dense hyperloglog data structure.
+ * Actually nothing is added, but the max 0 pattern counter of the subset
+ * the element belongs to is incremented if needed.
  *
  * 'registers' is expected to have room for HLL_REGISTERS plus an
  * additional byte on the right. This requirement is met by sds strings
@@ -485,9 +486,12 @@ int hllPatLen(unsigned char *ele, size_t elesize, long *regp) {
  * The function always succeed, however if as a result of the operation
  * the approximated cardinality changed, 1 is returned. Otherwise 0
  * is returned. */
-int hllDenseSet(uint8_t *registers, long index, uint8_t count) {
-    uint8_t oldcount;
+int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
+    uint8_t oldcount, count;
+    long index;
 
+    /* Update the register if this element produced a longer run of zeroes. */
+    count = hllPatLen(ele,elesize,&index);
     HLL_DENSE_GET_REGISTER(oldcount,registers,index);
     if (count > oldcount) {
         HLL_DENSE_SET_REGISTER(registers,index,count);
@@ -497,19 +501,6 @@ int hllDenseSet(uint8_t *registers, long index, uint8_t count) {
     }
 }
 
-/* "Add" the element in the dense hyperloglog data structure.
- * Actually nothing is added, but the max 0 pattern counter of the subset
- * the element belongs to is incremented if needed.
- *
- * This is just a wrapper to hllDenseSet(), performing the hashing of the
- * element in order to retrieve the index and zero-run count. */
-int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
-    long index;
-    uint8_t count = hllPatLen(ele,elesize,&index);
-    /* Update the register if this element produced a longer run of zeroes. */
-    return hllDenseSet(registers,index,count);
-}
-
 /* Compute SUM(2^-reg) in the dense representation.
  * PE is an array with a pre-computer table of values 2^-reg indexed by reg.
  * As a side effect the integer pointed by 'ezp' is set to the number
@@ -632,8 +623,9 @@ int hllSparseToDense(robj *o) {
     return C_OK;
 }
 
-/* Low level function to set the sparse HLL register at 'index' to the
- * specified value if the current value is smaller than 'count'.
+/* "Add" the element in the sparse hyperloglog data structure.
+ * Actually nothing is added, but the max 0 pattern counter of the subset
+ * the element belongs to is incremented if needed.
  *
  * The object 'o' is the String object holding the HLL. The function requires
  * a reference to the object in order to be able to enlarge the string if
@@ -647,12 +639,15 @@ int hllSparseToDense(robj *o) {
  * sparse to dense: this happens when a register requires to be set to a value
  * not representable with the sparse representation, or when the resulting
  * size would be greater than server.hll_sparse_max_bytes. */
-int hllSparseSet(robj *o, long index, uint8_t count) {
+int hllSparseAdd(robj *o, unsigned char *ele, size_t elesize) {
     struct hllhdr *hdr;
-    uint8_t oldcount, *sparse, *end, *p, *prev, *next;
-    long first, span;
+    uint8_t oldcount, count, *sparse, *end, *p, *prev, *next;
+    long index, first, span;
     long is_zero = 0, is_xzero = 0, is_val = 0, runlen = 0;
 
+    /* Update the register if this element produced a longer run of zeroes. */
+    count = hllPatLen(ele,elesize,&index);
+
     /* If the count is too big to be representable by the sparse representation
      * switch to dense representation. */
     if (count > HLL_SPARSE_VAL_MAX_VALUE) goto promote;
@@ -885,24 +880,11 @@ 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. */
-    int dense_retval = hllDenseSet(hdr->registers,index,count);
+    int dense_retval = hllDenseAdd(hdr->registers, ele, elesize);
     serverAssert(dense_retval == 1);
     return dense_retval;
 }
 
-/* "Add" the element in the sparse hyperloglog data structure.
- * Actually nothing is added, but the max 0 pattern counter of the subset
- * the element belongs to is incremented if needed.
- *
- * This function is actually a wrapper for hllSparseSet(), it only performs
- * the hashshing of the elmenet to obtain the index and zeros run length. */
-int hllSparseAdd(robj *o, unsigned char *ele, size_t elesize) {
-    long index;
-    uint8_t count = hllPatLen(ele,elesize,&index);
-    /* Update the register if this element produced a longer run of zeroes. */
-    return hllSparseSet(o,index,count);
-}
-
 /* Compute SUM(2^-reg) in the sparse representation.
  * PE is an array with a pre-computer table of values 2^-reg indexed by reg.
  * As a side effect the integer pointed by 'ezp' is set to the number
@@ -1298,10 +1280,9 @@ void pfmergeCommand(client *c) {
     uint8_t max[HLL_REGISTERS];
     struct hllhdr *hdr;
     int j;
-    int use_dense = 0; /* Use dense representation as target? */
 
     /* Compute an HLL with M[i] = MAX(M[i]_j).
-     * We store the maximum into the max array of registers. We'll write
+     * We we the maximum into the max array of registers. We'll write
      * it to the target variable later. */
     memset(max,0,sizeof(max));
     for (j = 1; j < c->argc; j++) {
@@ -1310,11 +1291,6 @@ void pfmergeCommand(client *c) {
         if (o == NULL) continue; /* Assume empty HLL for non existing var. */
         if (isHLLObjectOrReply(c,o) != C_OK) return;
 
-        /* If at least one involved HLL is dense, use the dense representation
-         * as target ASAP to save time and avoid the conversion step. */
-        hdr = o->ptr;
-        if (hdr->encoding == HLL_DENSE) use_dense = 1;
-
         /* Merge with this HLL with our 'max' HHL by setting max[i]
          * to MAX(max[i],hll[i]). */
         if (hllMerge(max,o) == C_ERR) {
@@ -1338,29 +1314,22 @@ void pfmergeCommand(client *c) {
         o = dbUnshareStringValue(c->db,c->argv[1],o);
     }
 
-    /* Convert the destination object to dense representation if at least
-     * one of the inputs was dense. */
-    if (use_dense && hllSparseToDense(o) == C_ERR) {
+    /* Only support dense objects as destination. */
+    if (hllSparseToDense(o) == C_ERR) {
         addReplySds(c,sdsnew(invalid_hll_err));
         return;
     }
 
     /* Write the resulting HLL to the destination HLL registers and
      * invalidate the cached value. */
+    hdr = o->ptr;
     for (j = 0; j < HLL_REGISTERS; j++) {
-        if (max[j] == 0) continue;
-        hdr = o->ptr;
-        switch(hdr->encoding) {
-        case HLL_DENSE: hllDenseSet(hdr->registers,j,max[j]); break;
-        case HLL_SPARSE: hllSparseSet(o,j,max[j]); break;
-        }
+        HLL_DENSE_SET_REGISTER(hdr->registers,j,max[j]);
     }
-    hdr = o->ptr; /* o->ptr may be different now, as a side effect of
-                     last hllSparseSet() call. */
     HLL_INVALIDATE_CACHE(hdr);
 
     signalModifiedKey(c->db,c->argv[1]);
-    /* We generate a PFADD event for PFMERGE for semantical simplicity
+    /* We generate an PFADD event for PFMERGE for semantical simplicity
      * since in theory this is a mass-add of elements. */
     notifyKeyspaceEvent(NOTIFY_STRING,"pfadd",c->argv[1],c->db->id);
     server.dirty++;

src/latency.c

@@ -109,8 +109,6 @@ void latencyAddSample(char *event, mstime_t latency) {
         dictAdd(server.latency_events,zstrdup(event),ts);
     }
 
-    if (latency > ts->max) ts->max = latency;
-
     /* If the previous sample is in the same second, we update our old sample
      * if this latency is > of the old one, or just return. */
     prev = (ts->idx + LATENCY_TS_LEN - 1) % LATENCY_TS_LEN;
@@ -122,6 +120,7 @@ void latencyAddSample(char *event, mstime_t latency) {
 
     ts->samples[ts->idx].time = time(NULL);
     ts->samples[ts->idx].latency = latency;
+    if (latency > ts->max) ts->max = latency;
 
     ts->idx++;
     if (ts->idx == LATENCY_TS_LEN) ts->idx = 0;

src/lazyfree.c

@@ -64,15 +64,9 @@ int dbAsyncDelete(redisDb *db, robj *key) {
         robj *val = dictGetVal(de);
         size_t free_effort = lazyfreeGetFreeEffort(val);
 
-        /* If releasing the object is too much work, do it in the background
-         * by adding the object to the lazy free list.
-         * Note that if the object is shared, to reclaim it now it is not
-         * possible. This rarely happens, however sometimes the implementation
-         * of parts of the Redis core may call incrRefCount() to protect
-         * objects, and then call dbDelete(). In this case we'll fall
-         * through and reach the dictFreeUnlinkedEntry() call, that will be
-         * equivalent to just calling decrRefCount(). */
-        if (free_effort > LAZYFREE_THRESHOLD && val->refcount == 1) {
+        /* If releasing the object is too much work, let's put it into the
+         * lazy free list. */
+        if (free_effort > LAZYFREE_THRESHOLD) {
             atomicIncr(lazyfree_objects,1);
             bioCreateBackgroundJob(BIO_LAZY_FREE,val,NULL,NULL);
             dictSetVal(db->dict,de,NULL);

src/listpack.c

@@ -1,783 +0,0 @@
-/* Listpack -- A lists of strings serialization format
- *
- * This file implements the specification you can find at:
- *
- *  https://github.com/antirez/listpack
- *
- * Copyright (c) 2017, 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 <stdint.h>
-#include <limits.h>
-#include <sys/types.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "listpack.h"
-#include "listpack_malloc.h"
-
-#define LP_HDR_SIZE 6       /* 32 bit total len + 16 bit number of elements. */
-#define LP_HDR_NUMELE_UNKNOWN UINT16_MAX
-#define LP_MAX_INT_ENCODING_LEN 9
-#define LP_MAX_BACKLEN_SIZE 5
-#define LP_MAX_ENTRY_BACKLEN 34359738367ULL
-#define LP_ENCODING_INT 0
-#define LP_ENCODING_STRING 1
-
-#define LP_ENCODING_7BIT_UINT 0
-#define LP_ENCODING_7BIT_UINT_MASK 0x80
-#define LP_ENCODING_IS_7BIT_UINT(byte) (((byte)&LP_ENCODING_7BIT_UINT_MASK)==LP_ENCODING_7BIT_UINT)
-
-#define LP_ENCODING_6BIT_STR 0x80
-#define LP_ENCODING_6BIT_STR_MASK 0xC0
-#define LP_ENCODING_IS_6BIT_STR(byte) (((byte)&LP_ENCODING_6BIT_STR_MASK)==LP_ENCODING_6BIT_STR)
-
-#define LP_ENCODING_13BIT_INT 0xC0
-#define LP_ENCODING_13BIT_INT_MASK 0xE0
-#define LP_ENCODING_IS_13BIT_INT(byte) (((byte)&LP_ENCODING_13BIT_INT_MASK)==LP_ENCODING_13BIT_INT)
-
-#define LP_ENCODING_12BIT_STR 0xE0
-#define LP_ENCODING_12BIT_STR_MASK 0xF0
-#define LP_ENCODING_IS_12BIT_STR(byte) (((byte)&LP_ENCODING_12BIT_STR_MASK)==LP_ENCODING_12BIT_STR)
-
-#define LP_ENCODING_16BIT_INT 0xF1
-#define LP_ENCODING_16BIT_INT_MASK 0xFF
-#define LP_ENCODING_IS_16BIT_INT(byte) (((byte)&LP_ENCODING_16BIT_INT_MASK)==LP_ENCODING_16BIT_INT)
-
-#define LP_ENCODING_24BIT_INT 0xF2
-#define LP_ENCODING_24BIT_INT_MASK 0xFF
-#define LP_ENCODING_IS_24BIT_INT(byte) (((byte)&LP_ENCODING_24BIT_INT_MASK)==LP_ENCODING_24BIT_INT)
-
-#define LP_ENCODING_32BIT_INT 0xF3
-#define LP_ENCODING_32BIT_INT_MASK 0xFF
-#define LP_ENCODING_IS_32BIT_INT(byte) (((byte)&LP_ENCODING_32BIT_INT_MASK)==LP_ENCODING_32BIT_INT)
-
-#define LP_ENCODING_64BIT_INT 0xF4
-#define LP_ENCODING_64BIT_INT_MASK 0xFF
-#define LP_ENCODING_IS_64BIT_INT(byte) (((byte)&LP_ENCODING_64BIT_INT_MASK)==LP_ENCODING_64BIT_INT)
-
-#define LP_ENCODING_32BIT_STR 0xF0
-#define LP_ENCODING_32BIT_STR_MASK 0xFF
-#define LP_ENCODING_IS_32BIT_STR(byte) (((byte)&LP_ENCODING_32BIT_STR_MASK)==LP_ENCODING_32BIT_STR)
-
-#define LP_EOF 0xFF
-
-#define LP_ENCODING_6BIT_STR_LEN(p) ((p)[0] & 0x3F)
-#define LP_ENCODING_12BIT_STR_LEN(p) ((((p)[0] & 0xF) << 8) | (p)[1])
-#define LP_ENCODING_32BIT_STR_LEN(p) (((uint32_t)(p)[1]<<0) | \
-                                      ((uint32_t)(p)[2]<<8) | \
-                                      ((uint32_t)(p)[3]<<16) | \
-                                      ((uint32_t)(p)[4]<<24))
-
-#define lpGetTotalBytes(p)           (((uint32_t)(p)[0]<<0) | \
-                                      ((uint32_t)(p)[1]<<8) | \
-                                      ((uint32_t)(p)[2]<<16) | \
-                                      ((uint32_t)(p)[3]<<24))
-
-#define lpGetNumElements(p)          (((uint32_t)(p)[4]<<0) | \
-                                      ((uint32_t)(p)[5]<<8))
-#define lpSetTotalBytes(p,v) do { \
-    (p)[0] = (v)&0xff; \
-    (p)[1] = ((v)>>8)&0xff; \
-    (p)[2] = ((v)>>16)&0xff; \
-    (p)[3] = ((v)>>24)&0xff; \
-} while(0)
-
-#define lpSetNumElements(p,v) do { \
-    (p)[4] = (v)&0xff; \
-    (p)[5] = ((v)>>8)&0xff; \
-} while(0)
-
-/* Convert a string into a signed 64 bit integer.
- * The function returns 1 if the string could be parsed into a (non-overflowing)
- * signed 64 bit int, 0 otherwise. The 'value' will be set to the parsed value
- * when the function returns success.
- *
- * Note that this function demands that the string strictly represents
- * a int64 value: no spaces or other characters before or after the string
- * representing the number are accepted, nor zeroes at the start if not
- * for the string "0" representing the zero number.
- *
- * Because of its strictness, it is safe to use this function to check if
- * you can convert a string into a long long, and obtain back the string
- * from the number without any loss in the string representation. *
- *
- * -----------------------------------------------------------------------------
- *
- * Credits: this function was adapted from the Redis source code, file
- * "utils.c", function string2ll(), and is copyright:
- *
- * Copyright(C) 2011, Pieter Noordhuis
- * Copyright(C) 2011, Salvatore Sanfilippo
- *
- * The function is released under the BSD 3-clause license.
- */
-int lpStringToInt64(const char *s, unsigned long slen, int64_t *value) {
-    const char *p = s;
-    unsigned long plen = 0;
-    int negative = 0;
-    uint64_t v;
-
-    if (plen == slen)
-        return 0;
-
-    /* Special case: first and only digit is 0. */
-    if (slen == 1 && p[0] == '0') {
-        if (value != NULL) *value = 0;
-        return 1;
-    }
-
-    if (p[0] == '-') {
-        negative = 1;
-        p++; plen++;
-
-        /* Abort on only a negative sign. */
-        if (plen == slen)
-            return 0;
-    }
-
-    /* First digit should be 1-9, otherwise the string should just be 0. */
-    if (p[0] >= '1' && p[0] <= '9') {
-        v = p[0]-'0';
-        p++; plen++;
-    } else if (p[0] == '0' && slen == 1) {
-        *value = 0;
-        return 1;
-    } else {
-        return 0;
-    }
-
-    while (plen < slen && p[0] >= '0' && p[0] <= '9') {
-        if (v > (UINT64_MAX / 10)) /* Overflow. */
-            return 0;
-        v *= 10;
-
-        if (v > (UINT64_MAX - (p[0]-'0'))) /* Overflow. */
-            return 0;
-        v += p[0]-'0';
-
-        p++; plen++;
-    }
-
-    /* Return if not all bytes were used. */
-    if (plen < slen)
-        return 0;
-
-    if (negative) {
-        if (v > ((uint64_t)(-(INT64_MIN+1))+1)) /* Overflow. */
-            return 0;
-        if (value != NULL) *value = -v;
-    } else {
-        if (v > INT64_MAX) /* Overflow. */
-            return 0;
-        if (value != NULL) *value = v;
-    }
-    return 1;
-}
-
-/* Create a new, empty listpack.
- * On success the new listpack is returned, otherwise an error is returned. */
-unsigned char *lpNew(void) {
-    unsigned char *lp = lp_malloc(LP_HDR_SIZE+1);
-    if (lp == NULL) return NULL;
-    lpSetTotalBytes(lp,LP_HDR_SIZE+1);
-    lpSetNumElements(lp,0);
-    lp[LP_HDR_SIZE] = LP_EOF;
-    return lp;
-}
-
-/* Free the specified listpack. */
-void lpFree(unsigned char *lp) {
-    lp_free(lp);
-}
-
-/* Given an element 'ele' of size 'size', determine if the element can be
- * represented inside the listpack encoded as integer, and returns
- * LP_ENCODING_INT if so. Otherwise returns LP_ENCODING_STR if no integer
- * encoding is possible.
- *
- * If the LP_ENCODING_INT is returned, the function stores the integer encoded
- * representation of the element in the 'intenc' buffer.
- *
- * Regardless of the returned encoding, 'enclen' is populated by reference to
- * the number of bytes that the string or integer encoded element will require
- * in order to be represented. */
-int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
-    int64_t v;
-    if (lpStringToInt64((const char*)ele, size, &v)) {
-        if (v >= 0 && v <= 127) {
-            /* Single byte 0-127 integer. */
-            intenc[0] = v;
-            *enclen = 1;
-        } else if (v >= -4096 && v <= 4095) {
-            /* 13 bit integer. */
-            if (v < 0) v = ((int64_t)1<<13)+v;
-            intenc[0] = (v>>8)|LP_ENCODING_13BIT_INT;
-            intenc[1] = v&0xff;
-            *enclen = 2;
-        } else if (v >= -32768 && v <= 32767) {
-            /* 16 bit integer. */
-            if (v < 0) v = ((int64_t)1<<16)+v;
-            intenc[0] = LP_ENCODING_16BIT_INT;
-            intenc[1] = v&0xff;
-            intenc[2] = v>>8;
-            *enclen = 3;
-        } else if (v >= -8388608 && v <= 8388607) {
-            /* 24 bit integer. */
-            if (v < 0) v = ((int64_t)1<<24)+v;
-            intenc[0] = LP_ENCODING_24BIT_INT;
-            intenc[1] = v&0xff;
-            intenc[2] = (v>>8)&0xff;
-            intenc[3] = v>>16;
-            *enclen = 4;
-        } else if (v >= -2147483648 && v <= 2147483647) {
-            /* 32 bit integer. */
-            if (v < 0) v = ((int64_t)1<<32)+v;
-            intenc[0] = LP_ENCODING_32BIT_INT;
-            intenc[1] = v&0xff;
-            intenc[2] = (v>>8)&0xff;
-            intenc[3] = (v>>16)&0xff;
-            intenc[4] = v>>24;
-            *enclen = 5;
-        } else {
-            /* 64 bit integer. */
-            uint64_t uv = v;
-            intenc[0] = LP_ENCODING_64BIT_INT;
-            intenc[1] = uv&0xff;
-            intenc[2] = (uv>>8)&0xff;
-            intenc[3] = (uv>>16)&0xff;
-            intenc[4] = (uv>>24)&0xff;
-            intenc[5] = (uv>>32)&0xff;
-            intenc[6] = (uv>>40)&0xff;
-            intenc[7] = (uv>>48)&0xff;
-            intenc[8] = uv>>56;
-            *enclen = 9;
-        }
-        return LP_ENCODING_INT;
-    } else {
-        if (size < 64) *enclen = 1+size;
-        else if (size < 4096) *enclen = 2+size;
-        else *enclen = 5+size;
-        return LP_ENCODING_STRING;
-    }
-}
-
-/* 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
- * needed in order to encode the backlen. */
-unsigned long lpEncodeBacklen(unsigned char *buf, uint64_t l) {
-    if (l <= 127) {
-        if (buf) buf[0] = l;
-        return 1;
-    } else if (l < 16383) {
-        if (buf) {
-            buf[0] = l>>7;
-            buf[1] = (l&127)|128;
-        }
-        return 2;
-    } else if (l < 2097151) {
-        if (buf) {
-            buf[0] = l>>14;
-            buf[1] = ((l>>7)&127)|128;
-            buf[2] = (l&127)|128;
-        }
-        return 3;
-    } else if (l < 268435455) {
-        if (buf) {
-            buf[0] = l>>21;
-            buf[1] = ((l>>14)&127)|128;
-            buf[2] = ((l>>7)&127)|128;
-            buf[3] = (l&127)|128;
-        }
-        return 4;
-    } else {
-        if (buf) {
-            buf[0] = l>>28;
-            buf[1] = ((l>>21)&127)|128;
-            buf[2] = ((l>>14)&127)|128;
-            buf[3] = ((l>>7)&127)|128;
-            buf[4] = (l&127)|128;
-        }
-        return 5;
-    }
-}
-
-/* Decode the backlen and returns it. If the encoding looks invalid (more than
- * 5 bytes are used), UINT64_MAX is returned to report the problem. */
-uint64_t lpDecodeBacklen(unsigned char *p) {
-    uint64_t val = 0;
-    uint64_t shift = 0;
-    do {
-        val |= (uint64_t)(p[0] & 127) << shift;
-        if (!(p[0] & 128)) break;
-        shift += 7;
-        p--;
-        if (shift > 28) return UINT64_MAX;
-    } while(1);
-    return val;
-}
-
-/* Encode the string element pointed by 's' of size 'len' in the target
- * buffer 's'. The function should be called with 'buf' having always enough
- * space for encoding the string. This is done by calling lpEncodeGetType()
- * before calling this function. */
-void lpEncodeString(unsigned char *buf, unsigned char *s, uint32_t len) {
-    if (len < 64) {
-        buf[0] = len | LP_ENCODING_6BIT_STR;
-        memcpy(buf+1,s,len);
-    } else if (len < 4096) {
-        buf[0] = (len >> 8) | LP_ENCODING_12BIT_STR;
-        buf[1] = len & 0xff;
-        memcpy(buf+2,s,len);
-    } else {
-        buf[0] = LP_ENCODING_32BIT_STR;
-        buf[1] = len & 0xff;
-        buf[2] = (len >> 8) & 0xff;
-        buf[3] = (len >> 16) & 0xff;
-        buf[4] = (len >> 24) & 0xff;
-        memcpy(buf+5,s,len);
-    }
-}
-
-/* Return the encoded length of the listpack element pointed by 'p'. If the
- * element encoding is wrong then 0 is returned. */
-uint32_t lpCurrentEncodedSize(unsigned char *p) {
-    if (LP_ENCODING_IS_7BIT_UINT(p[0])) return 1;
-    if (LP_ENCODING_IS_6BIT_STR(p[0])) return 1+LP_ENCODING_6BIT_STR_LEN(p);
-    if (LP_ENCODING_IS_13BIT_INT(p[0])) return 2;
-    if (LP_ENCODING_IS_16BIT_INT(p[0])) return 3;
-    if (LP_ENCODING_IS_24BIT_INT(p[0])) return 4;
-    if (LP_ENCODING_IS_32BIT_INT(p[0])) return 5;
-    if (LP_ENCODING_IS_64BIT_INT(p[0])) return 9;
-    if (LP_ENCODING_IS_12BIT_STR(p[0])) return 2+LP_ENCODING_12BIT_STR_LEN(p);
-    if (LP_ENCODING_IS_32BIT_STR(p[0])) return 5+LP_ENCODING_32BIT_STR_LEN(p);
-    if (p[0] == LP_EOF) return 1;
-    return 0;
-}
-
-/* Skip the current entry returning the next. It is invalid to call this
- * function if the current element is the EOF element at the end of the
- * listpack, however, while this function is used to implement lpNext(),
- * it does not return NULL when the EOF element is encountered. */
-unsigned char *lpSkip(unsigned char *p) {
-    unsigned long entrylen = lpCurrentEncodedSize(p);
-    entrylen += lpEncodeBacklen(NULL,entrylen);
-    p += entrylen;
-    return p;
-}
-
-/* If 'p' points to an element of the listpack, calling lpNext() will return
- * the pointer to the next element (the one on the right), or NULL if 'p'
- * already pointed to the last element of the listpack. */
-unsigned char *lpNext(unsigned char *lp, unsigned char *p) {
-    ((void) lp); /* lp is not used for now. However lpPrev() uses it. */
-    p = lpSkip(p);
-    if (p[0] == LP_EOF) return NULL;
-    return p;
-}
-
-/* If 'p' points to an element of the listpack, calling lpPrev() will return
- * the pointer to the preivous element (the one on the left), or NULL if 'p'
- * already pointed to the first element of the listpack. */
-unsigned char *lpPrev(unsigned char *lp, unsigned char *p) {
-    if (p-lp == LP_HDR_SIZE) return NULL;
-    p--; /* Seek the first backlen byte of the last element. */
-    uint64_t prevlen = lpDecodeBacklen(p);
-    prevlen += lpEncodeBacklen(NULL,prevlen);
-    return p-prevlen+1; /* Seek the first byte of the previous entry. */
-}
-
-/* Return a pointer to the first element of the listpack, or NULL if the
- * listpack has no elements. */
-unsigned char *lpFirst(unsigned char *lp) {
-    lp += LP_HDR_SIZE; /* Skip the header. */
-    if (lp[0] == LP_EOF) return NULL;
-    return lp;
-}
-
-/* Return a pointer to the last element of the listpack, or NULL if the
- * listpack has no elements. */
-unsigned char *lpLast(unsigned char *lp) {
-    unsigned char *p = lp+lpGetTotalBytes(lp)-1; /* Seek EOF element. */
-    return lpPrev(lp,p); /* Will return NULL if EOF is the only element. */
-}
-
-/* Return the number of elements inside the listpack. This function attempts
- * to use the cached value when within range, otherwise a full scan is
- * needed. As a side effect of calling this function, the listpack header
- * could be modified, because if the count is found to be already within
- * the 'numele' header field range, the new value is set. */
-uint32_t lpLength(unsigned char *lp) {
-    uint32_t numele = lpGetNumElements(lp);
-    if (numele != LP_HDR_NUMELE_UNKNOWN) return numele;
-
-    /* Too many elements inside the listpack. We need to scan in order
-     * to get the total number. */
-    uint32_t count = 0;
-    unsigned char *p = lpFirst(lp);
-    while(p) {
-        count++;
-        p = lpNext(lp,p);
-    }
-
-    /* If the count is again within range of the header numele field,
-     * set it. */
-    if (count < LP_HDR_NUMELE_UNKNOWN) lpSetNumElements(lp,count);
-    return count;
-}
-
-/* Return the listpack element pointed by 'p'.
- *
- * The function changes behavior depending on the passed 'intbuf' value.
- * Specifically, if 'intbuf' is NULL:
- *
- * If the element is internally encoded as an integer, the function returns
- * NULL and populates the integer value by reference in 'count'. Otherwise if
- * the element is encoded as a string a pointer to the string (pointing inside
- * the listpack itself) is returned, and 'count' is set to the length of the
- * string.
- *
- * If instead 'intbuf' points to a buffer passed by the caller, that must be
- * at least LP_INTBUF_SIZE bytes, the function always returns the element as
- * it was a string (returning the pointer to the string and setting the
- * 'count' argument to the string length by reference). However if the element
- * is encoded as an integer, the 'intbuf' buffer is used in order to store
- * the string representation.
- *
- * The user should use one or the other form depending on what the value will
- * be used for. If there is immediate usage for an integer value returned
- * by the function, than to pass a buffer (and convert it back to a number)
- * is of course useless.
- *
- * If the function is called against a badly encoded ziplist, so that there
- * is no valid way to parse it, the function returns like if there was an
- * integer encoded with value 12345678900000000 + <unrecognized byte>, this may
- * be an hint to understand that something is wrong. To crash in this case is
- * not sensible because of the different requirements of the application using
- * this lib.
- *
- * Similarly, there is no error returned since the listpack normally can be
- * assumed to be valid, so that would be a very high API cost. However a function
- * in order to check the integrity of the listpack at load time is provided,
- * check lpIsValid(). */
-unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf) {
-    int64_t val;
-    uint64_t uval, negstart, negmax;
-
-    if (LP_ENCODING_IS_7BIT_UINT(p[0])) {
-        negstart = UINT64_MAX; /* 7 bit ints are always positive. */
-        negmax = 0;
-        uval = p[0] & 0x7f;
-    } else if (LP_ENCODING_IS_6BIT_STR(p[0])) {
-        *count = LP_ENCODING_6BIT_STR_LEN(p);
-        return p+1;
-    } else if (LP_ENCODING_IS_13BIT_INT(p[0])) {
-        uval = ((p[0]&0x1f)<<8) | p[1];
-        negstart = (uint64_t)1<<12;
-        negmax = 8191;
-    } else if (LP_ENCODING_IS_16BIT_INT(p[0])) {
-        uval = (uint64_t)p[1] |
-               (uint64_t)p[2]<<8;
-        negstart = (uint64_t)1<<15;
-        negmax = UINT16_MAX;
-    } else if (LP_ENCODING_IS_24BIT_INT(p[0])) {
-        uval = (uint64_t)p[1] |
-               (uint64_t)p[2]<<8 |
-               (uint64_t)p[3]<<16;
-        negstart = (uint64_t)1<<23;
-        negmax = UINT32_MAX>>8;
-    } else if (LP_ENCODING_IS_32BIT_INT(p[0])) {
-        uval = (uint64_t)p[1] |
-               (uint64_t)p[2]<<8 |
-               (uint64_t)p[3]<<16 |
-               (uint64_t)p[4]<<24;
-        negstart = (uint64_t)1<<31;
-        negmax = UINT32_MAX;
-    } else if (LP_ENCODING_IS_64BIT_INT(p[0])) {
-        uval = (uint64_t)p[1] |
-               (uint64_t)p[2]<<8 |
-               (uint64_t)p[3]<<16 |
-               (uint64_t)p[4]<<24 |
-               (uint64_t)p[5]<<32 |
-               (uint64_t)p[6]<<40 |
-               (uint64_t)p[7]<<48 |
-               (uint64_t)p[8]<<56;
-        negstart = (uint64_t)1<<63;
-        negmax = UINT64_MAX;
-    } else if (LP_ENCODING_IS_12BIT_STR(p[0])) {
-        *count = LP_ENCODING_12BIT_STR_LEN(p);
-        return p+2;
-    } else if (LP_ENCODING_IS_32BIT_STR(p[0])) {
-        *count = LP_ENCODING_32BIT_STR_LEN(p);
-        return p+5;
-    } else {
-        uval = 12345678900000000ULL + p[0];
-        negstart = UINT64_MAX;
-        negmax = 0;
-    }
-
-    /* We reach this code path only for integer encodings.
-     * Convert the unsigned value to the signed one using two's complement
-     * rule. */
-    if (uval >= negstart) {
-        /* This three steps conversion should avoid undefined behaviors
-         * in the unsigned -> signed conversion. */
-        uval = negmax-uval;
-        val = uval;
-        val = -val-1;
-    } else {
-        val = uval;
-    }
-
-    /* Return the string representation of the integer or the value itself
-     * depending on intbuf being NULL or not. */
-    if (intbuf) {
-        *count = snprintf((char*)intbuf,LP_INTBUF_SIZE,"%lld",val);
-        return intbuf;
-    } else {
-        *count = val;
-        return NULL;
-    }
-}
-
-/* Insert, delete or replace the specified element 'ele' of lenght 'len' at
- * the specified position 'p', with 'p' being a listpack element pointer
- * obtained with lpFirst(), lpLast(), lpIndex(), lpNext(), lpPrev() or
- * lpSeek().
- *
- * The element is inserted before, after, or replaces the element pointed
- * by 'p' depending on the 'where' argument, that can be LP_BEFORE, LP_AFTER
- * or LP_REPLACE.
- *
- * If 'ele' is set to NULL, the function removes the element pointed by 'p'
- * instead of inserting one.
- *
- * Returns NULL on out of memory or when the listpack total length would exceed
- * the max allowed size of 2^32-1, otherwise the new pointer to the listpack
- * holding the new element is returned (and the old pointer passed is no longer
- * considered valid)
- *
- * If 'newp' is not NULL, at the end of a successful call '*newp' will be set
- * to the address of the element just added, so that it will be possible to
- * continue an interation with lpNext() and lpPrev().
- *
- * For deletion operations ('ele' set to NULL) 'newp' is set to the next
- * element, on the right of the deleted one, or to NULL if the deleted element
- * was the last one. */
-unsigned char *lpInsert(unsigned char *lp, unsigned char *ele, uint32_t size, unsigned char *p, int where, unsigned char **newp) {
-    unsigned char intenc[LP_MAX_INT_ENCODING_LEN];
-    unsigned char backlen[LP_MAX_BACKLEN_SIZE];
-
-    uint64_t enclen; /* The length of the encoded element. */
-
-    /* An element pointer set to NULL means deletion, which is conceptually
-     * replacing the element with a zero-length element. So whatever we
-     * get passed as 'where', set it to LP_REPLACE. */
-    if (ele == NULL) where = LP_REPLACE;
-
-    /* If we need to insert after the current element, we just jump to the
-     * next element (that could be the EOF one) and handle the case of
-     * inserting before. So the function will actually deal with just two
-     * cases: LP_BEFORE and LP_REPLACE. */
-    if (where == LP_AFTER) {
-        p = lpSkip(p);
-        where = LP_BEFORE;
-    }
-
-    /* Store the offset of the element 'p', so that we can obtain its
-     * address again after a reallocation. */
-    unsigned long poff = p-lp;
-
-    /* Calling lpEncodeGetType() results into the encoded version of the
-     * element to be stored into 'intenc' in case it is representable as
-     * an integer: in that case, the function returns LP_ENCODING_INT.
-     * Otherwise if LP_ENCODING_STR is returned, we'll have to call
-     * lpEncodeString() to actually write the encoded string on place later.
-     *
-     * Whatever the returned encoding is, 'enclen' is populated with the
-     * length of the encoded element. */
-    int enctype;
-    if (ele) {
-        enctype = lpEncodeGetType(ele,size,intenc,&enclen);
-    } else {
-        enctype = -1;
-        enclen = 0;
-    }
-
-    /* We need to also encode the backward-parsable length of the element
-     * and append it to the end: this allows to traverse the listpack from
-     * the end to the start. */
-    unsigned long backlen_size = ele ? lpEncodeBacklen(backlen,enclen) : 0;
-    uint64_t old_listpack_bytes = lpGetTotalBytes(lp);
-    uint32_t replaced_len  = 0;
-    if (where == LP_REPLACE) {
-        replaced_len = lpCurrentEncodedSize(p);
-        replaced_len += lpEncodeBacklen(NULL,replaced_len);
-    }
-
-    uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
-                                  - replaced_len;
-    if (new_listpack_bytes > UINT32_MAX) return NULL;
-
-    /* We now need to reallocate in order to make space or shrink the
-     * allocation (in case 'when' value is LP_REPLACE and the new element is
-     * smaller). However we do that before memmoving the memory to
-     * make room for the new element if the final allocation will get
-     * larger, or we do it after if the final allocation will get smaller. */
-
-    unsigned char *dst = lp + poff; /* May be updated after reallocation. */
-
-    /* Realloc before: we need more room. */
-    if (new_listpack_bytes > old_listpack_bytes) {
-        if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
-        dst = lp + poff;
-    }
-
-    /* Setup the listpack relocating the elements to make the exact room
-     * we need to store the new one. */
-    if (where == LP_BEFORE) {
-        memmove(dst+enclen+backlen_size,dst,old_listpack_bytes-poff);
-    } else { /* LP_REPLACE. */
-        long lendiff = (enclen+backlen_size)-replaced_len;
-        memmove(dst+replaced_len+lendiff,
-                dst+replaced_len,
-                old_listpack_bytes-poff-replaced_len);
-    }
-
-    /* Realloc after: we need to free space. */
-    if (new_listpack_bytes < old_listpack_bytes) {
-        if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
-        dst = lp + poff;
-    }
-
-    /* Store the entry. */
-    if (newp) {
-        *newp = dst;
-        /* In case of deletion, set 'newp' to NULL if the next element is
-         * the EOF element. */
-        if (!ele && dst[0] == LP_EOF) *newp = NULL;
-    }
-    if (ele) {
-        if (enctype == LP_ENCODING_INT) {
-            memcpy(dst,intenc,enclen);
-        } else {
-            lpEncodeString(dst,ele,size);
-        }
-        dst += enclen;
-        memcpy(dst,backlen,backlen_size);
-        dst += backlen_size;
-    }
-
-    /* Update header. */
-    if (where != LP_REPLACE || ele == NULL) {
-        uint32_t num_elements = lpGetNumElements(lp);
-        if (num_elements != LP_HDR_NUMELE_UNKNOWN) {
-            if (ele)
-                lpSetNumElements(lp,num_elements+1);
-            else
-                lpSetNumElements(lp,num_elements-1);
-        }
-    }
-    lpSetTotalBytes(lp,new_listpack_bytes);
-    return lp;
-}
-
-/* Append the specified element 'ele' of lenght '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) {
-    uint64_t listpack_bytes = lpGetTotalBytes(lp);
-    unsigned char *eofptr = lp + listpack_bytes - 1;
-    return lpInsert(lp,ele,size,eofptr,LP_BEFORE,NULL);
-}
-
-/* Remove the element pointed by 'p', and return the resulting listpack.
- * If 'newp' is not NULL, the next element pointer (to the right of the
- * deleted one) is returned by reference. If the deleted element was the
- * last one, '*newp' is set to NULL. */
-unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp) {
-    return lpInsert(lp,NULL,0,p,LP_REPLACE,newp);
-}
-
-/* Return the total number of bytes the listpack is composed of. */
-uint32_t lpBytes(unsigned char *lp) {
-    return lpGetTotalBytes(lp);
-}
-
-/* Seek the specified element and returns the pointer to the seeked element.
- * Positive indexes specify the zero-based element to seek from the head to
- * the tail, negative indexes specify elements starting from the tail, where
- * -1 means the last element, -2 the penultimate and so forth. If the index
- * is out of range, NULL is returned. */
-unsigned char *lpSeek(unsigned char *lp, long index) {
-    int forward = 1; /* Seek forward by default. */
-
-    /* We want to seek from left to right or the other way around
-     * depending on the listpack length and the element position.
-     * However if the listpack length cannot be obtained in constant time,
-     * we always seek from left to right. */
-    uint32_t numele = lpGetNumElements(lp);
-    if (numele != LP_HDR_NUMELE_UNKNOWN) {
-        if (index < 0) index = (long)numele+index;
-        if (index < 0) return NULL; /* Index still < 0 means out of range. */
-        if (index >= numele) return NULL; /* Out of range the other side. */
-        /* We want to scan right-to-left if the element we are looking for
-         * is past the half of the listpack. */
-        if (index > numele/2) {
-            forward = 0;
-            /* Left to right scanning always expects a negative index. Convert
-             * our index to negative form. */
-            index -= numele;
-        }
-    } else {
-        /* If the listpack length is unspecified, for negative indexes we
-         * want to always scan left-to-right. */
-        if (index < 0) forward = 0;
-    }
-
-    /* Forward and backward scanning is trivially based on lpNext()/lpPrev(). */
-    if (forward) {
-        unsigned char *ele = lpFirst(lp);
-        while (index > 0 && ele) {
-            ele = lpNext(lp,ele);
-            index--;
-        }
-        return ele;
-    } else {
-        unsigned char *ele = lpLast(lp);
-        while (index < -1 && ele) {
-            ele = lpPrev(lp,ele);
-            index++;
-        }
-        return ele;
-    }
-}
-

src/listpack.h

@@ -1,61 +0,0 @@
-/* Listpack -- A lists of strings serialization format
- *
- * This file implements the specification you can find at:
- *
- *  https://github.com/antirez/listpack
- *
- * Copyright (c) 2017, 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.
- */
-
-#ifndef __LISTPACK_H
-#define __LISTPACK_H
-
-#include <stdint.h>
-
-#define LP_INTBUF_SIZE 21 /* 20 digits of -2^63 + 1 null term = 21. */
-
-/* lpInsert() where argument possible values: */
-#define LP_BEFORE 0
-#define LP_AFTER 1
-#define LP_REPLACE 2
-
-unsigned char *lpNew(void);
-void lpFree(unsigned char *lp);
-unsigned char *lpInsert(unsigned char *lp, unsigned char *ele, uint32_t size, unsigned char *p, int where, unsigned char **newp);
-unsigned char *lpAppend(unsigned char *lp, unsigned char *ele, uint32_t size);
-unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp);
-uint32_t lpLength(unsigned char *lp);
-unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf);
-unsigned char *lpFirst(unsigned char *lp);
-unsigned char *lpLast(unsigned char *lp);
-unsigned char *lpNext(unsigned char *lp, unsigned char *p);
-unsigned char *lpPrev(unsigned char *lp, unsigned char *p);
-uint32_t lpBytes(unsigned char *lp);
-unsigned char *lpSeek(unsigned char *lp, long index);
-
-#endif

src/listpack_malloc.h

@@ -1,45 +0,0 @@
-/* Listpack -- A lists of strings serialization format
- * https://github.com/antirez/listpack
- *
- * Copyright (c) 2017, 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.
- */
-
-/* Allocator selection.
- *
- * This file is used in order to change the Rax allocator at compile time.
- * Just define the following defines to what you want to use. Also add
- * the include of your alternate allocator if needed (not needed in order
- * to use the default libc allocator). */
-
-#ifndef LISTPACK_ALLOC_H
-#define LISTPACK_ALLOC_H
-#include "zmalloc.h"
-#define lp_malloc zmalloc
-#define lp_realloc zrealloc
-#define lp_free zfree
-#endif

src/lzfP.h

@@ -79,11 +79,7 @@
  * Unconditionally aligning does not cost very much, so do it if unsure
  */
 #ifndef STRICT_ALIGN
-# if !(defined(__i386) || defined (__amd64))
-#  define STRICT_ALIGN 1
-# else
-#  define STRICT_ALIGN 0
-# endif
+# define STRICT_ALIGN !(defined(__i386) || defined (__amd64))
 #endif
 
 /*

src/module.c

@@ -216,31 +216,6 @@ static list *moduleUnblockedClients;
  * allow thread safe contexts to execute commands at a safe moment. */
 static pthread_mutex_t moduleGIL = PTHREAD_MUTEX_INITIALIZER;
 
-
-/* Function pointer type for keyspace event notification subscriptions from modules. */
-typedef int (*RedisModuleNotificationFunc) (RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key);
-
-/* Keyspace notification subscriber information.
- * See RM_SubscribeToKeyspaceEvents() for more information. */
-typedef struct RedisModuleKeyspaceSubscriber {
-    /* The module subscribed to the event */
-    RedisModule *module;
-    /* Notification callback in the module*/
-    RedisModuleNotificationFunc notify_callback;
-    /* A bit mask of the events the module is interested in */
-    int event_mask;
-    /* Active flag set on entry, to avoid reentrant subscribers
-     * calling themselves */
-    int active;
-} RedisModuleKeyspaceSubscriber;
-
-/* The module keyspace notification subscribers list */
-static list *moduleKeyspaceSubscribers;
-
-/* Static client recycled for all notification clients, to avoid allocating
- * per round. */
-static client *moduleKeyspaceSubscribersClient;
-
 /* --------------------------------------------------------------------------
  * Prototypes
  * -------------------------------------------------------------------------- */
@@ -638,7 +613,7 @@ int RM_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc c
     sds cmdname = sdsnew(name);
 
     /* Check if the command name is busy. */
-    if (lookupCommand(cmdname) != NULL) {
+    if (lookupCommand((char*)name) != NULL) {
         sdsfree(cmdname);
         return REDISMODULE_ERR;
     }
@@ -673,7 +648,7 @@ int RM_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc c
  *
  * This is an internal function, Redis modules developers don't need
  * to use it. */
-void RM_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int apiver) {
+void RM_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int apiver){
     RedisModule *module;
 
     if (ctx->module != NULL) return;
@@ -685,15 +660,6 @@ void RM_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int api
     ctx->module = module;
 }
 
-/* Return non-zero if the module name is busy.
- * Otherwise zero is returned. */
-int RM_IsModuleNameBusy(const char *name) {
-    sds modulename = sdsnew(name);
-    dictEntry *de = dictFind(modules,modulename);
-    sdsfree(modulename);
-    return de != NULL;
-}
-
 /* Return the current UNIX time in milliseconds. */
 long long RM_Milliseconds(void) {
     return mstime();
@@ -1196,9 +1162,7 @@ int RM_ReplyWithDouble(RedisModuleCtx *ctx, double d) {
  * in the context of a command execution. EXEC will be handled by the
  * RedisModuleCommandDispatcher() function. */
 void moduleReplicateMultiIfNeeded(RedisModuleCtx *ctx) {
-    /* Skip this if client explicitly wrap the command with MULTI, or if
-     * the module command was called by a script. */
-    if (ctx->client->flags & (CLIENT_MULTI|CLIENT_LUA)) return;
+    if (ctx->client->flags & CLIENT_LUA) return;
     /* If we already emitted MULTI return ASAP. */
     if (ctx->flags & REDISMODULE_CTX_MULTI_EMITTED) return;
     /* If this is a thread safe context, we do not want to wrap commands
@@ -1481,20 +1445,6 @@ int RM_DeleteKey(RedisModuleKey *key) {
     return REDISMODULE_OK;
 }
 
-/* If the key is open for writing, unlink it (that is delete it in a 
- * non-blocking way, not reclaiming memory immediately) and setup the key to
- * accept new writes as an empty key (that will be created on demand).
- * On success REDISMODULE_OK is returned. If the key is not open for
- * writing REDISMODULE_ERR is returned. */
-int RM_UnlinkKey(RedisModuleKey *key) {
-    if (!(key->mode & REDISMODULE_WRITE)) return REDISMODULE_ERR;
-    if (key->value) {
-        dbAsyncDelete(key->db,key->key);
-        key->value = NULL;
-    }
-    return REDISMODULE_OK;
-}
-
 /* Return the key expire value, as milliseconds of remaining TTL.
  * If no TTL is associated with the key or if the key is empty,
  * REDISMODULE_NO_EXPIRE is returned. */
@@ -3063,7 +3013,7 @@ int64_t RM_LoadSigned(RedisModuleIO *io) {
 void RM_SaveString(RedisModuleIO *io, RedisModuleString *s) {
     if (io->error) return;
     /* Save opcode. */
-    ssize_t retval = rdbSaveLen(io->rio, RDB_MODULE_OPCODE_STRING);
+    int retval = rdbSaveLen(io->rio, RDB_MODULE_OPCODE_STRING);
     if (retval == -1) goto saveerr;
     io->bytes += retval;
     /* Save value. */
@@ -3081,7 +3031,7 @@ saveerr:
 void RM_SaveStringBuffer(RedisModuleIO *io, const char *str, size_t len) {
     if (io->error) return;
     /* Save opcode. */
-    ssize_t retval = rdbSaveLen(io->rio, RDB_MODULE_OPCODE_STRING);
+    int retval = rdbSaveLen(io->rio, RDB_MODULE_OPCODE_STRING);
     if (retval == -1) goto saveerr;
     io->bytes += retval;
     /* Save value. */
@@ -3694,120 +3644,6 @@ void moduleReleaseGIL(void) {
     pthread_mutex_unlock(&moduleGIL);
 }
 
-
-/* --------------------------------------------------------------------------
- * Module Keyspace Notifications API
- * -------------------------------------------------------------------------- */
-
-/* Subscribe to keyspace notifications. This is a low-level version of the
- * keyspace-notifications API. A module cand register callbacks to be notified
- * when keyspce events occur.
- *
- * Notification events are filtered by their type (string events, set events,
- * etc), and the subsriber callback receives only events that match a specific
- * mask of event types.
- *
- * When subscribing to notifications with RedisModule_SubscribeToKeyspaceEvents 
- * the module must provide an event type-mask, denoting the events the subscriber
- * is interested in. This can be an ORed mask of any of the following flags:
- *
- *  - REDISMODULE_NOTIFY_GENERIC: Generic commands like DEL, EXPIRE, RENAME
- *  - REDISMODULE_NOTIFY_STRING: String events
- *  - REDISMODULE_NOTIFY_LIST: List events
- *  - REDISMODULE_NOTIFY_SET: Set events
- *  - REDISMODULE_NOTIFY_HASH: Hash events
- *  - REDISMODULE_NOTIFY_ZSET: Sorted Set events
- *  - REDISMODULE_NOTIFY_EXPIRED: Expiration events
- *  - REDISMODULE_NOTIFY_EVICTED: Eviction events
- *  - REDISMODULE_NOTIFY_STREAM: Stream events
- *  - REDISMODULE_NOTIFY_ALL: All events
- *
- * We do not distinguish between key events and keyspace events, and it is up
- * to the module to filter the actions taken based on the key.
- *
- * The subscriber signature is:
- *
- *   int (*RedisModuleNotificationFunc) (RedisModuleCtx *ctx, int type,
- *                                       const char *event,
- *                                       RedisModuleString *key);
- *
- * `type` is the event type bit, that must match the mask given at registration
- * time. The event string is the actual command being executed, and key is the
- * relevant Redis key.
- *
- * 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.
- *
- * Notice that it is not necessary to enable norifications in redis.conf for
- * module notifications to work.
- *
- * Warning: the notification callbacks are performed in a synchronous manner,
- * so notification callbacks must to be fast, or they would slow Redis down.
- * If you need to take long actions, use threads to offload them.
- *
- * See https://redis.io/topics/notifications for more information.
- */
-int RM_SubscribeToKeyspaceEvents(RedisModuleCtx *ctx, int types, RedisModuleNotificationFunc callback) {
-    RedisModuleKeyspaceSubscriber *sub = zmalloc(sizeof(*sub));
-    sub->module = ctx->module;
-    sub->event_mask = types;
-    sub->notify_callback = callback;
-    sub->active = 0;
-
-    listAddNodeTail(moduleKeyspaceSubscribers, sub);
-    return REDISMODULE_OK;
-}
-
-/* Dispatcher for keyspace notifications to module subscriber functions.
- * This gets called  only if at least one module requested to be notified on
- * keyspace notifications */
-void moduleNotifyKeyspaceEvent(int type, const char *event, robj *key, int dbid) {
-    /* Don't do anything if there aren't any subscribers */
-    if (listLength(moduleKeyspaceSubscribers) == 0) return;
-
-    listIter li;
-    listNode *ln;
-    listRewind(moduleKeyspaceSubscribers,&li);
-
-    /* Remove irrelevant flags from the type mask */
-    type &= ~(NOTIFY_KEYEVENT | NOTIFY_KEYSPACE);
-
-    while((ln = listNext(&li))) {
-        RedisModuleKeyspaceSubscriber *sub = ln->value;
-        /* Only notify subscribers on events matching they registration,
-         * and avoid subscribers triggering themselves */
-        if ((sub->event_mask & type) && sub->active == 0) {
-            RedisModuleCtx ctx = REDISMODULE_CTX_INIT;
-            ctx.module = sub->module;
-            ctx.client = moduleKeyspaceSubscribersClient;
-            selectDb(ctx.client, dbid);
-
-            /* mark the handler as activer to avoid reentrant loops.
-             * If the subscriber performs an action triggering itself,
-             * it will not be notified about it. */
-            sub->active = 1;
-            sub->notify_callback(&ctx, type, event, key);
-            sub->active = 0;
-            moduleFreeContext(&ctx);
-        }
-    }
-}
-
-/* Unsubscribe any notification subscirbers this module has upon unloading */
-void moduleUnsubscribeNotifications(RedisModule *module) {
-    listIter li;
-    listNode *ln;
-    listRewind(moduleKeyspaceSubscribers,&li);
-    while((ln = listNext(&li))) {
-        RedisModuleKeyspaceSubscriber *sub = ln->value;
-        if (sub->module == module) {
-            listDelNode(moduleKeyspaceSubscribers, ln);
-            zfree(sub);
-        }
-    }
-}
-
 /* --------------------------------------------------------------------------
  * Modules API internals
  * -------------------------------------------------------------------------- */
@@ -3845,14 +3681,9 @@ void moduleRegisterCoreAPI(void);
 
 void moduleInitModulesSystem(void) {
     moduleUnblockedClients = listCreate();
+
     server.loadmodule_queue = listCreate();
     modules = dictCreate(&modulesDictType,NULL);
-
-    /* Set up the keyspace notification susbscriber list and static client */
-    moduleKeyspaceSubscribers = listCreate();
-    moduleKeyspaceSubscribersClient = createClient(-1);
-    moduleKeyspaceSubscribersClient->flags |= CLIENT_MODULE;
-
     moduleRegisterCoreAPI();
     if (pipe(server.module_blocked_pipe) == -1) {
         serverLog(LL_WARNING,
@@ -3903,28 +3734,6 @@ void moduleFreeModuleStructure(struct RedisModule *module) {
     zfree(module);
 }
 
-void moduleUnregisterCommands(struct RedisModule *module) {
-    /* Unregister all the commands registered by this module. */
-    dictIterator *di = dictGetSafeIterator(server.commands);
-    dictEntry *de;
-    while ((de = dictNext(di)) != NULL) {
-        struct redisCommand *cmd = dictGetVal(de);
-        if (cmd->proc == RedisModuleCommandDispatcher) {
-            RedisModuleCommandProxy *cp =
-                (void*)(unsigned long)cmd->getkeys_proc;
-            sds cmdname = cp->rediscmd->name;
-            if (cp->module == module) {
-                dictDelete(server.commands,cmdname);
-                dictDelete(server.orig_commands,cmdname);
-                sdsfree(cmdname);
-                zfree(cp->rediscmd);
-                zfree(cp);
-            }
-        }
-    }
-    dictReleaseIterator(di);
-}
-
 /* Load a module and initialize it. On success C_OK is returned, otherwise
  * C_ERR is returned. */
 int moduleLoad(const char *path, void **module_argv, int module_argc) {
@@ -3945,10 +3754,7 @@ int moduleLoad(const char *path, void **module_argv, int module_argc) {
         return C_ERR;
     }
     if (onload((void*)&ctx,module_argv,module_argc) == REDISMODULE_ERR) {
-        if (ctx.module) {
-            moduleUnregisterCommands(ctx.module);
-            moduleFreeModuleStructure(ctx.module);
-        }
+        if (ctx.module) moduleFreeModuleStructure(ctx.module);
         dlclose(handle);
         serverLog(LL_WARNING,
             "Module %s initialization failed. Module not loaded",path);
@@ -3963,7 +3769,6 @@ int moduleLoad(const char *path, void **module_argv, int module_argc) {
     return C_OK;
 }
 
-
 /* Unload the module registered with the specified name. On success
  * C_OK is returned, otherwise C_ERR is returned and errno is set
  * to the following values depending on the type of error:
@@ -3983,10 +3788,25 @@ int moduleUnload(sds name) {
         return REDISMODULE_ERR;
     }
 
-    moduleUnregisterCommands(module);
-
-    /* Remvoe any noification subscribers this module might have */
-    moduleUnsubscribeNotifications(module);
+    /* Unregister all the commands registered by this module. */
+    dictIterator *di = dictGetSafeIterator(server.commands);
+    dictEntry *de;
+    while ((de = dictNext(di)) != NULL) {
+        struct redisCommand *cmd = dictGetVal(de);
+        if (cmd->proc == RedisModuleCommandDispatcher) {
+            RedisModuleCommandProxy *cp =
+                (void*)(unsigned long)cmd->getkeys_proc;
+            sds cmdname = cp->rediscmd->name;
+            if (cp->module == module) {
+                dictDelete(server.commands,cmdname);
+                dictDelete(server.orig_commands,cmdname);
+                sdsfree(cmdname);
+                zfree(cp->rediscmd);
+                zfree(cp);
+            }
+        }
+    }
+    dictReleaseIterator(di);
 
     /* Unregister all the hooks. TODO: Yet no hooks support here. */
 
@@ -4081,7 +3901,6 @@ void moduleRegisterCoreAPI(void) {
     REGISTER_API(Strdup);
     REGISTER_API(CreateCommand);
     REGISTER_API(SetModuleAttribs);
-    REGISTER_API(IsModuleNameBusy);
     REGISTER_API(WrongArity);
     REGISTER_API(ReplyWithLongLong);
     REGISTER_API(ReplyWithError);
@@ -4122,7 +3941,6 @@ void moduleRegisterCoreAPI(void) {
     REGISTER_API(Replicate);
     REGISTER_API(ReplicateVerbatim);
     REGISTER_API(DeleteKey);
-    REGISTER_API(UnlinkKey);
     REGISTER_API(StringSet);
     REGISTER_API(StringDMA);
     REGISTER_API(StringTruncate);
@@ -4185,5 +4003,4 @@ void moduleRegisterCoreAPI(void) {
     REGISTER_API(DigestAddStringBuffer);
     REGISTER_API(DigestAddLongLong);
     REGISTER_API(DigestEndSequence);
-    REGISTER_API(SubscribeToKeyspaceEvents);
 }

src/modules/testmodule.c

@@ -30,7 +30,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#define REDISMODULE_EXPERIMENTAL_API
 #include "../redismodule.h"
 #include <string.h>
 
@@ -121,187 +120,81 @@ int TestStringPrintf(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
     return REDISMODULE_OK;
 }
 
-int failTest(RedisModuleCtx *ctx, const char *msg) {
-    RedisModule_ReplyWithError(ctx, msg);
-    return REDISMODULE_ERR;
-}
-
-int TestUnlink(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    RedisModule_AutoMemory(ctx);
-    REDISMODULE_NOT_USED(argv);
-    REDISMODULE_NOT_USED(argc);
-
-    RedisModuleKey *k = RedisModule_OpenKey(ctx, RedisModule_CreateStringPrintf(ctx, "unlinked"), REDISMODULE_WRITE | REDISMODULE_READ);
-    if (!k) return failTest(ctx, "Could not create key");
-    
-    if (REDISMODULE_ERR == RedisModule_StringSet(k, RedisModule_CreateStringPrintf(ctx, "Foobar"))) {
-        return failTest(ctx, "Could not set string value");
-    }
-
-    RedisModuleCallReply *rep = RedisModule_Call(ctx, "EXISTS", "c", "unlinked");
-    if (!rep || RedisModule_CallReplyInteger(rep) != 1) {
-        return failTest(ctx, "Key does not exist before unlink");
-    }
-
-    if (REDISMODULE_ERR == RedisModule_UnlinkKey(k)) {
-        return failTest(ctx, "Could not unlink key");
-    }
-
-    rep = RedisModule_Call(ctx, "EXISTS", "c", "unlinked");
-    if (!rep || RedisModule_CallReplyInteger(rep) != 0) {
-        return failTest(ctx, "Could not verify key to be unlinked");
-    }
-    return RedisModule_ReplyWithSimpleString(ctx, "OK");
-    
-}
-
-int NotifyCallback(RedisModuleCtx *ctx, int type, const char *event,
-                   RedisModuleString *key) {
-  /* Increment a counter on the notifications: for each key notified we
-   * increment a counter */
-  RedisModule_Log(ctx, "notice", "Got event type %d, event %s, key %s", type,
-                  event, RedisModule_StringPtrLen(key, NULL));
-
-  RedisModule_Call(ctx, "HINCRBY", "csc", "notifications", key, "1");
-  return REDISMODULE_OK;
-}
-
-/* TEST.NOTIFICATIONS -- Test Keyspace Notifications. */
-int TestNotifications(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    REDISMODULE_NOT_USED(argv);
-    REDISMODULE_NOT_USED(argc);
-
-#define FAIL(msg, ...)                                                                       \
-    {                                                                                        \
-        RedisModule_Log(ctx, "warning", "Failed NOTIFY Test. Reason: " #msg, ##__VA_ARGS__); \
-        goto err;                                                                            \
-    }
-    RedisModule_Call(ctx, "FLUSHDB", "");
-
-    RedisModule_Call(ctx, "SET", "cc", "foo", "bar");
-    RedisModule_Call(ctx, "SET", "cc", "foo", "baz");
-    RedisModule_Call(ctx, "SADD", "cc", "bar", "x");
-    RedisModule_Call(ctx, "SADD", "cc", "bar", "y");
-
-    RedisModule_Call(ctx, "HSET", "ccc", "baz", "x", "y");
-    /* LPUSH should be ignored and not increment any counters */
-    RedisModule_Call(ctx, "LPUSH", "cc", "l", "y");
-    RedisModule_Call(ctx, "LPUSH", "cc", "l", "y");
-
-    size_t sz;
-    const char *rep;
-    RedisModuleCallReply *r = RedisModule_Call(ctx, "HGET", "cc", "notifications", "foo");
-    if (r == NULL || RedisModule_CallReplyType(r) != REDISMODULE_REPLY_STRING) {
-        FAIL("Wrong or no reply for foo");
-    } else {
-        rep = RedisModule_CallReplyStringPtr(r, &sz);
-        if (sz != 1 || *rep != '2') {
-            FAIL("Got reply '%s'. expected '2'", RedisModule_CallReplyStringPtr(r, NULL));
-        }
-    }
-
-    r = RedisModule_Call(ctx, "HGET", "cc", "notifications", "bar");
-    if (r == NULL || RedisModule_CallReplyType(r) != REDISMODULE_REPLY_STRING) {
-        FAIL("Wrong or no reply for bar");
-    } else {
-        rep = RedisModule_CallReplyStringPtr(r, &sz);
-        if (sz != 1 || *rep != '2') {
-            FAIL("Got reply '%s'. expected '2'", rep);
-        }
-    }
-
-    r = RedisModule_Call(ctx, "HGET", "cc", "notifications", "baz");
-    if (r == NULL || RedisModule_CallReplyType(r) != REDISMODULE_REPLY_STRING) {
-        FAIL("Wrong or no reply for baz");
-    } else {
-        rep = RedisModule_CallReplyStringPtr(r, &sz);
-        if (sz != 1 || *rep != '1') {
-            FAIL("Got reply '%.*s'. expected '1'", sz, rep);
-        }
-    }
-    /* For l we expect nothing since we didn't subscribe to list events */
-    r = RedisModule_Call(ctx, "HGET", "cc", "notifications", "l");
-    if (r == NULL || RedisModule_CallReplyType(r) != REDISMODULE_REPLY_NULL) {
-        FAIL("Wrong reply for l");
-    }
-
-    RedisModule_Call(ctx, "FLUSHDB", "");
-
-    return RedisModule_ReplyWithSimpleString(ctx, "OK");
-err:
-    RedisModule_Call(ctx, "FLUSHDB", "");
-
-    return RedisModule_ReplyWithSimpleString(ctx, "ERR");
-}
 
 /* TEST.CTXFLAGS -- Test GetContextFlags. */
 int TestCtxFlags(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
     REDISMODULE_NOT_USED(argc);
     REDISMODULE_NOT_USED(argv);
-
+  
     RedisModule_AutoMemory(ctx);
-
+  
     int ok = 1;
     const char *errString = NULL;
-#undef FAIL
-#define FAIL(msg)        \
-    {                    \
-        ok = 0;          \
-        errString = msg; \
-        goto end;        \
+  
+  #define FAIL(msg)    \
+    {                  \
+      ok = 0;          \
+      errString = msg; \
+      goto end;        \
     }
-
+  
     int flags = RedisModule_GetContextFlags(ctx);
     if (flags == 0) {
-        FAIL("Got no flags");
+      FAIL("Got no flags");
     }
-
+  
     if (flags & REDISMODULE_CTX_FLAGS_LUA) FAIL("Lua flag was set");
     if (flags & REDISMODULE_CTX_FLAGS_MULTI) FAIL("Multi flag was set");
-
+  
     if (flags & REDISMODULE_CTX_FLAGS_AOF) FAIL("AOF Flag was set")
     /* Enable AOF to test AOF flags */
     RedisModule_Call(ctx, "config", "ccc", "set", "appendonly", "yes");
     flags = RedisModule_GetContextFlags(ctx);
-    if (!(flags & REDISMODULE_CTX_FLAGS_AOF)) FAIL("AOF Flag not set after config set");
-
+    if (!(flags & REDISMODULE_CTX_FLAGS_AOF))
+      FAIL("AOF Flag not set after config set");
+  
     if (flags & REDISMODULE_CTX_FLAGS_RDB) FAIL("RDB Flag was set");
     /* Enable RDB to test RDB flags */
     RedisModule_Call(ctx, "config", "ccc", "set", "save", "900 1");
     flags = RedisModule_GetContextFlags(ctx);
-    if (!(flags & REDISMODULE_CTX_FLAGS_RDB)) FAIL("RDB Flag was not set after config set");
-
+    if (!(flags & REDISMODULE_CTX_FLAGS_RDB))
+      FAIL("RDB Flag was not set after config set");
+  
     if (!(flags & REDISMODULE_CTX_FLAGS_MASTER)) FAIL("Master flag was not set");
     if (flags & REDISMODULE_CTX_FLAGS_SLAVE) FAIL("Slave flag was set");
     if (flags & REDISMODULE_CTX_FLAGS_READONLY) FAIL("Read-only flag was set");
     if (flags & REDISMODULE_CTX_FLAGS_CLUSTER) FAIL("Cluster flag was set");
-
+  
     if (flags & REDISMODULE_CTX_FLAGS_MAXMEMORY) FAIL("Maxmemory flag was set");
-
+    ;
     RedisModule_Call(ctx, "config", "ccc", "set", "maxmemory", "100000000");
     flags = RedisModule_GetContextFlags(ctx);
     if (!(flags & REDISMODULE_CTX_FLAGS_MAXMEMORY))
-        FAIL("Maxmemory flag was not set after config set");
-
+      FAIL("Maxmemory flag was not set after config set");
+  
     if (flags & REDISMODULE_CTX_FLAGS_EVICT) FAIL("Eviction flag was set");
-    RedisModule_Call(ctx, "config", "ccc", "set", "maxmemory-policy", "allkeys-lru");
+    RedisModule_Call(ctx, "config", "ccc", "set", "maxmemory-policy",
+                     "allkeys-lru");
     flags = RedisModule_GetContextFlags(ctx);
-    if (!(flags & REDISMODULE_CTX_FLAGS_EVICT)) FAIL("Eviction flag was not set after config set");
-
-end:
+    if (!(flags & REDISMODULE_CTX_FLAGS_EVICT))
+      FAIL("Eviction flag was not set after config set");
+  
+  end:
     /* Revert config changes */
     RedisModule_Call(ctx, "config", "ccc", "set", "appendonly", "no");
     RedisModule_Call(ctx, "config", "ccc", "set", "save", "");
     RedisModule_Call(ctx, "config", "ccc", "set", "maxmemory", "0");
     RedisModule_Call(ctx, "config", "ccc", "set", "maxmemory-policy", "noeviction");
-
+  
     if (!ok) {
-        RedisModule_Log(ctx, "warning", "Failed CTXFLAGS Test. Reason: %s", errString);
-        return RedisModule_ReplyWithSimpleString(ctx, "ERR");
+      RedisModule_Log(ctx, "warning", "Failed CTXFLAGS Test. Reason: %s",
+                      errString);
+      return RedisModule_ReplyWithSimpleString(ctx, "ERR");
     }
-
+  
     return RedisModule_ReplyWithSimpleString(ctx, "OK");
-}
+  }
+
 
 /* ----------------------------- Test framework ----------------------------- */
 
@@ -376,18 +269,12 @@ int TestIt(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
     T("test.string.append","");
     if (!TestAssertStringReply(ctx,reply,"foobar",6)) goto fail;
 
-    T("test.unlink","");
-    if (!TestAssertStringReply(ctx,reply,"OK",2)) goto fail;
-
     T("test.string.append.am","");
     if (!TestAssertStringReply(ctx,reply,"foobar",6)) goto fail;
 
     T("test.string.printf", "cc", "foo", "bar");
     if (!TestAssertStringReply(ctx,reply,"Got 3 args. argv[1]: foo, argv[2]: bar",38)) goto fail;
 
-    T("test.notify", "");
-    if (!TestAssertStringReply(ctx,reply,"OK",2)) goto fail;
-
     RedisModule_ReplyWithSimpleString(ctx,"ALL TESTS PASSED");
     return REDISMODULE_OK;
 
@@ -423,23 +310,10 @@ int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
     if (RedisModule_CreateCommand(ctx,"test.ctxflags",
         TestCtxFlags,"readonly",1,1,1) == REDISMODULE_ERR)
         return REDISMODULE_ERR;
-    
-    if (RedisModule_CreateCommand(ctx,"test.unlink",
-        TestUnlink,"write deny-oom",1,1,1) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
 
     if (RedisModule_CreateCommand(ctx,"test.it",
         TestIt,"readonly",1,1,1) == REDISMODULE_ERR)
         return REDISMODULE_ERR;
 
-    RedisModule_SubscribeToKeyspaceEvents(ctx,
-                                            REDISMODULE_NOTIFY_HASH |
-                                            REDISMODULE_NOTIFY_SET |
-                                            REDISMODULE_NOTIFY_STRING,
-                                        NotifyCallback);
-    if (RedisModule_CreateCommand(ctx,"test.notify",
-        TestNotifications,"write deny-oom",1,1,1) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
     return REDISMODULE_OK;
 }

src/networking.c

@@ -33,7 +33,7 @@
 #include <math.h>
 #include <ctype.h>
 
-static void setProtocolError(const char *errstr, client *c, long pos);
+static void setProtocolError(const char *errstr, client *c, int pos);
 
 /* Return the size consumed from the allocator, for the specified SDS string,
  * including internal fragmentation. This function is used in order to compute
@@ -67,16 +67,6 @@ int listMatchObjects(void *a, void *b) {
     return equalStringObjects(a,b);
 }
 
-/* This function links the client to the global linked list of clients.
- * unlinkClient() does the opposite, among other things. */
-void linkClient(client *c) {
-    listAddNodeTail(server.clients,c);
-    /* Note that we remember the linked list node where the client is stored,
-     * 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);
-}
-
 client *createClient(int fd) {
     client *c = zmalloc(sizeof(client));
 
@@ -134,21 +124,18 @@ client *createClient(int fd) {
     listSetDupMethod(c->reply,dupClientReplyValue);
     c->btype = BLOCKED_NONE;
     c->bpop.timeout = 0;
-    c->bpop.keys = dictCreate(&objectKeyHeapPointerValueDictType,NULL);
+    c->bpop.keys = dictCreate(&objectKeyPointerValueDictType,NULL);
     c->bpop.target = NULL;
-    c->bpop.xread_group = NULL;
     c->bpop.numreplicas = 0;
-    c->bpop.aofepoch = 0;
     c->bpop.reploffset = 0;
     c->woff = 0;
     c->watched_keys = listCreate();
     c->pubsub_channels = dictCreate(&objectKeyPointerValueDictType,NULL);
     c->pubsub_patterns = listCreate();
     c->peerid = NULL;
-    c->client_list_node = NULL;
     listSetFreeMethod(c->pubsub_patterns,decrRefCountVoid);
     listSetMatchMethod(c->pubsub_patterns,listMatchObjects);
-    if (fd != -1) linkClient(c);
+    if (fd != -1) listAddNodeTail(server.clients,c);
     initClientMultiState(c);
     return c;
 }
@@ -389,12 +376,6 @@ void addReplyErrorLength(client *c, const char *s, size_t len) {
     addReplyString(c,"-ERR ",5);
     addReplyString(c,s,len);
     addReplyString(c,"\r\n",2);
-    if (c->flags & CLIENT_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);
-    }
 }
 
 void addReplyError(client *c, const char *err) {
@@ -585,7 +566,7 @@ void addReplyBulkSds(client *c, sds s)  {
     addReply(c,shared.crlf);
 }
 
-/* Add a C null term string as bulk reply */
+/* Add a C nul term string as bulk reply */
 void addReplyBulkCString(client *c, const char *s) {
     if (s == NULL) {
         addReply(c,shared.nullbulk);
@@ -603,26 +584,6 @@ void addReplyBulkLongLong(client *c, long long ll) {
     addReplyBulkCBuffer(c,buf,len);
 }
 
-/* Add an array of C strings as status replies with a heading.
- * This function is typically invoked by from commands that support
- * subcommands in response to the 'help' subcommand. The help array
- * is terminated by NULL sentinel. */
-void addReplyHelp(client *c, const char **help) {
-    sds cmd = sdsnew((char*) c->argv[0]->ptr);
-    void *blenp = addDeferredMultiBulkLength(c);
-    int blen = 0;
-
-    sdstoupper(cmd);
-    addReplyStatusFormat(c,
-        "%s <subcommand> arg arg ... arg. Subcommands are:",cmd);
-    sdsfree(cmd);
-
-    while (help[blen]) addReplyStatus(c,help[blen++]);
-
-    blen++;  /* Account for the header line(s). */
-    setDeferredMultiBulkLength(c,blenp,blen);
-}
-
 /* Copy 'src' client output buffers into 'dst' client output buffers.
  * The function takes care of freeing the old output buffers of the
  * destination client. */
@@ -782,10 +743,9 @@ void unlinkClient(client *c) {
      * fd is already set to -1. */
     if (c->fd != -1) {
         /* Remove from the list of active clients. */
-        if (c->client_list_node) {
-            listDelNode(server.clients,c->client_list_node);
-            c->client_list_node = NULL;
-        }
+        ln = listSearchKey(server.clients,c);
+        serverAssert(ln != NULL);
+        listDelNode(server.clients,ln);
 
         /* Unregister async I/O handlers and close the socket. */
         aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
@@ -979,15 +939,10 @@ int writeToClient(int fd, client *c, int handler_installed) {
          * scenario think about 'KEYS *' against the loopback interface).
          *
          * However if we are over the maxmemory limit we ignore that and
-         * just deliver as much data as it is possible to deliver.
-         *
-         * Moreover, we also send as much as possible if the client is
-         * a slave (otherwise, on high-speed traffic, the replication
-         * buffer will grow indefinitely) */
+         * just deliver as much data as it is possible to deliver. */
         if (totwritten > NET_MAX_WRITES_PER_EVENT &&
             (server.maxmemory == 0 ||
-             zmalloc_used_memory() < server.maxmemory) &&
-            !(c->flags & CLIENT_SLAVE)) break;
+             zmalloc_used_memory() < server.maxmemory)) break;
     }
     server.stat_net_output_bytes += totwritten;
     if (nwritten == -1) {
@@ -1045,25 +1000,13 @@ int handleClientsWithPendingWrites(void) {
         /* Try to write buffers to the client socket. */
         if (writeToClient(c->fd,c,0) == C_ERR) continue;
 
-        /* If after the synchronous writes above we still have data to
-         * output to the client, we need to install the writable handler. */
-        if (clientHasPendingReplies(c)) {
-            int ae_flags = AE_WRITABLE;
-            /* For the fsync=always policy, we want that a given FD is never
-             * served for reading and writing in the same event loop iteration,
-             * so that in the middle of receiving the query, and serving it
-             * to the client, we'll call beforeSleep() that will do the
-             * actual fsync of AOF to disk. AE_BARRIER ensures that. */
-            if (server.aof_state == AOF_ON &&
-                server.aof_fsync == AOF_FSYNC_ALWAYS)
-            {
-                ae_flags |= AE_BARRIER;
-            }
-            if (aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
+        /* If there is nothing left, do nothing. Otherwise install
+         * the write handler. */
+        if (clientHasPendingReplies(c) &&
+            aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
                 sendReplyToClient, c) == AE_ERR)
-            {
-                    freeClientAsync(c);
-            }
+        {
+            freeClientAsync(c);
         }
     }
     return processed;
@@ -1164,7 +1107,7 @@ int processInlineBuffer(client *c) {
 /* Helper function. Trims query buffer to make the function that processes
  * multi bulk requests idempotent. */
 #define PROTO_DUMP_LEN 128
-static void setProtocolError(const char *errstr, client *c, long pos) {
+static void setProtocolError(const char *errstr, client *c, int pos) {
     if (server.verbosity <= LL_VERBOSE) {
         sds client = catClientInfoString(sdsempty(),c);
 
@@ -1205,8 +1148,7 @@ static void setProtocolError(const char *errstr, client *c, long pos) {
  * to be '*'. Otherwise for inline commands processInlineBuffer() is called. */
 int processMultibulkBuffer(client *c) {
     char *newline = NULL;
-    long pos = 0;
-    int ok;
+    int pos = 0, ok;
     long long ll;
 
     if (c->multibulklen == 0) {
@@ -1278,7 +1220,7 @@ int processMultibulkBuffer(client *c) {
             }
 
             ok = string2ll(c->querybuf+pos+1,newline-(c->querybuf+pos+1),&ll);
-            if (!ok || ll < 0 || ll > server.proto_max_bulk_len) {
+            if (!ok || ll < 0 || ll > 512*1024*1024) {
                 addReplyError(c,"Protocol error: invalid bulk length");
                 setProtocolError("invalid bulk length",c,pos);
                 return C_ERR;
@@ -1304,7 +1246,7 @@ int processMultibulkBuffer(client *c) {
         }
 
         /* Read bulk argument */
-        if (sdslen(c->querybuf)-pos < (size_t)(c->bulklen+2)) {
+        if (sdslen(c->querybuf)-pos < (unsigned)(c->bulklen+2)) {
             /* Not enough data (+2 == trailing \r\n) */
             break;
         } else {
@@ -1313,13 +1255,13 @@ int processMultibulkBuffer(client *c) {
              * just use the current sds string. */
             if (pos == 0 &&
                 c->bulklen >= PROTO_MBULK_BIG_ARG &&
-                sdslen(c->querybuf) == (size_t)(c->bulklen+2))
+                (signed) sdslen(c->querybuf) == c->bulklen+2)
             {
                 c->argv[c->argc++] = createObject(OBJ_STRING,c->querybuf);
                 sdsIncrLen(c->querybuf,-2); /* remove CRLF */
                 /* Assume that if we saw a fat argument we'll see another one
                  * likely... */
-                c->querybuf = sdsnewlen(SDS_NOINIT,c->bulklen+2);
+                c->querybuf = sdsnewlen(NULL,c->bulklen+2);
                 sdsclear(c->querybuf);
                 pos = 0;
             } else {
@@ -1424,7 +1366,7 @@ void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
     if (c->reqtype == PROTO_REQ_MULTIBULK && c->multibulklen && c->bulklen != -1
         && c->bulklen >= PROTO_MBULK_BIG_ARG)
     {
-        ssize_t remaining = (size_t)(c->bulklen+2)-sdslen(c->querybuf);
+        int remaining = (unsigned)(c->bulklen+2)-sdslen(c->querybuf);
 
         if (remaining < readlen) readlen = remaining;
     }
@@ -1598,7 +1540,7 @@ sds getAllClientsInfoString(void) {
     listNode *ln;
     listIter li;
     client *client;
-    sds o = sdsnewlen(SDS_NOINIT,200*listLength(server.clients));
+    sds o = sdsnewlen(NULL,200*listLength(server.clients));
     sdsclear(o);
     listRewind(server.clients,&li);
     while ((ln = listNext(&li)) != NULL) {
@@ -1614,22 +1556,7 @@ void clientCommand(client *c) {
     listIter li;
     client *client;
 
-    if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {
-        const char *help[] = {
-"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.",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (!strcasecmp(c->argv[1]->ptr,"list") && c->argc == 2) {
+    if (!strcasecmp(c->argv[1]->ptr,"list") && c->argc == 2) {
         /* CLIENT LIST */
         sds o = getAllClientsInfoString();
         addReplyBulkCBuffer(c,o,sdslen(o));
@@ -1775,7 +1702,7 @@ NULL
         pauseClients(duration);
         addReply(c,shared.ok);
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try CLIENT HELP", (char*)c->argv[1]->ptr);
+        addReplyError(c, "Syntax error, try CLIENT (LIST | KILL | GETNAME | SETNAME | PAUSE | REPLY)");
     }
 }
 

src/notify.c

@@ -54,7 +54,6 @@ int keyspaceEventsStringToFlags(char *classes) {
         case 'e': flags |= NOTIFY_EVICTED; break;
         case 'K': flags |= NOTIFY_KEYSPACE; break;
         case 'E': flags |= NOTIFY_KEYEVENT; break;
-        case 't': flags |= NOTIFY_STREAM; break;
         default: return -1;
         }
     }
@@ -80,7 +79,6 @@ sds keyspaceEventsFlagsToString(int flags) {
         if (flags & NOTIFY_ZSET) res = sdscatlen(res,"z",1);
         if (flags & NOTIFY_EXPIRED) res = sdscatlen(res,"x",1);
         if (flags & NOTIFY_EVICTED) res = sdscatlen(res,"e",1);
-        if (flags & NOTIFY_STREAM) res = sdscatlen(res,"t",1);
     }
     if (flags & NOTIFY_KEYSPACE) res = sdscatlen(res,"K",1);
     if (flags & NOTIFY_KEYEVENT) res = sdscatlen(res,"E",1);
@@ -100,12 +98,6 @@ void notifyKeyspaceEvent(int type, char *event, robj *key, int dbid) {
     int len = -1;
     char buf[24];
 
-    /* If any modules are interested in events, notify the module system now. 
-     * This bypasses the notifications configuration, but the module engine
-     * will only call event subscribers if the event type matches the types
-     * they are interested in. */
-     moduleNotifyKeyspaceEvent(type, event, key, dbid);
-    
     /* If notifications for this class of events are off, return ASAP. */
     if (!(server.notify_keyspace_events & type)) return;
 
@@ -123,7 +115,7 @@ void notifyKeyspaceEvent(int type, char *event, robj *key, int dbid) {
         decrRefCount(chanobj);
     }
 
-    /* __keyevent@<db>__:<event> <key> notifications. */
+    /* __keyevente@<db>__:<event> <key> notifications. */
     if (server.notify_keyspace_events & NOTIFY_KEYEVENT) {
         chan = sdsnewlen("__keyevent@",11);
         if (len == -1) len = ll2string(buf,sizeof(buf),dbid);

src/object.c

@@ -98,9 +98,7 @@ robj *createEmbeddedStringObject(const char *ptr, size_t len) {
     sh->len = len;
     sh->alloc = len;
     sh->flags = SDS_TYPE_8;
-    if (ptr == SDS_NOINIT)
-        sh->buf[len] = '\0';
-    else if (ptr) {
+    if (ptr) {
         memcpy(sh->buf,ptr,len);
         sh->buf[len] = '\0';
     } else {
@@ -147,7 +145,7 @@ robj *createStringObjectFromLongLong(long long value) {
  *
  * The 'humanfriendly' option is used for INCRBYFLOAT and HINCRBYFLOAT. */
 robj *createStringObjectFromLongDouble(long double value, int humanfriendly) {
-    char buf[MAX_LONG_DOUBLE_CHARS];
+    char buf[256];
     int len = ld2string(buf,sizeof(buf),value,humanfriendly);
     return createStringObject(buf,len);
 }
@@ -234,13 +232,6 @@ robj *createZsetZiplistObject(void) {
     return o;
 }
 
-robj *createStreamObject(void) {
-    stream *s = streamNew();
-    robj *o = createObject(OBJ_STREAM,s);
-    o->encoding = OBJ_ENCODING_STREAM;
-    return o;
-}
-
 robj *createModuleObject(moduleType *mt, void *value) {
     moduleValue *mv = zmalloc(sizeof(*mv));
     mv->type = mt;
@@ -312,10 +303,6 @@ void freeModuleObject(robj *o) {
     zfree(mv);
 }
 
-void freeStreamObject(robj *o) {
-    freeStream(o->ptr);
-}
-
 void incrRefCount(robj *o) {
     if (o->refcount != OBJ_SHARED_REFCOUNT) o->refcount++;
 }
@@ -329,7 +316,6 @@ void decrRefCount(robj *o) {
         case OBJ_ZSET: freeZsetObject(o); break;
         case OBJ_HASH: freeHashObject(o); break;
         case OBJ_MODULE: freeModuleObject(o); break;
-        case OBJ_STREAM: freeStreamObject(o); break;
         default: serverPanic("Unknown object type"); break;
         }
         zfree(o);
@@ -574,7 +560,7 @@ int getDoubleFromObject(const robj *o, double *target) {
             value = strtod(o->ptr, &eptr);
             if (sdslen(o->ptr) == 0 ||
                 isspace(((const char*)o->ptr)[0]) ||
-                (size_t)(eptr-(char*)o->ptr) != sdslen(o->ptr) ||
+                eptr[0] != '\0' ||
                 (errno == ERANGE &&
                     (value == HUGE_VAL || value == -HUGE_VAL || value == 0)) ||
                 isnan(value))
@@ -616,7 +602,7 @@ int getLongDoubleFromObject(robj *o, long double *target) {
             value = strtold(o->ptr, &eptr);
             if (sdslen(o->ptr) == 0 ||
                 isspace(((const char*)o->ptr)[0]) ||
-                (size_t)(eptr-(char*)o->ptr) != sdslen(o->ptr) ||
+                eptr[0] != '\0' ||
                 (errno == ERANGE &&
                     (value == HUGE_VAL || value == -HUGE_VAL || value == 0)) ||
                 isnan(value))
@@ -741,7 +727,7 @@ size_t objectComputeSize(robj *o, size_t sample_size) {
                 elesize += sizeof(quicklistNode)+ziplistBlobLen(node->zl);
                 samples++;
             } while ((node = node->next) && samples < sample_size);
-            asize += (double)elesize/samples*ql->len;
+            asize += (double)elesize/samples*listTypeLength(o);
         } else if (o->encoding == OBJ_ENCODING_ZIPLIST) {
             asize = sizeof(*o)+ziplistBlobLen(o->ptr);
         } else {
@@ -802,49 +788,6 @@ size_t objectComputeSize(robj *o, size_t sample_size) {
         } else {
             serverPanic("Unknown hash encoding");
         }
-    } else if (o->type == OBJ_STREAM) {
-        stream *s = o->ptr;
-        /* Note: to guess the size of the radix tree is not trivial, so we
-         * approximate it considering 64 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
-         * workloads, and then adjusting the constants to get numbers that
-         * more or less match the real memory usage.
-         *
-         * Actually the number of nodes and keys may be different depending
-         * on the insertion speed and thus the ability of the radix tree
-         * to compress prefixes. */
-        asize = sizeof(*o);
-        asize += s->rax->numele * 64;
-        asize += s->rax->numnodes * sizeof(raxNode);
-        asize += s->rax->numnodes * 32*7; /* Add a few child pointers... */
-
-        /* Now we have to add the listpacks. The last listpack is often non
-         * complete, so we estimate the size of the first N listpacks, and
-         * use the average to compute the size of the first N-1 listpacks, and
-         * finally add the real size of the last node. */
-        raxIterator ri;
-        raxStart(&ri,s->rax);
-        raxSeek(&ri,"^",NULL,0);
-        size_t lpsize = 0, samples = 0;
-        while(samples < sample_size && raxNext(&ri)) {
-            unsigned char *lp = ri.data;
-            lpsize += lpBytes(lp);
-            samples++;
-        }
-        if (s->rax->numele <= samples) {
-            asize += lpsize;
-        } else {
-            if (samples) lpsize /= samples; /* Compute the average. */
-            asize += lpsize * (s->rax->numele-1);
-            /* No need to check if seek succeeded, we enter this branch only
-             * if there are a few elements in the radix tree. */
-            raxSeek(&ri,"$",NULL,0);
-            raxNext(&ri);
-            asize += lpBytes(ri.data);
-        }
-        raxStop(&ri);
     } else if (o->type == OBJ_MODULE) {
         moduleValue *mv = o->ptr;
         moduleType *mt = mv->type;
@@ -1069,20 +1012,11 @@ robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply) {
 }
 
 /* Object command allows to inspect the internals of an Redis Object.
- * Usage: OBJECT <refcount|encoding|idletime|freq> <key> */
+ * Usage: OBJECT <refcount|encoding|idletime> <key> */
 void objectCommand(client *c) {
     robj *o;
 
-    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.",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (!strcasecmp(c->argv[1]->ptr,"refcount") && c->argc == 3) {
+    if (!strcasecmp(c->argv[1]->ptr,"refcount") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                 == NULL) return;
         addReplyLongLong(c,o->refcount);
@@ -1101,17 +1035,13 @@ NULL
     } else if (!strcasecmp(c->argv[1]->ptr,"freq") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                 == NULL) return;
-        if (!(server.maxmemory_policy & MAXMEMORY_FLAG_LFU)) {
-            addReplyError(c,"An LFU maxmemory policy is not selected, access frequency not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
+        if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
+            addReplyError(c,"An LRU maxmemory policy is selected, access frequency not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
             return;
         }
-        /* LFUDecrAndReturn should be called
-         * in case of the key has not been accessed for a long time,
-         * because we update the access time only
-         * when the key is read or overwritten. */
-        addReplyLongLong(c,LFUDecrAndReturn(o));
+        addReplyLongLong(c,o->lru&255);
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try OBJECT help", (char *)c->argv[1]->ptr);
+        addReplyError(c,"Syntax error. Try OBJECT (refcount|encoding|idletime|freq)");
     }
 }
 

src/pubsub.c

@@ -325,16 +325,8 @@ void publishCommand(client *c) {
 
 /* PUBSUB command for Pub/Sub introspection. */
 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).",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (!strcasecmp(c->argv[1]->ptr,"channels") &&
-        (c->argc == 2 || c->argc == 3))
+    if (!strcasecmp(c->argv[1]->ptr,"channels") &&
+        (c->argc == 2 || c->argc ==3))
     {
         /* PUBSUB CHANNELS [<pattern>] */
         sds pat = (c->argc == 2) ? NULL : c->argv[2]->ptr;
@@ -372,7 +364,8 @@ NULL
         /* PUBSUB NUMPAT */
         addReplyLongLong(c,listLength(server.pubsub_patterns));
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try PUBSUB HELP",
+        addReplyErrorFormat(c,
+            "Unknown PUBSUB subcommand or wrong number of arguments for '%s'",
             (char*)c->argv[1]->ptr);
     }
 }

src/quicklist.c

@@ -149,7 +149,7 @@ REDIS_STATIC quicklistNode *quicklistCreateNode(void) {
 }
 
 /* Return cached quicklist count */
-unsigned long quicklistCount(const quicklist *ql) { return ql->count; }
+unsigned int quicklistCount(const quicklist *ql) { return ql->count; }
 
 /* Free entire quicklist. */
 void quicklistRelease(quicklist *quicklist) {

src/quicklist.h

@@ -64,7 +64,7 @@ typedef struct quicklistLZF {
     char compressed[];
 } quicklistLZF;
 
-/* quicklist is a 40 byte struct (on 64-bit systems) describing a quicklist.
+/* quicklist is a 32 byte struct (on 64-bit systems) describing a quicklist.
  * 'count' is the number of total entries.
  * 'len' is the number of quicklist nodes.
  * 'compress' is: -1 if compression disabled, otherwise it's the number
@@ -74,7 +74,7 @@ typedef struct quicklist {
     quicklistNode *head;
     quicklistNode *tail;
     unsigned long count;        /* total count of all entries in all ziplists */
-    unsigned long len;          /* number of quicklistNodes */
+    unsigned int len;           /* number of quicklistNodes */
     int fill : 16;              /* fill factor for individual nodes */
     unsigned int compress : 16; /* depth of end nodes not to compress;0=off */
 } quicklist;
@@ -154,7 +154,7 @@ int quicklistPopCustom(quicklist *quicklist, int where, unsigned char **data,
                        void *(*saver)(unsigned char *data, unsigned int sz));
 int quicklistPop(quicklist *quicklist, int where, unsigned char **data,
                  unsigned int *sz, long long *slong);
-unsigned long quicklistCount(const quicklist *ql);
+unsigned int quicklistCount(const quicklist *ql);
 int quicklistCompare(unsigned char *p1, unsigned char *p2, int p2_len);
 size_t quicklistGetLzf(const quicklistNode *node, void **data);
 

src/rax.c

@@ -131,7 +131,7 @@ static inline void raxStackFree(raxStack *ts) {
 }
 
 /* ----------------------------------------------------------------------------
- * Radix tree implementation
+ * Radis tree implementation
  * --------------------------------------------------------------------------*/
 
 /* Allocate a new non compressed node with the specified number of children.
@@ -873,8 +873,7 @@ raxNode *raxRemoveChild(raxNode *parent, raxNode *child) {
     memmove(((char*)cp)-1,cp,(parent->size-taillen-1)*sizeof(raxNode**));
 
     /* Move the remaining "tail" pointer at the right position as well. */
-    size_t valuelen = (parent->iskey && !parent->isnull) ? sizeof(void*) : 0;
-    memmove(((char*)c)-1,c+1,taillen*sizeof(raxNode**)+valuelen);
+    memmove(((char*)c)-1,c+1,taillen*sizeof(raxNode**)+parent->iskey*sizeof(void*));
 
     /* 4. Update size. */
     parent->size--;
@@ -1093,34 +1092,26 @@ int raxRemove(rax *rax, unsigned char *s, size_t len, void **old) {
 
 /* This is the core of raxFree(): performs a depth-first scan of the
  * tree and releases all the nodes found. */
-void raxRecursiveFree(rax *rax, raxNode *n, void (*free_callback)(void*)) {
+void raxRecursiveFree(rax *rax, raxNode *n) {
     debugnode("free traversing",n);
     int numchildren = n->iscompr ? 1 : n->size;
     raxNode **cp = raxNodeLastChildPtr(n);
     while(numchildren--) {
         raxNode *child;
         memcpy(&child,cp,sizeof(child));
-        raxRecursiveFree(rax,child,free_callback);
+        raxRecursiveFree(rax,child);
         cp--;
     }
     debugnode("free depth-first",n);
-    if (free_callback && n->iskey && !n->isnull)
-        free_callback(raxGetData(n));
     rax_free(n);
     rax->numnodes--;
 }
 
-/* Free a whole radix tree, calling the specified callback in order to
- * free the auxiliary data. */
-void raxFreeWithCallback(rax *rax, void (*free_callback)(void*)) {
-    raxRecursiveFree(rax,rax->head,free_callback);
-    assert(rax->numnodes == 0);
-    rax_free(rax);
-}
-
 /* Free a whole radix tree. */
 void raxFree(rax *rax) {
-    raxFreeWithCallback(rax,NULL);
+    raxRecursiveFree(rax,rax->head);
+    assert(rax->numnodes == 0);
+    rax_free(rax);
 }
 
 /* ------------------------------- Iterator --------------------------------- */
@@ -1184,7 +1175,7 @@ void raxIteratorDelChars(raxIterator *it, size_t count) {
  * The function returns 1 on success or 0 on out of memory. */
 int raxIteratorNextStep(raxIterator *it, int noup) {
     if (it->flags & RAX_ITER_EOF) {
-        return 1;
+        return 0;
     } else if (it->flags & RAX_ITER_JUST_SEEKED) {
         it->flags &= ~RAX_ITER_JUST_SEEKED;
         return 1;
@@ -1196,6 +1187,10 @@ int raxIteratorNextStep(raxIterator *it, int noup) {
     size_t orig_stack_items = it->stack.items;
     raxNode *orig_node = it->node;
 
+    /* Clear the EOF flag: it will be set again if the EOF condition
+     * is still valid. */
+    it->flags &= ~RAX_ITER_EOF;
+
     while(1) {
         int children = it->node->iscompr ? 1 : it->node->size;
         if (!noup && children) {
@@ -1296,7 +1291,7 @@ int raxSeekGreatest(raxIterator *it) {
  * effect to the one of raxIteratorPrevSte(). */
 int raxIteratorPrevStep(raxIterator *it, int noup) {
     if (it->flags & RAX_ITER_EOF) {
-        return 1;
+        return 0;
     } else if (it->flags & RAX_ITER_JUST_SEEKED) {
         it->flags &= ~RAX_ITER_JUST_SEEKED;
         return 1;
@@ -1417,7 +1412,6 @@ int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len) {
         it->node = it->rt->head;
         if (!raxSeekGreatest(it)) return 0;
         assert(it->node->iskey);
-        it->data = raxGetData(it->node);
         return 1;
     }
 
@@ -1436,7 +1430,6 @@ int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len) {
         /* We found our node, since the key matches and we have an
          * "equal" condition. */
         if (!raxIteratorAddChars(it,ele,len)) return 0; /* OOM. */
-        it->data = raxGetData(it->node);
     } else if (lt || gt) {
         /* Exact key not found or eq flag not set. We have to set as current
          * key the one represented by the node we stopped at, and perform
@@ -1509,7 +1502,6 @@ int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len) {
                  * the previous sub-tree. */
                 if (nodechar < keychar) {
                     if (!raxSeekGreatest(it)) return 0;
-                    it->data = raxGetData(it->node);
                 } else {
                     if (!raxIteratorAddChars(it,it->node->data,it->node->size))
                         return 0;
@@ -1626,8 +1618,8 @@ int raxCompare(raxIterator *iter, const char *op, unsigned char *key, size_t key
     int eq = 0, lt = 0, gt = 0;
 
     if (op[0] == '=' || op[1] == '=') eq = 1;
-    if (op[0] == '>') gt = 1;
-    else if (op[0] == '<') lt = 1;
+    if (op[1] == '>') gt = 1;
+    else if (op[1] == '<') lt = 1;
     else if (op[1] != '=') return 0; /* Syntax error. */
 
     size_t minlen = key_len < iter->key_len ? key_len : iter->key_len;
@@ -1655,19 +1647,6 @@ void raxStop(raxIterator *it) {
     raxStackFree(&it->stack);
 }
 
-/* Return if the iterator is in an EOF state. This happens when raxSeek()
- * failed to seek an appropriate element, so that raxNext() or raxPrev()
- * will return zero, or when an EOF condition was reached while iterating
- * with raxNext() and raxPrev(). */
-int raxEOF(raxIterator *it) {
-    return it->flags & RAX_ITER_EOF;
-}
-
-/* Return the number of elements inside the radix tree. */
-uint64_t raxSize(rax *rax) {
-    return rax->numele;
-}
-
 /* ----------------------------- Introspection ------------------------------ */
 
 /* This function is mostly used for debugging and learning purposes.

src/rax.h

@@ -148,7 +148,6 @@ int raxInsert(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);
-void raxFreeWithCallback(rax *rax, void (*free_callback)(void*));
 void raxStart(raxIterator *it, rax *rt);
 int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len);
 int raxNext(raxIterator *it);
@@ -156,8 +155,6 @@ int raxPrev(raxIterator *it);
 int raxRandomWalk(raxIterator *it, size_t steps);
 int raxCompare(raxIterator *iter, const char *op, unsigned char *key, size_t key_len);
 void raxStop(raxIterator *it);
-int raxEOF(raxIterator *it);
 void raxShow(rax *rax);
-uint64_t raxSize(rax *rax);
 
 #endif

src/rdb.c

@@ -31,7 +31,6 @@
 #include "lzf.h"    /* LZF compression library */
 #include "zipmap.h"
 #include "endianconv.h"
-#include "stream.h"
 
 #include <math.h>
 #include <sys/types.h>
@@ -255,7 +254,7 @@ void *rdbLoadIntegerObject(rio *rdb, int enctype, int flags, size_t *lenptr) {
         char buf[LONG_STR_SIZE], *p;
         int len = ll2string(buf,sizeof(buf),val);
         if (lenptr) *lenptr = len;
-        p = plain ? zmalloc(len) : sdsnewlen(SDS_NOINIT,len);
+        p = plain ? zmalloc(len) : sdsnewlen(NULL,len);
         memcpy(p,buf,len);
         return p;
     } else if (encode) {
@@ -344,10 +343,10 @@ void *rdbLoadLzfStringObject(rio *rdb, int flags, size_t *lenptr) {
     /* Allocate our target according to the uncompressed size. */
     if (plain) {
         val = zmalloc(len);
+        if (lenptr) *lenptr = len;
     } else {
-        val = sdsnewlen(SDS_NOINIT,len);
+        val = sdsnewlen(NULL,len);
     }
-    if (lenptr) *lenptr = len;
 
     /* Load the compressed representation and uncompress it to target. */
     if (rioRead(rdb,c,clen) == 0) goto err;
@@ -425,7 +424,7 @@ ssize_t rdbSaveLongLongAsStringObject(rio *rdb, long long value) {
 }
 
 /* Like rdbSaveRawString() gets a Redis object instead. */
-ssize_t rdbSaveStringObject(rio *rdb, robj *obj) {
+int rdbSaveStringObject(rio *rdb, robj *obj) {
     /* Avoid to decode the object, then encode it again, if the
      * object is already integer encoded. */
     if (obj->encoding == OBJ_ENCODING_INT) {
@@ -472,7 +471,7 @@ void *rdbGenericLoadStringObject(rio *rdb, int flags, size_t *lenptr) {
 
     if (len == RDB_LENERR) return NULL;
     if (plain || sds) {
-        void *buf = plain ? zmalloc(len) : sdsnewlen(SDS_NOINIT,len);
+        void *buf = plain ? zmalloc(len) : sdsnewlen(NULL,len);
         if (lenptr) *lenptr = len;
         if (len && rioRead(rdb,buf,len) == 0) {
             if (plain)
@@ -483,8 +482,8 @@ void *rdbGenericLoadStringObject(rio *rdb, int flags, size_t *lenptr) {
         }
         return buf;
     } else {
-        robj *o = encode ? createStringObject(SDS_NOINIT,len) :
-                           createRawStringObject(SDS_NOINIT,len);
+        robj *o = encode ? createStringObject(NULL,len) :
+                           createRawStringObject(NULL,len);
         if (len && rioRead(rdb,o->ptr,len) == 0) {
             decrRefCount(o);
             return NULL;
@@ -623,8 +622,6 @@ int rdbSaveObjectType(rio *rdb, robj *o) {
             return rdbSaveType(rdb,RDB_TYPE_HASH);
         else
             serverPanic("Unknown hash encoding");
-    case OBJ_STREAM:
-        return rdbSaveType(rdb,RDB_TYPE_STREAM_LISTPACKS);
     case OBJ_MODULE:
         return rdbSaveType(rdb,RDB_TYPE_MODULE_2);
     default:
@@ -765,39 +762,7 @@ ssize_t rdbSaveObject(rio *rdb, robj *o) {
         } else {
             serverPanic("Unknown hash encoding");
         }
-    } else if (o->type == OBJ_STREAM) {
-        /* Store how many listpacks we have inside the radix tree. */
-        stream *s = o->ptr;
-        rax *rax = s->rax;
-        if ((n = rdbSaveLen(rdb,raxSize(rax))) == -1) return -1;
-        nwritten += n;
 
-        /* Serialize all the listpacks inside the radix tree as they are,
-         * when loading back, we'll use the first entry of each listpack
-         * to insert it back into the radix tree. */
-        raxIterator ri;
-        raxStart(&ri,rax);
-        raxSeek(&ri,"^",NULL,0);
-        while (raxNext(&ri)) {
-            unsigned char *lp = ri.data;
-            size_t lp_bytes = lpBytes(lp);
-            if ((n = rdbSaveRawString(rdb,ri.key,ri.key_len)) == -1) return -1;
-            nwritten += n;
-            if ((n = rdbSaveRawString(rdb,lp,lp_bytes)) == -1) return -1;
-            nwritten += n;
-        }
-        raxStop(&ri);
-
-        /* Save the number of elements inside the stream. We cannot obtain
-         * this easily later, since our macro nodes should be checked for
-         * number of items: not a great CPU / space tradeoff. */
-        if ((n = rdbSaveLen(rdb,s->length)) == -1) return -1;
-        nwritten += n;
-        /* Save the last entry ID. */
-        if ((n = rdbSaveLen(rdb,s->last_id.ms)) == -1) return -1;
-        nwritten += n;
-        if ((n = rdbSaveLen(rdb,s->last_id.seq)) == -1) return -1;
-        nwritten += n;
     } else if (o->type == OBJ_MODULE) {
         /* Save a module-specific value. */
         RedisModuleIO io;
@@ -861,25 +826,21 @@ int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val,
 }
 
 /* Save an AUX field. */
-ssize_t rdbSaveAuxField(rio *rdb, void *key, size_t keylen, void *val, size_t vallen) {
-    ssize_t ret, len = 0;
-    if ((ret = rdbSaveType(rdb,RDB_OPCODE_AUX)) == -1) return -1;
-    len += ret;
-    if ((ret = rdbSaveRawString(rdb,key,keylen) == -1)) return -1;
-    len += ret;
-    if ((ret = rdbSaveRawString(rdb,val,vallen) == -1)) return -1;
-    len += ret;
-    return len;
+int rdbSaveAuxField(rio *rdb, void *key, size_t keylen, void *val, size_t vallen) {
+    if (rdbSaveType(rdb,RDB_OPCODE_AUX) == -1) return -1;
+    if (rdbSaveRawString(rdb,key,keylen) == -1) return -1;
+    if (rdbSaveRawString(rdb,val,vallen) == -1) return -1;
+    return 1;
 }
 
 /* Wrapper for rdbSaveAuxField() used when key/val length can be obtained
  * with strlen(). */
-ssize_t rdbSaveAuxFieldStrStr(rio *rdb, char *key, char *val) {
+int rdbSaveAuxFieldStrStr(rio *rdb, char *key, char *val) {
     return rdbSaveAuxField(rdb,key,strlen(key),val,strlen(val));
 }
 
 /* Wrapper for strlen(key) + integer type (up to long long range). */
-ssize_t rdbSaveAuxFieldStrInt(rio *rdb, char *key, long long val) {
+int rdbSaveAuxFieldStrInt(rio *rdb, char *key, long long val) {
     char buf[LONG_STR_SIZE];
     int vlen = ll2string(buf,sizeof(buf),val);
     return rdbSaveAuxField(rdb,key,strlen(key),buf,vlen);
@@ -982,20 +943,6 @@ int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
     }
     di = NULL; /* So that we don't release it again on error. */
 
-    /* If we are storing the replication information on disk, persist
-     * the script cache as well: on successful PSYNC after a restart, we need
-     * to be able to process any EVALSHA inside the replication backlog the
-     * master will send us. */
-    if (rsi && dictSize(server.lua_scripts)) {
-        di = dictGetIterator(server.lua_scripts);
-        while((de = dictNext(di)) != NULL) {
-            robj *body = dictGetVal(de);
-            if (rdbSaveAuxField(rdb,"lua",3,body->ptr,sdslen(body->ptr)) == -1)
-                goto werr;
-        }
-        dictReleaseIterator(di);
-    }
-
     /* EOF opcode */
     if (rdbSaveType(rdb,RDB_OPCODE_EOF) == -1) goto werr;
 
@@ -1448,45 +1395,6 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
                 rdbExitReportCorruptRDB("Unknown RDB encoding type %d",rdbtype);
                 break;
         }
-    } else if (rdbtype == RDB_TYPE_STREAM_LISTPACKS) {
-        o = createStreamObject();
-        stream *s = o->ptr;
-        uint64_t listpacks = rdbLoadLen(rdb,NULL);
-
-        while(listpacks--) {
-            /* Get the master ID, the one we'll use as key of the radix tree
-             * node: the entries inside the listpack itself are delta-encoded
-             * relatively to this ID. */
-            sds nodekey = rdbGenericLoadStringObject(rdb,RDB_LOAD_SDS,NULL);
-            if (sdslen(nodekey) != sizeof(streamID)) {
-                rdbExitReportCorruptRDB("Stream node key entry is not the "
-                                        "size of a stream ID");
-            }
-
-            /* Load the listpack. */
-            unsigned char *lp =
-                rdbGenericLoadStringObject(rdb,RDB_LOAD_PLAIN,NULL);
-            if (lp == NULL) return NULL;
-            unsigned char *first = lpFirst(lp);
-            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. */
-                rdbExitReportCorruptRDB("Empty listpack inside stream");
-            }
-
-            /* Insert the key in the radix tree. */
-            int retval = raxInsert(s->rax,
-                (unsigned char*)nodekey,sizeof(streamID),lp,NULL);
-            sdsfree(nodekey);
-            if (!retval)
-                rdbExitReportCorruptRDB("Listpack re-added with existing key");
-        }
-        /* Load total number of items inside the stream. */
-        s->length = rdbLoadLen(rdb,NULL);
-        /* Load the last entry ID. */
-        s->last_id.ms = rdbLoadLen(rdb,NULL);
-        s->last_id.seq = rdbLoadLen(rdb,NULL);
     } else if (rdbtype == RDB_TYPE_MODULE || rdbtype == RDB_TYPE_MODULE_2) {
         uint64_t moduleid = rdbLoadLen(rdb,NULL);
         moduleType *mt = moduleTypeLookupModuleByID(moduleid);
@@ -1681,13 +1589,6 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi) {
                 }
             } else if (!strcasecmp(auxkey->ptr,"repl-offset")) {
                 if (rsi) rsi->repl_offset = strtoll(auxval->ptr,NULL,10);
-            } else if (!strcasecmp(auxkey->ptr,"lua")) {
-                /* Load the script back in memory. */
-                if (luaCreateFunction(NULL,server.lua,auxval) == NULL) {
-                    rdbExitReportCorruptRDB(
-                        "Can't load Lua script from RDB file! "
-                        "BODY: %s", auxval->ptr);
-                }
             } else {
                 /* We ignore fields we don't understand, as by AUX field
                  * contract. */
@@ -2099,9 +2000,6 @@ void bgsaveCommand(client *c) {
         }
     }
 
-    rdbSaveInfo rsi, *rsiptr;
-    rsiptr = rdbPopulateSaveInfo(&rsi);
-
     if (server.rdb_child_pid != -1) {
         addReplyError(c,"Background save already in progress");
     } else if (server.aof_child_pid != -1) {
@@ -2114,7 +2012,7 @@ void bgsaveCommand(client *c) {
                 "Use BGSAVE SCHEDULE in order to schedule a BGSAVE whenever "
                 "possible.");
         }
-    } else if (rdbSaveBackground(server.rdb_filename,rsiptr) == C_OK) {
+    } else if (rdbSaveBackground(server.rdb_filename,NULL) == C_OK) {
         addReplyStatus(c,"Background saving started");
     } else {
         addReply(c,shared.err);
@@ -2135,37 +2033,22 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
     *rsi = rsi_init;
 
     /* If the instance is a master, we can populate the replication info
-     * only when repl_backlog is not NULL. If the repl_backlog is NULL,
-     * it means that the instance isn't in any replication chains. In this
-     * scenario the replication info is useless, because when a slave
-     * connects to us, the NULL repl_backlog will trigger a full
-     * synchronization, at the same time we will use a new replid and clear
-     * replid2. */
-    if (!server.masterhost && server.repl_backlog) {
-        /* Note that when server.slaveseldb is -1, it means that this master
-         * didn't apply any write commands after a full synchronization.
-         * So we can let repl_stream_db be 0, this allows a restarted slave
-         * to reload replication ID/offset, it's safe because the next write
-         * command must generate a SELECT statement. */
-        rsi->repl_stream_db = server.slaveseldb == -1 ? 0 : server.slaveseldb;
+     * in all the cases, even if sometimes in incomplete (but safe) form. */
+    if (!server.masterhost) {
+        if (server.repl_backlog) rsi->repl_stream_db = server.slaveseldb;
+        /* Note that if repl_backlog is NULL, it means that histories
+         * following from this point will trigger a full synchronization
+         * generating a SELECT statement, so we can leave the currently
+         * selected DB set to -1. This allows a restarted master to reload
+         * its replication ID/offset when there are no connected slaves. */
         return rsi;
     }
 
-    /* If the instance is a slave we need a connected master
-     * in order to fetch the currently selected DB. */
+    /* If the instance is a slave we need a connected master in order to
+     * fetch the currently selected DB. */
     if (server.master) {
         rsi->repl_stream_db = server.master->db->id;
         return rsi;
     }
-
-    /* If we have a cached master we can use it in order to populate the
-     * replication selected DB info inside the RDB file: the slave can
-     * increment the master_repl_offset only from data arriving from the
-     * master, so if we are disconnected the offset in the cached master
-     * is valid. */
-    if (server.cached_master) {
-        rsi->repl_stream_db = server.cached_master->db->id;
-        return rsi;
-    }
     return NULL;
 }

src/rdb.h

@@ -69,9 +69,8 @@
 #define RDB_ENC_INT32 2       /* 32 bit signed integer */
 #define RDB_ENC_LZF 3         /* string compressed with FASTLZ */
 
-/* Map object types to RDB object types. Macros starting with OBJ_ are for
- * memory storage and may change. Instead RDB types must be fixed because
- * we store them on disk. */
+/* Dup object types to RDB object types. Only reason is readability (are we
+ * dealing with RDB types or with in-memory object types?). */
 #define RDB_TYPE_STRING 0
 #define RDB_TYPE_LIST   1
 #define RDB_TYPE_SET    2
@@ -90,11 +89,10 @@
 #define RDB_TYPE_ZSET_ZIPLIST  12
 #define RDB_TYPE_HASH_ZIPLIST  13
 #define RDB_TYPE_LIST_QUICKLIST 14
-#define RDB_TYPE_STREAM_LISTPACKS 15
 /* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */
 
 /* Test if a type is an object type. */
-#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 15))
+#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 14))
 
 /* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */
 #define RDB_OPCODE_AUX        250
@@ -141,7 +139,7 @@ robj *rdbLoadObject(int type, rio *rdb);
 void backgroundSaveDoneHandler(int exitcode, int bysignal);
 int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime, long long now);
 robj *rdbLoadStringObject(rio *rdb);
-ssize_t rdbSaveStringObject(rio *rdb, robj *obj);
+int rdbSaveStringObject(rio *rdb, robj *obj);
 ssize_t rdbSaveRawString(rio *rdb, unsigned char *s, size_t len);
 void *rdbGenericLoadStringObject(rio *rdb, int flags, size_t *lenptr);
 int rdbSaveBinaryDoubleValue(rio *rdb, double val);

src/redis-benchmark.c

@@ -614,7 +614,7 @@ int showThroughput(struct aeEventLoop *eventLoop, long long id, void *clientData
     UNUSED(id);
     UNUSED(clientData);
 
-    if (config.liveclients == 0 && config.requests_finished != config.requests) {
+    if (config.liveclients == 0) {
         fprintf(stderr,"All clients disconnected... aborting.\n");
         exit(1);
     }

src/redis-check-rdb.c

@@ -193,12 +193,12 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
     buf[9] = '\0';
     if (memcmp(buf,"REDIS",5) != 0) {
         rdbCheckError("Wrong signature trying to load DB from file");
-        goto err;
+        return 1;
     }
     rdbver = atoi(buf+5);
     if (rdbver < 1 || rdbver > RDB_VERSION) {
         rdbCheckError("Can't handle RDB format version %d",rdbver);
-        goto err;
+        return 1;
     }
 
     startLoading(fp);
@@ -270,7 +270,7 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
         } else {
             if (!rdbIsObjectType(type)) {
                 rdbCheckError("Invalid object type: %d", type);
-                goto err;
+                return 1;
             }
             rdbstate.key_type = type;
         }
@@ -307,7 +307,6 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
             rdbCheckInfo("RDB file was saved with checksum disabled: no check performed.");
         } else if (cksum != expected) {
             rdbCheckError("RDB CRC error");
-            goto err;
         } else {
             rdbCheckInfo("Checksum OK");
         }
@@ -322,8 +321,6 @@ eoferr: /* unexpected end of file is handled here with a fatal exit */
     } else {
         rdbCheckError("Unexpected EOF reading RDB file");
     }
-err:
-    if (closefile) fclose(fp);
     return 1;
 }
 

src/redis-cli.c

@@ -107,7 +107,6 @@ static struct config {
     char *pattern;
     char *rdb_filename;
     int bigkeys;
-    int hotkeys;
     int stdinarg; /* get last arg from stdin. (-x option) */
     char *auth;
     int output; /* output mode, see OUTPUT_* defines */
@@ -199,92 +198,6 @@ static sds getDotfilePath(char *envoverride, char *dotfilename) {
     return dotPath;
 }
 
-/* URL-style percent decoding. */
-#define isHexChar(c) (isdigit(c) || (c >= 'a' && c <= 'f'))
-#define decodeHexChar(c) (isdigit(c) ? c - '0' : c - 'a' + 10)
-#define decodeHex(h, l) ((decodeHexChar(h) << 4) + decodeHexChar(l))
-
-static sds percentDecode(const char *pe, size_t len) {
-    const char *end = pe + len;
-    sds ret = sdsempty();
-    const char *curr = pe;
-
-    while (curr < end) {
-        if (*curr == '%') {
-            if ((end - curr) < 2) {
-                fprintf(stderr, "Incomplete URI encoding\n");
-                exit(1);
-            }
-
-            char h = tolower(*(++curr));
-            char l = tolower(*(++curr));
-            if (!isHexChar(h) || !isHexChar(l)) {
-                fprintf(stderr, "Illegal character in URI encoding\n");
-                exit(1);
-            }
-            char c = decodeHex(h, l);
-            ret = sdscatlen(ret, &c, 1);
-            curr++;
-        } else {
-            ret = sdscatlen(ret, curr++, 1);
-        }
-    }
-
-    return ret;
-}
-
-/* Parse a URI and extract the server connection information.
- * URI scheme is based on the the provisional specification[1] excluding support
- * for query parameters. Valid URIs are:
- *   scheme:    "redis://"
- *   authority: [<username> ":"] <password> "@"] [<hostname> [":" <port>]]
- *   path:      ["/" [<db>]]
- *
- *  [1]: https://www.iana.org/assignments/uri-schemes/prov/redis */
-static void parseRedisUri(const char *uri) {
-
-    const char *scheme = "redis://";
-    const char *curr = uri;
-    const char *end = uri + strlen(uri);
-    const char *userinfo, *username, *port, *host, *path;
-
-    /* URI must start with a valid scheme. */
-    if (strncasecmp(scheme, curr, strlen(scheme))) {
-        fprintf(stderr,"Invalid URI scheme\n");
-        exit(1);
-    }
-    curr += strlen(scheme);
-    if (curr == end) return;
-
-    /* Extract user info. */
-    if ((userinfo = strchr(curr,'@'))) {
-        if ((username = strchr(curr, ':')) && username < userinfo) {
-            /* If provided, username is ignored. */
-            curr = username + 1;
-        }
-
-        config.auth = percentDecode(curr, userinfo - curr);
-        curr = userinfo + 1;
-    }
-    if (curr == end) return;
-
-    /* Extract host and port. */
-    path = strchr(curr, '/');
-    if (*curr != '/') {
-        host = path ? path - 1 : end;
-        if ((port = strchr(curr, ':'))) {
-            config.hostport = atoi(port + 1);
-            host = port - 1;
-        }
-        config.hostip = sdsnewlen(curr, host - curr + 1);
-    }
-    curr = path ? path + 1 : end;
-    if (curr == end) return;
-
-    /* Extract database number. */
-    config.dbnum = atoi(curr);
-}
-
 /*------------------------------------------------------------------------------
  * Help functions
  *--------------------------------------------------------------------------- */
@@ -711,7 +624,7 @@ int isColorTerm(void) {
     return t != NULL && strstr(t,"xterm") != NULL;
 }
 
-/* Helper  function for sdsCatColorizedLdbReply() appending colorize strings
+/* Helpe  function for sdsCatColorizedLdbReply() appending colorize strings
  * to an SDS string. */
 sds sdscatcolor(sds o, char *s, size_t len, char *color) {
     if (!isColorTerm()) return sdscatlen(o,s,len);
@@ -1089,8 +1002,6 @@ static int parseOptions(int argc, char **argv) {
             config.dbnum = atoi(argv[++i]);
         } else if (!strcmp(argv[i],"-a") && !lastarg) {
             config.auth = argv[++i];
-        } else if (!strcmp(argv[i],"-u") && !lastarg) {
-            parseRedisUri(argv[++i]);
         } else if (!strcmp(argv[i],"--raw")) {
             config.output = OUTPUT_RAW;
         } else if (!strcmp(argv[i],"--no-raw")) {
@@ -1130,8 +1041,6 @@ static int parseOptions(int argc, char **argv) {
             config.pipe_timeout = atoi(argv[++i]);
         } else if (!strcmp(argv[i],"--bigkeys")) {
             config.bigkeys = 1;
-        } else if (!strcmp(argv[i],"--hotkeys")) {
-            config.hotkeys = 1;
         } else if (!strcmp(argv[i],"--eval") && !lastarg) {
             config.eval = argv[++i];
         } else if (!strcmp(argv[i],"--ldb")) {
@@ -1200,7 +1109,6 @@ static void usage(void) {
 "  -p <port>          Server port (default: 6379).\n"
 "  -s <socket>        Server socket (overrides hostname and port).\n"
 "  -a <password>      Password to use when connecting to the server.\n"
-"  -u <uri>           Server URI.\n"
 "  -r <repeat>        Execute specified command N times.\n"
 "  -i <interval>      When -r is used, waits <interval> seconds per command.\n"
 "                     It is possible to specify sub-second times like -i 0.1.\n"
@@ -1232,8 +1140,6 @@ static void usage(void) {
 "                     no reply is received within <n> seconds.\n"
 "                     Default timeout: %d. Use 0 to wait forever.\n"
 "  --bigkeys          Sample Redis keys looking for big keys.\n"
-"  --hotkeys          Sample Redis keys looking for hot keys.\n"
-"                     only works when maxmemory-policy is *lfu.\n"
 "  --scan             List all keys using the SCAN command.\n"
 "  --pattern <pat>    Useful with --scan to specify a SCAN pattern.\n"
 "  --intrinsic-latency <sec> Run a test to measure intrinsic system latency.\n"
@@ -1386,9 +1292,8 @@ static void repl(void) {
     /* Only use history and load the rc file when stdin is a tty. */
     if (isatty(fileno(stdin))) {
         historyfile = getDotfilePath(REDIS_CLI_HISTFILE_ENV,REDIS_CLI_HISTFILE_DEFAULT);
-        //keep in-memory history always regardless if history file can be determined
-        history = 1;
         if (historyfile != NULL) {
+            history = 1;
             linenoiseHistoryLoad(historyfile);
         }
         cliLoadPreferences();
@@ -2075,8 +1980,7 @@ static void pipeMode(void) {
 #define TYPE_SET    2
 #define TYPE_HASH   3
 #define TYPE_ZSET   4
-#define TYPE_STREAM 5
-#define TYPE_NONE   6
+#define TYPE_NONE   5
 
 static redisReply *sendScan(unsigned long long *it) {
     redisReply *reply = redisCommand(context, "SCAN %llu", *it);
@@ -2135,8 +2039,6 @@ static int toIntType(char *key, char *type) {
         return TYPE_HASH;
     } else if(!strcmp(type, "zset")) {
         return TYPE_ZSET;
-    } else if(!strcmp(type, "stream")) {
-        return TYPE_STREAM;
     } else if(!strcmp(type, "none")) {
         return TYPE_NONE;
     } else {
@@ -2225,7 +2127,7 @@ static void findBigKeys(void) {
     unsigned long long biggest[5] = {0}, counts[5] = {0}, totalsize[5] = {0};
     unsigned long long sampled = 0, total_keys, totlen=0, *sizes=NULL, it=0;
     sds maxkeys[5] = {0};
-    char *typename[] = {"string","list","set","hash","zset","stream"};
+    char *typename[] = {"string","list","set","hash","zset"};
     char *typeunit[] = {"bytes","items","members","fields","members"};
     redisReply *reply, *keys;
     unsigned int arrsize=0, i;
@@ -2352,129 +2254,6 @@ static void findBigKeys(void) {
     exit(0);
 }
 
-static void getKeyFreqs(redisReply *keys, unsigned long long *freqs) {
-    redisReply *reply;
-    unsigned int i;
-
-    /* Pipeline OBJECT freq commands */
-    for(i=0;i<keys->elements;i++) {
-        redisAppendCommand(context, "OBJECT freq %s", keys->element[i]->str);
-    }
-
-    /* Retrieve freqs */
-    for(i=0;i<keys->elements;i++) {
-        if(redisGetReply(context, (void**)&reply)!=REDIS_OK) {
-            fprintf(stderr, "Error getting freq for key '%s' (%d: %s)\n",
-                keys->element[i]->str, context->err, context->errstr);
-            exit(1);
-        } else if(reply->type != REDIS_REPLY_INTEGER) {
-            if(reply->type == REDIS_REPLY_ERROR) {
-                fprintf(stderr, "Error: %s\n", reply->str);
-                exit(1);
-            } else {
-                fprintf(stderr, "Warning: OBJECT freq on '%s' failed (may have been deleted)\n", keys->element[i]->str);
-                freqs[i] = 0;
-            }
-        } else {
-            freqs[i] = reply->integer;
-        }
-        freeReplyObject(reply);
-    }
-}
-
-#define HOTKEYS_SAMPLE 16
-static void findHotKeys(void) {
-    redisReply *keys, *reply;
-    unsigned long long counters[HOTKEYS_SAMPLE] = {0};
-    sds hotkeys[HOTKEYS_SAMPLE] = {NULL};
-    unsigned long long sampled = 0, total_keys, *freqs = NULL, it = 0;
-    unsigned int arrsize = 0, i, k;
-    double pct;
-
-    /* Total keys pre scanning */
-    total_keys = getDbSize();
-
-    /* Status message */
-    printf("\n# Scanning the entire keyspace to find hot keys as well as\n");
-    printf("# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec\n");
-    printf("# per 100 SCAN commands (not usually needed).\n\n");
-
-    /* SCAN loop */
-    do {
-        /* Calculate approximate percentage completion */
-        pct = 100 * (double)sampled/total_keys;
-
-        /* Grab some keys and point to the keys array */
-        reply = sendScan(&it);
-        keys  = reply->element[1];
-
-        /* Reallocate our freqs array if we need to */
-        if(keys->elements > arrsize) {
-            freqs = zrealloc(freqs, sizeof(unsigned long long)*keys->elements);
-
-            if(!freqs) {
-                fprintf(stderr, "Failed to allocate storage for keys!\n");
-                exit(1);
-            }
-
-            arrsize = keys->elements;
-        }
-
-        getKeyFreqs(keys, freqs);
-
-        /* Now update our stats */
-        for(i=0;i<keys->elements;i++) {
-            sampled++;
-            /* Update overall progress */
-            if(sampled % 1000000 == 0) {
-                printf("[%05.2f%%] Sampled %llu keys so far\n", pct, sampled);
-            }
-
-            /* Use eviction pool here */
-            k = 0;
-            while (k < HOTKEYS_SAMPLE && freqs[i] > counters[k]) k++;
-            if (k == 0) continue;
-            k--;
-            if (k == 0 || counters[k] == 0) {
-                sdsfree(hotkeys[k]);
-            } else {
-                sdsfree(hotkeys[0]);
-                memmove(counters,counters+1,sizeof(counters[0])*k);
-                memmove(hotkeys,hotkeys+1,sizeof(hotkeys[0])*k);
-            }
-            counters[k] = freqs[i];
-            hotkeys[k] = sdsnew(keys->element[i]->str);
-            printf(
-               "[%05.2f%%] Hot key '%s' found so far with counter %llu\n",
-               pct, keys->element[i]->str, freqs[i]);
-        }
-
-        /* Sleep if we've been directed to do so */
-        if(sampled && (sampled %100) == 0 && config.interval) {
-            usleep(config.interval);
-        }
-
-        freeReplyObject(reply);
-    } while(it != 0);
-
-    if (freqs) zfree(freqs);
-
-    /* We're done */
-    printf("\n-------- summary -------\n\n");
-
-    printf("Sampled %llu keys in the keyspace!\n", sampled);
-
-    for (i=1; i<= HOTKEYS_SAMPLE; i++) {
-        k = HOTKEYS_SAMPLE - i;
-        if(counters[k]>0) {
-            printf("hot key found with counter: %llu\tkeyname: %s\n", counters[k], hotkeys[k]);
-            sdsfree(hotkeys[k]);
-        }
-    }
-
-    exit(0);
-}
-
 /*------------------------------------------------------------------------------
  * Stats mode
  *--------------------------------------------------------------------------- */
@@ -2585,7 +2364,7 @@ static void statMode(void) {
         sprintf(buf,"%ld",aux);
         printf("%-8s",buf);
 
-        /* Requests */
+        /* Requets */
         aux = getLongInfoField(reply->str,"total_commands_processed");
         sprintf(buf,"%ld (+%ld)",aux,requests == 0 ? 0 : aux-requests);
         printf("%-19s",buf);
@@ -2852,7 +2631,6 @@ int main(int argc, char **argv) {
     config.pipe_mode = 0;
     config.pipe_timeout = REDIS_CLI_DEFAULT_PIPE_TIMEOUT;
     config.bigkeys = 0;
-    config.hotkeys = 0;
     config.stdinarg = 0;
     config.auth = NULL;
     config.eval = NULL;
@@ -2913,12 +2691,6 @@ int main(int argc, char **argv) {
         findBigKeys();
     }
 
-    /* Find hot keys */
-    if (config.hotkeys) {
-        if (cliConnect(0) == REDIS_ERR) exit(1);
-        findHotKeys();
-    }
-
     /* Stat mode */
     if (config.stat_mode) {
         if (cliConnect(0) == REDIS_ERR) exit(1);

src/redis-trib.rb

@@ -701,12 +701,7 @@ class RedisTrib
 
         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...
+        # Alloc slots on masters
         slots_per_node = ClusterHashSlots.to_f / masters_count
         first = 0
         cursor = 0.0
@@ -774,131 +769,6 @@ class RedisTrib
                 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 becuase 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

src/redismodule.h

@@ -82,18 +82,6 @@
 #define REDISMODULE_CTX_FLAGS_EVICT 0x0200 
 
 
-#define REDISMODULE_NOTIFY_GENERIC (1<<2)     /* g */
-#define REDISMODULE_NOTIFY_STRING (1<<3)      /* $ */
-#define REDISMODULE_NOTIFY_LIST (1<<4)        /* l */
-#define REDISMODULE_NOTIFY_SET (1<<5)         /* s */
-#define REDISMODULE_NOTIFY_HASH (1<<6)        /* h */
-#define REDISMODULE_NOTIFY_ZSET (1<<7)        /* z */
-#define REDISMODULE_NOTIFY_EXPIRED (1<<8)     /* x */
-#define REDISMODULE_NOTIFY_EVICTED (1<<9)     /* e */
-#define REDISMODULE_NOTIFY_STREAM (1<<10)     /* t */ 
-#define REDISMODULE_NOTIFY_ALL (REDISMODULE_NOTIFY_GENERIC | REDISMODULE_NOTIFY_STRING | REDISMODULE_NOTIFY_LIST | REDISMODULE_NOTIFY_SET | REDISMODULE_NOTIFY_HASH | REDISMODULE_NOTIFY_ZSET | REDISMODULE_NOTIFY_EXPIRED | REDISMODULE_NOTIFY_EVICTED | REDISMODULE_NOTIFY_STREAM)      /* A */
-
-
 /* A special pointer that we can use between the core and the module to signal
  * field deletion, and that is impossible to be a valid pointer. */
 #define REDISMODULE_HASH_DELETE ((RedisModuleString*)(long)1)
@@ -124,7 +112,6 @@ typedef struct RedisModuleBlockedClient RedisModuleBlockedClient;
 
 typedef int (*RedisModuleCmdFunc) (RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
 
-typedef int (*RedisModuleNotificationFunc) (RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key);
 typedef void *(*RedisModuleTypeLoadFunc)(RedisModuleIO *rdb, int encver);
 typedef void (*RedisModuleTypeSaveFunc)(RedisModuleIO *rdb, void *value);
 typedef void (*RedisModuleTypeRewriteFunc)(RedisModuleIO *aof, RedisModuleString *key, void *value);
@@ -156,8 +143,7 @@ void *REDISMODULE_API_FUNC(RedisModule_Calloc)(size_t nmemb, size_t size);
 char *REDISMODULE_API_FUNC(RedisModule_Strdup)(const char *str);
 int REDISMODULE_API_FUNC(RedisModule_GetApi)(const char *, void *);
 int REDISMODULE_API_FUNC(RedisModule_CreateCommand)(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep);
-void REDISMODULE_API_FUNC(RedisModule_SetModuleAttribs)(RedisModuleCtx *ctx, const char *name, int ver, int apiver);
-int REDISMODULE_API_FUNC(RedisModule_IsModuleNameBusy)(const char *name);
+int REDISMODULE_API_FUNC(RedisModule_SetModuleAttribs)(RedisModuleCtx *ctx, const char *name, int ver, int apiver);
 int REDISMODULE_API_FUNC(RedisModule_WrongArity)(RedisModuleCtx *ctx);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithLongLong)(RedisModuleCtx *ctx, long long ll);
 int REDISMODULE_API_FUNC(RedisModule_GetSelectedDb)(RedisModuleCtx *ctx);
@@ -198,7 +184,6 @@ int REDISMODULE_API_FUNC(RedisModule_ReplicateVerbatim)(RedisModuleCtx *ctx);
 const char *REDISMODULE_API_FUNC(RedisModule_CallReplyStringPtr)(RedisModuleCallReply *reply, size_t *len);
 RedisModuleString *REDISMODULE_API_FUNC(RedisModule_CreateStringFromCallReply)(RedisModuleCallReply *reply);
 int REDISMODULE_API_FUNC(RedisModule_DeleteKey)(RedisModuleKey *key);
-int REDISMODULE_API_FUNC(RedisModule_UnlinkKey)(RedisModuleKey *key);
 int REDISMODULE_API_FUNC(RedisModule_StringSet)(RedisModuleKey *key, RedisModuleString *str);
 char *REDISMODULE_API_FUNC(RedisModule_StringDMA)(RedisModuleKey *key, size_t *len, int mode);
 int REDISMODULE_API_FUNC(RedisModule_StringTruncate)(RedisModuleKey *key, size_t newlen);
@@ -264,8 +249,6 @@ RedisModuleCtx *REDISMODULE_API_FUNC(RedisModule_GetThreadSafeContext)(RedisModu
 void REDISMODULE_API_FUNC(RedisModule_FreeThreadSafeContext)(RedisModuleCtx *ctx);
 void REDISMODULE_API_FUNC(RedisModule_ThreadSafeContextLock)(RedisModuleCtx *ctx);
 void REDISMODULE_API_FUNC(RedisModule_ThreadSafeContextUnlock)(RedisModuleCtx *ctx);
-int REDISMODULE_API_FUNC(RedisModule_SubscribeToKeyspaceEvents)(RedisModuleCtx *ctx, int types, RedisModuleNotificationFunc cb);
-
 #endif
 
 /* This is included inline inside each Redis module. */
@@ -280,7 +263,6 @@ static int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int
     REDISMODULE_GET_API(Strdup);
     REDISMODULE_GET_API(CreateCommand);
     REDISMODULE_GET_API(SetModuleAttribs);
-    REDISMODULE_GET_API(IsModuleNameBusy);
     REDISMODULE_GET_API(WrongArity);
     REDISMODULE_GET_API(ReplyWithLongLong);
     REDISMODULE_GET_API(ReplyWithError);
@@ -322,7 +304,6 @@ static int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int
     REDISMODULE_GET_API(Replicate);
     REDISMODULE_GET_API(ReplicateVerbatim);
     REDISMODULE_GET_API(DeleteKey);
-    REDISMODULE_GET_API(UnlinkKey);
     REDISMODULE_GET_API(StringSet);
     REDISMODULE_GET_API(StringDMA);
     REDISMODULE_GET_API(StringTruncate);
@@ -387,11 +368,8 @@ static int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int
     REDISMODULE_GET_API(IsBlockedTimeoutRequest);
     REDISMODULE_GET_API(GetBlockedClientPrivateData);
     REDISMODULE_GET_API(AbortBlock);
-    REDISMODULE_GET_API(SubscribeToKeyspaceEvents);
-
 #endif
 
-    if (RedisModule_IsModuleNameBusy && RedisModule_IsModuleNameBusy(name)) return REDISMODULE_ERR;
     RedisModule_SetModuleAttribs(ctx,name,ver,apiver);
     return REDISMODULE_OK;
 }

src/replication.c

@@ -1330,8 +1330,7 @@ char *sendSynchronousCommand(int flags, int fd, ...) {
             cmd = sdscat(cmd,arg);
         }
         cmd = sdscatlen(cmd,"\r\n",2);
-        va_end(ap);
-        
+
         /* Transfer command to the server. */
         if (syncWrite(fd,cmd,sdslen(cmd),server.repl_syncio_timeout*1000)
             == -1)
@@ -1341,6 +1340,7 @@ char *sendSynchronousCommand(int flags, int fd, ...) {
                     strerror(errno));
         }
         sdsfree(cmd);
+        va_end(ap);
     }
 
     /* Read the reply from the server. */
@@ -1970,12 +1970,6 @@ void replicationUnsetMaster(void) {
      * with PSYNC version 2, there is no need for full resync after a
      * master switch. */
     server.slaveseldb = -1;
-
-    /* Once we turn from slave to master, we consider the starting time without
-     * slaves (that is used to count the replication backlog time to live) as
-     * starting from now. Otherwise the backlog will be freed after a
-     * failover if slaves do not connect immediately. */
-    server.repl_no_slaves_since = server.unixtime;
 }
 
 /* This function is called when the slave lose the connection with the
@@ -2211,7 +2205,7 @@ void replicationResurrectCachedMaster(int newfd) {
     server.repl_state = REPL_STATE_CONNECTED;
 
     /* Re-add to the list of clients. */
-    linkClient(server.master);
+    listAddNodeTail(server.clients,server.master);
     if (aeCreateFileEvent(server.el, newfd, AE_READABLE,
                           readQueryFromClient, server.master)) {
         serverLog(LL_WARNING,"Error resurrecting the cached master, impossible to add the readable handler: %s", strerror(errno));
@@ -2394,26 +2388,15 @@ void waitCommand(client *c) {
     mstime_t timeout;
     long numreplicas, ackreplicas;
     long long offset = c->woff;
-    int waitaof = 0; /* True if the user requested to wait for AOF sync. */
 
     if (server.masterhost) {
         addReplyError(c,"WAIT cannot be used with slave instances. Please also note that since Redis 4.0 if a slave is configured to be writable (which is not the default) writes to slaves are just local and are not propagated.");
         return;
     }
 
-    /* AOF or number of replicas argument parsing. */
-    if (!strcasecmp(c->argv[1]->ptr,"AOF")) {
-        waitaof = 1;
-        if (server.aof_state != AOF_ON) {
-            addReplyError(c,"WAIT AOF is only allowed when AOF is enabled");
-            return;
-        }
-    } else {
-        if (getLongFromObjectOrReply(c,c->argv[1],&numreplicas,NULL) != C_OK)
-            return;
-    }
-
-    /* Timeout parsing. */
+    /* Argument parsing. */
+    if (getLongFromObjectOrReply(c,c->argv[1],&numreplicas,NULL) != C_OK)
+        return;
     if (getTimeoutFromObjectOrReply(c,c->argv[2],&timeout,UNIT_MILLISECONDS)
         != C_OK) return;
 
@@ -2426,17 +2409,11 @@ void waitCommand(client *c) {
 
     /* Otherwise block the client and put it into our list of clients
      * waiting for ack from slaves. */
-    if (waitaof) {
-        c->bpop.aofepoch = aofNextEpoch();
-        listAddNodeTail(server.clients_waiting_acks,c);
-        blockClient(c,BLOCKED_AOF);
-    } else {
-        c->bpop.timeout = timeout;
-        c->bpop.reploffset = offset;
-        c->bpop.numreplicas = numreplicas;
-        listAddNodeTail(server.clients_waiting_acks,c);
-        blockClient(c,BLOCKED_WAIT);
-    }
+    c->bpop.timeout = timeout;
+    c->bpop.reploffset = offset;
+    c->bpop.numreplicas = numreplicas;
+    listAddNodeTail(server.clients_waiting_acks,c);
+    blockClient(c,BLOCKED_WAIT);
 
     /* Make sure that the server will send an ACK request to all the slaves
      * before returning to the event loop. */
@@ -2455,7 +2432,7 @@ void unblockClientWaitingReplicas(client *c) {
 
 /* Check if there are clients blocked in WAIT that can be unblocked since
  * we received enough ACKs from slaves. */
-void processClientsBlockedInWait(void) {
+void processClientsWaitingReplicas(void) {
     long long last_offset = 0;
     int last_numreplicas = 0;
 
@@ -2466,36 +2443,23 @@ void processClientsBlockedInWait(void) {
     while((ln = listNext(&li))) {
         client *c = ln->value;
 
-        if (c->btype == BLOCKED_AOF) {
-            /* Handle WAIT AOF. */
-            if (server.aof_fsync == AOF_FSYNC_ALWAYS ||
-                c->bpop.aofepoch <= server.aof_fsync_epoch)
-            {
-                unblockClient(c);
-                addReply(c,shared.cone);
-            }
+        /* Every time we find a client that is satisfied for a given
+         * offset and number of replicas, we remember it so the next client
+         * may be unblocked without calling replicationCountAcksByOffset()
+         * if the requested offset / replicas were equal or less. */
+        if (last_offset && last_offset > c->bpop.reploffset &&
+                           last_numreplicas > c->bpop.numreplicas)
+        {
+            unblockClient(c);
+            addReplyLongLong(c,last_numreplicas);
         } else {
-            /* Handle WAIT for slaves to ACK.
-             *
-             * Every time we find a client that is satisfied for a given
-             * offset and number of replicas, we remember it so the next client
-             * may be unblocked without calling replicationCountAcksByOffset()
-             * if the requested offset / replicas were equal or less. */
-            if (last_offset && last_offset > c->bpop.reploffset &&
-                               last_numreplicas > c->bpop.numreplicas)
-            {
-                unblockClient(c);
-                addReplyLongLong(c,last_numreplicas);
-            } else {
-                int numreplicas =
-                    replicationCountAcksByOffset(c->bpop.reploffset);
+            int numreplicas = replicationCountAcksByOffset(c->bpop.reploffset);
 
-                if (numreplicas >= c->bpop.numreplicas) {
-                    last_offset = c->bpop.reploffset;
-                    last_numreplicas = numreplicas;
-                    unblockClient(c);
-                    addReplyLongLong(c,numreplicas);
-                }
+            if (numreplicas >= c->bpop.numreplicas) {
+                last_offset = c->bpop.reploffset;
+                last_numreplicas = numreplicas;
+                unblockClient(c);
+                addReplyLongLong(c,numreplicas);
             }
         }
     }
@@ -2649,23 +2613,6 @@ void replicationCron(void) {
         time_t idle = server.unixtime - server.repl_no_slaves_since;
 
         if (idle > server.repl_backlog_time_limit) {
-            /* When we free the backlog, we always use a new
-             * replication ID and clear the ID2. This is needed
-             * because when there is no backlog, the master_repl_offset
-             * is not updated, but we would still retain our replication
-             * ID, leading to the following problem:
-             *
-             * 1. We are a master instance.
-             * 2. Our slave is promoted to master. It's repl-id-2 will
-             *    be the same as our repl-id.
-             * 3. We, yet as master, receive some updates, that will not
-             *    increment the master_repl_offset.
-             * 4. Later we are turned into a slave, connecto to the new
-             *    master that will accept our PSYNC request by second
-             *    replication ID, but there will be data inconsistency
-             *    because we received writes. */
-            changeReplicationId();
-            clearReplicationId2();
             freeReplicationBacklog();
             serverLog(LL_NOTICE,
                 "Replication backlog freed after %d seconds "

src/rio.c

@@ -310,7 +310,7 @@ void rioSetAutoSync(rio *r, off_t bytes) {
  * generating the Redis protocol for the Append Only File. */
 
 /* Write multi bulk count in the format: "*<count>\r\n". */
-size_t rioWriteBulkCount(rio *r, char prefix, long count) {
+size_t rioWriteBulkCount(rio *r, char prefix, int count) {
     char cbuf[128];
     int clen;
 

src/rio.h

@@ -130,7 +130,7 @@ void rioInitWithFdset(rio *r, int *fds, int numfds);
 
 void rioFreeFdset(rio *r);
 
-size_t rioWriteBulkCount(rio *r, char prefix, long count);
+size_t rioWriteBulkCount(rio *r, char prefix, int count);
 size_t rioWriteBulkString(rio *r, const char *buf, size_t len);
 size_t rioWriteBulkLongLong(rio *r, long long l);
 size_t rioWriteBulkDouble(rio *r, double d);

src/scripting.c

@@ -358,13 +358,6 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error) {
     static size_t cached_objects_len[LUA_CMD_OBJCACHE_SIZE];
     static int inuse = 0;   /* Recursive calls detection. */
 
-    /* Reflect MULTI state */
-    if (server.lua_multi_emitted || (server.lua_caller->flags & CLIENT_MULTI)) {
-        c->flags |= CLIENT_MULTI;
-    } else {
-        c->flags &= ~CLIENT_MULTI;
-    }
-
     /* By using Lua debug hooks it is possible to trigger a recursive call
      * to luaRedisGenericCommand(), which normally should never happen.
      * To make this function reentrant is futile and makes it slower, but
@@ -542,7 +535,6 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error) {
      * a Lua script in the context of AOF and slaves. */
     if (server.lua_replicate_commands &&
         !server.lua_multi_emitted &&
-        !(server.lua_caller->flags & CLIENT_MULTI) &&
         server.lua_write_dirty &&
         server.lua_repl != PROPAGATE_NONE)
     {
@@ -1141,38 +1133,18 @@ int redis_math_randomseed (lua_State *L) {
  * EVAL and SCRIPT commands implementation
  * ------------------------------------------------------------------------- */
 
-/* Define a Lua function with the specified body.
- * The function name will be generated in the following form:
+/* Define a lua function with the specified function name and body.
+ * The function name musts be a 42 characters long string, since all the
+ * functions we defined in the Lua context are in the form:
  *
  *   f_<hex sha1 sum>
  *
- * The function increments the reference count of the 'body' object as a
- * side effect of a successful call.
- *
- * On success a pointer to an SDS string representing the function SHA1 of the
- * just added function is returned (and will be valid until the next call
- * to scriptingReset() function), otherwise NULL is returned.
- *
- * The function handles the fact of being called with a script that already
- * exists, and in such a case, it behaves like in the success case.
- *
- * If 'c' is not NULL, on error the client is informed with an appropriate
- * error describing the nature of the problem and the Lua interpreter error. */
-sds luaCreateFunction(client *c, lua_State *lua, robj *body) {
-    char funcname[43];
-    dictEntry *de;
-
-    funcname[0] = 'f';
-    funcname[1] = '_';
-    sha1hex(funcname+2,body->ptr,sdslen(body->ptr));
-
-    sds sha = sdsnewlen(funcname+2,40);
-    if ((de = dictFind(server.lua_scripts,sha)) != NULL) {
-        sdsfree(sha);
-        return dictGetKey(de);
-    }
-
+ * On success C_OK is returned, and nothing is left on the Lua stack.
+ * On error C_ERR is returned and an appropriate error is set in the
+ * client context. */
+int luaCreateFunction(client *c, lua_State *lua, char *funcname, robj *body) {
     sds funcdef = sdsempty();
+
     funcdef = sdscat(funcdef,"function ");
     funcdef = sdscatlen(funcdef,funcname,42);
     funcdef = sdscatlen(funcdef,"() ",3);
@@ -1180,35 +1152,30 @@ sds luaCreateFunction(client *c, lua_State *lua, robj *body) {
     funcdef = sdscatlen(funcdef,"\nend",4);
 
     if (luaL_loadbuffer(lua,funcdef,sdslen(funcdef),"@user_script")) {
-        if (c != NULL) {
-            addReplyErrorFormat(c,
-                "Error compiling script (new function): %s\n",
-                lua_tostring(lua,-1));
-        }
+        addReplyErrorFormat(c,"Error compiling script (new function): %s\n",
+            lua_tostring(lua,-1));
         lua_pop(lua,1);
-        sdsfree(sha);
         sdsfree(funcdef);
-        return NULL;
+        return C_ERR;
     }
     sdsfree(funcdef);
-
     if (lua_pcall(lua,0,0,0)) {
-        if (c != NULL) {
-            addReplyErrorFormat(c,"Error running script (new function): %s\n",
-                lua_tostring(lua,-1));
-        }
+        addReplyErrorFormat(c,"Error running script (new function): %s\n",
+            lua_tostring(lua,-1));
         lua_pop(lua,1);
-        sdsfree(sha);
-        return NULL;
+        return C_ERR;
     }
 
     /* We also save a SHA1 -> Original script map in a dictionary
      * so that we can replicate / write in the AOF all the
      * EVALSHA commands as EVAL using the original script. */
-    int retval = dictAdd(server.lua_scripts,sha,body);
-    serverAssertWithInfo(c ? c : server.lua_client,NULL,retval == DICT_OK);
-    incrRefCount(body);
-    return sha;
+    {
+        int retval = dictAdd(server.lua_scripts,
+                             sdsnewlen(funcname+2,40),body);
+        serverAssertWithInfo(c,NULL,retval == DICT_OK);
+        incrRefCount(body);
+    }
+    return C_OK;
 }
 
 /* This is the Lua script "count" hook that we use to detect scripts timeout. */
@@ -1307,10 +1274,10 @@ void evalGenericCommand(client *c, int evalsha) {
             addReply(c, shared.noscripterr);
             return;
         }
-        if (luaCreateFunction(c,lua,c->argv[1]) == NULL) {
+        if (luaCreateFunction(c,lua,funcname,c->argv[1]) == C_ERR) {
             lua_pop(lua,1); /* remove the error handler from the stack. */
             /* The error is sent to the client by luaCreateFunction()
-             * itself when it returns NULL. */
+             * itself when it returns C_ERR. */
             return;
         }
         /* Now the following is guaranteed to return non nil */
@@ -1455,17 +1422,7 @@ 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.",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"flush")) {
+    if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"flush")) {
         scriptingReset();
         addReply(c,shared.ok);
         replicationScriptCacheFlush();
@@ -1481,9 +1438,22 @@ NULL
                 addReply(c,shared.czero);
         }
     } else if (c->argc == 3 && !strcasecmp(c->argv[1]->ptr,"load")) {
-        sds sha = luaCreateFunction(c,server.lua,c->argv[2]);
-        if (sha == NULL) return; /* The error was sent by luaCreateFunction(). */
-        addReplyBulkCBuffer(c,sha,40);
+        char funcname[43];
+        sds sha;
+
+        funcname[0] = 'f';
+        funcname[1] = '_';
+        sha1hex(funcname+2,c->argv[2]->ptr,sdslen(c->argv[2]->ptr));
+        sha = sdsnewlen(funcname+2,40);
+        if (dictFind(server.lua_scripts,sha) == NULL) {
+            if (luaCreateFunction(c,server.lua,funcname,c->argv[2])
+                    == C_ERR) {
+                sdsfree(sha);
+                return;
+            }
+        }
+        addReplyBulkCBuffer(c,funcname+2,40);
+        sdsfree(sha);
         forceCommandPropagation(c,PROPAGATE_REPL|PROPAGATE_AOF);
     } else if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"kill")) {
         if (server.lua_caller == NULL) {
@@ -1511,10 +1481,9 @@ NULL
             c->flags |= CLIENT_LUA_DEBUG_SYNC;
         } else {
             addReplyError(c,"Use SCRIPT DEBUG yes/sync/no");
-            return;
         }
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try SCRIPT HELP", (char*)c->argv[1]->ptr);
+        addReplyError(c, "Unknown SCRIPT subcommand or wrong # of args.");
     }
 }
 

src/sds.c

@@ -39,8 +39,6 @@
 #include "sds.h"
 #include "sdsalloc.h"
 
-const char *SDS_NOINIT = "SDS_NOINIT";
-
 static inline int sdsHdrSize(char type) {
     switch(type&SDS_TYPE_MASK) {
         case SDS_TYPE_5:
@@ -74,7 +72,6 @@ static inline char sdsReqType(size_t string_size) {
 /* Create a new sds string with the content specified by the 'init' pointer
  * and 'initlen'.
  * If NULL is used for 'init' the string is initialized with zero bytes.
- * If SDS_NOINIT is used, the buffer is left uninitialized;
  *
  * The string is always null-termined (all the sds strings are, always) so
  * even if you create an sds string with:
@@ -95,9 +92,7 @@ sds sdsnewlen(const void *init, size_t initlen) {
     unsigned char *fp; /* flags pointer. */
 
     sh = s_malloc(hdrlen+initlen+1);
-    if (init==SDS_NOINIT)
-        init = NULL;
-    else if (!init)
+    if (!init)
         memset(sh, 0, hdrlen+initlen+1);
     if (sh == NULL) return NULL;
     s = (char*)sh+hdrlen;
@@ -180,7 +175,7 @@ void sdsfree(sds s) {
  * the output will be "6" as the string was modified but the logical length
  * remains 6 bytes. */
 void sdsupdatelen(sds s) {
-    size_t reallen = strlen(s);
+    int reallen = strlen(s);
     sdssetlen(s, reallen);
 }
 
@@ -324,7 +319,7 @@ void *sdsAllocPtr(sds s) {
  * ... check for nread <= 0 and handle it ...
  * sdsIncrLen(s, nread);
  */
-void sdsIncrLen(sds s, ssize_t incr) {
+void sdsIncrLen(sds s, int incr) {
     unsigned char flags = s[-1];
     size_t len;
     switch(flags&SDS_TYPE_MASK) {
@@ -594,7 +589,7 @@ sds sdscatprintf(sds s, const char *fmt, ...) {
 sds sdscatfmt(sds s, char const *fmt, ...) {
     size_t initlen = sdslen(s);
     const char *f = fmt;
-    long i;
+    int i;
     va_list ap;
 
     va_start(ap,fmt);
@@ -726,7 +721,7 @@ sds sdstrim(sds s, const char *cset) {
  * s = sdsnew("Hello World");
  * sdsrange(s,1,-1); => "ello World"
  */
-void sdsrange(sds s, ssize_t start, ssize_t end) {
+void sdsrange(sds s, int start, int end) {
     size_t newlen, len = sdslen(s);
 
     if (len == 0) return;
@@ -740,9 +735,9 @@ void sdsrange(sds s, ssize_t start, ssize_t end) {
     }
     newlen = (start > end) ? 0 : (end-start)+1;
     if (newlen != 0) {
-        if (start >= (ssize_t)len) {
+        if (start >= (signed)len) {
             newlen = 0;
-        } else if (end >= (ssize_t)len) {
+        } else if (end >= (signed)len) {
             end = len-1;
             newlen = (start > end) ? 0 : (end-start)+1;
         }
@@ -756,14 +751,14 @@ void sdsrange(sds s, ssize_t start, ssize_t end) {
 
 /* Apply tolower() to every character of the sds string 's'. */
 void sdstolower(sds s) {
-    size_t len = sdslen(s), j;
+    int len = sdslen(s), j;
 
     for (j = 0; j < len; j++) s[j] = tolower(s[j]);
 }
 
 /* Apply toupper() to every character of the sds string 's'. */
 void sdstoupper(sds s) {
-    size_t len = sdslen(s), j;
+    int len = sdslen(s), j;
 
     for (j = 0; j < len; j++) s[j] = toupper(s[j]);
 }
@@ -787,7 +782,7 @@ int sdscmp(const sds s1, const sds s2) {
     l2 = sdslen(s2);
     minlen = (l1 < l2) ? l1 : l2;
     cmp = memcmp(s1,s2,minlen);
-    if (cmp == 0) return l1>l2? 1: (l1<l2? -1: 0);
+    if (cmp == 0) return l1-l2;
     return cmp;
 }
 
@@ -807,9 +802,8 @@ int sdscmp(const sds s1, const sds s2) {
  * requires length arguments. sdssplit() is just the
  * same function but for zero-terminated strings.
  */
-sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count) {
-    int elements = 0, slots = 5;
-    long start = 0, j;
+sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count) {
+    int elements = 0, slots = 5, start = 0, j;
     sds *tokens;
 
     if (seplen < 1 || len < 0) return NULL;

src/sds.h

@@ -34,7 +34,6 @@
 #define __SDS_H
 
 #define SDS_MAX_PREALLOC (1024*1024)
-const char *SDS_NOINIT;
 
 #include <sys/types.h>
 #include <stdarg.h>
@@ -237,11 +236,11 @@ sds sdscatprintf(sds s, const char *fmt, ...);
 
 sds sdscatfmt(sds s, char const *fmt, ...);
 sds sdstrim(sds s, const char *cset);
-void sdsrange(sds s, ssize_t start, ssize_t end);
+void sdsrange(sds s, int start, int end);
 void sdsupdatelen(sds s);
 void sdsclear(sds s);
 int sdscmp(const sds s1, const sds s2);
-sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
+sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
 void sdsfreesplitres(sds *tokens, int count);
 void sdstolower(sds s);
 void sdstoupper(sds s);
@@ -254,7 +253,7 @@ sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
 
 /* Low level functions exposed to the user API */
 sds sdsMakeRoomFor(sds s, size_t addlen);
-void sdsIncrLen(sds s, ssize_t incr);
+void sdsIncrLen(sds s, int incr);
 sds sdsRemoveFreeSpace(sds s);
 size_t sdsAllocSize(sds s);
 void *sdsAllocPtr(sds s);

src/server.c

@@ -125,7 +125,7 @@ volatile unsigned long lru_clock; /* Server global current LRU time. */
  *    are not fast commands.
  */
 struct redisCommand redisCommandTable[] = {
-    {"module",moduleCommand,-2,"as",0,NULL,0,0,0,0,0},
+    {"module",moduleCommand,-2,"as",0,NULL,1,1,1,0,0},
     {"get",getCommand,2,"rF",0,NULL,1,1,1,0,0},
     {"set",setCommand,-3,"wm",0,NULL,1,1,1,0,0},
     {"setnx",setnxCommand,3,"wmF",0,NULL,1,1,1,0,0},
@@ -258,7 +258,7 @@ struct redisCommand redisCommandTable[] = {
     {"persist",persistCommand,2,"wF",0,NULL,1,1,1,0,0},
     {"slaveof",slaveofCommand,3,"ast",0,NULL,0,0,0,0,0},
     {"role",roleCommand,1,"lst",0,NULL,0,0,0,0,0},
-    {"debug",debugCommand,-2,"as",0,NULL,0,0,0,0,0},
+    {"debug",debugCommand,-1,"as",0,NULL,0,0,0,0,0},
     {"config",configCommand,-2,"lat",0,NULL,0,0,0,0,0},
     {"subscribe",subscribeCommand,-2,"pslt",0,NULL,0,0,0,0,0},
     {"unsubscribe",unsubscribeCommand,-1,"pslt",0,NULL,0,0,0,0,0},
@@ -276,7 +276,7 @@ struct redisCommand redisCommandTable[] = {
     {"readonly",readonlyCommand,1,"F",0,NULL,0,0,0,0,0},
     {"readwrite",readwriteCommand,1,"F",0,NULL,0,0,0,0,0},
     {"dump",dumpCommand,2,"r",0,NULL,1,1,1,0,0},
-    {"object",objectCommand,-2,"r",0,NULL,2,2,2,0,0},
+    {"object",objectCommand,3,"r",0,NULL,2,2,2,0,0},
     {"memory",memoryCommand,-2,"r",0,NULL,0,0,0,0,0},
     {"client",clientCommand,-2,"as",0,NULL,0,0,0,0,0},
     {"eval",evalCommand,-3,"s",0,evalGetKeys,0,0,0,0,0},
@@ -302,11 +302,6 @@ struct redisCommand redisCommandTable[] = {
     {"pfcount",pfcountCommand,-2,"r",0,NULL,1,-1,1,0,0},
     {"pfmerge",pfmergeCommand,-2,"wm",0,NULL,1,-1,1,0,0},
     {"pfdebug",pfdebugCommand,-3,"w",0,NULL,0,0,0,0,0},
-    {"xadd",xaddCommand,-5,"wmF",0,NULL,1,1,1,0,0},
-    {"xrange",xrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
-    {"xrevrange",xrevrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
-    {"xlen",xlenCommand,2,"rF",0,NULL,1,1,1,0,0},
-    {"xread",xreadCommand,-3,"rs",0,xreadGetKeys,1,1,1,0,0},
     {"post",securityWarningCommand,-1,"lt",0,NULL,0,0,0,0,0},
     {"host:",securityWarningCommand,-1,"lt",0,NULL,0,0,0,0,0},
     {"latency",latencyCommand,-2,"aslt",0,NULL,0,0,0,0,0}
@@ -552,21 +547,10 @@ dictType objectKeyPointerValueDictType = {
     NULL,                      /* key dup */
     NULL,                      /* val dup */
     dictEncObjKeyCompare,      /* key compare */
-    dictObjectDestructor,      /* key destructor */
+    dictObjectDestructor, /* key destructor */
     NULL                       /* val destructor */
 };
 
-/* Like objectKeyPointerValueDictType(), but values can be destroyed, if
- * not NULL, calling zfree(). */
-dictType objectKeyHeapPointerValueDictType = {
-    dictEncObjHash,            /* hash function */
-    NULL,                      /* key dup */
-    NULL,                      /* val dup */
-    dictEncObjKeyCompare,      /* key compare */
-    dictObjectDestructor,      /* key destructor */
-    dictVanillaFree            /* val destructor */
-};
-
 /* Set dictionary type. Keys are SDS strings, values are ot used. */
 dictType setDictType = {
     dictSdsHash,               /* hash function */
@@ -1095,7 +1079,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. */
+         * we have to save/rewrite now */
          for (j = 0; j < server.saveparamslen; j++) {
             struct saveparam *sp = server.saveparams+j;
 
@@ -1118,9 +1102,8 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
             }
          }
 
-         /* Trigger an AOF rewrite if needed. */
-         if (server.aof_state == AOF_ON &&
-             server.rdb_child_pid == -1 &&
+         /* Trigger an AOF rewrite if needed */
+         if (server.rdb_child_pid == -1 &&
              server.aof_child_pid == -1 &&
              server.aof_rewrite_perc &&
              server.aof_current_size > server.aof_rewrite_min_size)
@@ -1229,19 +1212,9 @@ void beforeSleep(struct aeEventLoop *eventLoop) {
     }
 
     /* Unblock all the clients blocked for synchronous replication
-     * or AOF sync in WAIT. */
-    if (listLength(server.clients_waiting_acks)) {
-        processClientsBlockedInWait();
-
-        /* If after this cycle we have still clients blocked waiting for
-         * AOF fsync, try to start a new sync cycle. Note that if one is
-         * already in progress, the call does nothing. */
-        if (server.blocked_clients_by_type[BLOCKED_AOF] &&
-            server.aof_state == AOF_ON)
-        {
-            aofStartBackgroundFsync();
-        }
-    }
+     * in WAIT. */
+    if (listLength(server.clients_waiting_acks))
+        processClientsWaitingReplicas();
 
     /* Check if there are clients unblocked by modules that implement
      * blocking commands. */
@@ -1399,7 +1372,6 @@ void initServerConfig(void) {
     server.active_defrag_threshold_upper = CONFIG_DEFAULT_DEFRAG_THRESHOLD_UPPER;
     server.active_defrag_cycle_min = CONFIG_DEFAULT_DEFRAG_CYCLE_MIN;
     server.active_defrag_cycle_max = CONFIG_DEFAULT_DEFRAG_CYCLE_MAX;
-    server.proto_max_bulk_len = CONFIG_DEFAULT_PROTO_MAX_BULK_LEN;
     server.client_max_querybuf_len = PROTO_MAX_QUERYBUF_LEN;
     server.saveparams = NULL;
     server.loading = 0;
@@ -1428,8 +1400,6 @@ void initServerConfig(void) {
     server.aof_rewrite_incremental_fsync = CONFIG_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC;
     server.aof_load_truncated = CONFIG_DEFAULT_AOF_LOAD_TRUNCATED;
     server.aof_use_rdb_preamble = CONFIG_DEFAULT_AOF_USE_RDB_PREAMBLE;
-    server.aof_fsync_in_progress_epoch = 0;
-    server.aof_fsync_epoch = 0;
     server.pidfile = NULL;
     server.rdb_filename = zstrdup(CONFIG_DEFAULT_RDB_FILENAME);
     server.aof_filename = zstrdup(CONFIG_DEFAULT_AOF_FILENAME);
@@ -1441,9 +1411,7 @@ void initServerConfig(void) {
     server.active_defrag_running = 0;
     server.notify_keyspace_events = 0;
     server.maxclients = CONFIG_DEFAULT_MAX_CLIENTS;
-    server.blocked_clients = 0;
-    memset(server.blocked_clients_by_type,0,
-           sizeof(server.blocked_clients_by_type));
+    server.bpop_blocked_clients = 0;
     server.maxmemory = CONFIG_DEFAULT_MAXMEMORY;
     server.maxmemory_policy = CONFIG_DEFAULT_MAXMEMORY_POLICY;
     server.maxmemory_samples = CONFIG_DEFAULT_MAXMEMORY_SAMPLES;
@@ -1581,29 +1549,16 @@ int restartServer(int flags, mstime_t delay) {
 
     /* Check if we still have accesses to the executable that started this
      * server instance. */
-    if (access(server.executable,X_OK) == -1) {
-        serverLog(LL_WARNING,"Can't restart: this process has no "
-                             "permissions to execute %s", server.executable);
-        return C_ERR;
-    }
+    if (access(server.executable,X_OK) == -1) return C_ERR;
 
     /* Config rewriting. */
     if (flags & RESTART_SERVER_CONFIG_REWRITE &&
         server.configfile &&
-        rewriteConfig(server.configfile) == -1)
-    {
-        serverLog(LL_WARNING,"Can't restart: configuration rewrite process "
-                             "failed");
-        return C_ERR;
-    }
+        rewriteConfig(server.configfile) == -1) return C_ERR;
 
     /* Perform a proper shutdown. */
     if (flags & RESTART_SERVER_GRACEFULLY &&
-        prepareForShutdown(SHUTDOWN_NOFLAGS) != C_OK)
-    {
-        serverLog(LL_WARNING,"Can't restart: error preparing for shutdown");
-        return C_ERR;
-    }
+        prepareForShutdown(SHUTDOWN_NOFLAGS) != C_OK) return C_ERR;
 
     /* Close all file descriptors, with the exception of stdin, stdout, strerr
      * which are useful if we restart a Redis server which is not daemonized. */
@@ -1615,8 +1570,6 @@ int restartServer(int flags, mstime_t delay) {
 
     /* Execute the server with the original command line. */
     if (delay) usleep(delay*1000);
-    zfree(server.exec_argv[0]);
-    server.exec_argv[0] = zstrdup(server.executable);
     execve(server.executable,server.exec_argv,environ);
 
     /* If an error occurred here, there is nothing we can do, but exit. */
@@ -1811,8 +1764,6 @@ void resetServerStats(void) {
     server.stat_numcommands = 0;
     server.stat_numconnections = 0;
     server.stat_expiredkeys = 0;
-    server.stat_expired_stale_perc = 0;
-    server.stat_expired_time_cap_reached_count = 0;
     server.stat_evictedkeys = 0;
     server.stat_keyspace_misses = 0;
     server.stat_keyspace_hits = 0;
@@ -2494,9 +2445,8 @@ int processCommand(client *c) {
         return C_OK;
     }
 
-    /* Only allow commands with flag "t", such as INFO, SLAVEOF and so on,
-     * when slave-serve-stale-data is no and we are a slave with a broken
-     * link with master. */
+    /* Only allow INFO and SLAVEOF when slave-serve-stale-data is no and
+     * we are a slave with a broken link with master. */
     if (server.masterhost && server.repl_state != REPL_STATE_CONNECTED &&
         server.repl_serve_stale_data == 0 &&
         !(c->cmd->flags & CMD_STALE))
@@ -2540,7 +2490,7 @@ int processCommand(client *c) {
         call(c,CMD_CALL_FULL);
         c->woff = server.master_repl_offset;
         if (listLength(server.ready_keys))
-            handleClientsBlockedOnKeys();
+            handleClientsBlockedOnLists();
     }
     return C_OK;
 }
@@ -2783,16 +2733,7 @@ void commandCommand(client *c) {
     dictIterator *di;
     dictEntry *de;
 
-    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.",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (c->argc == 1) {
+    if (c->argc == 1) {
         addReplyMultiBulkLen(c, dictSize(server.commands));
         di = dictGetIterator(server.commands);
         while ((de = dictNext(di)) != NULL) {
@@ -2826,7 +2767,8 @@ 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);
+        addReplyError(c, "Unknown subcommand or wrong number of arguments.");
+        return;
     }
 }
 
@@ -2957,7 +2899,7 @@ sds genRedisInfoString(char *section) {
             "blocked_clients:%d\r\n",
             listLength(server.clients)-listLength(server.slaves),
             lol, bib,
-            server.blocked_clients);
+            server.bpop_blocked_clients);
     }
 
     /* Memory */
@@ -3146,8 +3088,6 @@ sds genRedisInfoString(char *section) {
             "sync_partial_ok:%lld\r\n"
             "sync_partial_err:%lld\r\n"
             "expired_keys:%lld\r\n"
-            "expired_stale_perc:%.2f\r\n"
-            "expired_time_cap_reached_count:%lld\r\n"
             "evicted_keys:%lld\r\n"
             "keyspace_hits:%lld\r\n"
             "keyspace_misses:%lld\r\n"
@@ -3172,8 +3112,6 @@ sds genRedisInfoString(char *section) {
             server.stat_sync_partial_ok,
             server.stat_sync_partial_err,
             server.stat_expiredkeys,
-            server.stat_expired_stale_perc*100,
-            server.stat_expired_time_cap_reached_count,
             server.stat_evictedkeys,
             server.stat_keyspace_hits,
             server.stat_keyspace_misses,
@@ -3602,8 +3540,7 @@ void loadDataFromDisk(void) {
                 rsi.repl_id_is_set &&
                 rsi.repl_offset != -1 &&
                 /* Note that older implementations may save a repl_stream_db
-                 * of -1 inside the RDB file in a wrong way, see more information
-                 * in function rdbPopulateSaveInfo. */
+                 * of -1 inside the RDB file. */
                 rsi.repl_stream_db != -1)
             {
                 memcpy(server.replid,rsi.repl_id,sizeof(server.replid));

src/server.h

@@ -59,7 +59,6 @@ typedef long long mstime_t; /* millisecond time type. */
 #include "anet.h"    /* Networking the easy way */
 #include "ziplist.h" /* Compact list data structure */
 #include "intset.h"  /* Compact integer set structure */
-#include "stream.h"  /* Stream data type header file. */
 #include "version.h" /* Version macro */
 #include "util.h"    /* Misc functions useful in many places */
 #include "latency.h" /* Latency monitor API */
@@ -161,7 +160,6 @@ typedef long long mstime_t; /* millisecond time type. */
 #define CONFIG_DEFAULT_DEFRAG_IGNORE_BYTES (100<<20) /* don't defrag if frag overhead is below 100mb */
 #define CONFIG_DEFAULT_DEFRAG_CYCLE_MIN 25 /* 25% CPU min (at lower threshold) */
 #define CONFIG_DEFAULT_DEFRAG_CYCLE_MAX 75 /* 75% CPU max (at upper threshold) */
-#define CONFIG_DEFAULT_PROTO_MAX_BULK_LEN (512ll*1024*1024) /* Bulk request max size */
 
 #define ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP 20 /* Loopkups per loop. */
 #define ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 /* Microseconds */
@@ -257,9 +255,6 @@ typedef long long mstime_t; /* millisecond time type. */
 #define BLOCKED_LIST 1    /* BLPOP & co. */
 #define BLOCKED_WAIT 2    /* WAIT for synchronous replication. */
 #define BLOCKED_MODULE 3  /* Blocked by a loadable module. */
-#define BLOCKED_STREAM 4  /* XREAD. */
-#define BLOCKED_AOF 5     /* WAIT AOF waiting for AOF sync. */
-#define BLOCKED_NUM 6     /* Number of blocked states. */
 
 /* Client request types */
 #define PROTO_REQ_INLINE 1
@@ -429,8 +424,7 @@ typedef long long mstime_t; /* millisecond time type. */
 #define NOTIFY_ZSET (1<<7)        /* z */
 #define NOTIFY_EXPIRED (1<<8)     /* x */
 #define NOTIFY_EVICTED (1<<9)     /* e */
-#define NOTIFY_STREAM (1<<10)     /* t */
-#define NOTIFY_ALL (NOTIFY_GENERIC | NOTIFY_STRING | NOTIFY_LIST | NOTIFY_SET | NOTIFY_HASH | NOTIFY_ZSET | NOTIFY_EXPIRED | NOTIFY_EVICTED | NOTIFY_STREAM) /* A flag */
+#define NOTIFY_ALL (NOTIFY_GENERIC | NOTIFY_STRING | NOTIFY_LIST | NOTIFY_SET | NOTIFY_HASH | NOTIFY_ZSET | NOTIFY_EXPIRED | NOTIFY_EVICTED)      /* A */
 
 /* Get the first bind addr or NULL */
 #define NET_FIRST_BIND_ADDR (server.bindaddr_count ? server.bindaddr[0] : NULL)
@@ -452,11 +446,11 @@ typedef long long mstime_t; /* millisecond time type. */
 /* A redis object, that is a type able to hold a string / list / set */
 
 /* The actual Redis Object */
-#define OBJ_STRING 0    /* String object. */
-#define OBJ_LIST 1      /* List object. */
-#define OBJ_SET 2       /* Set object. */
-#define OBJ_ZSET 3      /* Sorted set object. */
-#define OBJ_HASH 4      /* Hash object. */
+#define OBJ_STRING 0
+#define OBJ_LIST 1
+#define OBJ_SET 2
+#define OBJ_ZSET 3
+#define OBJ_HASH 4
 
 /* The "module" object type is a special one that signals that the object
  * is one directly managed by a Redis module. In this case the value points
@@ -469,8 +463,7 @@ typedef long long mstime_t; /* millisecond time type. */
  * by a 64 bit module type ID, which has a 54 bits module-specific signature
  * in order to dispatch the loading to the right module, plus a 10 bits
  * encoding version. */
-#define OBJ_MODULE 5    /* Module object. */
-#define OBJ_STREAM 6    /* Stream object. */
+#define OBJ_MODULE 5
 
 /* Extract encver / signature from a module type ID. */
 #define REDISMODULE_TYPE_ENCVER_BITS 10
@@ -582,7 +575,6 @@ typedef struct RedisModuleDigest {
 #define OBJ_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
 #define OBJ_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
 #define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
-#define OBJ_ENCODING_STREAM 10 /* Encoded as a radix tree of listpacks */
 
 #define LRU_BITS 24
 #define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) /* Max value of obj->lru */
@@ -594,7 +586,7 @@ typedef struct redisObject {
     unsigned encoding:4;
     unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                             * LFU data (least significant 8 bits frequency
-                            * and most significant 16 bits access time). */
+                            * and most significant 16 bits decreas time). */
     int refcount;
     void *ptr;
 } robj;
@@ -646,24 +638,16 @@ typedef struct blockingState {
     mstime_t timeout;       /* Blocking operation timeout. If UNIX current time
                              * is > timeout then the operation timed out. */
 
-    /* BLOCKED_LIST and BLOCKED_STREAM */
+    /* BLOCKED_LIST */
     dict *keys;             /* The keys we are waiting to terminate a blocking
-                             * operation such as BLPOP or XREAD. Or NULL. */
+                             * operation such as BLPOP. Otherwise NULL. */
     robj *target;           /* The key that should receive the element,
                              * for BRPOPLPUSH. */
 
-    /* BLOCK_STREAM */
-    size_t xread_count;     /* XREAD COUNT option. */
-    robj *xread_group;      /* XREAD group name. */
-    mstime_t xread_retry_time, xread_retry_ttl;
-
     /* BLOCKED_WAIT */
     int numreplicas;        /* Number of replicas we are waiting for ACK. */
     long long reploffset;   /* Replication offset to reach. */
 
-    /* BLOCKED_AOF */
-    uint64_t aofepoch;      /* WAIT AOF: the sync epoch we are waiting for. */
-
     /* BLOCKED_MODULE */
     void *module_blocked_handle; /* RedisModuleBlockedClient structure.
                                     which is opaque for the Redis core, only
@@ -738,7 +722,6 @@ typedef struct client {
     dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
     list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */
     sds peerid;             /* Cached peer ID. */
-    listNode *client_list_node; /* list node in client list */
 
     /* Response buffer */
     int bufpos;
@@ -954,8 +937,6 @@ struct redisServer {
     long long stat_numcommands;     /* Number of processed commands */
     long long stat_numconnections;  /* Number of connections received */
     long long stat_expiredkeys;     /* Number of expired keys */
-    double stat_expired_stale_perc; /* Percentage of keys probably expired */
-    long long stat_expired_time_cap_reached_count; /* Early expire cylce stops.*/
     long long stat_evictedkeys;     /* Number of evicted keys (maxmemory) */
     long long stat_keyspace_hits;   /* Number of successful lookups of keys */
     long long stat_keyspace_misses; /* Number of failed lookups of keys */
@@ -1020,7 +1001,7 @@ struct redisServer {
     int aof_fd;       /* File descriptor of currently selected AOF file */
     int aof_selected_db; /* Currently selected DB in AOF */
     time_t aof_flush_postponed_start; /* UNIX time of postponed AOF flush */
-    time_t aof_last_fsync;            /* UNIX time of last fsync() *attempt* */
+    time_t aof_last_fsync;            /* UNIX time of last fsync() */
     time_t aof_rewrite_time_last;   /* Time used by last AOF rewrite run. */
     time_t aof_rewrite_time_start;  /* Current AOF rewrite start time. */
     int aof_lastbgrewrite_status;   /* C_OK or C_ERR */
@@ -1030,8 +1011,6 @@ struct redisServer {
     int aof_last_write_errno;       /* Valid if aof_last_write_status is ERR */
     int aof_load_truncated;         /* Don't stop on unexpected AOF EOF. */
     int aof_use_rdb_preamble;       /* Use RDB preamble on AOF rewrites. */
-    uint64_t aof_fsync_epoch;       /* AOF sync epoch used for WAIT AOF. */
-    uint64_t aof_fsync_in_progress_epoch; /* Current ongoing AOF sync epoch. */
     /* AOF pipes used to communicate between parent and child during rewrite. */
     int aof_pipe_write_data_to_child;
     int aof_pipe_read_data_from_parent;
@@ -1139,12 +1118,10 @@ struct redisServer {
     unsigned long long maxmemory;   /* Max number of memory bytes to use */
     int maxmemory_policy;           /* Policy for key eviction */
     int maxmemory_samples;          /* Pricision of random sampling */
-    int lfu_log_factor;             /* LFU logarithmic counter factor. */
-    int lfu_decay_time;             /* LFU counter decay factor. */
-    long long proto_max_bulk_len;   /* Protocol bulk length maximum size. */
+    unsigned int lfu_log_factor;    /* LFU logarithmic counter factor. */
+    unsigned int lfu_decay_time;    /* LFU counter decay factor. */
     /* Blocked clients */
-    unsigned int blocked_clients;   /* # of clients executing a blocking cmd.*/
-    unsigned int blocked_clients_by_type[BLOCKED_NUM];
+    unsigned int bpop_blocked_clients; /* Number of clients blocked by lists */
     list *unblocked_clients; /* list of clients to unblock before next loop */
     list *ready_keys;        /* List of readyList structures for BLPOP & co */
     /* Sort parameters - qsort_r() is only available under BSD so we
@@ -1311,7 +1288,6 @@ typedef struct {
 extern struct redisServer server;
 extern struct sharedObjectsStruct shared;
 extern dictType objectKeyPointerValueDictType;
-extern dictType objectKeyHeapPointerValueDictType;
 extern dictType setDictType;
 extern dictType zsetDictType;
 extern dictType clusterNodesDictType;
@@ -1343,8 +1319,6 @@ void moduleBlockedClientPipeReadable(aeEventLoop *el, int fd, void *privdata, in
 size_t moduleCount(void);
 void moduleAcquireGIL(void);
 void moduleReleaseGIL(void);
-void moduleNotifyKeyspaceEvent(int type, const char *event, robj *key, int dbid);
-
 
 /* Utils */
 long long ustime(void);
@@ -1383,7 +1357,6 @@ void addReplyDouble(client *c, double d);
 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 copyClientOutputBuffer(client *dst, client *src);
 size_t sdsZmallocSize(sds s);
 size_t getStringObjectSdsUsedMemory(robj *o);
@@ -1412,7 +1385,6 @@ int handleClientsWithPendingWrites(void);
 int clientHasPendingReplies(client *c);
 void unlinkClient(client *c);
 int writeToClient(int fd, client *c, int handler_installed);
-void linkClient(client *c);
 
 #ifdef __GNUC__
 void addReplyErrorFormat(client *c, const char *fmt, ...)
@@ -1438,7 +1410,9 @@ int listTypeEqual(listTypeEntry *entry, robj *o);
 void listTypeDelete(listTypeIterator *iter, listTypeEntry *entry);
 void listTypeConvert(robj *subject, int enc);
 void unblockClientWaitingData(client *c);
+void handleClientsBlockedOnLists(void);
 void popGenericCommand(client *c, int where);
+void signalListAsReady(redisDb *db, robj *key);
 
 /* MULTI/EXEC/WATCH... */
 void unwatchAllKeys(client *c);
@@ -1481,7 +1455,6 @@ robj *createIntsetObject(void);
 robj *createHashObject(void);
 robj *createZsetObject(void);
 robj *createZsetZiplistObject(void);
-robj *createStreamObject(void);
 robj *createModuleObject(moduleType *mt, void *value);
 int getLongFromObjectOrReply(client *c, robj *o, long *target, const char *msg);
 int checkType(client *c, robj *o, int type);
@@ -1519,7 +1492,7 @@ void replicationScriptCacheInit(void);
 void replicationScriptCacheFlush(void);
 void replicationScriptCacheAdd(sds sha1);
 int replicationScriptCacheExists(sds sha1);
-void processClientsBlockedInWait(void);
+void processClientsWaitingReplicas(void);
 void unblockClientWaitingReplicas(client *c);
 int replicationCountAcksByOffset(long long offset);
 void replicationSendNewlineToMaster(void);
@@ -1554,8 +1527,6 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal);
 void aofRewriteBufferReset(void);
 unsigned long aofRewriteBufferSize(void);
 ssize_t aofReadDiffFromParent(void);
-void aofStartBackgroundFsync(void);
-uint64_t aofNextEpoch(void);
 
 /* Child info */
 void openChildInfoPipe(void);
@@ -1783,7 +1754,6 @@ int *evalGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys);
 int *sortGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys);
 int *migrateGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys);
 int *georadiusGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys);
-int *xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys);
 
 /* Cluster */
 void clusterInit(void);
@@ -1811,7 +1781,6 @@ void scriptingInit(int setup);
 int ldbRemoveChild(pid_t pid);
 void ldbKillForkedSessions(void);
 int ldbPendingChildren(void);
-sds luaCreateFunction(client *c, lua_State *lua, robj *body);
 
 /* Blocked clients */
 void processUnblockedClients(void);
@@ -1820,9 +1789,6 @@ void unblockClient(client *c);
 void replyToBlockedClientTimedOut(client *c);
 int getTimeoutFromObjectOrReply(client *c, robj *object, mstime_t *timeout, int unit);
 void disconnectAllBlockedClients(void);
-void handleClientsBlockedOnKeys(void);
-void signalKeyAsReady(redisDb *db, robj *key);
-void blockForKeys(client *c, int btype, robj **keys, int numkeys, mstime_t timeout, robj *target, streamID *ids);
 
 /* expire.c -- Handling of expired keys */
 void activeExpireCycle(int type);
@@ -1836,7 +1802,6 @@ void evictionPoolAlloc(void);
 #define LFU_INIT_VAL 5
 unsigned long LFUGetTimeInMinutes(void);
 uint8_t LFULogIncr(uint8_t value);
-unsigned long LFUDecrAndReturn(robj *o);
 
 /* Keys hashing / comparison functions for dict.c hash tables. */
 uint64_t dictSdsHash(const void *key);
@@ -2025,11 +1990,6 @@ void pfdebugCommand(client *c);
 void latencyCommand(client *c);
 void moduleCommand(client *c);
 void securityWarningCommand(client *c);
-void xaddCommand(client *c);
-void xrangeCommand(client *c);
-void xrevrangeCommand(client *c);
-void xlenCommand(client *c);
-void xreadCommand(client *c);
 
 #if defined(__GNUC__)
 void *calloc(size_t count, size_t size) __attribute__ ((deprecated));

src/setproctitle.c

@@ -39,11 +39,7 @@
 #include <errno.h>	/* errno program_invocation_name program_invocation_short_name */
 
 #if !defined(HAVE_SETPROCTITLE)
-#if (defined __NetBSD__ || defined __FreeBSD__ || defined __OpenBSD__)
-#define HAVE_SETPROCTITLE 1
-#else
-#define HAVE_SETPROCTITLE 0
-#endif
+#define HAVE_SETPROCTITLE (defined __NetBSD__ || defined __FreeBSD__ || defined __OpenBSD__)
 #endif
 
 

src/slowlog.c

@@ -140,17 +140,7 @@ void slowlogReset(void) {
 /* The SLOWLOG command. Implements all the subcommands needed to handle the
  * Redis slow log. */
 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)."
-"    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.",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"reset")) {
+    if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"reset")) {
         slowlogReset();
         addReply(c,shared.ok);
     } else if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"len")) {
@@ -187,6 +177,7 @@ 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);
+        addReplyError(c,
+            "Unknown SLOWLOG subcommand or wrong # of args. Try GET, RESET, LEN.");
     }
 }

src/stream.h

@@ -1,59 +0,0 @@
-#ifndef STREAM_H
-#define STREAM_H
-
-#include "rax.h"
-#include "listpack.h"
-
-/* Stream item ID: a 128 bit number composed of a milliseconds time and
- * a sequence counter. IDs generated in the same millisecond (or in a past
- * millisecond if the clock jumped backward) will use the millisecond time
- * of the latest generated ID and an incremented sequence. */
-typedef struct streamID {
-    uint64_t ms;        /* Unix time in milliseconds. */
-    uint64_t seq;       /* Sequence number. */
-} streamID;
-
-typedef struct stream {
-    rax *rax;               /* The radix tree holding the stream. */
-    uint64_t length;        /* Number of elements inside this stream. */
-    streamID last_id;       /* Zero if there are yet no items. */
-} stream;
-
-/* We define an iterator to iterate stream items in an abstract way, without
- * caring about the radix tree + listpack representation. Technically speaking
- * the iterator is only used inside streamReplyWithRange(), so could just
- * be implemented inside the function, but practically there is the AOF
- * rewriting code that also needs to iterate the stream to emit the XADD
- * commands. */
-typedef struct streamIterator {
-    streamID master_id;     /* ID of the master entry at listpack head. */
-    uint64_t master_fields_count;       /* Master entries # of fields. */
-    unsigned char *master_fields_start; /* Master entries start in listpack. */
-    unsigned char *master_fields_ptr;   /* Master field to emit next. */
-    int entry_flags;                    /* Flags of entry we are emitting. */
-    int rev;                /* True if iterating end to start (reverse). */
-    uint64_t start_key[2];  /* Start key as 128 bit big endian. */
-    uint64_t end_key[2];    /* End key as 128 bit big endian. */
-    raxIterator ri;         /* Rax iterator. */
-    unsigned char *lp;      /* Current listpack. */
-    unsigned char *lp_ele;  /* Current listpack cursor. */
-    /* Buffers used to hold the string of lpGet() when the element is
-     * integer encoded, so that there is no string representation of the
-     * element inside the listpack itself. */
-    unsigned char field_buf[LP_INTBUF_SIZE];
-    unsigned char value_buf[LP_INTBUF_SIZE];
-} streamIterator;
-
-/* Prototypes of exported APIs. */
-
-struct client;
-
-stream *streamNew(void);
-void freeStream(stream *s);
-size_t streamReplyWithRange(struct client *c, stream *s, streamID *start, streamID *end, size_t count, int rev);
-void streamIteratorStart(streamIterator *si, stream *s, streamID *start, streamID *end, int rev);
-int streamIteratorGetID(streamIterator *si, streamID *id, int64_t *numfields);
-void streamIteratorGetField(streamIterator *si, unsigned char **fieldptr, unsigned char **valueptr, int64_t *fieldlen, int64_t *valuelen);
-void streamIteratorStop(streamIterator *si);
-
-#endif

src/t_hash.c

@@ -287,8 +287,8 @@ int hashTypeDelete(robj *o, sds field) {
         if (fptr != NULL) {
             fptr = ziplistFind(fptr, (unsigned char*)field, sdslen(field), 1);
             if (fptr != NULL) {
-                zl = ziplistDelete(zl,&fptr); /* Delete the key. */
-                zl = ziplistDelete(zl,&fptr); /* Delete the value. */
+                zl = ziplistDelete(zl,&fptr);
+                zl = ziplistDelete(zl,&fptr);
                 o->ptr = zl;
                 deleted = 1;
             }
@@ -616,7 +616,7 @@ void hincrbyfloatCommand(client *c) {
 
     value += incr;
 
-    char buf[MAX_LONG_DOUBLE_CHARS];
+    char buf[256];
     int len = ld2string(buf,sizeof(buf),value,1);
     new = sdsnewlen(buf,len);
     hashTypeSet(o,c->argv[2]->ptr,new,HASH_SET_TAKE_VALUE);

src/t_list.c

@@ -603,6 +603,119 @@ void rpoplpushCommand(client *c) {
  * Blocking POP operations
  *----------------------------------------------------------------------------*/
 
+/* This is how the current blocking POP works, we use BLPOP as example:
+ * - If the user calls BLPOP and the key exists and contains a non empty list
+ *   then LPOP is called instead. So BLPOP is semantically the same as LPOP
+ *   if blocking is not required.
+ * - If instead BLPOP is called and the key does not exists or the list is
+ *   empty we need to block. In order to do so we remove the notification for
+ *   new data to read in the client socket (so that we'll not serve new
+ *   requests if the blocking request is not served). Also we put the client
+ *   in a dictionary (db->blocking_keys) mapping keys to a list of clients
+ *   blocking for this keys.
+ * - If a PUSH operation against a key with blocked clients waiting is
+ *   performed, we mark this key as "ready", and after the current command,
+ *   MULTI/EXEC block, or script, is executed, we serve all the clients waiting
+ *   for this list, from the one that blocked first, to the last, accordingly
+ *   to the number of elements we have in the ready list.
+ */
+
+/* Set a client in blocking mode for the specified key, with the specified
+ * timeout */
+void blockForKeys(client *c, robj **keys, int numkeys, mstime_t timeout, robj *target) {
+    dictEntry *de;
+    list *l;
+    int j;
+
+    c->bpop.timeout = timeout;
+    c->bpop.target = target;
+
+    if (target != NULL) incrRefCount(target);
+
+    for (j = 0; j < numkeys; j++) {
+        /* If the key already exists in the dict ignore it. */
+        if (dictAdd(c->bpop.keys,keys[j],NULL) != DICT_OK) continue;
+        incrRefCount(keys[j]);
+
+        /* And in the other "side", to map keys -> clients */
+        de = dictFind(c->db->blocking_keys,keys[j]);
+        if (de == NULL) {
+            int retval;
+
+            /* For every key we take a list of clients blocked for it */
+            l = listCreate();
+            retval = dictAdd(c->db->blocking_keys,keys[j],l);
+            incrRefCount(keys[j]);
+            serverAssertWithInfo(c,keys[j],retval == DICT_OK);
+        } else {
+            l = dictGetVal(de);
+        }
+        listAddNodeTail(l,c);
+    }
+    blockClient(c,BLOCKED_LIST);
+}
+
+/* Unblock a client that's waiting in a blocking operation such as BLPOP.
+ * You should never call this function directly, but unblockClient() instead. */
+void unblockClientWaitingData(client *c) {
+    dictEntry *de;
+    dictIterator *di;
+    list *l;
+
+    serverAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0);
+    di = dictGetIterator(c->bpop.keys);
+    /* The client may wait for multiple keys, so unblock it for every key. */
+    while((de = dictNext(di)) != NULL) {
+        robj *key = dictGetKey(de);
+
+        /* Remove this client from the list of clients waiting for this key. */
+        l = dictFetchValue(c->db->blocking_keys,key);
+        serverAssertWithInfo(c,key,l != NULL);
+        listDelNode(l,listSearchKey(l,c));
+        /* If the list is empty we need to remove it to avoid wasting memory */
+        if (listLength(l) == 0)
+            dictDelete(c->db->blocking_keys,key);
+    }
+    dictReleaseIterator(di);
+
+    /* Cleanup the client structure */
+    dictEmpty(c->bpop.keys,NULL);
+    if (c->bpop.target) {
+        decrRefCount(c->bpop.target);
+        c->bpop.target = NULL;
+    }
+}
+
+/* If the specified key has clients blocked waiting for list pushes, this
+ * function will put the key reference into the server.ready_keys list.
+ * Note that db->ready_keys is a hash table that allows us to avoid putting
+ * the same key again and again in the list in case of multiple pushes
+ * made by a script or in the context of MULTI/EXEC.
+ *
+ * The list will be finally processed by handleClientsBlockedOnLists() */
+void signalListAsReady(redisDb *db, robj *key) {
+    readyList *rl;
+
+    /* No clients blocking for this key? No need to queue it. */
+    if (dictFind(db->blocking_keys,key) == NULL) return;
+
+    /* Key was already signaled? No need to queue it again. */
+    if (dictFind(db->ready_keys,key) != NULL) return;
+
+    /* Ok, we need to queue this key into server.ready_keys. */
+    rl = zmalloc(sizeof(*rl));
+    rl->key = key;
+    rl->db = db;
+    incrRefCount(key);
+    listAddNodeTail(server.ready_keys,rl);
+
+    /* We also add the key in the db->ready_keys dictionary in order
+     * to avoid adding it multiple times into a list with a simple O(1)
+     * check. */
+    incrRefCount(key);
+    serverAssert(dictAdd(db->ready_keys,key,NULL) == DICT_OK);
+}
+
 /* This is a helper function for handleClientsBlockedOnLists(). It's work
  * is to serve a specific client (receiver) that is blocked on 'key'
  * in the context of the specified 'db', doing the following:
@@ -672,6 +785,97 @@ int serveClientBlockedOnList(client *receiver, robj *key, robj *dstkey, redisDb
     return C_OK;
 }
 
+/* This function should be called by Redis every time a single command,
+ * a MULTI/EXEC block, or a Lua script, terminated its execution after
+ * being called by a client.
+ *
+ * All the keys with at least one client blocked that received at least
+ * one new element via some PUSH operation are accumulated into
+ * the server.ready_keys list. This function will run the list and will
+ * serve clients accordingly. Note that the function will iterate again and
+ * again as a result of serving BRPOPLPUSH we can have new blocking clients
+ * to serve because of the PUSH side of BRPOPLPUSH. */
+void handleClientsBlockedOnLists(void) {
+    while(listLength(server.ready_keys) != 0) {
+        list *l;
+
+        /* Point server.ready_keys to a fresh list and save the current one
+         * locally. This way as we run the old list we are free to call
+         * signalListAsReady() that may push new elements in server.ready_keys
+         * when handling clients blocked into BRPOPLPUSH. */
+        l = server.ready_keys;
+        server.ready_keys = listCreate();
+
+        while(listLength(l) != 0) {
+            listNode *ln = listFirst(l);
+            readyList *rl = ln->value;
+
+            /* First of all remove this key from db->ready_keys so that
+             * we can safely call signalListAsReady() against this key. */
+            dictDelete(rl->db->ready_keys,rl->key);
+
+            /* If the key exists and it's a list, serve blocked clients
+             * with data. */
+            robj *o = lookupKeyWrite(rl->db,rl->key);
+            if (o != NULL && o->type == OBJ_LIST) {
+                dictEntry *de;
+
+                /* We serve clients in the same order they blocked for
+                 * this key, from the first blocked to the last. */
+                de = dictFind(rl->db->blocking_keys,rl->key);
+                if (de) {
+                    list *clients = dictGetVal(de);
+                    int numclients = listLength(clients);
+
+                    while(numclients--) {
+                        listNode *clientnode = listFirst(clients);
+                        client *receiver = clientnode->value;
+                        robj *dstkey = receiver->bpop.target;
+                        int where = (receiver->lastcmd &&
+                                     receiver->lastcmd->proc == blpopCommand) ?
+                                    LIST_HEAD : LIST_TAIL;
+                        robj *value = listTypePop(o,where);
+
+                        if (value) {
+                            /* Protect receiver->bpop.target, that will be
+                             * freed by the next unblockClient()
+                             * call. */
+                            if (dstkey) incrRefCount(dstkey);
+                            unblockClient(receiver);
+
+                            if (serveClientBlockedOnList(receiver,
+                                rl->key,dstkey,rl->db,value,
+                                where) == C_ERR)
+                            {
+                                /* If we failed serving the client we need
+                                 * to also undo the POP operation. */
+                                    listTypePush(o,value,where);
+                            }
+
+                            if (dstkey) decrRefCount(dstkey);
+                            decrRefCount(value);
+                        } else {
+                            break;
+                        }
+                    }
+                }
+
+                if (listTypeLength(o) == 0) {
+                    dbDelete(rl->db,rl->key);
+                }
+                /* We don't call signalModifiedKey() as it was already called
+                 * when an element was pushed on the list. */
+            }
+
+            /* Free this item. */
+            decrRefCount(rl->key);
+            zfree(rl);
+            listDelNode(l,ln);
+        }
+        listRelease(l); /* We have the new list on place at this point. */
+    }
+}
+
 /* Blocking RPOP/LPOP */
 void blockingPopGenericCommand(client *c, int where) {
     robj *o;
@@ -726,7 +930,7 @@ void blockingPopGenericCommand(client *c, int where) {
     }
 
     /* If the list is empty or the key does not exists we must block */
-    blockForKeys(c,BLOCKED_LIST,c->argv + 1,c->argc - 2,timeout,NULL,NULL);
+    blockForKeys(c, c->argv + 1, c->argc - 2, timeout, NULL);
 }
 
 void blpopCommand(client *c) {
@@ -752,7 +956,7 @@ void brpoplpushCommand(client *c) {
             addReply(c, shared.nullbulk);
         } else {
             /* The list is empty and the client blocks. */
-            blockForKeys(c,BLOCKED_LIST,c->argv + 1,1,timeout,c->argv[2],NULL);
+            blockForKeys(c, c->argv + 1, 1, timeout, c->argv[2]);
         }
     } else {
         if (key->type != OBJ_LIST) {

src/t_set.c

@@ -407,7 +407,7 @@ void spopWithCountCommand(client *c) {
     /* Get the count argument */
     if (getLongFromObjectOrReply(c,c->argv[2],&l,NULL) != C_OK) return;
     if (l >= 0) {
-        count = (unsigned long) l;
+        count = (unsigned) l;
     } else {
         addReply(c,shared.outofrangeerr);
         return;
@@ -626,7 +626,7 @@ void srandmemberWithCountCommand(client *c) {
 
     if (getLongFromObjectOrReply(c,c->argv[2],&l,NULL) != C_OK) return;
     if (l >= 0) {
-        count = (unsigned long) l;
+        count = (unsigned) l;
     } else {
         /* A negative count means: return the same elements multiple times
          * (i.e. don't remove the extracted element after every extraction). */
@@ -774,21 +774,15 @@ void srandmemberCommand(client *c) {
 }
 
 int qsortCompareSetsByCardinality(const void *s1, const void *s2) {
-    if (setTypeSize(*(robj**)s1) > setTypeSize(*(robj**)s2)) return 1;
-    if (setTypeSize(*(robj**)s1) < setTypeSize(*(robj**)s2)) return -1;
-    return 0;
+    return setTypeSize(*(robj**)s1)-setTypeSize(*(robj**)s2);
 }
 
 /* This is used by SDIFF and in this case we can receive NULL that should
  * be handled as empty sets. */
 int qsortCompareSetsByRevCardinality(const void *s1, const void *s2) {
     robj *o1 = *(robj**)s1, *o2 = *(robj**)s2;
-    unsigned long first = o1 ? setTypeSize(o1) : 0;
-    unsigned long second = o2 ? setTypeSize(o2) : 0;
 
-    if (first < second) return 1;
-    if (first > second) return -1;
-    return 0;
+    return  (o2 ? setTypeSize(o2) : 0) - (o1 ? setTypeSize(o1) : 0);
 }
 
 void sinterGenericCommand(client *c, robj **setkeys,

src/util.c

@@ -84,7 +84,7 @@ int stringmatchlen(const char *pattern, int patternLen,
             }
             match = 0;
             while(1) {
-                if (pattern[0] == '\\' && patternLen >= 2) {
+                if (pattern[0] == '\\') {
                     pattern++;
                     patternLen--;
                     if (pattern[0] == string[0])

src/util.h

@@ -33,11 +33,6 @@
 #include <stdint.h>
 #include "sds.h"
 
-/* The maximum number of characters needed to represent a long double
- * as a string (long double has a huge range).
- * This should be the size of the buffer given to ld2string */
-#define MAX_LONG_DOUBLE_CHARS 5*1024
-
 int stringmatchlen(const char *p, int plen, const char *s, int slen, int nocase);
 int stringmatch(const char *p, const char *s, int nocase);
 long long memtoll(const char *p, int *err);

src/ziplist.c

@@ -53,20 +53,20 @@
  * <prevlen> <encoding>
  *
  * The length of the previous entry, <prevlen>, is encoded in the following way:
- * If this length is smaller than 254 bytes, it will only consume a single
+ * If this length is smaller than 255 bytes, it will only consume a single
  * byte representing the length as an unsinged 8 bit integer. When the length
- * is greater than or equal to 254, it will consume 5 bytes. The first byte is
- * set to 254 (FE) to indicate a larger value is following. The remaining 4
+ * is greater than or equal to 255, it will consume 5 bytes. The first byte is
+ * set to 255 (FF) to indicate a larger value is following. The remaining 4
  * bytes take the length of the previous entry as value.
  *
  * So practically an entry is encoded in the following way:
  *
- * <prevlen from 0 to 253> <encoding> <entry>
+ * <prevlen from 0 to 254> <encoding> <entry>
  *
- * Or alternatively if the previous entry length is greater than 253 bytes
+ * Or alternatively if the previous entry length is greater than 254 bytes
  * the following encoding is used:
  *
- * 0xFE <4 bytes unsigned little endian prevlen> <encoding> <entry>
+ * 0xFF <4 bytes unsigned little endian prevlen> <encoding> <entry>
  *
  * The encoding field of the entry depends on the content of the
  * entry. When the entry is a string, the first 2 bits of the encoding first
@@ -440,7 +440,7 @@ unsigned int zipStorePrevEntryLength(unsigned char *p, unsigned int len) {
     if ((prevlensize) == 1) {                                                  \
         (prevlen) = (ptr)[0];                                                  \
     } else if ((prevlensize) == 5) {                                           \
-        assert(sizeof((prevlen)) == 4);                                    \
+        assert(sizeof((prevlensize)) == 4);                                    \
         memcpy(&(prevlen), ((char*)(ptr)) + 1, 4);                             \
         memrev32ifbe(&prevlen);                                                \
     }                                                                          \

tests/instances.tcl

@@ -318,7 +318,7 @@ proc end_tests {} {
         puts "GOOD! No errors."
         exit 0
     } else {
-        puts "WARNING $::failed test(s) failed."
+        puts "WARNING $::failed tests faield."
         exit 1
     }
 }

tests/integration/psync2.tcl

@@ -10,7 +10,7 @@ start_server {} {
     # Config
     set debug_msg 0                 ; # Enable additional debug messages
 
-    set no_exit 0                   ; # Do not exit at end of the test
+    set no_exit 0;                  ; # Do not exit at end of the test
 
     set duration 20                 ; # Total test seconds
 
@@ -175,69 +175,6 @@ start_server {} {
         assert {$sync_count == $new_sync_count}
     }
 
-    test "PSYNC2: Slave RDB restart with EVALSHA in backlog issue #4483" {
-        # Pick a random slave
-        set slave_id [expr {($master_id+1)%5}]
-        set sync_count [status $R($master_id) sync_full]
-
-        # Make sure to replicate the first EVAL while the salve is online
-        # so that it's part of the scripts the master believes it's safe
-        # to propagate as EVALSHA.
-        $R($master_id) EVAL {return redis.call("incr","__mycounter")} 0
-        $R($master_id) EVALSHA e6e0b547500efcec21eddb619ac3724081afee89 0
-
-        # Wait for the two to sync
-        wait_for_condition 50 1000 {
-            [$R($master_id) debug digest] == [$R($slave_id) debug digest]
-        } else {
-            fail "Slave not reconnecting"
-        }
-
-        # Prevent the slave from receiving master updates, and at
-        # the same time send a new script several times to the
-        # master, so that we'll end with EVALSHA into the backlog.
-        $R($slave_id) slaveof 127.0.0.1 0
-
-        $R($master_id) EVALSHA e6e0b547500efcec21eddb619ac3724081afee89 0
-        $R($master_id) EVALSHA e6e0b547500efcec21eddb619ac3724081afee89 0
-        $R($master_id) EVALSHA e6e0b547500efcec21eddb619ac3724081afee89 0
-
-        catch {
-            $R($slave_id) config rewrite
-            $R($slave_id) debug restart
-        }
-
-        # Reconfigure the slave correctly again, when it's back online.
-        set retry 50
-        while {$retry} {
-            if {[catch {
-                $R($slave_id) slaveof $master_host $master_port
-            }]} {
-                after 1000
-            } else {
-                break
-            }
-            incr retry -1
-        }
-
-        # The master should be back at 4 slaves eventually
-        wait_for_condition 50 1000 {
-            [status $R($master_id) connected_slaves] == 4
-        } else {
-            fail "Slave not reconnecting"
-        }
-        set new_sync_count [status $R($master_id) sync_full]
-        assert {$sync_count == $new_sync_count}
-
-        # However if the slave started with the full state of the
-        # scripting engine, we should now have the same digest.
-        wait_for_condition 50 1000 {
-            [$R($master_id) debug digest] == [$R($slave_id) debug digest]
-        } else {
-            fail "Debug digest mismatch between master and slave in post-restart handshake"
-        }
-    }
-
     if {$no_exit} {
         while 1 { puts -nonewline .; flush stdout; after 1000}
     }

tests/integration/replication-2.tcl

@@ -2,12 +2,9 @@ start_server {tags {"repl"}} {
     start_server {} {
         test {First server should have role slave after SLAVEOF} {
             r -1 slaveof [srv 0 host] [srv 0 port]
-            wait_for_condition 50 100 {
-                [s -1 master_link_status] eq {up}
-            } else {
-                fail "Replication not started."
-            }
-        }
+            after 1000
+            s -1 role
+        } {slave}
 
         test {If min-slaves-to-write is honored, write is accepted} {
             r config set min-slaves-to-write 1

tests/integration/replication-3.tcl

@@ -100,6 +100,7 @@ start_server {tags {"repl"}} {
                 close $fd
                 puts "Master - Slave inconsistency"
                 puts "Run diff -u against /tmp/repldump*.txt for more info"
+
             }
 
             set old_digest [r debug digest]
@@ -108,27 +109,5 @@ start_server {tags {"repl"}} {
             set new_digest [r debug digest]
             assert {$old_digest eq $new_digest}
         }
-
-        test {SLAVE can reload "lua" AUX RDB fields of duplicated scripts} {
-            # Force a Slave full resynchronization
-            r debug change-repl-id
-            r -1 client kill type master
-
-            # Check that after a full resync the slave can still load
-            # correctly the RDB file: such file will contain "lua" AUX
-            # sections with scripts already in the memory of the master.
-
-            wait_for_condition 50 100 {
-                [s -1 master_link_status] eq {up}
-            } else {
-                fail "Replication not started."
-            }
-
-            wait_for_condition 50 100 {
-                [r debug digest] eq [r -1 debug digest]
-            } else {
-                fail "DEBUG DIGEST mismatch after full SYNC with many scripts"
-            }
-        }
     }
 }

tests/test_helper.tcl

@@ -26,7 +26,6 @@ set ::all_tests {
     unit/type/set
     unit/type/zset
     unit/type/hash
-    unit/type/stream
     unit/sort
     unit/expire
     unit/other

tests/unit/dump.tcl

@@ -308,28 +308,4 @@ start_server {tags {"dump"}} {
         }
     }
 
-    test {MIGRATE AUTH: correct and wrong password cases} {
-        set first [srv 0 client]
-        r del list
-        r lpush list a b c d
-        start_server {tags {"repl"}} {
-            set second [srv 0 client]
-            set second_host [srv 0 host]
-            set second_port [srv 0 port]
-            $second config set requirepass foobar
-            $second auth foobar
-
-            assert {[$first exists list] == 1}
-            assert {[$second exists list] == 0}
-            set ret [r -1 migrate $second_host $second_port list 9 5000 AUTH foobar]
-            assert {$ret eq {OK}}
-            assert {[$second exists list] == 1}
-            assert {[$second lrange list 0 -1] eq {d c b a}}
-
-            r -1 lpush list a b c d
-            $second config set requirepass foobar2
-            catch {r -1 migrate $second_host $second_port list 9 5000 AUTH foobar} err
-            assert_match {*invalid password*} $err
-        }
-    }
 }

tests/unit/latency-monitor.tcl

@@ -47,18 +47,4 @@ start_server {tags {"latency-monitor"}} {
         assert {[r latency reset] > 0}
         assert {[r latency latest] eq {}}
     }
-
-    test {LATENCY of expire events are correctly collected} {
-        r config set latency-monitor-threshold 20
-        r eval {
-            local i = 0
-            while (i < 1000000) do
-                redis.call('sadd','mybigkey',i)
-                i = i+1
-             end
-        } 0
-        r pexpire mybigkey 1
-        after 500
-        assert_match {*expire-cycle*} [r latency latest]
-    }
 }

tests/unit/type/incr.tcl

@@ -144,11 +144,4 @@ start_server {tags {"incr"}} {
         r set foo 1
         roundFloat [r incrbyfloat foo -1.1]
     } {-0.1}
-
-    test {string to double with null terminator} {
-        r set foo 1
-        r setrange foo 2 2
-        catch {r incrbyfloat foo 1} err
-        format $err
-    } {ERR*valid*}
 }

tests/unit/type/stream.tcl

@@ -1,256 +0,0 @@
-# return value is like strcmp() and similar.
-proc streamCompareID {a b} {
-    if {$a eq $b} {return 0}
-    lassign [split $a -] a_ms a_seq
-    lassign [split $b -] b_ms b_seq
-    if {$a_ms > $b_ms} {return 1}
-    if {$a_ms < $b_ms} {return -1}
-    # Same ms case, compare seq.
-    if {$a_seq > $b_seq} {return 1}
-    if {$a_seq < $b_seq} {return -1}
-}
-
-# return the ID immediately greater than the specified one.
-# Note that this function does not care to handle 'seq' overflow
-# since it's a 64 bit value.
-proc streamNextID {id} {
-    lassign [split $id -] ms seq
-    incr seq
-    join [list $ms $seq] -
-}
-
-# Generate a random stream entry ID with the ms part between min and max
-# and a low sequence number (0 - 999 range), in order to stress test
-# XRANGE against a Tcl implementation implementing the same concept
-# with Tcl-only code in a linear array.
-proc streamRandomID {min_id max_id} {
-    lassign [split $min_id -] min_ms min_seq
-    lassign [split $max_id -] max_ms max_seq
-    set delta [expr {$max_ms-$min_ms+1}]
-    set ms [expr {$min_ms+[randomInt $delta]}]
-    set seq [randomInt 1000]
-    return $ms-$seq
-}
-
-# Tcl-side implementation of XRANGE to perform fuzz testing in the Redis
-# XRANGE implementation.
-proc streamSimulateXRANGE {items start end} {
-    set res {}
-    foreach i $items  {
-        set this_id [lindex $i 0]
-        if {[streamCompareID $this_id $start] >= 0} {
-            if {[streamCompareID $this_id $end] <= 0} {
-                lappend res $i
-            }
-        }
-    }
-    return $res
-}
-
-set content {} ;# Will be populated with Tcl side copy of the stream content.
-
-start_server {
-    tags {"stream"}
-} {
-    test {XADD can add entries into a stream that XRANGE can fetch} {
-        r XADD mystream * item 1 value a
-        r XADD mystream * item 2 value b
-        assert_equal 2 [r XLEN mystream]
-        set items [r XRANGE mystream - +]
-        assert_equal [lindex $items 0 1] {item 1 value a}
-        assert_equal [lindex $items 1 1] {item 2 value b}
-    }
-
-    test {XADD IDs are incremental} {
-        set id1 [r XADD mystream * item 1 value a]
-        set id2 [r XADD mystream * item 2 value b]
-        set id3 [r XADD mystream * item 3 value c]
-        assert {[streamCompareID $id1 $id2] == -1}
-        assert {[streamCompareID $id2 $id3] == -1}
-    }
-
-    test {XADD IDs are incremental when ms is the same as well} {
-        r multi
-        r XADD mystream * item 1 value a
-        r XADD mystream * item 2 value b
-        r XADD mystream * item 3 value c
-        lassign [r exec] id1 id2 id3
-        assert {[streamCompareID $id1 $id2] == -1}
-        assert {[streamCompareID $id2 $id3] == -1}
-    }
-
-    test {XADD with MAXLEN option} {
-        r DEL mystream
-        for {set j 0} {$j < 1000} {incr j} {
-            if {rand() < 0.9} {
-                r XADD mystream MAXLEN 5 * xitem $j
-            } else {
-                r XADD mystream MAXLEN 5 * yitem $j
-            }
-        }
-        set res [r xrange mystream - +]
-        set expected 995
-        foreach r $res {
-            assert {[lindex $r 1 1] == $expected}
-            incr expected
-        }
-    }
-
-    test {XADD mass insertion and XLEN} {
-        r DEL mystream
-        r multi
-        for {set j 0} {$j < 10000} {incr j} {
-            # From time to time insert a field with a different set
-            # of fields in order to stress the stream compression code.
-            if {rand() < 0.9} {
-                r XADD mystream * item $j
-            } else {
-                r XADD mystream * item $j otherfield foo
-            }
-        }
-        r exec
-
-        set items [r XRANGE mystream - +]
-        for {set j 0} {$j < 10000} {incr j} {
-            assert {[lrange [lindex $items $j 1] 0 1] eq [list item $j]}
-        }
-        assert {[r xlen mystream] == $j}
-    }
-
-    test {XRANGE COUNT works as expected} {
-        assert {[llength [r xrange mystream - + COUNT 10]] == 10}
-    }
-
-    test {XREVRANGE COUNT works as expected} {
-        assert {[llength [r xrevrange mystream + - COUNT 10]] == 10}
-    }
-
-    test {XRANGE can be used to iterate the whole stream} {
-        set last_id "-"
-        set j 0
-        while 1 {
-            set elements [r xrange mystream $last_id + COUNT 100]
-            if {[llength $elements] == 0} break
-            foreach e $elements {
-                assert {[lrange [lindex $e 1] 0 1] eq [list item $j]}
-                incr j;
-            }
-            set last_id [streamNextID [lindex $elements end 0]]
-        }
-        assert {$j == 10000}
-    }
-
-    test {XREVRANGE returns the reverse of XRANGE} {
-        assert {[r xrange mystream - +] == [lreverse [r xrevrange mystream + -]]}
-    }
-
-    test {XREAD with non empty stream} {
-        set res [r XREAD COUNT 1 STREAMS mystream 0.0]
-        assert {[lrange [lindex $res 0 1 0 1] 0 1] eq {item 0}}
-    }
-
-    test {Non blocking XREAD with empty streams} {
-        set res [r XREAD STREAMS s1 s2 0.0 0.0]
-        assert {$res eq {}}
-    }
-
-    test {XREAD with non empty second stream} {
-        set res [r XREAD COUNT 1 STREAMS nostream mystream 0.0 0.0]
-        assert {[lindex $res 0 0] eq {mystream}}
-        assert {[lrange [lindex $res 0 1 0 1] 0 1] eq {item 0}}
-    }
-
-    test {Blocking XREAD waiting new data} {
-        r XADD s2 * old abcd1234
-        set rd [redis_deferring_client]
-        $rd XREAD BLOCK 20000 STREAMS s1 s2 s3 $ $ $
-        r XADD s2 * new abcd1234
-        set res [$rd read]
-        assert {[lindex $res 0 0] eq {s2}}
-        assert {[lindex $res 0 1 0 1] eq {new abcd1234}}
-    }
-
-    test {Blocking XREAD waiting old data} {
-        set rd [redis_deferring_client]
-        $rd XREAD BLOCK 20000 STREAMS s1 s2 s3 $ 0.0 $
-        r XADD s2 * foo abcd1234
-        set res [$rd read]
-        assert {[lindex $res 0 0] eq {s2}}
-        assert {[lindex $res 0 1 0 1] eq {old abcd1234}}
-    }
-
-    test "XREAD: XADD + DEL should not awake client" {
-        set rd [redis_deferring_client]
-        r del s1
-        $rd XREAD BLOCK 20000 STREAMS s1 $
-        r multi
-        r XADD s1 * old abcd1234
-        r DEL s1
-        r exec
-        r XADD s1 * new abcd1234
-        set res [$rd read]
-        assert {[lindex $res 0 0] eq {s1}}
-        assert {[lindex $res 0 1 0 1] eq {new abcd1234}}
-    }
-
-    test "XREAD: XADD + DEL + LPUSH should not awake client" {
-        set rd [redis_deferring_client]
-        r del s1
-        $rd XREAD BLOCK 20000 STREAMS s1 $
-        r multi
-        r XADD s1 * old abcd1234
-        r DEL s1
-        r LPUSH s1 foo bar
-        r exec
-        r DEL s1
-        r XADD s1 * new abcd1234
-        set res [$rd read]
-        assert {[lindex $res 0 0] eq {s1}}
-        assert {[lindex $res 0 1 0 1] eq {new abcd1234}}
-    }
-
-    test {XREAD with same stream name multiple times should work} {
-        r XADD s2 * old abcd1234
-        set rd [redis_deferring_client]
-        $rd XREAD BLOCK 20000 STREAMS s2 s2 s2 $ $ $
-        r XADD s2 * new abcd1234
-        set res [$rd read]
-        assert {[lindex $res 0 0] eq {s2}}
-        assert {[lindex $res 0 1 0 1] eq {new abcd1234}}
-    }
-
-    test {XREAD + multiple XADD inside transaction} {
-        r XADD s2 * old abcd1234
-        set rd [redis_deferring_client]
-        $rd XREAD BLOCK 20000 STREAMS s2 s2 s2 $ $ $
-        r MULTI
-        r XADD s2 * field one
-        r XADD s2 * field two
-        r XADD s2 * field three
-        r EXEC
-        set res [$rd read]
-        assert {[lindex $res 0 0] eq {s2}}
-        assert {[lindex $res 0 1 0 1] eq {field one}}
-        assert {[lindex $res 0 1 1 1] eq {field two}}
-    }
-
-    test {XRANGE fuzzing} {
-        set low_id [lindex $items 0 0]
-        set high_id [lindex $items end 0]
-        for {set j 0} {$j < 100} {incr j} {
-            set start [streamRandomID $low_id $high_id]
-            set end [streamRandomID $low_id $high_id]
-            set range [r xrange mystream $start $end]
-            set tcl_range [streamSimulateXRANGE $items $start $end]
-            if {$range ne $tcl_range} {
-                puts "*** WARNING *** - XRANGE fuzzing mismatch: $start - $end"
-                puts "---"
-                puts "XRANGE: '$range'"
-                puts "---"
-                puts "TCL: '$tcl_range'"
-                puts "---"
-                fail "XRANGE fuzzing failed, check logs for details"
-            }
-        }
-    }
-}