Abstract out ptr->hosts[server_key] references.

[m6w6/libmemcached] / libmemcached / get.c

diff --git a/libmemcached/get.c b/libmemcached/get.c
index 5f8bc825c330875b5bb418b123ff83092ac5ee3f..7032a1a5417495c8ce0ddc24d8028723610901dd 100644 (file)
--- a/libmemcached/get.c
+++ b/libmemcached/get.c
@@ -129,7 +129,7 @@ memcached_return_t memcached_mget(memcached_st *ptr,
 }
 
 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
-                                             unsigned int master_server_key,
+                                             uint32_t master_server_key,
                                              bool is_master_key_set,
                                              const char * const *keys,
                                              const size_t *key_length,
@@ -209,51 +209,58 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   */
   for (x= 0; x < number_of_keys; x++)
   {
-    unsigned int server_key;
+    memcached_server_instance_st *instance;
+    uint32_t server_key;
 
     if (is_master_key_set)
+    {
       server_key= master_server_key;
+    }
     else
+    {
       server_key= memcached_generate_hash(ptr, keys[x], key_length[x]);
+    }
 
-    if (memcached_server_response_count(&ptr->hosts[server_key]) == 0)
+    instance= memcached_server_instance_fetch(ptr, server_key);
+
+    if (memcached_server_response_count(instance) == 0)
     {
-      rc= memcached_connect(&ptr->hosts[server_key]);
+      rc= memcached_connect(instance);
 
       if (rc != MEMCACHED_SUCCESS)
         continue;
 
-      if ((memcached_io_write(&ptr->hosts[server_key], get_command, get_command_length, 0)) == -1)
+      if ((memcached_io_write(instance, get_command, get_command_length, 0)) == -1)
       {
         rc= MEMCACHED_SOME_ERRORS;
         continue;
       }
-      WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 0);
-      memcached_server_response_increment(&ptr->hosts[server_key]);
-      WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 1);
+      WATCHPOINT_ASSERT(instance->cursor_active == 0);
+      memcached_server_response_increment(instance);
+      WATCHPOINT_ASSERT(instance->cursor_active == 1);
     }
 
     /* Only called when we have a prefix key */
     if (ptr->prefix_key[0] != 0)
     {
-      if ((memcached_io_write(&ptr->hosts[server_key], ptr->prefix_key, ptr->prefix_key_length, 0)) == -1)
+      if ((memcached_io_write(instance, ptr->prefix_key, ptr->prefix_key_length, 0)) == -1)
       {
-        memcached_server_response_reset(&ptr->hosts[server_key]);
+        memcached_server_response_reset(instance);
         rc= MEMCACHED_SOME_ERRORS;
         continue;
       }
     }
 
-    if ((memcached_io_write(&ptr->hosts[server_key], keys[x], key_length[x], 0)) == -1)
+    if ((memcached_io_write(instance, keys[x], key_length[x], 0)) == -1)
     {
-      memcached_server_response_reset(&ptr->hosts[server_key]);
+      memcached_server_response_reset(instance);
       rc= MEMCACHED_SOME_ERRORS;
       continue;
     }
 
-    if ((memcached_io_write(&ptr->hosts[server_key], " ", 1, 0)) == -1)
+    if ((memcached_io_write(instance, " ", 1, 0)) == -1)
     {
-      memcached_server_response_reset(&ptr->hosts[server_key]);
+      memcached_server_response_reset(instance);
       rc= MEMCACHED_SOME_ERRORS;
       continue;
     }
@@ -331,7 +338,7 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr,
 }
 
 static memcached_return_t simple_binary_mget(memcached_st *ptr,
-                                             unsigned int master_server_key,
+                                             uint32_t master_server_key,
                                              bool is_master_key_set,
                                              const char * const *keys,
                                              const size_t *key_length,
@@ -348,16 +355,23 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
   */
   for (x= 0; x < number_of_keys; x++)
   {
-    unsigned int server_key;
+    uint32_t server_key;
+    memcached_server_instance_st *instance;
 
     if (is_master_key_set)
+    {
       server_key= master_server_key;
+    }
     else
+    {
       server_key= memcached_generate_hash(ptr, keys[x], key_length[x]);
+    }
+
+    instance= memcached_server_instance_fetch(ptr, server_key);
 
-    if (memcached_server_response_count(&ptr->hosts[server_key]) == 0)
+    if (memcached_server_response_count(instance) == 0)
     {
-      rc= memcached_connect(&ptr->hosts[server_key]);
+      rc= memcached_connect(instance);
       if (rc != MEMCACHED_SUCCESS)
         continue;
     }
@@ -375,7 +389,10 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     unlikely (vk != MEMCACHED_SUCCESS)
     {
       if (x > 0)
-        memcached_io_reset(&ptr->hosts[server_key]);
+      {
+        memcached_io_reset(instance);
+      }
+
       return vk;
     }
 
@@ -383,19 +400,19 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
     request.message.header.request.bodylen= htonl((uint32_t) key_length[x]);
 
-    if ((memcached_io_write(&ptr->hosts[server_key], request.bytes,
+    if ((memcached_io_write(instance, request.bytes,
                             sizeof(request.bytes), 0) == -1) ||
-        (memcached_io_write(&ptr->hosts[server_key], keys[x],
+        (memcached_io_write(instance, keys[x],
                             key_length[x], (char) flush) == -1))
     {
-      memcached_server_response_reset(&ptr->hosts[server_key]);
+      memcached_server_response_reset(instance);
       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]);
+    memcached_server_response_reset(instance);
+    memcached_server_response_increment(instance);
     if ((x > 0 && x == ptr->io_key_prefetch) &&
         memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
       rc= MEMCACHED_SOME_ERRORS;
@@ -526,7 +543,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
 }
 
 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
-                                             unsigned int master_server_key,
+                                             uint32_t master_server_key,
                                              bool is_master_key_set,
                                              const char * const *keys,
                                              const size_t *key_length,