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

   1 #include "common.h"
   2 #include <sys/types.h>
   3 #include <sys/socket.h>
   4 #include <netinet/tcp.h>
   5
   6 /*
   7   This function is used to modify the behabior of running client.
   8
   9   We quit all connections so we can reset the sockets.
  10 */
  11
  12 void set_behavior_flag(memcached_st *ptr, memcached_flags temp_flag, uint64_t data)
  13 {
  14   if (data)
  15     ptr->flags|= temp_flag;
  16   else
  17     ptr->flags&= ~temp_flag;
  18 }
  19
  20 memcached_return memcached_behavior_set(memcached_st *ptr,
  21                                         memcached_behavior flag,
  22                                         uint64_t data)
  23 {
  24   switch (flag)
  25   {
  26   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
  27     ptr->snd_timeout= (int32_t)data;
  28     break;
  29   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
  30     ptr->rcv_timeout= (int32_t)data;
  31     break;
  32   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
  33     set_behavior_flag(ptr, MEM_BINARY_PROTOCOL, data);
  34     break;
  35   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
  36     set_behavior_flag(ptr, MEM_SUPPORT_CAS, data);
  37     break;
  38   case MEMCACHED_BEHAVIOR_NO_BLOCK:
  39     set_behavior_flag(ptr, MEM_NO_BLOCK, data);
  40     memcached_quit(ptr);
  41   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
  42     set_behavior_flag(ptr, MEM_BUFFER_REQUESTS, data);
  43     memcached_quit(ptr);
  44     break;
  45   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
  46     set_behavior_flag(ptr, MEM_TCP_NODELAY, data);
  47     memcached_quit(ptr);
  48     break;
  49   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
  50     {
  51       ptr->distribution= (memcached_server_distribution)(data);
  52       run_distribution(ptr);
  53       break;
  54     }
  55   case MEMCACHED_BEHAVIOR_KETAMA:
  56     {
  57       if (data)
  58       {
  59         ptr->hash= MEMCACHED_HASH_MD5;
  60         ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
  61       }
  62       else
  63       {
  64         ptr->hash= 0;
  65         ptr->distribution= 0;
  66       }
  67       run_distribution(ptr);
  68       break;
  69     }
  70   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
  71     {
  72       ptr->hash= MEMCACHED_HASH_MD5;
  73       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
  74       set_behavior_flag(ptr, MEM_KETAMA_WEIGHTED, data);
  75       run_distribution(ptr);
  76       break;
  77     }
  78   case MEMCACHED_BEHAVIOR_HASH:
  79     ptr->hash= (memcached_hash)(data);
  80     break;
  81   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
  82     ptr->hash_continuum= (memcached_hash)(data);
  83     run_distribution(ptr);
  84     break;
  85   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
  86     set_behavior_flag(ptr, MEM_USE_CACHE_LOOKUPS, data);
  87     memcached_quit(ptr);
  88     break;
  89   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
  90     set_behavior_flag(ptr, MEM_VERIFY_KEY, data);
  91     break;
  92   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
  93     {
  94       set_behavior_flag(ptr, MEM_USE_SORT_HOSTS, data);
  95       run_distribution(ptr);
  96
  97       break;
  98     }
  99   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 100     ptr->poll_timeout= (int32_t)data;
 101     break;
 102   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 103     ptr->connect_timeout= (int32_t)data;
 104     break;
 105   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 106     ptr->retry_timeout= (int32_t)data;
 107     break;
 108   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 109     ptr->send_size= (int32_t)data;
 110     memcached_quit(ptr);
 111     break;
 112   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 113     ptr->recv_size= (int32_t)data;
 114     memcached_quit(ptr);
 115     break;
 116   case MEMCACHED_BEHAVIOR_USER_DATA:
 117     return MEMCACHED_FAILURE;
 118   }
 119
 120   return MEMCACHED_SUCCESS;
 121 }
 122
 123 uint64_t memcached_behavior_get(memcached_st *ptr,
 124                                 memcached_behavior flag)
 125 {
 126   memcached_flags temp_flag= 0;
 127
 128   switch (flag)
 129   {
 130   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
 131     temp_flag= MEM_BINARY_PROTOCOL;
 132     break;
 133   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
 134     temp_flag= MEM_SUPPORT_CAS;
 135     break;
 136   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 137     temp_flag= MEM_USE_CACHE_LOOKUPS;
 138     break;
 139   case MEMCACHED_BEHAVIOR_NO_BLOCK:
 140     temp_flag= MEM_NO_BLOCK;
 141     break;
 142   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
 143     temp_flag= MEM_BUFFER_REQUESTS;
 144     break;
 145   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
 146     temp_flag= MEM_TCP_NODELAY;
 147     break;
 148   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 149     temp_flag= MEM_VERIFY_KEY;
 150     break;
 151   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 152     temp_flag= MEM_KETAMA_WEIGHTED;
 153     break;
 154   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
 155     return ptr->distribution;
 156   case MEMCACHED_BEHAVIOR_KETAMA:
 157     return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? 1 : 0;
 158   case MEMCACHED_BEHAVIOR_HASH:
 159     return ptr->hash;
 160   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 161     return ptr->hash_continuum;
 162   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 163     temp_flag= MEM_USE_SORT_HOSTS;
 164     break;
 165   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 166     {
 167       return (unsigned long long)ptr->poll_timeout;
 168     }
 169   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 170     {
 171       return (unsigned long long)ptr->connect_timeout;
 172     }
 173   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 174     {
 175       return (unsigned long long)ptr->retry_timeout;
 176     }
 177   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 178     {
 179       int sock_size;
 180       socklen_t sock_length= sizeof(int);
 181
 182       /* REFACTOR */
 183       /* We just try the first host, and if it is down we return zero */
 184       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 185         return 0;
 186
 187       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 188                      SO_SNDBUF, &sock_size, &sock_length))
 189         return 0; /* Zero means error */
 190
 191       return sock_size;
 192     }
 193   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 194     {
 195       int sock_size;
 196       socklen_t sock_length= sizeof(int);
 197
 198       /* REFACTOR */
 199       /* We just try the first host, and if it is down we return zero */
 200       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 201         return 0;
 202
 203       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 204                      SO_RCVBUF, &sock_size, &sock_length))
 205         return 0; /* Zero means error */
 206
 207       return sock_size;
 208     }
 209   case MEMCACHED_BEHAVIOR_USER_DATA:
 210     return MEMCACHED_FAILURE;
 211   }
 212
 213   WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */
 214   if (ptr->flags & temp_flag)
 215     return 1;
 216   else
 217     return 0;
 218
 219   return MEMCACHED_SUCCESS;
 220 }