git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/get.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Libmemcached library
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *  Copyright (C) 2006-2009 Brian Aker All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions are
  10  *  met:
  11  *
  12  *      * Redistributions of source code must retain the above copyright
  13  *  notice, this list of conditions and the following disclaimer.
  14  *
  15  *      * Redistributions in binary form must reproduce the above
  16  *  copyright notice, this list of conditions and the following disclaimer
  17  *  in the documentation and/or other materials provided with the
  18  *  distribution.
  19  *
  20  *      * The names of its contributors may not be used to endorse or
  21  *  promote products derived from this software without specific prior
  22  *  written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37
  38 #include <libmemcached/common.h>
  39 #include <cassert>
  40
  41 /*
  42   What happens if no servers exist?
  43 */
  44 char *memcached_get(memcached_st *ptr, const char *key,
  45                     size_t key_length,
  46                     size_t *value_length,
  47                     uint32_t *flags,
  48                     memcached_return_t *error)
  49 {
  50   return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length,
  51                               flags, error);
  52 }
  53
  54 static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
  55                                                      const char *group_key,
  56                                                      size_t group_key_length,
  57                                                      const char * const *keys,
  58                                                      const size_t *key_length,
  59                                                      size_t number_of_keys,
  60                                                      bool mget_mode);
  61
  62 char *memcached_get_by_key(memcached_st *ptr,
  63                            const char *group_key,
  64                            size_t group_key_length,
  65                            const char *key, size_t key_length,
  66                            size_t *value_length,
  67                            uint32_t *flags,
  68                            memcached_return_t *error)
  69 {
  70   unlikely (ptr->flags.use_udp)
  71   {
  72     if (value_length)
  73       *value_length= 0;
  74
  75     *error= memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
  76     return NULL;
  77   }
  78
  79   uint64_t query_id= ptr->query_id;
  80   (void)query_id;
  81
  82   /* Request the key */
  83   *error= memcached_mget_by_key_real(ptr, group_key, group_key_length,
  84                                      (const char * const *)&key,
  85                                      &key_length, 1, false);
  86   assert(ptr->query_id == query_id +1);
  87
  88
  89   if (memcached_failed(*error))
  90   {
  91     if (memcached_has_current_error(*ptr)) // Find the most accurate error
  92     {
  93       *error= memcached_last_error(ptr);
  94     }
  95
  96     if (value_length)
  97       *value_length= 0;
  98
  99     return NULL;
 100   }
 101
 102   char *value= memcached_fetch(ptr, NULL, NULL,
 103                                value_length, flags, error);
 104   assert(ptr->query_id == query_id +1);
 105
 106   /* This is for historical reasons */
 107   if (*error == MEMCACHED_END)
 108     *error= MEMCACHED_NOTFOUND;
 109
 110   if (value == NULL)
 111   {
 112     if (ptr->get_key_failure && *error == MEMCACHED_NOTFOUND)
 113     {
 114       memcached_result_reset(&ptr->result);
 115       memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, &ptr->result);
 116
 117       /* On all failure drop to returning NULL */
 118       if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED)
 119       {
 120         if (rc == MEMCACHED_BUFFERED)
 121         {
 122           uint64_t latch; /* We use latch to track the state of the original socket */
 123           latch= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS);
 124           if (latch == 0)
 125             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
 126
 127           rc= memcached_set(ptr, key, key_length,
 128                             (memcached_result_value(&ptr->result)),
 129                             (memcached_result_length(&ptr->result)),
 130                             0,
 131                             (memcached_result_flags(&ptr->result)));
 132
 133           if (rc == MEMCACHED_BUFFERED && latch == 0)
 134             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0);
 135         }
 136         else
 137         {
 138           rc= memcached_set(ptr, key, key_length,
 139                             (memcached_result_value(&ptr->result)),
 140                             (memcached_result_length(&ptr->result)),
 141                             0,
 142                             (memcached_result_flags(&ptr->result)));
 143         }
 144
 145         if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED)
 146         {
 147           *error= rc;
 148           *value_length= memcached_result_length(&ptr->result);
 149           *flags= memcached_result_flags(&ptr->result);
 150           return memcached_string_take_value(&ptr->result.value);
 151         }
 152       }
 153     }
 154     assert(ptr->query_id == query_id +1);
 155
 156     return NULL;
 157   }
 158
 159   size_t dummy_length;
 160   uint32_t dummy_flags;
 161   memcached_return_t dummy_error;
 162
 163   char *dummy_value= memcached_fetch(ptr, NULL, NULL,
 164                                      &dummy_length, &dummy_flags,
 165                                      &dummy_error);
 166   WATCHPOINT_ASSERT(dummy_length == 0);
 167   WATCHPOINT_ASSERT(dummy_value == 0);
 168   assert(ptr->query_id == query_id +1);
 169
 170   return value;
 171 }
 172
 173 memcached_return_t memcached_mget(memcached_st *ptr,
 174                                   const char * const *keys,
 175                                   const size_t *key_length,
 176                                   size_t number_of_keys)
 177 {
 178   return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys);
 179 }
 180
 181 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
 182                                              uint32_t master_server_key,
 183                                              bool is_group_key_set,
 184                                              const char * const *keys,
 185                                              const size_t *key_length,
 186                                              size_t number_of_keys,
 187                                              bool mget_mode);
 188
 189 static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 190                                                      const char *group_key,
 191                                                      size_t group_key_length,
 192                                                      const char * const *keys,
 193                                                      const size_t *key_length,
 194                                                      size_t number_of_keys,
 195                                                      bool mget_mode)
 196 {
 197   bool failures_occured_in_sending= false;
 198   const char *get_command= "get ";
 199   uint8_t get_command_length= 4;
 200   unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
 201
 202   memcached_return_t rc;
 203   if (memcached_failed(rc= initialize_query(ptr)))
 204   {
 205     return rc;
 206   }
 207
 208   unlikely (ptr->flags.use_udp)
 209   {
 210     return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
 211   }
 212
 213   LIBMEMCACHED_MEMCACHED_MGET_START();
 214
 215   if (number_of_keys == 0)
 216   {
 217     return memcached_set_error(*ptr, MEMCACHED_NOTFOUND, MEMCACHED_AT, memcached_literal_param("number_of_keys was zero"));
 218   }
 219
 220   if (ptr->flags.verify_key && (memcached_key_test(keys, key_length, number_of_keys) == MEMCACHED_BAD_KEY_PROVIDED))
 221   {
 222     return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad key value was provided"));
 223   }
 224
 225   bool is_group_key_set= false;
 226   if (group_key && group_key_length)
 227   {
 228     if (ptr->flags.verify_key and (memcached_key_test((const char * const *)&group_key, &group_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
 229     {
 230       return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad group key was provided."));
 231     }
 232
 233     master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
 234     is_group_key_set= true;
 235   }
 236
 237   /*
 238     Here is where we pay for the non-block API. We need to remove any data sitting
 239     in the queue before we start our get.
 240
 241     It might be optimum to bounce the connection if count > some number.
 242   */
 243   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
 244   {
 245     memcached_server_write_instance_st instance=
 246       memcached_server_instance_fetch(ptr, x);
 247
 248     if (memcached_server_response_count(instance))
 249     {
 250       char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
 251
 252       if (ptr->flags.no_block)
 253         (void)memcached_io_write(instance, NULL, 0, true);
 254
 255       while(memcached_server_response_count(instance))
 256         (void)memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result);
 257     }
 258   }
 259
 260   if (ptr->flags.binary_protocol)
 261   {
 262     return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys,
 263                               key_length, number_of_keys, mget_mode);
 264   }
 265
 266   if (ptr->flags.support_cas)
 267   {
 268     get_command= "gets ";
 269     get_command_length= 5;
 270   }
 271
 272   /*
 273     If a server fails we warn about errors and start all over with sending keys
 274     to the server.
 275   */
 276   WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS);
 277   size_t hosts_connected= 0;
 278   for (uint32_t x= 0; x < number_of_keys; x++)
 279   {
 280     memcached_server_write_instance_st instance;
 281     uint32_t server_key;
 282
 283     if (is_group_key_set)
 284     {
 285       server_key= master_server_key;
 286     }
 287     else
 288     {
 289       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
 290     }
 291
 292     instance= memcached_server_instance_fetch(ptr, server_key);
 293
 294     struct libmemcached_io_vector_st vector[]=
 295     {
 296       { get_command_length, get_command },
 297       { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) },
 298       { key_length[x], keys[x] },
 299       { 1, " " }
 300     };
 301
 302
 303     if (memcached_server_response_count(instance) == 0)
 304     {
 305       rc= memcached_connect(instance);
 306
 307       if (memcached_failed(rc))
 308       {
 309         memcached_set_error(*instance, rc, MEMCACHED_AT);
 310         continue;
 311       }
 312       hosts_connected++;
 313
 314       if ((memcached_io_writev(instance, vector, 4, false)) == -1)
 315       {
 316         failures_occured_in_sending= true;
 317         continue;
 318       }
 319       WATCHPOINT_ASSERT(instance->cursor_active == 0);
 320       memcached_server_response_increment(instance);
 321       WATCHPOINT_ASSERT(instance->cursor_active == 1);
 322     }
 323     else
 324     {
 325       if ((memcached_io_writev(instance, (vector + 1), 3, false)) == -1)
 326       {
 327         memcached_server_response_reset(instance);
 328         failures_occured_in_sending= true;
 329         continue;
 330       }
 331     }
 332   }
 333
 334   if (hosts_connected == 0)
 335   {
 336     LIBMEMCACHED_MEMCACHED_MGET_END();
 337
 338     if (memcached_failed(rc))
 339       return rc;
 340
 341     return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT);
 342   }
 343
 344
 345   /*
 346     Should we muddle on if some servers are dead?
 347   */
 348   bool success_happened= false;
 349   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
 350   {
 351     memcached_server_write_instance_st instance=
 352       memcached_server_instance_fetch(ptr, x);
 353
 354     if (memcached_server_response_count(instance))
 355     {
 356       /* We need to do something about non-connnected hosts in the future */
 357       if ((memcached_io_write(instance, "\r\n", 2, true)) == -1)
 358       {
 359         failures_occured_in_sending= true;
 360       }
 361       else
 362       {
 363         success_happened= true;
 364       }
 365     }
 366   }
 367
 368   LIBMEMCACHED_MEMCACHED_MGET_END();
 369
 370   if (failures_occured_in_sending && success_happened)
 371   {
 372     return MEMCACHED_SOME_ERRORS;
 373   }
 374
 375   if (success_happened)
 376     return MEMCACHED_SUCCESS;
 377
 378   return MEMCACHED_FAILURE; // Complete failure occurred
 379 }
 380
 381 memcached_return_t memcached_mget_by_key(memcached_st *ptr,
 382                                          const char *group_key,
 383                                          size_t group_key_length,
 384                                          const char * const *keys,
 385                                          const size_t *key_length,
 386                                          size_t number_of_keys)
 387 {
 388   return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys,
 389                                     key_length, number_of_keys, true);
 390 }
 391
 392 memcached_return_t memcached_mget_execute(memcached_st *ptr,
 393                                           const char * const *keys,
 394                                           const size_t *key_length,
 395                                           size_t number_of_keys,
 396                                           memcached_execute_fn *callback,
 397                                           void *context,
 398                                           unsigned int number_of_callbacks)
 399 {
 400   return memcached_mget_execute_by_key(ptr, NULL, 0, keys, key_length,
 401                                        number_of_keys, callback,
 402                                        context, number_of_callbacks);
 403 }
 404
 405 memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr,
 406                                                  const char *group_key,
 407                                                  size_t group_key_length,
 408                                                  const char * const *keys,
 409                                                  const size_t *key_length,
 410                                                  size_t number_of_keys,
 411                                                  memcached_execute_fn *callback,
 412                                                  void *context,
 413                                                  unsigned int number_of_callbacks)
 414 {
 415   if ((ptr->flags.binary_protocol) == 0)
 416     return MEMCACHED_NOT_SUPPORTED;
 417
 418   memcached_return_t rc;
 419   memcached_callback_st *original_callbacks= ptr->callbacks;
 420   memcached_callback_st cb= {
 421     callback,
 422     context,
 423     number_of_callbacks
 424   };
 425
 426   ptr->callbacks= &cb;
 427   rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys,
 428                             key_length, number_of_keys);
 429   ptr->callbacks= original_callbacks;
 430   return rc;
 431 }
 432
 433 static memcached_return_t simple_binary_mget(memcached_st *ptr,
 434                                              uint32_t master_server_key,
 435                                              bool is_group_key_set,
 436                                              const char * const *keys,
 437                                              const size_t *key_length,
 438                                              size_t number_of_keys, bool mget_mode)
 439 {
 440   memcached_return_t rc= MEMCACHED_NOTFOUND;
 441
 442   bool flush= (number_of_keys == 1);
 443
 444   /*
 445     If a server fails we warn about errors and start all over with sending keys
 446     to the server.
 447   */
 448   for (uint32_t x= 0; x < number_of_keys; ++x)
 449   {
 450     uint32_t server_key;
 451
 452     if (is_group_key_set)
 453     {
 454       server_key= master_server_key;
 455     }
 456     else
 457     {
 458       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
 459     }
 460
 461     memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key);
 462
 463     if (memcached_server_response_count(instance) == 0)
 464     {
 465       rc= memcached_connect(instance);
 466       if (memcached_failed(rc))
 467         continue;
 468     }
 469
 470     protocol_binary_request_getk request= { }; //= {.bytes= {0}};
 471     request.message.header.request.magic= PROTOCOL_BINARY_REQ;
 472     if (mget_mode)
 473       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
 474     else
 475       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
 476
 477     memcached_return_t vk;
 478     vk= memcached_validate_key_length(key_length[x],
 479                                       ptr->flags.binary_protocol);
 480     unlikely (vk != MEMCACHED_SUCCESS)
 481     {
 482       if (x > 0)
 483       {
 484         memcached_io_reset(instance);
 485       }
 486
 487       return vk;
 488     }
 489
 490     request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
 491     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 492     request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->prefix_key)));
 493
 494     struct libmemcached_io_vector_st vector[]=
 495     {
 496       { sizeof(request.bytes), request.bytes },
 497       { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) },
 498       { key_length[x], keys[x] }
 499     };
 500
 501     if (memcached_io_writev(instance, vector, 3, flush) == -1)
 502     {
 503       memcached_server_response_reset(instance);
 504       rc= MEMCACHED_SOME_ERRORS;
 505       continue;
 506     }
 507
 508     /* We just want one pending response per server */
 509     memcached_server_response_reset(instance);
 510     memcached_server_response_increment(instance);
 511     if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
 512     {
 513       rc= MEMCACHED_SOME_ERRORS;
 514     }
 515   }
 516
 517   if (mget_mode)
 518   {
 519     /*
 520       Send a noop command to flush the buffers
 521     */
 522     protocol_binary_request_noop request= {}; //= {.bytes= {0}};
 523     request.message.header.request.magic= PROTOCOL_BINARY_REQ;
 524     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP;
 525     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 526
 527     for (uint32_t x= 0; x < memcached_server_count(ptr); ++x)
 528     {
 529       memcached_server_write_instance_st instance=
 530         memcached_server_instance_fetch(ptr, x);
 531
 532       if (memcached_server_response_count(instance))
 533       {
 534         if (memcached_io_write(instance, NULL, 0, true) == -1)
 535         {
 536           memcached_server_response_reset(instance);
 537           memcached_io_reset(instance);
 538           rc= MEMCACHED_SOME_ERRORS;
 539         }
 540
 541         if (memcached_io_write(instance, request.bytes,
 542                                sizeof(request.bytes), true) == -1)
 543         {
 544           memcached_server_response_reset(instance);
 545           memcached_io_reset(instance);
 546           rc= MEMCACHED_SOME_ERRORS;
 547         }
 548       }
 549     }
 550   }
 551
 552
 553   return rc;
 554 }
 555
 556 static memcached_return_t replication_binary_mget(memcached_st *ptr,
 557                                                   uint32_t* hash,
 558                                                   bool* dead_servers,
 559                                                   const char *const *keys,
 560                                                   const size_t *key_length,
 561                                                   size_t number_of_keys)
 562 {
 563   memcached_return_t rc= MEMCACHED_NOTFOUND;
 564   uint32_t start= 0;
 565   uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
 566
 567   if (randomize_read)
 568     start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1);
 569
 570   /* Loop for each replica */
 571   for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica)
 572   {
 573     bool success= true;
 574
 575     for (uint32_t x= 0; x < number_of_keys; ++x)
 576     {
 577       if (hash[x] == memcached_server_count(ptr))
 578         continue; /* Already successfully sent */
 579
 580       uint32_t server= hash[x] + replica;
 581
 582       /* In case of randomized reads */
 583       if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas)))
 584         server += start;
 585
 586       while (server >= memcached_server_count(ptr))
 587         server -= memcached_server_count(ptr);
 588
 589       if (dead_servers[server])
 590         continue;
 591
 592       memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server);
 593
 594       if (memcached_server_response_count(instance) == 0)
 595       {
 596         rc= memcached_connect(instance);
 597         if (memcached_failed(rc))
 598         {
 599           memcached_io_reset(instance);
 600           dead_servers[server]= true;
 601           success= false;
 602           continue;
 603         }
 604       }
 605
 606       protocol_binary_request_getk request= {};
 607       request.message.header.request.magic= PROTOCOL_BINARY_REQ;
 608       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
 609       request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
 610       request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 611       request.message.header.request.bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
 612
 613       /*
 614        * We need to disable buffering to actually know that the request was
 615        * successfully sent to the server (so that we should expect a result
 616        * back). It would be nice to do this in buffered mode, but then it
 617        * would be complex to handle all error situations if we got to send
 618        * some of the messages, and then we failed on writing out some others
 619        * and we used the callback interface from memcached_mget_execute so
 620        * that we might have processed some of the responses etc. For now,
 621        * just make sure we work _correctly_
 622      */
 623       struct libmemcached_io_vector_st vector[]=
 624       {
 625         { sizeof(request.bytes), request.bytes },
 626         { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) },
 627         { key_length[x], keys[x] }
 628       };
 629
 630       if (memcached_io_writev(instance, vector, 3, true) == -1)
 631       {
 632         memcached_io_reset(instance);
 633         dead_servers[server]= true;
 634         success= false;
 635         continue;
 636       }
 637
 638       memcached_server_response_increment(instance);
 639       hash[x]= memcached_server_count(ptr);
 640     }
 641
 642     if (success)
 643       break;
 644   }
 645
 646   return rc;
 647 }
 648
 649 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
 650                                              uint32_t master_server_key,
 651                                              bool is_group_key_set,
 652                                              const char * const *keys,
 653                                              const size_t *key_length,
 654                                              size_t number_of_keys,
 655                                              bool mget_mode)
 656 {
 657   if (ptr->number_of_replicas == 0)
 658   {
 659     return simple_binary_mget(ptr, master_server_key, is_group_key_set,
 660                               keys, key_length, number_of_keys, mget_mode);
 661   }
 662
 663   uint32_t* hash= static_cast<uint32_t*>(libmemcached_malloc(ptr, sizeof(uint32_t) * number_of_keys));
 664   bool* dead_servers= static_cast<bool*>(libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(bool)));
 665
 666   if (hash == NULL || dead_servers == NULL)
 667   {
 668     libmemcached_free(ptr, hash);
 669     libmemcached_free(ptr, dead_servers);
 670     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 671   }
 672
 673   if (is_group_key_set)
 674   {
 675     for (size_t x= 0; x < number_of_keys; x++)
 676     {
 677       hash[x]= master_server_key;
 678     }
 679   }
 680   else
 681   {
 682     for (size_t x= 0; x < number_of_keys; x++)
 683     {
 684       hash[x]= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
 685     }
 686   }
 687
 688   memcached_return_t rc= replication_binary_mget(ptr, hash, dead_servers, keys,
 689                                                  key_length, number_of_keys);
 690
 691   WATCHPOINT_IFERROR(rc);
 692   libmemcached_free(ptr, hash);
 693   libmemcached_free(ptr, dead_servers);
 694
 695   return MEMCACHED_SUCCESS;
 696 }