Abstract out ptr->hosts[server_key] references.

[m6w6/libmemcached] / libmemcached / get.c

diff --git a/libmemcached/get.c b/libmemcached/get.c
index 30682427c8d71700421e95863a7fbb442e59156b..7032a1a5417495c8ce0ddc24d8028723610901dd 100644 (file)
--- a/libmemcached/get.c
+++ b/libmemcached/get.c
@@ -82,9 +82,10 @@ char *memcached_get_by_key(memcached_st *ptr,
             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
 
           rc= memcached_set(ptr, key, key_length,
-                            memcached_result_value(&ptr->result),
-                            memcached_result_length(&ptr->result),
-                            0, memcached_result_flags(&ptr->result));
+                            (memcached_result_value(&ptr->result)),
+                            (memcached_result_length(&ptr->result)),
+                            0,
+                            (memcached_result_flags(&ptr->result)));
 
           if (rc == MEMCACHED_BUFFERED && latch == 0)
             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0);
@@ -92,9 +93,10 @@ char *memcached_get_by_key(memcached_st *ptr,
         else
         {
           rc= memcached_set(ptr, key, key_length,
-                            memcached_result_value(&ptr->result),
-                            memcached_result_length(&ptr->result),
-                            0, memcached_result_flags(&ptr->result));
+                            (memcached_result_value(&ptr->result)),
+                            (memcached_result_length(&ptr->result)),
+                            0,
+                            (memcached_result_flags(&ptr->result)));
         }
 
         if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED)
@@ -127,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,
@@ -153,12 +155,11 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
     return MEMCACHED_NOT_SUPPORTED;
 
   LIBMEMCACHED_MEMCACHED_MGET_START();
-  ptr->cursor_server= 0;
 
   if (number_of_keys == 0)
     return MEMCACHED_NOTFOUND;
 
-  if (ptr->number_of_hosts == 0)
+  if (memcached_server_count(ptr) == 0)
     return MEMCACHED_NO_SERVERS;
 
   if (ptr->flags.verify_key && (memcached_key_test(keys, key_length, number_of_keys) == MEMCACHED_BAD_KEY_PROVIDED))
@@ -178,7 +179,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
     It might be optimum to bounce the connection if count > some number.
   */
-  for (x= 0; x < ptr->number_of_hosts; x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     if (memcached_server_response_count(&ptr->hosts[x]))
     {
@@ -208,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;
     }
@@ -261,7 +269,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   /*
     Should we muddle on if some servers are dead?
   */
-  for (x= 0; x < ptr->number_of_hosts; x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     if (memcached_server_response_count(&ptr->hosts[x]))
     {
@@ -330,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,
@@ -347,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;
     }
@@ -374,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;
     }
 
@@ -382,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;
@@ -410,7 +428,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP;
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 
-    for (x= 0; x < ptr->number_of_hosts; x++)
+    for (x= 0; x < memcached_server_count(ptr); x++)
       if (memcached_server_response_count(&ptr->hosts[x]))
       {
         if (memcached_io_write(&ptr->hosts[x], NULL, 0, 1) == -1)
@@ -455,7 +473,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
 
     for (x= 0; x < number_of_keys; ++x)
     {
-      if (hash[x] == ptr->number_of_hosts)
+      if (hash[x] == memcached_server_count(ptr))
         continue; /* Already successfully sent */
 
       uint32_t server= hash[x] + replica;
@@ -464,8 +482,8 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
       if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas)))
         server += start;
 
-      while (server >= ptr->number_of_hosts)
-        server -= ptr->number_of_hosts;
+      while (server >= memcached_server_count(ptr))
+        server -= memcached_server_count(ptr);
 
       if (dead_servers[server])
         continue;
@@ -514,7 +532,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
       }
 
       memcached_server_response_increment(&ptr->hosts[server]);
-      hash[x]= ptr->number_of_hosts;
+      hash[x]= memcached_server_count(ptr);
     }
 
     if (success)
@@ -525,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,
@@ -545,7 +563,7 @@ static memcached_return_t binary_mget_by_key(memcached_st *ptr,
     bool* dead_servers;
 
     hash= ptr->call_malloc(ptr, sizeof(uint32_t) * number_of_keys);
-    dead_servers= ptr->call_calloc(ptr, ptr->number_of_hosts, sizeof(bool));
+    dead_servers= ptr->call_calloc(ptr, memcached_server_count(ptr), sizeof(bool));
 
     if (hash == NULL || dead_servers == NULL)
     {