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