git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/behavior.c

   1 /* LibMemcached
   2  * Copyright (C) 2006-2009 Brian Aker
   3  * All rights reserved.
   4  *
   5  * Use and distribution licensed under the BSD license.  See
   6  * the COPYING file in the parent directory for full text.
   7  *
   8  * Summary: Change the behavior of the memcached connection.
   9  *
  10  */
  11
  12 #include "common.h"
  13 #include <time.h>
  14 #include <sys/types.h>
  15 #include <sys/socket.h>
  16 #include <netinet/tcp.h>
  17
  18 static bool set_flag(uint64_t data)
  19 {
  20   // Wordy :)
  21   return data ? true : false;
  22 }
  23
  24 /*
  25   This function is used to modify the behavior of running client.
  26
  27   We quit all connections so we can reset the sockets.
  28 */
  29
  30 memcached_return_t memcached_behavior_set(memcached_st *ptr,
  31                                           const memcached_behavior_t flag,
  32                                           uint64_t data)
  33 {
  34   switch (flag)
  35   {
  36   case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
  37     ptr->number_of_replicas= (uint32_t)data;
  38     break;
  39   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
  40     ptr->io_msg_watermark= (uint32_t) data;
  41     break;
  42   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
  43     ptr->io_bytes_watermark= (uint32_t)data;
  44     break;
  45   case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
  46     ptr->io_key_prefetch = (uint32_t)data;
  47     break;
  48   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
  49     ptr->snd_timeout= (int32_t)data;
  50     break;
  51   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
  52     ptr->rcv_timeout= (int32_t)data;
  53     break;
  54   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
  55     ptr->server_failure_limit= (uint32_t)data;
  56     break;
  57   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
  58     if (data)
  59     {
  60       ptr->flags.verify_key= false;
  61     }
  62     ptr->flags.binary_protocol= set_flag(data);
  63     break;
  64   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
  65     ptr->flags.support_cas= set_flag(data);
  66     break;
  67   case MEMCACHED_BEHAVIOR_NO_BLOCK:
  68     ptr->flags.no_block= set_flag(data);
  69     memcached_quit(ptr);
  70     break;
  71   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
  72     ptr->flags.buffer_requests= set_flag(data);
  73     memcached_quit(ptr);
  74     break;
  75   case MEMCACHED_BEHAVIOR_USE_UDP:
  76     if (memcached_server_count(ptr))
  77     {
  78       return MEMCACHED_FAILURE;
  79     }
  80     ptr->flags.use_udp= set_flag(data);
  81     if (data)
  82     {
  83       ptr->flags.no_reply= set_flag(data);
  84     }
  85     break;
  86   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
  87     ptr->flags.tcp_nodelay= set_flag(data);
  88     memcached_quit(ptr);
  89     break;
  90   case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE:
  91     ptr->flags.tcp_keepalive= set_flag(data);
  92     memcached_quit(ptr);
  93     break;
  94   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
  95     return memcached_behavior_set_distribution(ptr, (memcached_server_distribution_t)data);
  96   case MEMCACHED_BEHAVIOR_KETAMA:
  97     {
  98       if (data)
  99       {
 100         (void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
 101         (void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
 102         (void)memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
 103       }
 104       else
 105       {
 106         (void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_DEFAULT);
 107         (void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_DEFAULT);
 108         (void)memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_MODULA);
 109       }
 110
 111       break;
 112     }
 113   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 114     {
 115       (void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
 116       (void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
 117       ptr->flags.ketama_weighted= set_flag(data);
 118       /**
 119         @note We try to keep the same distribution going. This should be deprecated and rewritten.
 120       */
 121       return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
 122     }
 123   case MEMCACHED_BEHAVIOR_HASH:
 124     return memcached_behavior_set_key_hash(ptr, (memcached_hash_t)(data));
 125   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 126     return memcached_behavior_set_distribution_hash(ptr, (memcached_hash_t)(data));
 127   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 128     ptr->flags.use_cache_lookups= set_flag(data);
 129     memcached_quit(ptr);
 130     break;
 131   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 132     if (ptr->flags.binary_protocol)
 133       return MEMCACHED_FAILURE;
 134     ptr->flags.verify_key= set_flag(data);
 135     break;
 136   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 137     {
 138       ptr->flags.use_sort_hosts= set_flag(data);
 139       run_distribution(ptr);
 140
 141       break;
 142     }
 143   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 144     ptr->poll_timeout= (int32_t)data;
 145     break;
 146   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 147     ptr->connect_timeout= (int32_t)data;
 148     break;
 149   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 150     ptr->retry_timeout= (int32_t)data;
 151     break;
 152   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 153     ptr->send_size= (int32_t)data;
 154     memcached_quit(ptr);
 155     break;
 156   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 157     ptr->recv_size= (int32_t)data;
 158     memcached_quit(ptr);
 159     break;
 160   case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE:
 161     ptr->tcp_keepidle= (uint32_t)data;
 162     memcached_quit(ptr);
 163     break;
 164   case MEMCACHED_BEHAVIOR_USER_DATA:
 165     return MEMCACHED_FAILURE;
 166   case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
 167     ptr->flags.hash_with_prefix_key= set_flag(data);
 168     break;
 169   case MEMCACHED_BEHAVIOR_NOREPLY:
 170     ptr->flags.no_reply= set_flag(data);
 171     break;
 172   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
 173     ptr->flags.auto_eject_hosts= set_flag(data);
 174     break;
 175   case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
 176       srandom((uint32_t) time(NULL));
 177       ptr->flags.randomize_replica_read= set_flag(data);
 178       break;
 179   case MEMCACHED_BEHAVIOR_CORK:
 180       {
 181         memcached_server_write_instance_st instance;
 182         bool action= set_flag(data);
 183
 184         if (action == false)
 185         {
 186           ptr->flags.cork= set_flag(false);
 187           return MEMCACHED_SUCCESS;
 188         }
 189
 190         instance= memcached_server_instance_fetch(ptr, 0);
 191         if (! instance)
 192           return MEMCACHED_NO_SERVERS;
 193
 194
 195         /* We just try the first host, and if it is down we return zero */
 196         memcached_return_t rc;
 197         rc= memcached_connect(instance);
 198         if (rc != MEMCACHED_SUCCESS)
 199         {
 200           return rc;
 201         }
 202
 203         /* Now we test! */
 204         memcached_ternary_t enabled;
 205         enabled= test_cork(instance, true);
 206
 207         switch (enabled)
 208         {
 209         case MEM_FALSE:
 210           return ptr->cached_errno ? MEMCACHED_ERRNO : MEMCACHED_FAILURE ;
 211         case MEM_TRUE:
 212           {
 213             enabled= test_cork(instance, false);
 214
 215             if (enabled == false) // Possible bug in OS?
 216             {
 217               memcached_quit_server(instance, false); // We should reset everything on this error.
 218               return MEMCACHED_ERRNO;  // Errno will be true because we will have already set it.
 219             }
 220             ptr->flags.cork= true;
 221             ptr->flags.tcp_nodelay= true;
 222             memcached_quit(ptr); // We go on and reset the connections.
 223           }
 224           break;
 225         case MEM_NOT:
 226         default:
 227           return MEMCACHED_NOT_SUPPORTED;
 228         }
 229       }
 230       break;
 231   case MEMCACHED_BEHAVIOR_MAX:
 232   default:
 233     /* Shouldn't get here */
 234     WATCHPOINT_ASSERT(0);
 235     return MEMCACHED_FAILURE;
 236   }
 237
 238   return MEMCACHED_SUCCESS;
 239 }
 240
 241 inline bool _is_auto_eject_host(const memcached_st *ptr)
 242 {
 243   return ptr->flags.auto_eject_hosts;
 244 }
 245
 246 uint64_t memcached_behavior_get(memcached_st *ptr,
 247                                 const memcached_behavior_t flag)
 248 {
 249   switch (flag)
 250   {
 251   case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
 252     return ptr->number_of_replicas;
 253   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
 254     return ptr->io_msg_watermark;
 255   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
 256     return ptr->io_bytes_watermark;
 257   case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
 258     return ptr->io_key_prefetch;
 259   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
 260     return ptr->flags.binary_protocol;
 261   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
 262     return ptr->flags.support_cas;
 263   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 264     return ptr->flags.use_cache_lookups;
 265   case MEMCACHED_BEHAVIOR_NO_BLOCK:
 266     return ptr->flags.no_block;
 267   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
 268     return ptr->flags.buffer_requests;
 269   case MEMCACHED_BEHAVIOR_USE_UDP:
 270     return ptr->flags.use_udp;
 271   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
 272     return ptr->flags.tcp_nodelay;
 273   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 274     return ptr->flags.verify_key;
 275   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 276     return ptr->flags.ketama_weighted;
 277   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
 278     return ptr->distribution;
 279   case MEMCACHED_BEHAVIOR_KETAMA:
 280     return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? (uint64_t) 1 : 0;
 281   case MEMCACHED_BEHAVIOR_HASH:
 282     return hashkit_get_function(&ptr->hashkit);
 283   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 284     return hashkit_get_function(&ptr->distribution_hashkit);
 285   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
 286     return ptr->server_failure_limit;
 287   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 288     return ptr->flags.use_sort_hosts;
 289   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 290     return (uint64_t)ptr->poll_timeout;
 291   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 292     return (uint64_t)ptr->connect_timeout;
 293   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 294     return (uint64_t)ptr->retry_timeout;
 295   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
 296     return (uint64_t)ptr->snd_timeout;
 297   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
 298     return (uint64_t)ptr->rcv_timeout;
 299   case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE:
 300     return (uint64_t)ptr->tcp_keepidle;
 301   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 302     {
 303       int sock_size= 0;
 304       socklen_t sock_length= sizeof(int);
 305       memcached_server_write_instance_st instance;
 306
 307       if (ptr->send_size != -1) // If value is -1 then we are using the default
 308         return (uint64_t) ptr->send_size;
 309
 310       instance= memcached_server_instance_fetch(ptr, 0);
 311
 312       if (instance) // If we have an instance we test, otherwise we just set and pray
 313       {
 314         /* REFACTOR */
 315         /* We just try the first host, and if it is down we return zero */
 316         if ((memcached_connect(instance)) != MEMCACHED_SUCCESS)
 317           return 0;
 318
 319         if (getsockopt(instance->fd, SOL_SOCKET,
 320                        SO_SNDBUF, &sock_size, &sock_length))
 321           return 0; /* Zero means error */
 322       }
 323
 324       return (uint64_t) sock_size;
 325     }
 326   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 327     {
 328       int sock_size= 0;
 329       socklen_t sock_length= sizeof(int);
 330       memcached_server_write_instance_st instance;
 331
 332       if (ptr->recv_size != -1) // If value is -1 then we are using the default
 333         return (uint64_t) ptr->recv_size;
 334
 335       instance= memcached_server_instance_fetch(ptr, 0);
 336
 337       /**
 338         @note REFACTOR
 339       */
 340       if (instance)
 341       {
 342         /* We just try the first host, and if it is down we return zero */
 343         if ((memcached_connect(instance)) != MEMCACHED_SUCCESS)
 344           return 0;
 345
 346         if (getsockopt(instance->fd, SOL_SOCKET,
 347                        SO_RCVBUF, &sock_size, &sock_length))
 348           return 0; /* Zero means error */
 349
 350       }
 351
 352       return (uint64_t) sock_size;
 353     }
 354   case MEMCACHED_BEHAVIOR_USER_DATA:
 355     return MEMCACHED_FAILURE;
 356   case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
 357     return ptr->flags.hash_with_prefix_key;
 358   case MEMCACHED_BEHAVIOR_NOREPLY:
 359     return ptr->flags.no_reply;
 360   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
 361     return ptr->flags.auto_eject_hosts;
 362   case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
 363     return ptr->flags.randomize_replica_read;
 364   case MEMCACHED_BEHAVIOR_CORK:
 365     return ptr->flags.cork;
 366   case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE:
 367     return ptr->flags.tcp_keepalive;
 368   case MEMCACHED_BEHAVIOR_MAX:
 369   default:
 370     WATCHPOINT_ASSERT(0); /* Programming mistake if it gets this far */
 371     return 0;
 372   }
 373
 374   /* NOTREACHED */
 375 }
 376
 377
 378 memcached_return_t memcached_behavior_set_distribution(memcached_st *ptr, memcached_server_distribution_t type)
 379 {
 380   if (type < MEMCACHED_DISTRIBUTION_CONSISTENT_MAX)
 381   {
 382     ptr->distribution= type;
 383     run_distribution(ptr);
 384   }
 385   else
 386   {
 387     return MEMCACHED_FAILURE;
 388   }
 389
 390   return MEMCACHED_SUCCESS;
 391 }
 392
 393
 394 memcached_server_distribution_t memcached_behavior_get_distribution(memcached_st *ptr)
 395 {
 396   return ptr->distribution;
 397 }
 398
 399 memcached_return_t memcached_behavior_set_key_hash(memcached_st *ptr, memcached_hash_t type)
 400 {
 401   hashkit_return_t rc;
 402   rc= hashkit_set_function(&ptr->hashkit, (hashkit_hash_algorithm_t)type);
 403
 404   return rc == HASHKIT_SUCCESS ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 405 }
 406
 407 memcached_hash_t memcached_behavior_get_key_hash(memcached_st *ptr)
 408 {
 409   return (memcached_hash_t)hashkit_get_function(&ptr->hashkit);
 410 }
 411
 412 memcached_return_t memcached_behavior_set_distribution_hash(memcached_st *ptr, memcached_hash_t type)
 413 {
 414   hashkit_return_t rc;
 415   rc= hashkit_set_function(&ptr->distribution_hashkit, (hashkit_hash_algorithm_t)type);
 416
 417   return rc == HASHKIT_SUCCESS ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 418 }
 419
 420 memcached_hash_t memcached_behavior_get_distribution_hash(memcached_st *ptr)
 421 {
 422   return (memcached_hash_t)hashkit_get_function(&ptr->distribution_hashkit);
 423 }