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