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