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