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