X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fget.c;h=39f53373ce10f1be185a6478bfad11a3d8175ae0;hb=f285e1b3821f56a8983b5ce9fb1a0070e7bb0a1c;hp=55457f7f7ce683b1ca8de21896fba5e7094ea607;hpb=1acb07d2a94e162902cd1c1aeee812d017d78b71;p=awesomized%2Flibmemcached

diff --git a/libmemcached/get.c b/libmemcached/get.c
index 55457f7f..39f53373 100644
--- a/libmemcached/get.c
+++ b/libmemcached/get.c
@@ -1,5 +1,5 @@
 /* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker 
+ * Copyright (C) 2006-2009 Brian Aker
  * All rights reserved.
  *
  * Use and distribution licensed under the BSD license.  See
@@ -144,12 +144,18 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
                                                      size_t number_of_keys,
                                                      bool mget_mode)
 {
-  memcached_return_t rc= MEMCACHED_NOTFOUND;
+  bool failures_occured_in_sending= false;
   const char *get_command= "get ";
   uint8_t get_command_length= 4;
   unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
   bool is_master_key_set= false;
 
+  memcached_return_t rc;
+  if ((rc= initialize_query(ptr)) != MEMCACHED_SUCCESS)
+  {
+    return rc;
+  }
+
   unlikely (ptr->flags.use_udp)
     return MEMCACHED_NOT_SUPPORTED;
 
@@ -158,9 +164,6 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   if (number_of_keys == 0)
     return MEMCACHED_NOTFOUND;
 
-  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))
     return MEMCACHED_BAD_KEY_PROVIDED;
 
@@ -211,6 +214,8 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
     If a server fails we warn about errors and start all over with sending keys
     to the server.
   */
+  WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS);
+  size_t hosts_connected= 0;
   for (uint32_t x= 0; x < number_of_keys; x++)
   {
     memcached_server_write_instance_st instance;
@@ -227,13 +232,13 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
     instance= memcached_server_instance_fetch(ptr, server_key);
 
-    struct __write_vector_st vector[]=  
-    { 
-      { .length= get_command_length, .buffer= get_command }, 
-      { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key }, 
-      { .length= key_length[x], .buffer= keys[x] }, 
-      { .length= 1, .buffer= " " } 
-    };  
+    struct libmemcached_io_vector_st vector[]=
+    {
+      { .length= get_command_length, .buffer= get_command },
+      { .length= memcached_array_size(ptr->prefix_key), .buffer= memcached_array_string(ptr->prefix_key) },
+      { .length= key_length[x], .buffer= keys[x] },
+      { .length= 1, .buffer= " " }
+    };
 
 
     if (memcached_server_response_count(instance) == 0)
@@ -241,11 +246,14 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       rc= memcached_connect(instance);
 
       if (rc != MEMCACHED_SUCCESS)
+      {
         continue;
+      }
+      hosts_connected++;
 
       if ((memcached_io_writev(instance, vector, 4, false)) == -1)
       {
-        rc= MEMCACHED_SOME_ERRORS;
+        failures_occured_in_sending= true;
         continue;
       }
       WATCHPOINT_ASSERT(instance->cursor_active == 0);
@@ -257,15 +265,27 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       if ((memcached_io_writev(instance, (vector + 1), 3, false)) == -1)
       {
         memcached_server_response_reset(instance);
-        rc= MEMCACHED_SOME_ERRORS;
+        failures_occured_in_sending= true;
         continue;
       }
     }
   }
 
+  if (hosts_connected == 0)
+  {
+    LIBMEMCACHED_MEMCACHED_MGET_END();
+
+    if (rc != MEMCACHED_SUCCESS)
+      return rc;
+
+    return MEMCACHED_NO_SERVERS;
+  }
+
+
   /*
     Should we muddle on if some servers are dead?
   */
+  bool success_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_server_write_instance_st instance=
@@ -276,13 +296,24 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       /* We need to do something about non-connnected hosts in the future */
       if ((memcached_io_write(instance, "\r\n", 2, true)) == -1)
       {
-        rc= MEMCACHED_SOME_ERRORS;
+        failures_occured_in_sending= true;
+      }
+      else
+      {
+        success_happened= true;
       }
     }
   }
 
   LIBMEMCACHED_MEMCACHED_MGET_END();
-  return rc;
+
+  if (failures_occured_in_sending && success_happened)
+    return MEMCACHED_SOME_ERRORS;
+
+  if (success_happened)
+    return MEMCACHED_SUCCESS;
+
+  return MEMCACHED_FAILURE;
 }
 
 memcached_return_t memcached_mget_by_key(memcached_st *ptr,
@@ -346,7 +377,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
 {
   memcached_return_t rc= MEMCACHED_NOTFOUND;
 
-  int flush= number_of_keys == 1;
+  bool flush= (number_of_keys == 1);
 
   /*
     If a server fails we warn about errors and start all over with sending keys
@@ -395,16 +426,16 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       return vk;
     }
 
-    request.message.header.request.keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length));
+    request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
-    request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + ptr->prefix_key_length));
+    request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->prefix_key)));
 
-    struct __write_vector_st vector[]= 
+    struct libmemcached_io_vector_st vector[]=
     {
       { .length= sizeof(request.bytes), .buffer= request.bytes },
-      { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
+      { .length= memcached_array_size(ptr->prefix_key), .buffer= memcached_array_string(ptr->prefix_key) },
       { .length= key_length[x], .buffer= keys[x] }
-    }; 
+    };
 
     if (memcached_io_writev(instance, vector, 3, flush) == -1)
     {
@@ -517,9 +548,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
         .message.header.request= {
           .magic= PROTOCOL_BINARY_REQ,
           .opcode= PROTOCOL_BINARY_CMD_GETK,
-          .keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length)),
+          .keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key))),
           .datatype= PROTOCOL_BINARY_RAW_BYTES,
-          .bodylen= htonl((uint32_t)(key_length[x] + ptr->prefix_key_length))
+          .bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->prefix_key)))
         }
       };
 
@@ -533,12 +564,12 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
        * that we might have processed some of the responses etc. For now,
        * just make sure we work _correctly_
      */
-      struct __write_vector_st vector[]= 
+      struct libmemcached_io_vector_st vector[]=
       {
         { .length= sizeof(request.bytes), .buffer= request.bytes },
-        { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
+        { .length= memcached_array_size(ptr->prefix_key), .buffer= memcached_array_string(ptr->prefix_key) },
         { .length= key_length[x], .buffer= keys[x] }
-      }; 
+      };
 
       if (memcached_io_writev(instance, vector, 3, true) == -1)
       {