Merging, with changes, --file for memcat.

diff --git a/clients/memcapable.c b/clients/memcapable.c
index 9921f1f147fd26ce5460c2ed48aefb687dfa5f7a..08524c495647de4aa300624b40931445d9ab64b8 100644 (file)
--- a/clients/memcapable.c
+++ b/clients/memcapable.c
@@ -1173,9 +1173,9 @@ static enum test_return receive_error_response(void)
 {
   char buffer[80];
   execute(receive_line(buffer, sizeof(buffer)));
-  verify(strncmp(buffer, "ERROR\r\n", 7) == 0 ||
-         strncmp(buffer, "CLIENT_ERROR:", 13) == 0 ||
-         strncmp(buffer, "SERVER_ERROR:", 13) == 0);
+  verify(strncmp(buffer, "ERROR", 5) == 0 ||
+         strncmp(buffer, "CLIENT_ERROR", 12) == 0 ||
+         strncmp(buffer, "SERVER_ERROR", 12) == 0);
   return TEST_PASS;
 }
 

diff --git a/clients/memcat.c b/clients/memcat.c
index a25bc12c9f5c6f3fa60d6ad96a0b59c524b005bc..d0a6b38faf769e8e2a3c87b11d7c0a524f850555 100644 (file)
--- a/clients/memcat.c
+++ b/clients/memcat.c
@@ -92,33 +92,41 @@ int main(int argc, char *argv[])
       else
       {
         if (opt_verbose)
+        {
           printf("key: %s\nflags: %x\nlength: %zu\nvalue: ",
                  argv[optind], flags, string_length);
-        if (opt_file) {
-            FILE *fp;
-            size_t written = 0;
-
-            fp = fopen(opt_file, "w");
-            if (!fp) {
-                perror("fopen");
-                return_code= -1;
-                break;
-            }
-
-            written = fwrite(string, 1, string_length, fp);
-            if (written != string_length) {
-                fprintf(stderr, "error writing file (written %d, should be %d)\n", written, string_length);
-                return_code= -1;
-                break;
-            }
-
-            if (fclose(fp)) {
-                fprintf(stderr, "error closing file\n");
-                return_code= -1;
-                break;
-            }
         }
-        else {
+
+        if (opt_file)
+        {
+          FILE *fp;
+          size_t written;
+
+          fp= fopen(opt_file, "w");
+          if (!fp)
+          {
+            perror("fopen");
+            return_code= -1;
+            break;
+          }
+
+          written= fwrite(string, 1, string_length, fp);
+          if (written != string_length) 
+          {
+            fprintf(stderr, "error writing file (written %zu, should be %zu)\n", written, string_length);
+            return_code= -1;
+            break;
+          }
+
+          if (fclose(fp))
+          {
+            fprintf(stderr, "error closing file\n");
+            return_code= -1;
+            break;
+          }
+        }
+        else
+        {
             printf("%.*s\n", (int)string_length, string);
         }
         free(string);
@@ -129,7 +137,9 @@ int main(int argc, char *argv[])
       fprintf(stderr, "memcat: %s: memcache error %s",
               argv[optind], memcached_strerror(memc, rc));
       if (memc->cached_errno)
+      {
        fprintf(stderr, " system error %s", strerror(memc->cached_errno));
+      }
       fprintf(stderr, "\n");
 
       return_code= -1;

diff --git a/libmemcached/connect.c b/libmemcached/connect.c
index 8d0e0a9b389982372588860cefa5cddbb26f2a39..b17400ab3fe80ea6e01ddcc17afe321f6d02efaa 100644 (file)
--- a/libmemcached/connect.c
+++ b/libmemcached/connect.c
@@ -316,7 +316,7 @@ static memcached_return_t network_connect(memcached_server_st *ptr)
           fds[0].events = POLLOUT;
 
           int timeout= ptr->root->connect_timeout;
-          if (ptr->root->flags.no_block == false)
+          if (ptr->root->flags.no_block == true)
             timeout= -1;
 
           size_t loop_max= 5;
@@ -330,6 +330,8 @@ static memcached_return_t network_connect(memcached_server_st *ptr)
               loop_max= 1;
               break;
             case 0:
+              if (loop_max==1) 
+                return MEMCACHED_TIMEOUT;
               continue;
               // A real error occurred and we need to completely bail
             default:

diff --git a/libmemcached/memcached.h b/libmemcached/memcached.h
index 26f101f2ea81d75f2924237fa12d73b783c8e6ff..a7cdc97722e289e079b79582e4e129cf93965fdf 100644 (file)
--- a/libmemcached/memcached.h
+++ b/libmemcached/memcached.h
@@ -72,7 +72,7 @@ struct memcached_st {
     bool cork:1;
     bool hash_with_prefix_key:1;
     bool ketama_weighted:1;
-    bool no_block:1;
+    bool no_block:1; // Don't block
     bool no_reply:1;
     bool randomize_replica_read:1;
     bool reuse_memory:1;

diff --git a/tests/include.am b/tests/include.am
index be3e336399882c497585d8764cf486401710f9af..b71f0c79ed83f9cba3064dc32136d3f9e6ae0798 100644 (file)
--- a/tests/include.am
+++ b/tests/include.am
@@ -112,12 +112,14 @@ memcapable: clients/memcapable
 test-memcat: clients/memcat clients/memcp
        @echo "Testing memcat"
        @@MEMC_BINARY@ -d -P `pwd`/tests/Xumemc.pid -p 12555
-       @clients/memcp --servers="localhost:12555" clients/memcp
-       @clients/memcat --servers="localhost:12555" memcp > tests/scratch
+       @clients/memcp --servers="localhost:12555" `pwd`/clients/memcp
+       @clients/memcat --servers="localhost:12555" memcp > `pwd`/tests/scratch
+       @clients/memcat --servers="localhost:12555" --file=`pwd`/tests/scratch2 memcp
 #      @diff clients/memcp tests/scratch
-       @cat tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
-       @rm tests/Xumemc.pid
-       @rm tests/scratch
+       @cat `pwd`/tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
+       @rm `pwd`/tests/Xumemc.pid
+       @rm `pwd`/tests/scratch
+       @rm `pwd`/tests/scratch2
 
 valgrind-memcat: clients/memcat clients/memcp
        @echo "Testing memcat"

diff --git a/tests/mem_functions.c b/tests/mem_functions.c
index 3872ee387768a8372324b160e7e8db39fa71e780..ba99c0be58fbeec912fa714d7b2842bb80bc1c6e 100644 (file)
--- a/tests/mem_functions.c
+++ b/tests/mem_functions.c
@@ -5027,6 +5027,71 @@ static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+/*
+  Test case adapted from John Gorman <johngorman2@gmail.com> 
+
+  We are testing the error condition when we connect to a server via memcached_get_by_key() 
+  but find that the server is not available.
+*/
+static test_return_t memcached_get_by_key_MEMCACHED_SOME_ERRORS(memcached_st *memc)
+{
+  (void)memc;
+  memcached_st *tl_memc_h;
+  memcached_server_st *servers;
+
+  const char *key= "MemcachedLives";
+  size_t len;
+  uint32_t flags;
+  memcached_return rc;
+  char *value;
+
+  // Create a handle.
+  tl_memc_h= memcached_create(NULL);
+  servers= memcached_servers_parse("localhost:9898"); // This server should not exist
+  memcached_server_push(tl_memc_h, servers);
+  memcached_server_list_free(servers);
+
+  // See if memcached is reachable.
+  value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
+
+  if (value)
+  {
+    free(value);
+    test_true(value); // Pointer won't be zero so this is fine.
+  }
+
+  test_true(len == 0);
+  test_true(rc == MEMCACHED_SOME_ERRORS);
+
+  return TEST_SUCCESS;
+}
+
+/* 
+  We connect to a server which exists, but search for a key that does not exist.
+*/
+static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
+{
+  const char *key= "MemcachedKeyNotEXIST";
+  size_t len;
+  uint32_t flags;
+  memcached_return rc;
+  char *value;
+
+  // See if memcached is reachable.
+  value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
+
+  if (value)
+  {
+    free(value);
+    test_true(value); // Pointer won't be zero so this is fine.
+  }
+
+  test_true(len == 0);
+  test_true(rc == MEMCACHED_NOTFOUND);
+
+  return TEST_SUCCESS;
+}
+
 
 static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
 {
@@ -5795,6 +5860,34 @@ static test_return_t regression_bug_490486(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return_t regression_bug_583031(memcached_st *unused)
+{
+  (void)unused;
+
+    memcached_st *memc= memcached_create(NULL);
+    assert(memc);
+    memcached_server_add(memc, "10.2.3.4", 11211);
+
+    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
+    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
+    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
+    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
+    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
+    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
+
+    memcached_return_t rc;
+    size_t length;
+    uint32_t flags;
+
+    (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
+
+    test_true(rc == MEMCACHED_TIMEOUT);
+
+    memcached_free(memc);
+
+    return TEST_SUCCESS;
+}
+
 static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
 {
   fprintf(stderr, "Iteration #%u: ", it);
@@ -6106,6 +6199,7 @@ test_st regression_tests[]= {
   {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
   {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
   {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
+  {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
   {"lp:?", 1, (test_callback_fn)regression_bug_ },
   {0, 0, (test_callback_fn)0}
 };
@@ -6192,6 +6286,8 @@ test_st hash_tests[] ={
 test_st error_conditions[] ={
   {"memcached_get_MEMCACHED_SOME_ERRORS", 0, (test_callback_fn)memcached_get_MEMCACHED_SOME_ERRORS },
   {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
+  {"memcached_get_by_key_MEMCACHED_SOME_ERRORS", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_SOME_ERRORS },
+  {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
   {0, 0, (test_callback_fn)0}
 };