Refactor code for BRPOPLPUSH.

[redis.git] / src / t_list.c

diff --git a/src/t_list.c b/src/t_list.c
index 42e1d5873eb8af400d1288aa40f9f057784a9781..2dedf4811a4e619dc8d896126903c2741f186127 100644 (file)
--- a/src/t_list.c
+++ b/src/t_list.c
@@ -618,7 +618,7 @@ void lremCommand(redisClient *c) {
  * since the element is not just returned but pushed against another list
  * as well. This command was originally proposed by Ezra Zygmuntowicz.
  */
  * since the element is not just returned but pushed against another list
  * as well. This command was originally proposed by Ezra Zygmuntowicz.
  */

-void rpoplpushcommand(redisClient *c) {
+void rpoplpushCommand(redisClient *c) {

     robj *sobj, *value;
     if ((sobj = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
         checkType(c,sobj,REDIS_LIST)) return;
     robj *sobj, *value;
     if ((sobj = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
         checkType(c,sobj,REDIS_LIST)) return;


@@ -689,17 +689,23 @@ void rpoplpushcommand(redisClient *c) {
 
 /* Set a client in blocking mode for the specified key, with the specified
  * timeout */
 
 /* Set a client in blocking mode for the specified key, with the specified
  * timeout */

-void blockForKeys(redisClient *c, robj **keys, int numkeys, time_t timeout) {
+void blockForKeys(redisClient *c, robj **keys, int numkeys, time_t timeout, robj *target) {

     dictEntry *de;
     list *l;
     int j;
 
     dictEntry *de;
     list *l;
     int j;
 

-    c->blocking_keys = zmalloc(sizeof(robj*)*numkeys);
-    c->blocking_keys_num = numkeys;
-    c->blockingto = timeout;
+    c->bstate.keys = zmalloc(sizeof(robj*)*numkeys);
+    c->bstate.count = numkeys;
+    c->bstate.timeout = timeout;
+    c->bstate.target = target;
+
+    if (target != NULL) {
+      incrRefCount(target);
+    }
+

     for (j = 0; j < numkeys; j++) {
         /* Add the key in the client structure, to map clients -> keys */
     for (j = 0; j < numkeys; j++) {
         /* Add the key in the client structure, to map clients -> keys */

-        c->blocking_keys[j] = keys[j];
+        c->bstate.keys[j] = keys[j];

         incrRefCount(keys[j]);
 
         /* And in the other "side", to map keys -> clients */
         incrRefCount(keys[j]);
 
         /* And in the other "side", to map keys -> clients */


@@ -728,22 +734,28 @@ void unblockClientWaitingData(redisClient *c) {
     list *l;
     int j;
 
     list *l;
     int j;
 

-    redisAssert(c->blocking_keys != NULL);
+    redisAssert(c->bstate.keys != NULL);

     /* The client may wait for multiple keys, so unblock it for every key. */
     /* The client may wait for multiple keys, so unblock it for every key. */

-    for (j = 0; j < c->blocking_keys_num; j++) {
+    for (j = 0; j < c->bstate.count; j++) {

         /* Remove this client from the list of clients waiting for this key. */
         /* Remove this client from the list of clients waiting for this key. */

-        de = dictFind(c->db->blocking_keys,c->blocking_keys[j]);
+        de = dictFind(c->db->blocking_keys,c->bstate.keys[j]);

         redisAssert(de != NULL);
         l = dictGetEntryVal(de);
         listDelNode(l,listSearchKey(l,c));
         /* If the list is empty we need to remove it to avoid wasting memory */
         if (listLength(l) == 0)
         redisAssert(de != NULL);
         l = dictGetEntryVal(de);
         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,c->blocking_keys[j]);
-        decrRefCount(c->blocking_keys[j]);
+            dictDelete(c->db->blocking_keys,c->bstate.keys[j]);
+        decrRefCount(c->bstate.keys[j]);
+    }
+
+    if (c->bstate.target != NULL) {
+        decrRefCount(c->bstate.target);

     }
     }

+

     /* Cleanup the client structure */
     /* Cleanup the client structure */

-    zfree(c->blocking_keys);
-    c->blocking_keys = NULL;
+    zfree(c->bstate.keys);
+    c->bstate.keys = NULL;
+    c->bstate.target = NULL;

     c->flags &= (~REDIS_BLOCKED);
     server.blpop_blocked_clients--;
     /* We want to process data if there is some command waiting
     c->flags &= (~REDIS_BLOCKED);
     server.blpop_blocked_clients--;
     /* We want to process data if there is some command waiting


@@ -777,9 +789,26 @@ int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele) {
     redisAssert(ln != NULL);
     receiver = ln->value;
 
     redisAssert(ln != NULL);
     receiver = ln->value;
 

-    addReplyMultiBulkLen(receiver,2);
-    addReplyBulk(receiver,key);
-    addReplyBulk(receiver,ele);
+    if (receiver->bstate.target == NULL) {
+      addReplyMultiBulkLen(receiver,2);
+      addReplyBulk(receiver,key);
+      addReplyBulk(receiver,ele);
+    }
+    else {
+      robj *dobj = lookupKeyWrite(receiver->db,receiver->bstate.target);
+      if (dobj && checkType(receiver,dobj,REDIS_LIST)) return 0;
+
+      addReplyBulk(receiver,ele);
+
+      /* Create the list if the key does not exist */
+      if (!dobj) {
+          dobj = createZiplistObject();
+          dbAdd(receiver->db,receiver->bstate.target,dobj);
+      }
+
+      listTypePush(dobj,ele,REDIS_HEAD);
+    }
+

     unblockClientWaitingData(receiver);
     return 1;
 }
     unblockClientWaitingData(receiver);
     return 1;
 }


@@ -787,17 +816,10 @@ int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele) {
 /* Blocking RPOP/LPOP */
 void blockingPopGenericCommand(redisClient *c, int where) {
     robj *o;
 /* Blocking RPOP/LPOP */
 void blockingPopGenericCommand(redisClient *c, int where) {
     robj *o;

-    long long lltimeout;

     time_t timeout;
     int j;
 
     time_t timeout;
     int j;
 

-    /* Make sure timeout is an integer value */
-    if (getLongLongFromObjectOrReply(c,c->argv[c->argc-1],&lltimeout,
-            "timeout is not an integer") != REDIS_OK) return;
-
-    /* Make sure the timeout is not negative */
-    if (lltimeout < 0) {
-        addReplyError(c,"timeout is negative");
+    if (checkTimeout(c, c->argv[c->argc - 1], &timeout) != REDIS_OK) {

         return;
     }
 
         return;
     }
 


@@ -829,11 +851,13 @@ void blockingPopGenericCommand(redisClient *c, int where) {
                      * because it is... */
                     addReplyMultiBulkLen(c,2);
                     addReplyBulk(c,argv[1]);
                      * because it is... */
                     addReplyMultiBulkLen(c,2);
                     addReplyBulk(c,argv[1]);

+

                     popGenericCommand(c,where);
 
                     /* Fix the client structure with the original stuff */
                     c->argv = orig_argv;
                     c->argc = orig_argc;
                     popGenericCommand(c,where);
 
                     /* Fix the client structure with the original stuff */
                     c->argv = orig_argv;
                     c->argc = orig_argc;

+

                     return;
                 }
             }
                     return;
                 }
             }


@@ -848,9 +872,26 @@ void blockingPopGenericCommand(redisClient *c, int where) {
     }
 
     /* If the list is empty or the key does not exists we must block */
     }
 
     /* If the list is empty or the key does not exists we must block */

-    timeout = lltimeout;

     if (timeout > 0) timeout += time(NULL);
     if (timeout > 0) timeout += time(NULL);

-    blockForKeys(c,c->argv+1,c->argc-2,timeout);
+    blockForKeys(c, c->argv + 1, c->argc - 2, timeout, NULL);
+}
+
+int checkTimeout(redisClient *c, robj *object, time_t *timeout) {
+    long long lltimeout;
+
+    if (getLongLongFromObject(object, &lltimeout) != REDIS_OK) {
+      addReplyError(c, "timeout is not an integer");
+      return REDIS_ERR;
+    }
+    
+    if (lltimeout < 0) {
+      addReplyError(c, "timeout is negative");
+      return REDIS_ERR;
+    }
+
+    *timeout = lltimeout;
+
+    return REDIS_OK;

 }
 
 void blpopCommand(redisClient *c) {
 }
 
 void blpopCommand(redisClient *c) {


@@ -860,3 +901,30 @@ void blpopCommand(redisClient *c) {
 void brpopCommand(redisClient *c) {
     blockingPopGenericCommand(c,REDIS_TAIL);
 }
 void brpopCommand(redisClient *c) {
     blockingPopGenericCommand(c,REDIS_TAIL);
 }

+
+void brpoplpushCommand(redisClient *c) {
+    time_t timeout;
+
+    if (checkTimeout(c, c->argv[3], &timeout) != REDIS_OK) {
+        return;
+    }
+
+    robj *key = lookupKeyWrite(c->db, c->argv[1]);
+
+
+    if (key == NULL) {
+        // block
+        if (c->flags & REDIS_MULTI) {
+            addReply(c,shared.nullmultibulk);
+        } else {
+            if (timeout > 0) timeout += time(NULL);
+            blockForKeys(c, c->argv + 1, 1, timeout, c->argv[2]);
+        }
+    } else if (key->type != REDIS_LIST) {
+        addReply(c, shared.wrongtypeerr);
+    } else {
+        // The list exists and has elements.
+        redisAssert(listTypeLength(key) > 0);
+        rpoplpushCommand(c);
+    }
+}