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