Fix for lp:1062704

[awesomized/libmemcached] / libmemcached / hosts.cc

diff --git a/libmemcached/hosts.cc b/libmemcached/hosts.cc
index dbfba007bd8d93c9c4d2e648e19e67da4ceab69b..62b362ad7fee39eb9eed189f1fc14d8d732c9b0b 100644 (file)
--- a/libmemcached/hosts.cc
+++ b/libmemcached/hosts.cc
@@ -62,10 +62,7 @@ static void sort_hosts(memcached_st *ptr)
 {
   if (memcached_server_count(ptr))
   {
-
     qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(org::libmemcached::Instance), compare_servers);
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
-    instance->number_of_hosts= memcached_server_count(ptr);
   }
 }
 
@@ -121,11 +118,17 @@ static int continuum_item_cmp(const void *t1, const void *t2)
   /* Why 153? Hmmm... */
   WATCHPOINT_ASSERT(ct1->value != 153);
   if (ct1->value == ct2->value)
+  {
     return 0;
+  }
   else if (ct1->value > ct2->value)
+  {
     return 1;
+  }
   else
+  {
     return -1;
+  }
 }
 
 static memcached_return_t update_continuum(memcached_st *ptr)
@@ -170,8 +173,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     live_servers= memcached_server_count(ptr);
   }
 
-  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);
+  uint32_t points_per_server= (uint32_t) (memcached_is_weighted_ketama(ptr) ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER);
 
   if (live_servers == 0)
   {
@@ -194,7 +196,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
   }
 
   uint64_t total_weight= 0;
-  if (is_ketama_weighted)
+  if (memcached_is_weighted_ketama(ptr))
   {
     for (uint32_t host_index = 0; host_index < memcached_server_count(ptr); ++host_index)
     {
@@ -212,7 +214,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
       continue;
     }
 
-    if (is_ketama_weighted)
+    if (memcached_is_weighted_ketama(ptr))
     {
         float pct= (float)list[host_index].weight / (float)total_weight;
         pointer_per_server= (uint32_t) ((::floor((float) (pct * MEMCACHED_POINTS_PER_SERVER_KETAMA / 4 * (float)live_servers + 0.0000000001))) * 4);
@@ -256,7 +258,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
           fprintf(stdout, "update_continuum: key is %s\n", sort_host);
         }
 
-        if (is_ketama_weighted)
+        if (memcached_is_weighted_ketama(ptr))
         {
           for (uint32_t x= 0; x < pointer_per_hash; x++)
           {
@@ -304,7 +306,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
                                      memcached_literal_param("snprintf(sizeof(sort_host)))"));
         }
 
-        if (is_ketama_weighted)
+        if (memcached_is_weighted_ketama(ptr))
         {
           for (uint32_t x = 0; x < pointer_per_hash; x++)
           {
@@ -350,17 +352,29 @@ static memcached_return_t server_add(memcached_st *ptr,
 {
   assert_msg(ptr, "Programmer mistake, somehow server_add() was passed a NULL memcached_st");
 
-  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (ptr->number_of_hosts + 1), org::libmemcached::Instance);
+  if (ptr->number_of_hosts)
+  {
+    assert(memcached_instance_list(ptr));
+  }
+
+  if (memcached_instance_list(ptr))
+  {
+    assert(ptr->number_of_hosts);
+  }
+
+  uint32_t host_list_size= ptr->number_of_hosts +1;
+  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance);
 
   if (new_host_list == NULL)
   {
     return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
   }
 
-  memcached_instance_set(ptr, new_host_list);
+  memcached_instance_set(ptr, new_host_list, host_list_size);
+  assert(ptr->number_of_hosts == host_list_size);
 
   /* TODO: Check return type */
-  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, memcached_server_count(ptr));
+  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, memcached_server_count(ptr) -1);
 
   if (__instance_create_with(ptr, instance, hostname, port, weight, type) == NULL)
   {
@@ -369,15 +383,12 @@ static memcached_return_t server_add(memcached_st *ptr,
 
   if (weight > 1)
   {
-    ptr->ketama.weighted= true;
+    if (memcached_is_consistent_distribution(ptr))
+    {
+      memcached_set_weighted_ketama(ptr, true);
+    }
   }
 
-  ptr->number_of_hosts++;
-
-  // @note we place the count in the bottom of the server list
-  instance= memcached_instance_fetch(ptr, 0);
-  memcached_instance_set_count(instance, memcached_server_count(ptr));
-
   return run_distribution(ptr);
 }
 
@@ -389,23 +400,26 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
     return MEMCACHED_SUCCESS;
   }
 
+  uint32_t original_host_size= memcached_server_count(ptr);
   uint32_t count= memcached_server_list_count(list);
+  uint32_t host_list_size= count +original_host_size;
 
-  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (count + memcached_server_count(ptr)), org::libmemcached::Instance);
+  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance);
 
   if (new_host_list == NULL)
   {
     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
   }
 
-  memcached_instance_set(ptr, new_host_list);
+  memcached_instance_set(ptr, new_host_list, host_list_size);
 
-  for (uint32_t x= 0; x < count; x++)
+  ptr->state.is_parsing= true;
+  for (uint32_t x= 0; x < count; ++x, ++original_host_size)
   {
     WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
 
     // We have extended the array, and now we will find it, and use it.
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, memcached_server_count(ptr));
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size);
     WATCHPOINT_ASSERT(instance);
 
     memcached_string_t hostname= { memcached_string_make_from_cstr(list[x].hostname) };
@@ -413,22 +427,16 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
                                hostname,
                                list[x].port, list[x].weight, list[x].type) == NULL)
     {
+      ptr->state.is_parsing= false;
       return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
     }
 
     if (list[x].weight > 1)
     {
-      ptr->ketama.weighted= true;
+      memcached_set_weighted_ketama(ptr, true);
     }
-
-    ptr->number_of_hosts++;
-  }
-
-  // Provides backwards compatibility with server list.
-  {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
-    instance->number_of_hosts= memcached_server_count(ptr);
   }
+  ptr->state.is_parsing= false;
 
   return run_distribution(ptr);
 }
@@ -440,22 +448,28 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::
     return MEMCACHED_SUCCESS;
   }
 
-  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (number_of_hosts +memcached_server_count(ptr)), org::libmemcached::Instance);
+  uint32_t original_host_size= memcached_server_count(ptr);
+  uint32_t host_list_size= number_of_hosts +original_host_size;
+  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance);
 
   if (new_host_list == NULL)
   {
     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
   }
 
-  memcached_instance_set(ptr, new_host_list);
+  memcached_instance_set(ptr, new_host_list, host_list_size);
 
-  for (uint32_t x= 0; x < number_of_hosts; x++)
-  {
+  // We don't bother with lookups for this operation
+  ptr->state.is_parsing= true;
 
+  // We use original_host_size since size will now point to the first new
+  // instance allocated.
+  for (uint32_t x= 0; x < number_of_hosts; ++x, ++original_host_size)
+  {
     WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
 
     // We have extended the array, and now we will find it, and use it.
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, memcached_server_count(ptr));
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size);
     WATCHPOINT_ASSERT(instance);
 
     memcached_string_t hostname= { memcached_string_make_from_cstr(list[x].hostname) };
@@ -463,22 +477,16 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::
                                hostname,
                                list[x].port(), list[x].weight, list[x].type) == NULL)
     {
+      ptr->state.is_parsing= false;
       return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
     }
 
     if (list[x].weight > 1)
     {
-      ptr->ketama.weighted= true;
+      memcached_set_weighted_ketama(ptr, true);
     }
-
-    ptr->number_of_hosts++;
-  }
-
-  // Provides backwards compatibility with server list.
-  {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
-    instance->number_of_hosts= memcached_server_count(ptr);
   }
+  ptr->state.is_parsing= false;
 
   return run_distribution(ptr);
 }
@@ -499,9 +507,9 @@ memcached_return_t memcached_server_add_unix_socket_with_weight(memcached_st *pt
   }
 
   memcached_string_t _filename= { memcached_string_make_from_cstr(filename) };
-  if (memcached_is_valid_servername(_filename) == false)
+  if (memcached_is_valid_filename(_filename) == false)
   {
-    memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Invalid filename for socket provided"));
+    return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Invalid filename for socket provided"));
   }
 
   return server_add(ptr, _filename, 0, weight, MEMCACHED_CONNECTION_UNIX_SOCKET);