Merge lp:~y-maris/libmemcached/libmemcached into lp:libmemcached

[Maris Ruskulis]

Try next server from replica set if key not found on current, this feature is must have for php session storage and usage with pecl-memcached

[Brian Aker (brianaker)]

Reviewing.

[Brian Aker (brianaker)]

As is the patch causes several test failures (looking into it).

[xoJIog (xojiog)]

> As is the patch causes several test failures (looking into it).
Please include this in mainstream, as memcached redundancy using pecl-memcached is of vital importance to us.

[Brian Aker (brianaker)]

Thanks, looking at it.

On Apr 3, 2013, at 4:22 AM, xoJIog <email address hidden> wrote:

>> As is the patch causes several test failures (looking into it).
> Please include this in mainstream, as memcached redundancy using pecl-memcached is of vital importance to us.
> --
> https://code.launchpad.net/~y-maris/libmemcached/libmemcached/+merge/138735
> Your team Tangent is subscribed to branch lp:libmemcached.

[xoJIog (xojiog)]

bump

[Brian Aker (brianaker)]

I just did a merge of this and found that test cases failed when I ran it.

review: Needs Fixing

Unmerged revisions

1084. By Maris Ruskulis on 2012-12-07

Trying next server if key not found

=== modified file 'libmemcached/get.cc'
--- libmemcached/get.cc	2012-07-07 10:04:00 +0000
+++ libmemcached/get.cc	2012-12-07 13:44:57 +0000
@@ -56,7 +56,7 @@
                                                      const char * const *keys,
                                                      const size_t *key_length,
                                                      size_t number_of_keys,
-                                                     bool mget_mode);
+                                                     bool mget_mode, char **result, size_t *value_length);
 
 char *memcached_get_by_key(memcached_st *ptr,
                            const char *group_key,
@@ -66,6 +66,9 @@
                            uint32_t *flags,
                            memcached_return_t *error)
 {
+
+  char *value;
+
   memcached_return_t unused;
   if (error == NULL)
   {
@@ -81,7 +84,7 @@
   /* Request the key */
   *error= memcached_mget_by_key_real(ptr, group_key, group_key_length,
                                      (const char * const *)&key, &key_length, 
-                                     1, false);
+                                     1, false, &value, value_length);
   if (ptr)
   {
     assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
@@ -105,8 +108,6 @@
     return NULL;
   }
 
-  char *value= memcached_fetch(ptr, NULL, NULL,
-                               value_length, flags, error);
   assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
 
   /* This is for historical reasons */
@@ -191,7 +192,7 @@
                                              const char * const *keys,
                                              const size_t *key_length,
                                              size_t number_of_keys,
-                                             bool mget_mode);
+                                             bool mget_mode, char **result, size_t *value_length);
 
 static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
                                                      const char *group_key,
@@ -199,7 +200,7 @@
                                                      const char * const *keys,
                                                      const size_t *key_length,
                                                      size_t number_of_keys,
-                                                     bool mget_mode)
+                                                     bool mget_mode, char **result, size_t *value_length)
 {
   bool failures_occured_in_sending= false;
   const char *get_command= "get";
@@ -265,7 +266,7 @@
   if (memcached_is_binary(ptr))
   {
     return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys,
-                              key_length, number_of_keys, mget_mode);
+                              key_length, number_of_keys, mget_mode, result, value_length);
   }
 
   if (ptr->flags.support_cas)
@@ -393,7 +394,7 @@
                                          size_t number_of_keys)
 {
   return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys,
-                                    key_length, number_of_keys, true);
+                                    key_length, number_of_keys, true, NULL, NULL);
 }
 
 memcached_return_t memcached_mget_execute(memcached_st *ptr,
@@ -583,11 +584,12 @@
                                                   bool* dead_servers,
                                                   const char *const *keys,
                                                   const size_t *key_length,
-                                                  size_t number_of_keys)
+                                                  size_t number_of_keys, char **result, size_t *value_length)
 {
   memcached_return_t rc= MEMCACHED_NOTFOUND;
   uint32_t start= 0;
   uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
+  bool empty_response = false;
 
   if (randomize_read)
   {
@@ -601,8 +603,9 @@
 
     for (uint32_t x= 0; x < number_of_keys; ++x)
     {
-      if (hash[x] == memcached_server_count(ptr))
+      if (hash[x] == memcached_server_count(ptr) && !empty_response){
         continue; /* Already successfully sent */
+      }
 
       uint32_t server= hash[x] + replica;
 
@@ -671,6 +674,19 @@
 
       memcached_server_response_increment(instance);
       hash[x]= memcached_server_count(ptr);
+
+      uint32_t flags = 0;
+      *result = memcached_fetch(ptr, NULL, NULL,
+                               value_length, &flags, &rc); 
+
+      if(*result == NULL) {
+   success= false;
+   empty_response = true;
+   continue;
+      }else{
+   empty_response = false;
+        success = true;
+      } 
     }
 
     if (success)
@@ -688,7 +704,7 @@
                                              const char * const *keys,
                                              const size_t *key_length,
                                              size_t number_of_keys,
-                                             bool mget_mode)
+                                             bool mget_mode, char **result, size_t *value_length)
 {
   if (ptr->number_of_replicas == 0)
   {
@@ -722,7 +738,7 @@
   }
 
   memcached_return_t rc= replication_binary_mget(ptr, hash, dead_servers, keys,
-                                                 key_length, number_of_keys);
+                                                 key_length, number_of_keys, result, value_length);
 
   WATCHPOINT_IFERROR(rc);
   libmemcached_free(ptr, hash);