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

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