First merge of Trond's patches (cherry picking).

[m6w6/libmemcached] / libmemcached / memcached_hosts.c

diff --git a/libmemcached/memcached_hosts.c b/libmemcached/memcached_hosts.c
index d664ab2b5a7b0e7eefa89d88f2b5f28e1d9971be..8cc5f3e612bec72a9641e132bf0d9aa50ead2308 100644 (file)
--- a/libmemcached/memcached_hosts.c
+++ b/libmemcached/memcached_hosts.c
@@ -2,11 +2,11 @@
 #include <math.h>
 
 /* Protoypes (static) */
-static memcached_return server_add(memcached_st *ptr, const char *hostname,
-                                   unsigned int port,
-                                   uint32_t weight,
-                                   memcached_connection type);
-memcached_return update_continuum(memcached_st *ptr);
+static memcached_return_t server_add(memcached_st *ptr, const char *hostname,
+                                     in_port_t port,
+                                     uint32_t weight,
+                                     memcached_connection_t type);
+memcached_return_t update_continuum(memcached_st *ptr);
 
 static int compare_servers(const void *p1, const void *p2)
 {
@@ -34,15 +34,16 @@ static void sort_hosts(memcached_st *ptr)
 }
 
 
-memcached_return run_distribution(memcached_st *ptr)
+memcached_return_t run_distribution(memcached_st *ptr)
 {
   switch (ptr->distribution)
   {
   case MEMCACHED_DISTRIBUTION_CONSISTENT:
   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
+  case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY:
     return update_continuum(ptr);
   case MEMCACHED_DISTRIBUTION_MODULA:
-    if (ptr->flags & MEM_USE_SORT_HOSTS)
+    if (ptr->flags.use_sort_hosts)
       sort_hosts(ptr);
     break;
   case MEMCACHED_DISTRIBUTION_RANDOM:
@@ -102,7 +103,7 @@ static int continuum_item_cmp(const void *t1, const void *t2)
     return -1;
 }
 
-memcached_return update_continuum(memcached_st *ptr)
+memcached_return_t update_continuum(memcached_st *ptr)
 {
   uint32_t host_index;
   uint32_t continuum_index= 0;
@@ -198,47 +199,93 @@ memcached_return update_continuum(memcached_st *ptr)
                pointer_per_server);
 #endif
     }
-    for (pointer_index= 1;
-         pointer_index <= pointer_per_server / pointer_per_hash;
-         ++pointer_index)
-    {
-      char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
-      size_t sort_host_length;
 
-      if (list[host_index].port == MEMCACHED_DEFAULT_PORT)
-      {
-        sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
-                                            "%s-%d",
-                                            list[host_index].hostname,
-                                            pointer_index - 1);
 
-      }
-      else
+    if (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY)
+    {
+      for (pointer_index= 0;
+           pointer_index < pointer_per_server / pointer_per_hash;
+           pointer_index++)
       {
+        char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
+        size_t sort_host_length;
+
+        // Spymemcached ketema key format is: hostname/ip:port-index
+        // If hostname is not available then: /ip:port-index
         sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
-                                            "%s:%d-%d",
+                                            "/%s:%d-%d",
                                             list[host_index].hostname,
-                                            list[host_index].port, pointer_index - 1);
-      }
-      WATCHPOINT_ASSERT(sort_host_length);
+                                            list[host_index].port,
+                                            pointer_index);
+#ifdef DEBUG
+        printf("update_continuum: key is %s\n", sort_host);
+#endif
 
-      if (is_ketama_weighted)
-      {
-        unsigned int i;
-        for (i = 0; i < pointer_per_hash; i++)
+        WATCHPOINT_ASSERT(sort_host_length);
+
+        if (is_ketama_weighted)
+        {
+          unsigned int i;
+          for (i = 0; i < pointer_per_hash; i++)
+          {
+             value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i);
+             ptr->continuum[continuum_index].index= host_index;
+             ptr->continuum[continuum_index++].value= value;
+          }
+        }
+        else
         {
-          value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i);
+          value= memcached_generate_hash_value(sort_host, sort_host_length, ptr->hash_continuum);
           ptr->continuum[continuum_index].index= host_index;
           ptr->continuum[continuum_index++].value= value;
         }
       }
-      else
+    }
+    else
+    {
+      for (pointer_index= 1;
+           pointer_index <= pointer_per_server / pointer_per_hash;
+           pointer_index++)
       {
-        value= memcached_generate_hash_value(sort_host, sort_host_length, ptr->hash_continuum);
-        ptr->continuum[continuum_index].index= host_index;
-        ptr->continuum[continuum_index++].value= value;
+        char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
+        size_t sort_host_length;
+
+        if (list[host_index].port == MEMCACHED_DEFAULT_PORT)
+        {
+          sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
+                                              "%s-%d",
+                                              list[host_index].hostname,
+                                              pointer_index - 1);
+        }
+        else
+        {
+          sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
+                                              "%s:%d-%d",
+                                              list[host_index].hostname,
+                                              list[host_index].port, pointer_index - 1);
+        }
+
+        WATCHPOINT_ASSERT(sort_host_length);
+
+        if (is_ketama_weighted)
+        {
+          unsigned int i;
+          for (i = 0; i < pointer_per_hash; i++)
+          {
+             value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i);
+             ptr->continuum[continuum_index].index= host_index;
+             ptr->continuum[continuum_index++].value= value;
+          }
+        }
+        else
+        {
+          value= memcached_generate_hash_value(sort_host, sort_host_length, ptr->hash_continuum);
+          ptr->continuum[continuum_index].index= host_index;
+          ptr->continuum[continuum_index++].value= value;
+        }
       }
     }
+
     pointer_counter+= pointer_per_server;
   }
 
@@ -259,7 +306,7 @@ memcached_return update_continuum(memcached_st *ptr)
 }
 
 
-memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list)
+memcached_return_t memcached_server_push(memcached_st *ptr, memcached_server_st *list)
 {
   unsigned int x;
   uint16_t count;
@@ -279,9 +326,9 @@ memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *l
 
   for (x= 0; x < count; x++)
   {
-    if ((ptr->flags & MEM_USE_UDP && list[x].type != MEMCACHED_CONNECTION_UDP)
+    if ((ptr->flags.use_udp && list[x].type != MEMCACHED_CONNECTION_UDP)
             || ((list[x].type == MEMCACHED_CONNECTION_UDP)
-            && ! (ptr->flags & MEM_USE_UDP)) )
+            && ! (ptr->flags.use_udp)) )
       return MEMCACHED_INVALID_HOST_PROTOCOL;
 
     WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
@@ -296,15 +343,15 @@ memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *l
   return run_distribution(ptr);
 }
 
-memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
-                                                  const char *filename)
+memcached_return_t memcached_server_add_unix_socket(memcached_st *ptr,
+                                                    const char *filename)
 {
   return memcached_server_add_unix_socket_with_weight(ptr, filename, 0);
 }
 
-memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
-                                                              const char *filename,
-                                                              uint32_t weight)
+memcached_return_t memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
+                                                                const char *filename,
+                                                                uint32_t weight)
 {
   if (!filename)
     return MEMCACHED_FAILURE;
@@ -312,17 +359,17 @@ memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
   return server_add(ptr, filename, 0, weight, MEMCACHED_CONNECTION_UNIX_SOCKET);
 }
 
-memcached_return memcached_server_add_udp(memcached_st *ptr,
-                                          const char *hostname,
-                                          unsigned int port)
+memcached_return_t memcached_server_add_udp(memcached_st *ptr,
+                                            const char *hostname,
+                                            in_port_t port)
 {
   return memcached_server_add_udp_with_weight(ptr, hostname, port, 0);
 }
 
-memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
-                                                      const char *hostname,
-                                                      unsigned int port,
-                                                      uint32_t weight)
+memcached_return_t memcached_server_add_udp_with_weight(memcached_st *ptr,
+                                                        const char *hostname,
+                                                        in_port_t port,
+                                                        uint32_t weight)
 {
   if (!port)
     port= MEMCACHED_DEFAULT_PORT;
@@ -333,17 +380,17 @@ memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
   return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_UDP);
 }
 
-memcached_return memcached_server_add(memcached_st *ptr,
-                                      const char *hostname,
-                                      unsigned int port)
+memcached_return_t memcached_server_add(memcached_st *ptr,
+                                        const char *hostname,
+                                        in_port_t port)
 {
   return memcached_server_add_with_weight(ptr, hostname, port, 0);
 }
 
-memcached_return memcached_server_add_with_weight(memcached_st *ptr,
-                                                  const char *hostname,
-                                                  unsigned int port,
-                                                  uint32_t weight)
+memcached_return_t memcached_server_add_with_weight(memcached_st *ptr,
+                                                    const char *hostname,
+                                                    in_port_t port,
+                                                    uint32_t weight)
 {
   if (!port)
     port= MEMCACHED_DEFAULT_PORT;
@@ -354,15 +401,15 @@ memcached_return memcached_server_add_with_weight(memcached_st *ptr,
   return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_TCP);
 }
 
-static memcached_return server_add(memcached_st *ptr, const char *hostname,
-                                   unsigned int port,
-                                   uint32_t weight,
-                                   memcached_connection type)
+static memcached_return_t server_add(memcached_st *ptr, const char *hostname,
+                                     in_port_t port,
+                                     uint32_t weight,
+                                     memcached_connection_t type)
 {
   memcached_server_st *new_host_list;
 
-  if ( (ptr->flags & MEM_USE_UDP && type != MEMCACHED_CONNECTION_UDP)
-      || ( (type == MEMCACHED_CONNECTION_UDP) && !(ptr->flags & MEM_USE_UDP) ) )
+  if ( (ptr->flags.use_udp && type != MEMCACHED_CONNECTION_UDP)
+      || ( (type == MEMCACHED_CONNECTION_UDP) && (! ptr->flags.use_udp) ) )
     return MEMCACHED_INVALID_HOST_PROTOCOL;
 
   new_host_list= ptr->call_realloc(ptr, ptr->hosts,
@@ -381,7 +428,7 @@ static memcached_return server_add(memcached_st *ptr, const char *hostname,
   return run_distribution(ptr);
 }
 
-memcached_return memcached_server_remove(memcached_server_st *st_ptr)
+memcached_return_t memcached_server_remove(memcached_server_st *st_ptr)
 {
   uint32_t x, host_index;
   memcached_st *ptr= st_ptr->root;
@@ -409,16 +456,16 @@ memcached_return memcached_server_remove(memcached_server_st *st_ptr)
 }
 
 memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
-                                                  const char *hostname, unsigned int port,
-                                                  memcached_return *error)
+                                                  const char *hostname, in_port_t port,
+                                                  memcached_return_t *error)
 {
   return memcached_server_list_append_with_weight(ptr, hostname, port, 0, error);
 }
 
 memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
-                                                              const char *hostname, unsigned int port,
+                                                              const char *hostname, in_port_t port,
                                                               uint32_t weight,
-                                                              memcached_return *error)
+                                                              memcached_return_t *error)
 {
   unsigned int count;
   memcached_server_st *new_host_list;