git.m6w6.name Git - awesomized/libmemcached/blob - src/libmemcached/behavior.cc

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