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