git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/behavior.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 <libmemcached/options.hpp>
  40 #include <libmemcached/virtual_bucket.h>
  41
  42 #include <ctime>
  43 #include <sys/types.h>
  44
  45 /*
  46   This function is used to modify the behavior of running client.
  47
  48   We quit all connections so we can reset the sockets.
  49 */
  50
  51 memcached_return_t memcached_behavior_set(memcached_st *ptr,
  52                                           const memcached_behavior_t flag,
  53                                           uint64_t data)
  54 {
  55   if (not ptr)
  56     return MEMCACHED_INVALID_ARGUMENTS;
  57
  58   switch (flag)
  59   {
  60   case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
  61     ptr->number_of_replicas= (uint32_t)data;
  62     break;
  63
  64   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
  65     ptr->io_msg_watermark= (uint32_t) data;
  66     break;
  67
  68   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
  69     ptr->io_bytes_watermark= (uint32_t)data;
  70     break;
  71
  72   case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
  73     ptr->io_key_prefetch = (uint32_t)data;
  74     break;
  75
  76   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
  77     ptr->snd_timeout= (int32_t)data;
  78     break;
  79
  80   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
  81     ptr->rcv_timeout= (int32_t)data;
  82     break;
  83
  84   case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS:
  85     ptr->flags.auto_eject_hosts= bool(data);
  86
  87   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
  88     ptr->server_failure_limit= (uint32_t)data;
  89     break;
  90
  91   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
  92     send_quit(ptr); // We need t shutdown all of the connections to make sure we do the correct protocol
  93     if (data)
  94     {
  95       ptr->flags.verify_key= false;
  96     }
  97     ptr->flags.binary_protocol= bool(data);
  98     break;
  99
 100   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
 101     ptr->flags.support_cas= bool(data);
 102     break;
 103
 104   case MEMCACHED_BEHAVIOR_NO_BLOCK:
 105     ptr->flags.no_block= bool(data);
 106     send_quit(ptr);
 107     break;
 108
 109   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
 110     ptr->flags.buffer_requests= bool(data);
 111     send_quit(ptr);
 112     break;
 113
 114   case MEMCACHED_BEHAVIOR_USE_UDP:
 115     if (memcached_server_count(ptr))
 116     {
 117       return MEMCACHED_FAILURE;
 118     }
 119     ptr->flags.use_udp= bool(data);
 120     if (data)
 121     {
 122       ptr->flags.no_reply= bool(data);
 123     }
 124     break;
 125
 126   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
 127     ptr->flags.tcp_nodelay= bool(data);
 128     send_quit(ptr);
 129     break;
 130
 131   case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE:
 132     ptr->flags.tcp_keepalive= bool(data);
 133     send_quit(ptr);
 134     break;
 135
 136   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
 137     return memcached_behavior_set_distribution(ptr, (memcached_server_distribution_t)data);
 138
 139   case MEMCACHED_BEHAVIOR_KETAMA:
 140     {
 141       if (data) // Turn on
 142         return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
 143
 144       return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_MODULA);
 145     }
 146
 147   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 148     {
 149       (void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
 150       (void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
 151       ptr->ketama.weighted= bool(data);
 152       /**
 153         @note We try to keep the same distribution going. This should be deprecated and rewritten.
 154       */
 155       return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
 156     }
 157
 158   case MEMCACHED_BEHAVIOR_HASH:
 159     return memcached_behavior_set_key_hash(ptr, (memcached_hash_t)(data));
 160
 161   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 162     return memcached_behavior_set_distribution_hash(ptr, (memcached_hash_t)(data));
 163
 164   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 165     return memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
 166                                       memcached_literal_param("MEMCACHED_BEHAVIOR_CACHE_LOOKUPS has been deprecated."));
 167
 168   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 169     if (ptr->flags.binary_protocol)
 170       return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
 171                                         memcached_literal_param("MEMCACHED_BEHAVIOR_VERIFY_KEY if the binary protocol has been enabled."));
 172     ptr->flags.verify_key= bool(data);
 173     break;
 174
 175   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 176     {
 177       ptr->flags.use_sort_hosts= bool(data);
 178       run_distribution(ptr);
 179
 180       break;
 181     }
 182
 183   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 184     ptr->poll_timeout= (int32_t)data;
 185     break;
 186
 187   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 188     ptr->connect_timeout= (int32_t)data;
 189     break;
 190
 191   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 192     ptr->retry_timeout= (int32_t)data;
 193     break;
 194
 195   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 196     ptr->send_size= (int32_t)data;
 197     send_quit(ptr);
 198     break;
 199
 200   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 201     ptr->recv_size= (int32_t)data;
 202     send_quit(ptr);
 203     break;
 204
 205   case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE:
 206     ptr->tcp_keepidle= (uint32_t)data;
 207     send_quit(ptr);
 208     break;
 209
 210   case MEMCACHED_BEHAVIOR_USER_DATA:
 211     return memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
 212                                memcached_literal_param("MEMCACHED_BEHAVIOR_USER_DATA deprecated."));
 213
 214   case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
 215     ptr->flags.hash_with_namespace= bool(data);
 216     break;
 217
 218   case MEMCACHED_BEHAVIOR_NOREPLY:
 219     ptr->flags.no_reply= bool(data);
 220     break;
 221
 222   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
 223     ptr->flags.auto_eject_hosts= bool(data);
 224     break;
 225
 226   case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
 227       srandom((uint32_t) time(NULL));
 228       ptr->flags.randomize_replica_read= bool(data);
 229       break;
 230
 231   case MEMCACHED_BEHAVIOR_CORK:
 232       return memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
 233                                  memcached_literal_param("MEMCACHED_BEHAVIOR_CORK is now incorporated into the driver by default."));
 234
 235   case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE:
 236       return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
 237                                  memcached_literal_param("MEMCACHED_BEHAVIOR_LOAD_FROM_FILE can not be set with memcached_behavior_set()"));
 238
 239   case MEMCACHED_BEHAVIOR_MAX:
 240   default:
 241     /* Shouldn't get here */
 242     assert_msg(0, "Invalid behavior passed to memcached_behavior_set()");
 243     return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
 244                                memcached_literal_param("Invalid behavior passed to memcached_behavior_set()"));
 245   }
 246
 247   return MEMCACHED_SUCCESS;
 248 }
 249
 250 bool _is_auto_eject_host(const memcached_st *ptr)
 251 {
 252   return ptr->flags.auto_eject_hosts;
 253 }
 254
 255 uint64_t memcached_behavior_get(memcached_st *ptr,
 256                                 const memcached_behavior_t flag)
 257 {
 258   if (not ptr)
 259   {
 260     return MEMCACHED_INVALID_ARGUMENTS;
 261   }
 262
 263   switch (flag)
 264   {
 265   case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
 266     return ptr->number_of_replicas;
 267
 268   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
 269     return ptr->io_msg_watermark;
 270
 271   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
 272     return ptr->io_bytes_watermark;
 273
 274   case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
 275     return ptr->io_key_prefetch;
 276
 277   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
 278     return ptr->flags.binary_protocol;
 279
 280   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
 281     return ptr->flags.support_cas;
 282
 283   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 284     return true;
 285
 286   case MEMCACHED_BEHAVIOR_NO_BLOCK:
 287     return ptr->flags.no_block;
 288
 289   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
 290     return ptr->flags.buffer_requests;
 291
 292   case MEMCACHED_BEHAVIOR_USE_UDP:
 293     return ptr->flags.use_udp;
 294
 295   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
 296     return ptr->flags.tcp_nodelay;
 297
 298   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 299     return ptr->flags.verify_key;
 300
 301   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 302     return ptr->ketama.weighted;
 303
 304   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
 305     return ptr->distribution;
 306
 307   case MEMCACHED_BEHAVIOR_KETAMA:
 308     return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? (uint64_t) 1 : 0;
 309
 310   case MEMCACHED_BEHAVIOR_HASH:
 311     return hashkit_get_function(&ptr->hashkit);
 312
 313   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 314     return hashkit_get_function(&ptr->hashkit);
 315
 316   case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS:
 317   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
 318     return ptr->server_failure_limit;
 319
 320   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 321     return ptr->flags.use_sort_hosts;
 322
 323   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 324     return (uint64_t)ptr->poll_timeout;
 325
 326   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 327     return (uint64_t)ptr->connect_timeout;
 328
 329   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 330     return (uint64_t)ptr->retry_timeout;
 331
 332   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
 333     return (uint64_t)ptr->snd_timeout;
 334
 335   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
 336     return (uint64_t)ptr->rcv_timeout;
 337
 338   case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE:
 339     return (uint64_t)ptr->tcp_keepidle;
 340
 341   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 342     {
 343       int sock_size= 0;
 344       socklen_t sock_length= sizeof(int);
 345
 346       if (ptr->send_size != -1) // If value is -1 then we are using the default
 347         return (uint64_t) ptr->send_size;
 348
 349       memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, 0);
 350
 351       if (instance) // If we have an instance we test, otherwise we just set and pray
 352       {
 353         /* REFACTOR */
 354         /* We just try the first host, and if it is down we return zero */
 355         if (memcached_failed(memcached_connect(instance)))
 356         {
 357           return 0;
 358         }
 359
 360         if (memcached_failed(memcached_io_wait_for_write(instance)))
 361         {
 362           return 0;
 363         }
 364
 365         if (getsockopt(instance->fd, SOL_SOCKET, SO_SNDBUF, &sock_size, &sock_length) < 0)
 366         {
 367           memcached_set_errno(*ptr, errno, MEMCACHED_AT);
 368           return 0; /* Zero means error */
 369         }
 370       }
 371
 372       return (uint64_t) sock_size;
 373     }
 374
 375   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 376     {
 377       int sock_size= 0;
 378       socklen_t sock_length= sizeof(int);
 379
 380       if (ptr->recv_size != -1) // If value is -1 then we are using the default
 381         return (uint64_t) ptr->recv_size;
 382
 383       memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, 0);
 384
 385       /**
 386         @note REFACTOR
 387       */
 388       if (instance)
 389       {
 390         /* We just try the first host, and if it is down we return zero */
 391         if (memcached_failed(memcached_connect(instance)))
 392         {
 393           return 0;
 394         }
 395
 396         if (memcached_failed(memcached_io_wait_for_write(instance)))
 397         {
 398           return 0;
 399         }
 400
 401         if (getsockopt(instance->fd, SOL_SOCKET, SO_RCVBUF, &sock_size, &sock_length) < 0)
 402         {
 403           memcached_set_errno(*ptr, errno, MEMCACHED_AT);
 404           return 0; /* Zero means error */
 405         }
 406
 407       }
 408
 409       return (uint64_t) sock_size;
 410     }
 411
 412   case MEMCACHED_BEHAVIOR_USER_DATA:
 413     memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
 414                         memcached_literal_param("MEMCACHED_BEHAVIOR_USER_DATA deprecated."));
 415     return 0;
 416
 417   case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
 418     return ptr->flags.hash_with_namespace;
 419
 420   case MEMCACHED_BEHAVIOR_NOREPLY:
 421     return ptr->flags.no_reply;
 422
 423   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
 424     return ptr->flags.auto_eject_hosts;
 425
 426   case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
 427     return ptr->flags.randomize_replica_read;
 428
 429   case MEMCACHED_BEHAVIOR_CORK:
 430 #ifdef HAVE_MSG_MORE
 431     return true;
 432 #else
 433     return false;
 434 #endif
 435
 436   case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE:
 437     return ptr->flags.tcp_keepalive;
 438
 439   case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE:
 440     return bool(memcached_parse_filename(ptr));
 441
 442   case MEMCACHED_BEHAVIOR_MAX:
 443   default:
 444     assert_msg(0, "Invalid behavior passed to memcached_behavior_set()");
 445     return 0;
 446   }
 447
 448   /* NOTREACHED */
 449 }
 450
 451
 452 memcached_return_t memcached_behavior_set_distribution(memcached_st *ptr, memcached_server_distribution_t type)
 453 {
 454   if (type < MEMCACHED_DISTRIBUTION_CONSISTENT_MAX)
 455   {
 456     if (MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED)
 457     {
 458       ptr->ketama.weighted= true;
 459     }
 460     else
 461     {
 462       ptr->ketama.weighted= false;
 463     }
 464     ptr->distribution= type;
 465     run_distribution(ptr);
 466     return MEMCACHED_SUCCESS;
 467   }
 468
 469   return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
 470                              memcached_literal_param("Invalid memcached_server_distribution_t"));
 471 }
 472
 473
 474 memcached_server_distribution_t memcached_behavior_get_distribution(memcached_st *ptr)
 475 {
 476   return ptr->distribution;
 477 }
 478
 479 memcached_return_t memcached_behavior_set_key_hash(memcached_st *ptr, memcached_hash_t type)
 480 {
 481   if (hashkit_success(hashkit_set_function(&ptr->hashkit, (hashkit_hash_algorithm_t)type)))
 482     return MEMCACHED_SUCCESS;
 483
 484   return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
 485                              memcached_literal_param("Invalid memcached_hash_t()"));
 486 }
 487
 488 memcached_hash_t memcached_behavior_get_key_hash(memcached_st *ptr)
 489 {
 490   return (memcached_hash_t)hashkit_get_function(&ptr->hashkit);
 491 }
 492
 493 memcached_return_t memcached_behavior_set_distribution_hash(memcached_st *ptr, memcached_hash_t type)
 494 {
 495   if (hashkit_success(hashkit_set_distribution_function(&ptr->hashkit, (hashkit_hash_algorithm_t)type)))
 496     return MEMCACHED_SUCCESS;
 497
 498   return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
 499                              memcached_literal_param("Invalid memcached_hash_t()"));
 500 }
 501
 502 memcached_hash_t memcached_behavior_get_distribution_hash(memcached_st *ptr)
 503 {
 504   return (memcached_hash_t)hashkit_get_function(&ptr->hashkit);
 505 }
 506
 507 const char *libmemcached_string_behavior(const memcached_behavior_t flag)
 508 {
 509   switch (flag)
 510   {
 511   case MEMCACHED_BEHAVIOR_NO_BLOCK: return "MEMCACHED_BEHAVIOR_NO_BLOCK";
 512   case MEMCACHED_BEHAVIOR_TCP_NODELAY: return "MEMCACHED_BEHAVIOR_TCP_NODELAY";
 513   case MEMCACHED_BEHAVIOR_HASH: return "MEMCACHED_BEHAVIOR_HASH";
 514   case MEMCACHED_BEHAVIOR_KETAMA: return "MEMCACHED_BEHAVIOR_KETAMA";
 515   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE: return "MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE";
 516   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE: return "MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE";
 517   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS: return "MEMCACHED_BEHAVIOR_CACHE_LOOKUPS";
 518   case MEMCACHED_BEHAVIOR_SUPPORT_CAS: return "MEMCACHED_BEHAVIOR_SUPPORT_CAS";
 519   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT: return "MEMCACHED_BEHAVIOR_POLL_TIMEOUT";
 520   case MEMCACHED_BEHAVIOR_DISTRIBUTION: return "MEMCACHED_BEHAVIOR_DISTRIBUTION";
 521   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS: return "MEMCACHED_BEHAVIOR_BUFFER_REQUESTS";
 522   case MEMCACHED_BEHAVIOR_USER_DATA: return "MEMCACHED_BEHAVIOR_USER_DATA";
 523   case MEMCACHED_BEHAVIOR_SORT_HOSTS: return "MEMCACHED_BEHAVIOR_SORT_HOSTS";
 524   case MEMCACHED_BEHAVIOR_VERIFY_KEY: return "MEMCACHED_BEHAVIOR_VERIFY_KEY";
 525   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT: return "MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT";
 526   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT: return "MEMCACHED_BEHAVIOR_RETRY_TIMEOUT";
 527   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED: return "MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED";
 528   case MEMCACHED_BEHAVIOR_KETAMA_HASH: return "MEMCACHED_BEHAVIOR_KETAMA_HASH";
 529   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL: return "MEMCACHED_BEHAVIOR_BINARY_PROTOCOL";
 530   case MEMCACHED_BEHAVIOR_SND_TIMEOUT: return "MEMCACHED_BEHAVIOR_SND_TIMEOUT";
 531   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT: return "MEMCACHED_BEHAVIOR_RCV_TIMEOUT";
 532   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT: return "MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT";
 533   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK: return "MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK";
 534   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK: return "MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK";
 535   case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH: return "MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH";
 536   case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY: return "MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY";
 537   case MEMCACHED_BEHAVIOR_NOREPLY: return "MEMCACHED_BEHAVIOR_NOREPLY";
 538   case MEMCACHED_BEHAVIOR_USE_UDP: return "MEMCACHED_BEHAVIOR_USE_UDP";
 539   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS: return "MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS";
 540   case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS: return "MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS";
 541   case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS: return "MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS";
 542   case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ: return "MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ";
 543   case MEMCACHED_BEHAVIOR_CORK: return "MEMCACHED_BEHAVIOR_CORK";
 544   case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE: return "MEMCACHED_BEHAVIOR_TCP_KEEPALIVE";
 545   case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE: return "MEMCACHED_BEHAVIOR_TCP_KEEPIDLE";
 546   case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE: return "MEMCACHED_BEHAVIOR_LOAD_FROM_FILE";
 547   default:
 548   case MEMCACHED_BEHAVIOR_MAX: return "INVALID memcached_behavior_t";
 549   }
 550 }
 551
 552 const char *libmemcached_string_distribution(const memcached_server_distribution_t flag)
 553 {
 554   switch (flag)
 555   {
 556   case MEMCACHED_DISTRIBUTION_MODULA: return "MEMCACHED_DISTRIBUTION_MODULA";
 557   case MEMCACHED_DISTRIBUTION_CONSISTENT: return "MEMCACHED_DISTRIBUTION_CONSISTENT";
 558   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: return "MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA";
 559   case MEMCACHED_DISTRIBUTION_RANDOM: return "MEMCACHED_DISTRIBUTION_RANDOM";
 560   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: return "MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY";
 561   case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: return "MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED";
 562   case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: return "MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET";
 563   default:
 564   case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: return "INVALID memcached_server_distribution_t";
 565   }
 566 }
 567
 568 memcached_return_t memcached_bucket_set(memcached_st *self,
 569                                         const uint32_t *host_map,
 570                                         const uint32_t *forward_map,
 571                                         const uint32_t buckets,
 572                                         const uint32_t replicas)
 573 {
 574   memcached_return_t rc;
 575
 576   if (not self)
 577     return MEMCACHED_INVALID_ARGUMENTS;
 578
 579   if (not host_map)
 580     return MEMCACHED_INVALID_ARGUMENTS;
 581
 582   memcached_server_distribution_t old= memcached_behavior_get_distribution(self);
 583
 584   if (memcached_failed(rc =memcached_behavior_set_distribution(self, MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET)))
 585   {
 586     return rc;
 587   }
 588
 589   if (memcached_failed(rc= memcached_virtual_bucket_create(self, host_map, forward_map, buckets, replicas)))
 590   {
 591     memcached_behavior_set_distribution(self, old);
 592   }
 593
 594   return rc;
 595 }