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