X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fmemcached_get.c;h=7ee714fe2e3ead8dc5f887b2f4d5bdc04c36903c;hb=94cd1cbfb3fe6d0c446be9151ae9b15f775b6511;hp=ee4f68e7ecb0c006c4025f346340ba0941b41ca6;hpb=30578d352bf73625ef5a7528b7d583e5acd1ed1a;p=awesomized%2Flibmemcached

diff --git a/libmemcached/memcached_get.c b/libmemcached/memcached_get.c
index ee4f68e7..7ee714fe 100644
--- a/libmemcached/memcached_get.c
+++ b/libmemcached/memcached_get.c
@@ -14,6 +14,14 @@ char *memcached_get(memcached_st *ptr, const char *key,
                               flags, error);
 }
 
+static memcached_return memcached_mget_by_key_real(memcached_st *ptr, 
+                                       const char *master_key, 
+                                       size_t master_key_length,
+                                       const char **keys, 
+                                       size_t *key_length, 
+                                       size_t number_of_keys,
+				       bool mget_mode);
+
 char *memcached_get_by_key(memcached_st *ptr, 
                            const char *master_key, 
                            size_t master_key_length, 
@@ -34,10 +42,10 @@ char *memcached_get_by_key(memcached_st *ptr,
   }
 
   /* Request the key */
-  *error= memcached_mget_by_key(ptr, 
+  *error= memcached_mget_by_key_real(ptr, 
                                 master_key, 
                                 master_key_length, 
-                                (const char **)&key, &key_length, 1);
+                                (const char **)&key, &key_length, 1, false);
 
   value= memcached_fetch(ptr, NULL, NULL, 
                          value_length, flags, error);
@@ -112,14 +120,16 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
                                            const char **keys, size_t *key_length,
-                                           size_t number_of_keys);
+                                           size_t number_of_keys,
+					   bool mget_mode);
 
-memcached_return memcached_mget_by_key(memcached_st *ptr, 
+static memcached_return memcached_mget_by_key_real(memcached_st *ptr, 
                                        const char *master_key, 
                                        size_t master_key_length,
                                        const char **keys, 
                                        size_t *key_length, 
-                                       size_t number_of_keys)
+                                       size_t number_of_keys,
+				       bool mget_mode)
 {
   unsigned int x;
   memcached_return rc= MEMCACHED_NOTFOUND;
@@ -173,7 +183,7 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
   
   if (ptr->flags & MEM_BINARY_PROTOCOL)
     return binary_mget_by_key(ptr, master_server_key, is_master_key_set, keys, 
-                              key_length, number_of_keys);
+                              key_length, number_of_keys, mget_mode);
 
   if (ptr->flags & MEM_SUPPORT_CAS)
   {
@@ -256,11 +266,22 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
   return rc;
 }
 
+memcached_return memcached_mget_by_key(memcached_st *ptr, 
+                                       const char *master_key, 
+                                       size_t master_key_length,
+                                       const char **keys, 
+                                       size_t *key_length, 
+                                       size_t number_of_keys)
+{
+  return memcached_mget_by_key_real(ptr, master_key, master_key_length, keys, 
+                                    key_length, number_of_keys, true);
+}
+
 static memcached_return simple_binary_mget(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
                                            const char **keys, size_t *key_length, 
-                                           size_t number_of_keys)
+                                           size_t number_of_keys, bool mget_mode)
 {
   memcached_return rc= MEMCACHED_NOTFOUND;
   uint32_t x;
@@ -289,10 +310,10 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
      
     protocol_binary_request_getk request= {.bytes= {0}};
     request.message.header.request.magic= PROTOCOL_BINARY_REQ;
-    if (number_of_keys == 1)
-      request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
-    else
+    if (mget_mode)
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
+    else
+      request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
 
     memcached_return vk;
     vk= memcached_validate_key_length(key_length[x],
@@ -317,13 +338,16 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
       rc= MEMCACHED_SOME_ERRORS;
       continue;
     }
+    
+    /* We just want one pending response per server */
+    memcached_server_response_reset(&ptr->hosts[server_key]); 
     memcached_server_response_increment(&ptr->hosts[server_key]);    
     if ((x > 0 && x == ptr->io_key_prefetch) &&
         memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
       rc= MEMCACHED_SOME_ERRORS;
   }
 
-  if (number_of_keys > 1) 
+  if (mget_mode) 
   {
     /*
      * Send a noop command to flush the buffers
@@ -350,7 +374,6 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
           memcached_io_reset(&ptr->hosts[x]);
           rc= MEMCACHED_SOME_ERRORS;
         }
-        memcached_server_response_increment(&ptr->hosts[x]);    
       }
     }
 
@@ -361,7 +384,7 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
 static memcached_return replication_binary_mget(memcached_st *ptr,
                                              uint32_t* hash, bool* dead_servers,
                                              const char **keys, size_t *key_length,
-                                             size_t number_of_keys)
+                                             size_t number_of_keys, bool mget_mode)
 {
   memcached_return rc= MEMCACHED_NOTFOUND;
   uint32_t x;
@@ -398,10 +421,10 @@ static memcached_return replication_binary_mget(memcached_st *ptr,
 
       protocol_binary_request_getk request= {.bytes= {0}};
       request.message.header.request.magic= PROTOCOL_BINARY_REQ;
-      if (number_of_keys == 1)
-        request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
-      else
+      if (mget_mode)
         request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
+      else
+        request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
 
       request.message.header.request.keylen= htons((uint16_t)key_length[x]);
       request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
@@ -417,10 +440,12 @@ static memcached_return replication_binary_mget(memcached_st *ptr,
         success= false;
         continue;
       }
+      /* we just want one pending response per server */
+      memcached_server_response_reset(&ptr->hosts[server]); 
       memcached_server_response_increment(&ptr->hosts[server]);
     }
 
-    if (number_of_keys > 1)
+    if (mget_mode)
     {
       /*
        * Send a noop command to flush the buffers
@@ -440,7 +465,6 @@ static memcached_return replication_binary_mget(memcached_st *ptr,
             dead_servers[x]= true;
             success= false;
           }
-          memcached_server_response_increment(&ptr->hosts[x]);
 
           /* mark all of the messages bound for this server as sent! */
           for (x= 0; x < number_of_keys; ++x)
@@ -460,14 +484,14 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
                                            const char **keys, size_t *key_length,
-                                           size_t number_of_keys)
+                                           size_t number_of_keys, bool mget_mode)
 {
   memcached_return rc;
 
   if (ptr->number_of_replicas == 0) 
   {
     rc= simple_binary_mget(ptr, master_server_key, is_master_key_set,
-                           keys, key_length, number_of_keys);
+                           keys, key_length, number_of_keys, mget_mode);
   } 
   else 
   {
@@ -492,7 +516,7 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
         hash[x]= memcached_generate_hash(ptr, keys[x], key_length[x]);
 
     rc= replication_binary_mget(ptr, hash, dead_servers, keys, 
-                                key_length, number_of_keys);
+                                key_length, number_of_keys, mget_mode);
 
     ptr->call_free(ptr, hash);
     ptr->call_free(ptr, dead_servers);