Rename bstate to bpop.

diff --git a/src/networking.c b/src/networking.c
index 530e2ca87382df90f2e2f131453ce8300f3e8766..7d14ac53f18bfc8c60ef457ff3b4c6383e3d59da 100644 (file)
--- a/src/networking.c
+++ b/src/networking.c
@@ -41,10 +41,10 @@ redisClient *createClient(int fd) {
     c->reply = listCreate();
     listSetFreeMethod(c->reply,decrRefCount);
     listSetDupMethod(c->reply,dupClientReplyValue);
     c->reply = listCreate();
     listSetFreeMethod(c->reply,decrRefCount);
     listSetDupMethod(c->reply,dupClientReplyValue);

-    c->bstate.keys = NULL;
-    c->bstate.count = 0;
-    c->bstate.timeout = 0;
-    c->bstate.target = NULL;
+    c->bpop.keys = NULL;
+    c->bpop.count = 0;
+    c->bpop.timeout = 0;
+    c->bpop.target = NULL;

     c->io_keys = listCreate();
     c->watched_keys = listCreate();
     listSetFreeMethod(c->io_keys,decrRefCount);
     c->io_keys = listCreate();
     c->watched_keys = listCreate();
     listSetFreeMethod(c->io_keys,decrRefCount);


@@ -679,7 +679,7 @@ void closeTimedoutClients(void) {
             redisLog(REDIS_VERBOSE,"Closing idle client");
             freeClient(c);
         } else if (c->flags & REDIS_BLOCKED) {
             redisLog(REDIS_VERBOSE,"Closing idle client");
             freeClient(c);
         } else if (c->flags & REDIS_BLOCKED) {

-            if (c->bstate.timeout != 0 && c->bstate.timeout < now) {
+            if (c->bpop.timeout != 0 && c->bpop.timeout < now) {

                 addReply(c,shared.nullmultibulk);
                 unblockClientWaitingData(c);
             }
                 addReply(c,shared.nullmultibulk);
                 unblockClientWaitingData(c);
             }

diff --git a/src/redis.h b/src/redis.h
index 0de94585b89ca6ebc41ffd767539dd9d77d1f010..f1142a5b34fc52e37d10f8adcf5ee40f251f9a71 100644 (file)
--- a/src/redis.h
+++ b/src/redis.h
@@ -326,7 +326,7 @@ typedef struct redisClient {
     long repldboff;         /* replication DB file offset */
     off_t repldbsize;       /* replication DB file size */
     multiState mstate;      /* MULTI/EXEC state */
     long repldboff;         /* replication DB file offset */
     off_t repldbsize;       /* replication DB file size */
     multiState mstate;      /* MULTI/EXEC state */

-    blockingState bstate;   /* blocking state */
+    blockingState bpop;   /* blocking state */

     list *io_keys;          /* Keys this client is waiting to be loaded from the
                              * swap file in order to continue. */
     list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
     list *io_keys;          /* Keys this client is waiting to be loaded from the
                              * swap file in order to continue. */
     list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */

diff --git a/src/t_list.c b/src/t_list.c
index 7f12e4ac009f65065b5c87c187ac623ff5b1a646..f5739792aabea35f586d69c17f344c1d9113657b 100644 (file)
--- a/src/t_list.c
+++ b/src/t_list.c
@@ -694,10 +694,10 @@ void blockForKeys(redisClient *c, robj **keys, int numkeys, time_t timeout, robj
     list *l;
     int j;
 
     list *l;
     int j;
 

-    c->bstate.keys = zmalloc(sizeof(robj*)*numkeys);
-    c->bstate.count = numkeys;
-    c->bstate.timeout = timeout;
-    c->bstate.target = target;
+    c->bpop.keys = zmalloc(sizeof(robj*)*numkeys);
+    c->bpop.count = numkeys;
+    c->bpop.timeout = timeout;
+    c->bpop.target = target;

 
     if (target != NULL) {
       incrRefCount(target);
 
     if (target != NULL) {
       incrRefCount(target);


@@ -705,7 +705,7 @@ void blockForKeys(redisClient *c, robj **keys, int numkeys, time_t timeout, robj
 
     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->bstate.keys[j] = keys[j];
+        c->bpop.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 */


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

-    redisAssert(c->bstate.keys != NULL);
+    redisAssert(c->bpop.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->bstate.count; j++) {
+    for (j = 0; j < c->bpop.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->bstate.keys[j]);
+        de = dictFind(c->db->blocking_keys,c->bpop.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->bstate.keys[j]);
-        decrRefCount(c->bstate.keys[j]);
+            dictDelete(c->db->blocking_keys,c->bpop.keys[j]);
+        decrRefCount(c->bpop.keys[j]);

     }
 
     }
 

-    if (c->bstate.target != NULL) {
-        decrRefCount(c->bstate.target);
+    if (c->bpop.target != NULL) {
+        decrRefCount(c->bpop.target);

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

-    zfree(c->bstate.keys);
-    c->bstate.keys = NULL;
-    c->bstate.target = NULL;
+    zfree(c->bpop.keys);
+    c->bpop.keys = NULL;
+    c->bpop.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


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

-    if (receiver->bstate.target == NULL) {
+    if (receiver->bpop.target == NULL) {

         /* BRPOP/BLPOP return a multi-bulk with the name
          * of the popped list */
         addReplyMultiBulkLen(receiver,2);
         /* BRPOP/BLPOP return a multi-bulk with the name
          * of the popped list */
         addReplyMultiBulkLen(receiver,2);


@@ -798,16 +798,16 @@ int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele) {
     }
     else {
         /* BRPOPLPUSH */
     }
     else {
         /* BRPOPLPUSH */

-        robj *dobj = lookupKeyWrite(receiver->db,receiver->bstate.target);
+        robj *dobj = lookupKeyWrite(receiver->db,receiver->bpop.target);

         if (dobj && checkType(receiver,dobj,REDIS_LIST)) return 0;
 
         addReplyBulk(receiver,ele);
 
         if (dobj && checkType(receiver,dobj,REDIS_LIST)) return 0;
 
         addReplyBulk(receiver,ele);
 

-        if (!handleClientsWaitingListPush(receiver, receiver->bstate.target, ele)) {
+        if (!handleClientsWaitingListPush(receiver, receiver->bpop.target, ele)) {

             /* Create the list if the key does not exist */
             if (!dobj) {
                 dobj = createZiplistObject();
             /* Create the list if the key does not exist */
             if (!dobj) {
                 dobj = createZiplistObject();

-                dbAdd(receiver->db, receiver->bstate.target, dobj);
+                dbAdd(receiver->db, receiver->bpop.target, dobj);

             }
 
             listTypePush(dobj, ele, REDIS_HEAD);
             }
 
             listTypePush(dobj, ele, REDIS_HEAD);