More tests for consistent.

Fixed memory leak around addrinfo when host constantly fails.

diff --git a/ChangeLog b/ChangeLog
index ef18c9fb701a6f22076e84a7f639ceb4d754dab5..5750968b5dd8f7d88e57ee466c3e05ebe7430ad4 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,5 @@
+  * New consistent distribution tests.
+  * Found a memory leak when a server constantly fails.
   * Changed default timeout to 1 second for poll timeouts
   * Wheel uses less memory/dynamic allocation for size (no longer limited to
     512 hosts by default.

diff --git a/clients/memslap.c b/clients/memslap.c
index 52abb4b1e2707fcf071bed31a4a18b50cbbd7341..01f11e2d75dd08d7d1efb494a882538e5455298a 100644 (file)
--- a/clients/memslap.c
+++ b/clients/memslap.c
@@ -355,9 +355,6 @@ void *run_task(void *p)
   if (context->execute_pairs)
     pairs_free(context->execute_pairs);
 
-  if (context->initial_pairs)
-    pairs_free(context->initial_pairs);
-
   free(context);
 
   pthread_mutex_lock(&counter_mutex);

diff --git a/libmemcached/memcached_connect.c b/libmemcached/memcached_connect.c
index 74469870e1ad94d22d40791737a755f1989b4b64..7d6f85a49840c99ed2c8be8114e38a5b030d0200 100644 (file)
--- a/libmemcached/memcached_connect.c
+++ b/libmemcached/memcached_connect.c
@@ -218,6 +218,12 @@ test_connect:
               WATCHPOINT_NUMBER(ptr->root->connect_timeout);
               close(ptr->fd);
               ptr->fd= -1;
+              if (ptr->address_info)
+              {
+                freeaddrinfo(ptr->address_info);
+                ptr->address_info= NULL;
+              }
+
               return MEMCACHED_ERRNO;
             }
 
@@ -231,7 +237,6 @@ test_connect:
         default:
 handle_retry:
           ptr->cached_errno= errno;
-          WATCHPOINT_ERRNO(ptr->cached_errno);
           close(ptr->fd);
           ptr->fd= -1;
           if (ptr->root->retry_timeout)
@@ -290,9 +295,6 @@ memcached_return memcached_connect(memcached_server_st *ptr)
     WATCHPOINT_ASSERT(0);
   }
 
-  if (rc != MEMCACHED_SUCCESS)
-    WATCHPOINT_ERROR(rc);
-
   LIBMEMCACHED_MEMCACHED_CONNECT_END();
 
   return rc;

diff --git a/libmemcached/memcached_hosts.c b/libmemcached/memcached_hosts.c
index 18e37d7ba8c450a46509c00771f2c02e902814a4..231b2167ba37b2f876e3527baea682eee73316c1 100644 (file)
--- a/libmemcached/memcached_hosts.c
+++ b/libmemcached/memcached_hosts.c
@@ -121,7 +121,10 @@ void server_list_free(memcached_st *ptr, memcached_server_st *servers)
 
   for (x= 0; x < servers->count; x++)
     if (servers[x].address_info)
+    {
       freeaddrinfo(servers[x].address_info);
+      servers[x].address_info= NULL;
+    }
 
   if (ptr && ptr->call_free)
     ptr->call_free(ptr, servers);
@@ -218,7 +221,10 @@ memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *l
                                      sizeof(memcached_server_st) * (count + ptr->number_of_hosts));
 
   if (!new_host_list)
+  {
+    assert(0);
     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+  }
 
   ptr->hosts= new_host_list;
                                    

diff --git a/tests/function.c b/tests/function.c
index cc63daddcd4dbad3a6c09aceacbc1b8aac9b5e9a..d3d23e4739eecb98cb28552b8201377b9cf79d3b 100644 (file)
--- a/tests/function.c
+++ b/tests/function.c
@@ -2175,6 +2175,42 @@ test_return generate_buffer_data(memcached_st *memc)
   return 0;
 }
 
+test_return get_read_count(memcached_st *memc)
+{
+  unsigned int x;
+  memcached_return rc;
+  memcached_st *clone;
+
+  clone= memcached_clone(NULL, memc);
+  assert(clone);
+
+  memcached_server_add(clone, "localhost", 6666);
+
+  {
+    char *return_value;
+    size_t return_value_length;
+    uint32_t flags;
+    uint32_t count;
+
+    for (x= count= 0; x < global_count; x++)
+    {
+      return_value= memcached_get(clone, global_keys[x], global_keys_length[x],
+                                  &return_value_length, &flags, &rc);
+      if (rc == MEMCACHED_SUCCESS)
+      {
+        count++;
+        if (return_value)
+          free(return_value);
+      }
+    }
+    fprintf(stderr, "\t%u -> %u", global_count, count);
+  }
+
+  memcached_free(clone);
+
+  return 0;
+}
+
 test_return get_read(memcached_st *memc)
 {
   unsigned int x;
@@ -2695,6 +2731,13 @@ test_st generate_tests[] ={
   {0, 0, 0}
 };
 
+test_st consistent_tests[] ={
+  {"generate_pairs", 1, generate_pairs },
+  {"generate_data", 1, generate_data },
+  {"get_read", 0, get_read_count },
+  {"cleanup", 1, cleanup_pairs },
+  {0, 0, 0}
+};
 
 collection_st collection[] ={
   {"block", 0, 0, tests},
@@ -2728,6 +2771,9 @@ collection_st collection[] ={
   {"generate_md5", pre_md5, 0, generate_tests},
   {"generate_murmur", pre_murmur, 0, generate_tests},
   {"generate_nonblock", pre_nonblock, 0, generate_tests},
+  {"consistent_not", 0, 0, consistent_tests},
+  {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests},
+  {"consistent_wheel", enable_wheel, 0, consistent_tests},
   {0, 0, 0, 0}
 };
 

diff --git a/tests/server.c b/tests/server.c
index f5e44a9b182b8de8d8b257fd70383077ebccc274..1248981ba1acd63fd92d679daa1554c9ae7f2eae 100644 (file)
--- a/tests/server.c
+++ b/tests/server.c
@@ -42,7 +42,6 @@ void server_startup(server_startup_st *construct)
         else
           sprintf(buffer, "memcached -d -P /tmp/%umemc.pid -t 1 -p %u", x, x+ TEST_PORT_BASE);
         status= system(buffer);
-        WATCHPOINT_ASSERT(status == 0);
         count= sprintf(end_ptr, "localhost:%u,", x + TEST_PORT_BASE);
         end_ptr+= count;
       }