Uncrustify

[m6w6/libmemcached] / libmemcached / memcached_behavior.c

diff --git a/libmemcached/memcached_behavior.c b/libmemcached/memcached_behavior.c
index e8f65ddf6eb3a23d45c20feb47045600dff1d5d4..72b0d5ccada8418f613fee07248e1cffec0b74ea 100644 (file)
--- a/libmemcached/memcached_behavior.c
+++ b/libmemcached/memcached_behavior.c
@@ -1,10 +1,10 @@
-#include "common.h" 
+#include "common.h"

 #include <time.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/tcp.h>
 
 #include <time.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/tcp.h>
 

-/* 
+/*

   This function is used to modify the behavior of running client.
 
   We quit all connections so we can reset the sockets.
   This function is used to modify the behavior of running client.
 
   We quit all connections so we can reset the sockets.


@@ -18,38 +18,45 @@ static void set_behavior_flag(memcached_st *ptr, memcached_flags temp_flag, uint
     ptr->flags&= ~temp_flag;
 }
 
     ptr->flags&= ~temp_flag;
 }
 

-memcached_return memcached_behavior_set(memcached_st *ptr, 
-                                        memcached_behavior flag, 
+memcached_return memcached_behavior_set(memcached_st *ptr,
+                                        memcached_behavior flag,

                                         uint64_t data)
 {
   switch (flag)
   {
                                         uint64_t data)
 {
   switch (flag)
   {

+  case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
+    ptr->number_of_replicas= (uint32_t)data;
+    break;

   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:

-    ptr->io_msg_watermark= (int32_t)data;
+    ptr->io_msg_watermark= (uint32_t) data;

     break;
   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
     break;
   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:

-    ptr->io_bytes_watermark= (int32_t)data;
+    ptr->io_bytes_watermark= (uint32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
+    ptr->io_key_prefetch = (uint32_t)data;

     break;
   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
     ptr->snd_timeout= (int32_t)data;
     break;
   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
     ptr->snd_timeout= (int32_t)data;

-    break;     
+    break;

   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
     ptr->rcv_timeout= (int32_t)data;
   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
     ptr->rcv_timeout= (int32_t)data;

-    break;     
+    break;

   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
     ptr->server_failure_limit= (uint32_t)data;
   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
     ptr->server_failure_limit= (uint32_t)data;

-    break;     
+    break;

   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
     if (data)
         set_behavior_flag(ptr, MEM_VERIFY_KEY, 0);
     set_behavior_flag(ptr, MEM_BINARY_PROTOCOL, data);
   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
     if (data)
         set_behavior_flag(ptr, MEM_VERIFY_KEY, 0);
     set_behavior_flag(ptr, MEM_BINARY_PROTOCOL, data);

-    break;     
+    break;

   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
     set_behavior_flag(ptr, MEM_SUPPORT_CAS, data);
     break;
   case MEMCACHED_BEHAVIOR_NO_BLOCK:
     set_behavior_flag(ptr, MEM_NO_BLOCK, data);
     memcached_quit(ptr);
   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
     set_behavior_flag(ptr, MEM_SUPPORT_CAS, data);
     break;
   case MEMCACHED_BEHAVIOR_NO_BLOCK:
     set_behavior_flag(ptr, MEM_NO_BLOCK, data);
     memcached_quit(ptr);

+    break;

   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
     set_behavior_flag(ptr, MEM_BUFFER_REQUESTS, data);
     memcached_quit(ptr);
   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
     set_behavior_flag(ptr, MEM_BUFFER_REQUESTS, data);
     memcached_quit(ptr);


@@ -70,7 +77,7 @@ memcached_return memcached_behavior_set(memcached_st *ptr,
       ptr->distribution= (memcached_server_distribution)(data);
       if (ptr->distribution == MEMCACHED_DISTRIBUTION_RANDOM)
       {
       ptr->distribution= (memcached_server_distribution)(data);
       if (ptr->distribution == MEMCACHED_DISTRIBUTION_RANDOM)
       {

-        srandom(time(NULL));
+        srandom((uint32_t) time(NULL));

       }
       run_distribution(ptr);
       break;
       }
       run_distribution(ptr);
       break;


@@ -98,7 +105,27 @@ memcached_return memcached_behavior_set(memcached_st *ptr,
       run_distribution(ptr);
       break;
     }
       run_distribution(ptr);
       break;
     }

+  case MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE:
+    switch (data)
+    {
+    case MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED:
+      ptr->hash= MEMCACHED_HASH_MD5;
+      ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
+      break;
+    case MEMCACHED_KETAMA_COMPAT_SPY:
+      ptr->hash= MEMCACHED_HASH_MD5;
+      ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY;
+      break;
+    default:
+       return MEMCACHED_FAILURE;
+    }
+    run_distribution(ptr);
+    break;

   case MEMCACHED_BEHAVIOR_HASH:
   case MEMCACHED_BEHAVIOR_HASH:

+#ifndef HAVE_HSIEH_HASH
+    if ((memcached_hash)(data) == MEMCACHED_HASH_HSIEH)
+      return MEMCACHED_FAILURE;
+#endif

     ptr->hash= (memcached_hash)(data);
     break;
   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
     ptr->hash= (memcached_hash)(data);
     break;
   case MEMCACHED_BEHAVIOR_KETAMA_HASH:


@@ -145,26 +172,37 @@ memcached_return memcached_behavior_set(memcached_st *ptr,
     break;
   case MEMCACHED_BEHAVIOR_NOREPLY:
     set_behavior_flag(ptr, MEM_NOREPLY, data);
     break;
   case MEMCACHED_BEHAVIOR_NOREPLY:
     set_behavior_flag(ptr, MEM_NOREPLY, data);

-    break;     
+    break;
+  case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
+    set_behavior_flag(ptr, MEM_AUTO_EJECT_HOSTS, data);
+    break;
+  default:
+    /* Shouldn't get here */
+    WATCHPOINT_ASSERT(flag);
+    break;

   }
 
   return MEMCACHED_SUCCESS;
 }
 
   }
 
   return MEMCACHED_SUCCESS;
 }
 

-uint64_t memcached_behavior_get(memcached_st *ptr, 
+uint64_t memcached_behavior_get(memcached_st *ptr,

                                 memcached_behavior flag)
 {
                                 memcached_behavior flag)
 {

-  memcached_flags temp_flag= 0;
+  memcached_flags temp_flag= MEM_NO_BLOCK;

 
   switch (flag)
   {
 
   switch (flag)
   {

+  case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
+    return ptr->number_of_replicas;

   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
     return ptr->io_msg_watermark;
   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
     return ptr->io_bytes_watermark;
   case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
     return ptr->io_msg_watermark;
   case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
     return ptr->io_bytes_watermark;

+  case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
+    return ptr->io_key_prefetch;

   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
     temp_flag= MEM_BINARY_PROTOCOL;
   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
     temp_flag= MEM_BINARY_PROTOCOL;

-    break;     
+    break;

   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
     temp_flag= MEM_SUPPORT_CAS;
     break;
   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
     temp_flag= MEM_SUPPORT_CAS;
     break;


@@ -192,7 +230,18 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
     return ptr->distribution;
   case MEMCACHED_BEHAVIOR_KETAMA:
   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
     return ptr->distribution;
   case MEMCACHED_BEHAVIOR_KETAMA:

-    return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? 1 : 0;
+    return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? (uint64_t) 1 : 0;
+  case MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE:
+    switch (ptr->distribution)
+    {
+    case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
+      return MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED;
+    case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY:
+      return MEMCACHED_KETAMA_COMPAT_SPY;
+    default:
+      return (uint64_t)-1;
+    }
+    /* NOTREACHED */

   case MEMCACHED_BEHAVIOR_HASH:
     return ptr->hash;
   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
   case MEMCACHED_BEHAVIOR_HASH:
     return ptr->hash;
   case MEMCACHED_BEHAVIOR_KETAMA_HASH:


@@ -203,17 +252,11 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
     temp_flag= MEM_USE_SORT_HOSTS;
     break;
   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
     temp_flag= MEM_USE_SORT_HOSTS;
     break;
   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:

-    {
-      return (uint64_t)ptr->poll_timeout;
-    }
+    return (uint64_t)ptr->poll_timeout;

   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:

-    {
-      return (uint64_t)ptr->connect_timeout;
-    }
+    return (uint64_t)ptr->connect_timeout;

   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:

-    {
-      return (uint64_t)ptr->retry_timeout;
-    }
+    return (uint64_t)ptr->retry_timeout;

   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
     return (uint64_t)ptr->snd_timeout;
   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
     return (uint64_t)ptr->snd_timeout;
   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:


@@ -228,11 +271,11 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
         return 0;
 
       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
         return 0;
 

-      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET, 
+      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,

                      SO_SNDBUF, &sock_size, &sock_length))
         return 0; /* Zero means error */
 
                      SO_SNDBUF, &sock_size, &sock_length))
         return 0; /* Zero means error */
 

-      return sock_size;
+      return (uint64_t) sock_size;

     }
   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
     {
     }
   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
     {


@@ -244,11 +287,11 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
         return 0;
 
       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
         return 0;
 

-      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET, 
+      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,

                      SO_RCVBUF, &sock_size, &sock_length))
         return 0; /* Zero means error */
 
                      SO_RCVBUF, &sock_size, &sock_length))
         return 0; /* Zero means error */
 

-      return sock_size;
+      return (uint64_t) sock_size;

     }
   case MEMCACHED_BEHAVIOR_USER_DATA:
     return MEMCACHED_FAILURE;
     }
   case MEMCACHED_BEHAVIOR_USER_DATA:
     return MEMCACHED_FAILURE;


@@ -258,6 +301,12 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
   case MEMCACHED_BEHAVIOR_NOREPLY:
     temp_flag= MEM_NOREPLY;
     break;
   case MEMCACHED_BEHAVIOR_NOREPLY:
     temp_flag= MEM_NOREPLY;
     break;

+  case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
+    temp_flag= MEM_AUTO_EJECT_HOSTS;
+    break;
+  default:
+    WATCHPOINT_ASSERT(flag);
+    break;

   }
 
   WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */
   }
 
   WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */