Merge lp:~tangent-org/libmemcached/1.0-build/ Build: jenkins-Libmemcached-170

[awesomized/libmemcached] / libmemcached / hosts.cc

diff --git a/libmemcached/hosts.cc b/libmemcached/hosts.cc
index 4875615f4ae3c3a2bd37d6d1dbb5443794697e34..73fb66af0a82eab9abcd87a9b79a11721a01a689 100644 (file)
--- a/libmemcached/hosts.cc
+++ b/libmemcached/hosts.cc
@@ -36,6 +36,7 @@
  */
 
 #include <libmemcached/common.h>
+#include "libmemcached/assert.hpp"
 
 #include <cmath>
 #include <sys/time.h>
@@ -194,6 +195,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     ptr->ketama.continuum= new_ptr;
     ptr->ketama.continuum_count= live_servers + MEMCACHED_CONTINUUM_ADDITION;
   }
+  assert_msg(ptr->ketama.continuum, "Programmer Error, empty ketama continuum");
 
   uint64_t total_weight= 0;
   if (memcached_is_weighted_ketama(ptr))
@@ -327,9 +329,9 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     pointer_counter+= pointer_per_server;
   }
 
-  WATCHPOINT_ASSERT(ptr);
-  WATCHPOINT_ASSERT(ptr->ketama.continuum);
-  WATCHPOINT_ASSERT(memcached_server_count(ptr) * MEMCACHED_POINTS_PER_SERVER <= MEMCACHED_CONTINUUM_SIZE);
+  assert_msg(ptr, "Programmer Error, no valid ptr");
+  assert_msg(ptr->ketama.continuum, "Programmer Error, empty ketama continuum");
+  assert_msg(memcached_server_count(ptr) * MEMCACHED_POINTS_PER_SERVER <= MEMCACHED_CONTINUUM_SIZE, "invalid size information being given to qsort()");
   ptr->ketama.continuum_points_counter= pointer_counter;
   qsort(ptr->ketama.continuum, ptr->ketama.continuum_points_counter, sizeof(memcached_continuum_item_st), continuum_item_cmp);
 
@@ -352,17 +354,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)
   {
@@ -377,8 +391,6 @@ static memcached_return_t server_add(memcached_st *ptr,
     }
   }
 
-  ptr->number_of_hosts++;
-
   return run_distribution(ptr);
 }
 
@@ -390,23 +402,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) };
@@ -414,6 +429,7 @@ 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);
     }
 
@@ -421,9 +437,8 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
     {
       memcached_set_weighted_ketama(ptr, true);
     }
-
-    ptr->number_of_hosts++;
   }
+  ptr->state.is_parsing= false;
 
   return run_distribution(ptr);
 }
@@ -435,22 +450,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) };
@@ -458,6 +479,7 @@ 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);
     }
 
@@ -465,9 +487,8 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::
     {
       memcached_set_weighted_ketama(ptr, true);
     }
-
-    ptr->number_of_hosts++;
   }
+  ptr->state.is_parsing= false;
 
   return run_distribution(ptr);
 }
@@ -488,9 +509,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);
@@ -561,7 +582,7 @@ memcached_return_t memcached_server_add_parsed(memcached_st *ptr,
                                                in_port_t port,
                                                uint32_t weight)
 {
-  char buffer[NI_MAXHOST];
+  char buffer[MEMCACHED_NI_MAXHOST];
 
   memcpy(buffer, hostname, hostname_length);
   buffer[hostname_length]= 0;