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