X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fhosts.c;h=67ba6d19829ba466be2a6ac9c0545e8e66d1ef9d;hb=82b419129b70ae58c92b087a99ae1757743f54d5;hp=ec12c92f9813e048d9aacf887611945b7497f7ce;hpb=3c11b74c0aa013a6afd492d46a8e9c911e12b350;p=awesomized%2Flibmemcached

diff --git a/libmemcached/hosts.c b/libmemcached/hosts.c
index ec12c92f..67ba6d19 100644
--- a/libmemcached/hosts.c
+++ b/libmemcached/hosts.c
@@ -17,6 +17,7 @@ static memcached_return_t server_add(memcached_st *ptr, const char *hostname,
                                      in_port_t port,
                                      uint32_t weight,
                                      memcached_connection_t type);
+
 static memcached_return_t update_continuum(memcached_st *ptr);
 
 static int compare_servers(const void *p1, const void *p2)
@@ -58,7 +59,9 @@ memcached_return_t run_distribution(memcached_st *ptr)
   case MEMCACHED_DISTRIBUTION_CONSISTENT:
   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY:
+  case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED:
     return update_continuum(ptr);
+  case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET:
   case MEMCACHED_DISTRIBUTION_MODULA:
     break;
   case MEMCACHED_DISTRIBUTION_RANDOM:
@@ -101,43 +104,37 @@ static int continuum_item_cmp(const void *t1, const void *t2)
 
 static memcached_return_t update_continuum(memcached_st *ptr)
 {
-  uint32_t host_index;
   uint32_t continuum_index= 0;
-  uint32_t value;
   memcached_server_st *list;
-  uint32_t pointer_index;
   uint32_t pointer_counter= 0;
   uint32_t pointer_per_server= MEMCACHED_POINTS_PER_SERVER;
   uint32_t pointer_per_hash= 1;
   uint64_t total_weight= 0;
-  uint64_t is_ketama_weighted= 0;
-  uint64_t is_auto_ejecting= 0;
-  uint32_t points_per_server= 0;
   uint32_t live_servers= 0;
   struct timeval now;
 
   if (gettimeofday(&now, NULL) != 0)
   {
-    ptr->cached_errno = errno;
+    memcached_set_errno(ptr, errno, NULL);
     return MEMCACHED_ERRNO;
   }
 
-  list = memcached_server_list(ptr);
+  list= memcached_server_list(ptr);
 
   /* count live servers (those without a retry delay set) */
-  is_auto_ejecting= _is_auto_eject_host(ptr);
+  bool is_auto_ejecting= _is_auto_eject_host(ptr);
   if (is_auto_ejecting)
   {
     live_servers= 0;
-    ptr->next_distribution_rebuild= 0;
-    for (host_index= 0; host_index < memcached_server_count(ptr); ++host_index)
+    ptr->ketama.next_distribution_rebuild= 0;
+    for (uint32_t host_index= 0; host_index < memcached_server_count(ptr); ++host_index)
     {
       if (list[host_index].next_retry <= now.tv_sec)
         live_servers++;
       else
       {
-        if (ptr->next_distribution_rebuild == 0 || list[host_index].next_retry < ptr->next_distribution_rebuild)
-          ptr->next_distribution_rebuild= list[host_index].next_retry;
+        if (ptr->ketama.next_distribution_rebuild == 0 || list[host_index].next_retry < ptr->ketama.next_distribution_rebuild)
+          ptr->ketama.next_distribution_rebuild= list[host_index].next_retry;
       }
     }
   }
@@ -146,29 +143,29 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     live_servers= memcached_server_count(ptr);
   }
 
-  is_ketama_weighted= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
-  points_per_server= (uint32_t) (is_ketama_weighted ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER);
+  uint64_t is_ketama_weighted= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+  uint32_t points_per_server= (uint32_t) (is_ketama_weighted ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER);
 
   if (live_servers == 0)
     return MEMCACHED_SUCCESS;
 
-  if (live_servers > ptr->continuum_count)
+  if (live_servers > ptr->ketama.continuum_count)
   {
     memcached_continuum_item_st *new_ptr;
 
-    new_ptr= libmemcached_realloc(ptr, ptr->continuum,
+    new_ptr= libmemcached_realloc(ptr, ptr->ketama.continuum,
                                   sizeof(memcached_continuum_item_st) * (live_servers + MEMCACHED_CONTINUUM_ADDITION) * points_per_server);
 
     if (new_ptr == 0)
       return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 
-    ptr->continuum= new_ptr;
-    ptr->continuum_count= live_servers + MEMCACHED_CONTINUUM_ADDITION;
+    ptr->ketama.continuum= new_ptr;
+    ptr->ketama.continuum_count= live_servers + MEMCACHED_CONTINUUM_ADDITION;
   }
 
   if (is_ketama_weighted)
   {
-    for (host_index = 0; host_index < memcached_server_count(ptr); ++host_index)
+    for (uint32_t host_index = 0; host_index < memcached_server_count(ptr); ++host_index)
     {
       if (list[host_index].weight == 0)
       {
@@ -179,7 +176,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     }
   }
 
-  for (host_index= 0; host_index < memcached_server_count(ptr); ++host_index)
+  for (uint32_t host_index= 0; host_index < memcached_server_count(ptr); ++host_index)
   {
     if (is_auto_ejecting && list[host_index].next_retry > now.tv_sec)
       continue;
@@ -201,7 +198,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
 
     if (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY)
     {
-      for (pointer_index= 0;
+      for (uint32_t pointer_index= 0;
            pointer_index < pointer_per_server / pointer_per_hash;
            pointer_index++)
       {
@@ -230,22 +227,22 @@ static memcached_return_t update_continuum(memcached_st *ptr)
         {
           for (uint32_t x= 0; x < pointer_per_hash; x++)
           {
-             value= ketama_server_hash(sort_host, (size_t)sort_host_length, x);
-             ptr->continuum[continuum_index].index= host_index;
-             ptr->continuum[continuum_index++].value= value;
+            uint32_t value= ketama_server_hash(sort_host, (size_t)sort_host_length, x);
+             ptr->ketama.continuum[continuum_index].index= host_index;
+             ptr->ketama.continuum[continuum_index++].value= value;
           }
         }
         else
         {
-          value= hashkit_digest(&ptr->distribution_hashkit, sort_host, (size_t)sort_host_length);
-          ptr->continuum[continuum_index].index= host_index;
-          ptr->continuum[continuum_index++].value= value;
+          uint32_t value= hashkit_digest(&ptr->distribution_hashkit, sort_host, (size_t)sort_host_length);
+          ptr->ketama.continuum[continuum_index].index= host_index;
+          ptr->ketama.continuum[continuum_index++].value= value;
         }
       }
     }
     else
     {
-      for (pointer_index= 1;
+      for (uint32_t pointer_index= 1;
            pointer_index <= pointer_per_server / pointer_per_hash;
            pointer_index++)
       {
@@ -279,16 +276,16 @@ static memcached_return_t update_continuum(memcached_st *ptr)
         {
           for (uint32_t x = 0; x < pointer_per_hash; x++)
           {
-             value= ketama_server_hash(sort_host, (size_t)sort_host_length, x);
-             ptr->continuum[continuum_index].index= host_index;
-             ptr->continuum[continuum_index++].value= value;
+             uint32_t value= ketama_server_hash(sort_host, (size_t)sort_host_length, x);
+             ptr->ketama.continuum[continuum_index].index= host_index;
+             ptr->ketama.continuum[continuum_index++].value= value;
           }
         }
         else
         {
-          value= hashkit_digest(&ptr->distribution_hashkit, sort_host, (size_t)sort_host_length);
-          ptr->continuum[continuum_index].index= host_index;
-          ptr->continuum[continuum_index++].value= value;
+          uint32_t value= hashkit_digest(&ptr->distribution_hashkit, sort_host, (size_t)sort_host_length);
+          ptr->ketama.continuum[continuum_index].index= host_index;
+          ptr->ketama.continuum[continuum_index++].value= value;
         }
       }
     }
@@ -299,11 +296,11 @@ static memcached_return_t update_continuum(memcached_st *ptr)
   WATCHPOINT_ASSERT(ptr);
   WATCHPOINT_ASSERT(ptr->continuum);
   WATCHPOINT_ASSERT(memcached_server_count(ptr) * MEMCACHED_POINTS_PER_SERVER <= MEMCACHED_CONTINUUM_SIZE);
-  ptr->continuum_points_counter= pointer_counter;
-  qsort(ptr->continuum, ptr->continuum_points_counter, sizeof(memcached_continuum_item_st), continuum_item_cmp);
+  ptr->ketama.continuum_points_counter= pointer_counter;
+  qsort(ptr->ketama.continuum, ptr->ketama.continuum_points_counter, sizeof(memcached_continuum_item_st), continuum_item_cmp);
 
 #ifdef DEBUG
-  for (pointer_index= 0; memcached_server_count(ptr) && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++)
+  for (uint32_t pointer_index= 0; memcached_server_count(ptr) && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++)
   {
     WATCHPOINT_ASSERT(ptr->continuum[pointer_index].value <= ptr->continuum[pointer_index + 1].value);
   }
@@ -337,7 +334,9 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
     if ((ptr->flags.use_udp && list[x].type != MEMCACHED_CONNECTION_UDP)
             || ((list[x].type == MEMCACHED_CONNECTION_UDP)
             && ! (ptr->flags.use_udp)) )
+    {
       return MEMCACHED_INVALID_HOST_PROTOCOL;
+    }
 
     WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
 
@@ -447,3 +446,20 @@ static memcached_return_t server_add(memcached_st *ptr, const char *hostname,
 
   return run_distribution(ptr);
 }
+
+memcached_return_t memcached_server_add_parsed(memcached_st *ptr,
+                                               const char *hostname,
+                                               size_t hostname_length,
+                                               in_port_t port,
+                                               uint32_t weight)
+{
+  char buffer[NI_MAXHOST];
+
+  memcpy(buffer, hostname, hostname_length);
+  buffer[hostname_length]= 0;
+
+  return server_add(ptr, buffer,
+                    port,
+                    weight,
+                    MEMCACHED_CONNECTION_TCP);
+}