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

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