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