git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/memcached_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 /*
  19   This function is used to modify the behavior of running client.
  20
  21   We quit all connections so we can reset the sockets.
  22 */
  23
  24 memcached_return_t memcached_behavior_set(memcached_st *ptr,
  25                                           memcached_behavior_t flag,
  26                                           uint64_t data)
  27 {
  28   switch (flag)
  29   {
  30   case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
  31     ptr->number_of_replicas= (uint32_t)data;
  32     break;
  33   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
  34     ptr->io_msg_watermark= (uint32_t) data;
  35     break;
  36   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
  37     ptr->io_bytes_watermark= (uint32_t)data;
  38     break;
  39   case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
  40     ptr->io_key_prefetch = (uint32_t)data;
  41     break;
  42   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
  43     ptr->snd_timeout= (int32_t)data;
  44     break;
  45   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
  46     ptr->rcv_timeout= (int32_t)data;
  47     break;
  48   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
  49     ptr->server_failure_limit= (uint32_t)data;
  50     break;
  51   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
  52     if (data)
  53         ptr->flags.verify_key= false;
  54
  55     ptr->flags.binary_protocol= data ? true : false;
  56     break;
  57   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
  58     ptr->flags.support_cas= data ? true: false;
  59     break;
  60   case MEMCACHED_BEHAVIOR_NO_BLOCK:
  61     ptr->flags.no_block= data ? true: false;
  62     memcached_quit(ptr);
  63     break;
  64   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
  65     ptr->flags.buffer_requests= data ? true : false;
  66     memcached_quit(ptr);
  67     break;
  68   case MEMCACHED_BEHAVIOR_USE_UDP:
  69     if (ptr->number_of_hosts)
  70       return MEMCACHED_FAILURE;
  71     ptr->flags.use_udp= data ? true : false;
  72
  73     if (data)
  74       ptr->flags.no_reply= data ? true : false;
  75     break;
  76
  77   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
  78     ptr->flags.tcp_nodelay= data ? true : false;
  79     memcached_quit(ptr);
  80     break;
  81   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
  82     {
  83       ptr->distribution= (memcached_server_distribution_t)(data);
  84       if (ptr->distribution == MEMCACHED_DISTRIBUTION_RANDOM)
  85       {
  86         srandom((uint32_t) time(NULL));
  87       }
  88       run_distribution(ptr);
  89       break;
  90     }
  91   case MEMCACHED_BEHAVIOR_KETAMA:
  92     {
  93       if (data)
  94       {
  95         ptr->hash= MEMCACHED_HASH_MD5;
  96         ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
  97       }
  98       else
  99       {
 100         ptr->hash= 0;
 101         ptr->distribution= 0;
 102       }
 103       run_distribution(ptr);
 104       break;
 105     }
 106   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 107     {
 108       ptr->hash= MEMCACHED_HASH_MD5;
 109       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
 110       ptr->flags.ketama_weighted= data ? true : false;
 111       run_distribution(ptr);
 112       break;
 113     }
 114   case MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE:
 115     switch (data)
 116     {
 117     case MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED:
 118       ptr->hash= MEMCACHED_HASH_MD5;
 119       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
 120       break;
 121     case MEMCACHED_KETAMA_COMPAT_SPY:
 122       ptr->hash= MEMCACHED_HASH_MD5;
 123       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY;
 124       break;
 125     default:
 126        return MEMCACHED_FAILURE;
 127     }
 128     run_distribution(ptr);
 129     break;
 130   case MEMCACHED_BEHAVIOR_HASH:
 131 #ifndef HAVE_HSIEH_HASH
 132     if ((memcached_hash_t)(data) == MEMCACHED_HASH_HSIEH)
 133       return MEMCACHED_FAILURE;
 134 #endif
 135     ptr->hash= (memcached_hash_t)(data);
 136     break;
 137   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 138     ptr->hash_continuum= (memcached_hash_t)(data);
 139     run_distribution(ptr);
 140     break;
 141   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 142     ptr->flags.use_cache_lookups= data ? true : false;
 143     memcached_quit(ptr);
 144     break;
 145   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 146     if (ptr->flags.binary_protocol)
 147         break;
 148     ptr->flags.verify_key= data ? true : false;
 149     break;
 150   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 151     {
 152       ptr->flags.use_sort_hosts= data ? true : false;
 153       run_distribution(ptr);
 154
 155       break;
 156     }
 157   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 158     ptr->poll_timeout= (int32_t)data;
 159     break;
 160   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 161     ptr->connect_timeout= (int32_t)data;
 162     break;
 163   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 164     ptr->retry_timeout= (int32_t)data;
 165     break;
 166   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 167     ptr->send_size= (int32_t)data;
 168     memcached_quit(ptr);
 169     break;
 170   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 171     ptr->recv_size= (int32_t)data;
 172     memcached_quit(ptr);
 173     break;
 174   case MEMCACHED_BEHAVIOR_USER_DATA:
 175     return MEMCACHED_FAILURE;
 176   case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
 177     ptr->flags.hash_with_prefix_key= data ? true : false;
 178     break;
 179   case MEMCACHED_BEHAVIOR_NOREPLY:
 180     ptr->flags.no_reply= data ? true : false;
 181     break;
 182   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
 183     ptr->flags.auto_eject_hosts= data ? true : false;
 184     break;
 185   case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
 186       srandom((uint32_t) time(NULL));
 187       ptr->flags.randomize_replica_read= data ? true : false;
 188       break;
 189   default:
 190     /* Shouldn't get here */
 191     WATCHPOINT_ASSERT(flag);
 192     break;
 193   }
 194
 195   return MEMCACHED_SUCCESS;
 196 }
 197
 198 uint64_t memcached_behavior_get(memcached_st *ptr,
 199                                 memcached_behavior_t flag)
 200 {
 201   switch (flag)
 202   {
 203   case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
 204     return ptr->number_of_replicas;
 205   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
 206     return ptr->io_msg_watermark;
 207   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
 208     return ptr->io_bytes_watermark;
 209   case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
 210     return ptr->io_key_prefetch;
 211   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
 212     return ptr->flags.binary_protocol;
 213   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
 214     return ptr->flags.support_cas;
 215   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 216     return ptr->flags.use_cache_lookups;
 217     break;
 218   case MEMCACHED_BEHAVIOR_NO_BLOCK:
 219     return ptr->flags.no_block;
 220   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
 221     return ptr->flags.buffer_requests;
 222   case MEMCACHED_BEHAVIOR_USE_UDP:
 223     return ptr->flags.use_udp;
 224   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
 225     return ptr->flags.tcp_nodelay;
 226   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 227     return ptr->flags.verify_key;
 228   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 229     return ptr->flags.ketama_weighted;
 230   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
 231     return ptr->distribution;
 232   case MEMCACHED_BEHAVIOR_KETAMA:
 233     return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? (uint64_t) 1 : 0;
 234   case MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE:
 235     switch (ptr->distribution)
 236     {
 237     case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
 238       return MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED;
 239     case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY:
 240       return MEMCACHED_KETAMA_COMPAT_SPY;
 241     case MEMCACHED_DISTRIBUTION_MODULA:
 242     case MEMCACHED_DISTRIBUTION_CONSISTENT:
 243     case MEMCACHED_DISTRIBUTION_RANDOM:
 244     default:
 245       return (uint64_t)-1;
 246     }
 247     /* NOTREACHED */
 248   case MEMCACHED_BEHAVIOR_HASH:
 249     return ptr->hash;
 250   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 251     return ptr->hash_continuum;
 252   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
 253     return ptr->server_failure_limit;
 254   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 255     return ptr->flags.use_sort_hosts;
 256   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 257     return (uint64_t)ptr->poll_timeout;
 258   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 259     return (uint64_t)ptr->connect_timeout;
 260   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 261     return (uint64_t)ptr->retry_timeout;
 262   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
 263     return (uint64_t)ptr->snd_timeout;
 264   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
 265     return (uint64_t)ptr->rcv_timeout;
 266   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 267     {
 268       int sock_size;
 269       socklen_t sock_length= sizeof(int);
 270
 271       /* REFACTOR */
 272       /* We just try the first host, and if it is down we return zero */
 273       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 274         return 0;
 275
 276       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 277                      SO_SNDBUF, &sock_size, &sock_length))
 278         return 0; /* Zero means error */
 279
 280       return (uint64_t) sock_size;
 281     }
 282   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 283     {
 284       int sock_size;
 285       socklen_t sock_length= sizeof(int);
 286
 287       /* REFACTOR */
 288       /* We just try the first host, and if it is down we return zero */
 289       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 290         return 0;
 291
 292       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 293                      SO_RCVBUF, &sock_size, &sock_length))
 294         return 0; /* Zero means error */
 295
 296       return (uint64_t) sock_size;
 297     }
 298   case MEMCACHED_BEHAVIOR_USER_DATA:
 299     return MEMCACHED_FAILURE;
 300   case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
 301     return ptr->flags.hash_with_prefix_key;
 302   case MEMCACHED_BEHAVIOR_NOREPLY:
 303     return ptr->flags.no_reply;
 304   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
 305     return ptr->flags.auto_eject_hosts;
 306   case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
 307     return ptr->flags.randomize_replica_read;
 308   default:
 309     WATCHPOINT_ASSERT(flag);
 310     break;
 311   }
 312
 313   WATCHPOINT_ASSERT(0); /* Programming mistake if it gets this far */
 314   return 0;
 315 }