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