memcached 1.2.6 → 1.2.7

data/ext/libmemcached-0.32/tests/r/memcat.res

@@ -0,0 +1,19 @@
+memcat v1.0
+
+	Cat a set of key values to stdout.
+
+Current options. A '=' means the option takes a value.
+
+	 --version 
+		Display the version of the application and then exit.
+	 --help 
+		Diplay this message and then exit.
+	 --verbose 
+		Give more details on the progression of the application.
+	 --debug 
+		Provide output only useful for debugging.
+	 --servers=
+		List which servers you wish to connect to.
+	 --flag 
+		Provide flag information for storage operation.
+

data/ext/libmemcached-0.32/tests/r/memcp.res

@@ -0,0 +1,27 @@
+memcp v1.0
+
+	Copy a set of files to a memcached cluster.
+
+Current options. A '=' means the option takes a value.
+
+	 --version 
+		Display the version of the application and then exit.
+	 --help 
+		Diplay this message and then exit.
+	 --verbose 
+		Give more details on the progression of the application.
+	 --debug 
+		Provide output only useful for debugging.
+	 --servers=
+		List which servers you wish to connect to.
+	 --flag=
+		Provide flag information for storage operation.
+	 --expire=
+		Set the expire option for the object.
+	 --set 
+		Use set command with memcached when storing.
+	 --add 
+		Use add command with memcached when storing.
+	 --replace 
+		Use replace command with memcached when storing.
+

data/ext/libmemcached-0.32/tests/r/memrm.res

@@ -0,0 +1,19 @@
+memrm v1.0
+
+	Erase a key or set of keys from a memcached cluster.
+
+Current options. A '=' means the option takes a value.
+
+	 --version 
+		Display the version of the application and then exit.
+	 --help 
+		Diplay this message and then exit.
+	 --verbose 
+		Give more details on the progression of the application.
+	 --debug 
+		Provide output only useful for debugging.
+	 --servers=
+		List which servers you wish to connect to.
+	 --expire=
+		Set the expire option for the object.
+

data/ext/libmemcached-0.32/tests/r/memslap.res

@@ -0,0 +1,33 @@
+memslap v1.0
+
+	Generates a load against a memcached custer of servers.
+
+Current options. A '=' means the option takes a value.
+
+	 --concurrency=
+		Number of users to simulate with load.
+	 --debug 
+		Provide output only useful for debugging.
+	 --execute-number=
+		Number of times to execute the given test.
+	 --flag 
+		Provide flag information for storage operation.
+	 --flush 
+		Flush servers before running tests.
+	 --help 
+		Diplay this message and then exit.
+	 --initial-load=
+		Number of key pairs to load before executing tests.
+	 --non-blocking 
+		Set TCP up to use non-blocking IO.
+	 --servers=
+		List which servers you wish to connect to.
+	 --tcp-nodelay 
+		Set TCP socket up to use nodelay.
+	 --test=
+		Test to run.
+	 --verbose 
+		Give more details on the progression of the application.
+	 --version 
+		Display the version of the application and then exit.
+

data/ext/libmemcached-0.32/tests/r/memstat.res

@@ -0,0 +1,33 @@
+memslap v1.0
+
+	Generates a load against a memcached custer of servers.
+
+Current options. A '=' means the option takes a value.
+
+	 --concurrency=
+		Number of users to simulate with load.
+	 --debug 
+		Provide output only useful for debugging.
+	 --execute-number=
+		Number of times to execute the given test.
+	 --flag 
+		Provide flag information for storage operation.
+	 --flush 
+		Flush servers before running tests.
+	 --help 
+		Diplay this message and then exit.
+	 --initial-load=
+		Number of key pairs to load before executing tests.
+	 --non-blocking 
+		Set TCP up to use non-blocking IO.
+	 --servers=
+		List which servers you wish to connect to.
+	 --tcp-nodelay 
+		Set TCP socket up to use nodelay.
+	 --test=
+		Test to run.
+	 --verbose 
+		Give more details on the progression of the application.
+	 --version 
+		Display the version of the application and then exit.
+

data/ext/libmemcached-0.32/tests/server.c

@@ -0,0 +1,118 @@
+/*
+  Startup, and shutdown the memcached servers.
+*/
+
+#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT+10 
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+#include <signal.h>
+#include <libmemcached/memcached.h>
+#include <unistd.h>
+#include "server.h"
+
+void server_startup(server_startup_st *construct)
+{
+  unsigned int x;
+
+  if ((construct->server_list= getenv("MEMCACHED_SERVERS")))
+  {
+    printf("servers %s\n", construct->server_list);
+    construct->servers= memcached_servers_parse(construct->server_list);
+    construct->server_list= NULL;
+    construct->count= 0;
+  }
+  else
+  {
+    {
+      char server_string_buffer[8096];
+      char *end_ptr;
+      end_ptr= server_string_buffer;
+
+      for (x= 0; x < construct->count; x++)
+      {
+        char buffer[1024]; /* Nothing special for number */
+        int count;
+        int status;
+
+        sprintf(buffer, "/tmp/%umemc.pid", x);
+        if (access(buffer, F_OK) == 0) 
+        {
+          FILE *fp= fopen(buffer, "r");
+          remove(buffer);
+
+          if (fp != NULL)
+          {
+            if (fgets(buffer, sizeof(buffer), fp) != NULL)
+            { 
+              pid_t pid = (pid_t)atol(buffer);
+              if (pid != 0) 
+                kill(pid, SIGTERM);
+            }
+
+            fclose(fp);
+          }
+        }
+
+        if (x == 0)
+        {
+          sprintf(buffer, "%s -d -P /tmp/%umemc.pid -t 1 -p %u -U %u -m 128",
+                    MEMCACHED_BINARY, x, x + TEST_PORT_BASE, x + TEST_PORT_BASE);
+        } 
+        else
+        {
+          sprintf(buffer, "%s -d -P /tmp/%umemc.pid -t 1 -p %u -U %u",
+                    MEMCACHED_BINARY, x, x + TEST_PORT_BASE, x + TEST_PORT_BASE);
+        }
+        fprintf(stderr, "STARTING SERVER: %s\n", buffer);
+        status= system(buffer);
+        count= sprintf(end_ptr, "localhost:%u,", x + TEST_PORT_BASE);
+        end_ptr+= count;
+      }
+      *end_ptr= 0;
+
+      construct->server_list= strdup(server_string_buffer);
+    }
+    printf("servers %s\n", construct->server_list);
+    construct->servers= memcached_servers_parse(construct->server_list);
+  }
+
+  assert(construct->servers);
+
+  srandom((unsigned int)time(NULL));
+
+  for (x= 0; x < memcached_server_list_count(construct->servers); x++)
+  {
+    printf("\t%s : %u\n", construct->servers[x].hostname, construct->servers[x].port);
+    assert(construct->servers[x].fd == -1);
+    assert(construct->servers[x].cursor_active == 0);
+  }
+
+  printf("\n");
+}
+
+void server_shutdown(server_startup_st *construct)
+{
+  unsigned int x;
+
+  if (construct->server_list)
+  {
+    for (x= 0; x < construct->count; x++)
+    {
+      char buffer[1024]; /* Nothing special for number */
+      sprintf(buffer, "cat /tmp/%umemc.pid | xargs kill", x);
+      /* We have to check the return value of this or the compiler will yell */
+      int sys_ret= system(buffer);
+      assert(sys_ret != -1); 
+      sprintf(buffer, "/tmp/%umemc.pid", x);
+      unlink(buffer);
+    }
+
+    free(construct->server_list);
+  }
+}

data/ext/libmemcached-0.32/tests/server.h

@@ -0,0 +1,25 @@
+/*
+  Server startup and shutdown functions.
+*/
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <libmemcached/memcached.h>
+
+typedef struct server_startup_st server_startup_st;
+
+struct server_startup_st
+{
+  uint8_t count;
+  uint8_t udp;
+  memcached_server_st *servers;
+  char *server_list;
+};
+
+void server_startup(server_startup_st *construct);
+void server_shutdown(server_startup_st *construct);
+
+#ifdef	__cplusplus
+}
+#endif

data/ext/libmemcached-0.32/tests/start.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <string.h>
+#include "server.h"
+
+int main(void)
+{
+  server_startup_st construct;
+
+  memset(&construct, 0, sizeof(server_startup_st));
+
+  construct.count= 4;
+
+  server_startup(&construct);
+
+  return 0;
+}

data/ext/libmemcached-0.32/tests/t/memcat.test

@@ -0,0 +1,4 @@
+#!/bin/sh
+MEMCAT="../src/memcat"
+
+$MEMCAT --help

data/ext/libmemcached-0.32/tests/t/memcp.test

@@ -0,0 +1,3 @@
+MEMCP="../src/memcp"
+
+$MEMCP --help

data/ext/libmemcached-0.32/tests/t/memrm.test

@@ -0,0 +1,3 @@
+MEMRM="../src/memrm"
+
+$MEMRM --help

data/ext/libmemcached-0.32/tests/t/memslap.test

@@ -0,0 +1,5 @@
+MEMSLAP="../src/memslap"
+
+$MEMSLAP --help
+
+$MEMSLAP --initial-load=5000 --verbose --flush --concurrency=500 --execute-number=500 > /dev/null

data/ext/libmemcached-0.32/tests/t/memstat.test

@@ -0,0 +1,3 @@
+MEMSTAT="../src/memslap"
+
+$MEMSTAT --help

data/ext/libmemcached-0.32/tests/test.c

@@ -0,0 +1,137 @@
+/*
+  Sample test application.
+*/
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <time.h>
+#include <fnmatch.h>
+#include "server.h"
+
+#include "test.h"
+
+static long int timedif(struct timeval a, struct timeval b)
+{
+  register int us, s;
+
+  us = (int)(a.tv_usec - b.tv_usec);
+  us /= 1000;
+  s = (int)(a.tv_sec - b.tv_sec);
+  s *= 1000;
+  return s + us;
+}
+
+int main(int argc, char *argv[])
+{
+  unsigned int x;
+  char *collection_to_run= NULL;
+  char *wildcard= NULL;
+  server_startup_st *startup_ptr;
+  memcached_server_st *servers;
+  world_st world;
+  collection_st *collection;
+  collection_st *next;
+  uint8_t failed;
+  void *world_ptr;
+
+  memset(&world, 0, sizeof(world_st));
+  get_world(&world);
+  collection= world.collections;
+
+  if (world.create)
+    world_ptr= world.create();
+  else 
+    world_ptr= NULL;
+
+  startup_ptr= (server_startup_st *)world_ptr;
+  servers= (memcached_server_st *)startup_ptr->servers;
+
+  if (argc > 1)
+    collection_to_run= argv[1];
+
+  if (argc == 3)
+    wildcard= argv[2];
+
+  for (next= collection; next->name; next++)
+  {
+    test_st *run;
+
+    run= next->tests;
+    if (collection_to_run && fnmatch(collection_to_run, next->name, 0))
+      continue;
+
+    fprintf(stderr, "\n%s\n\n", next->name);
+
+    for (x= 0; run->name; run++)
+    {
+      unsigned int loop;
+      memcached_st *memc;
+      memcached_return rc;
+      struct timeval start_time, end_time;
+      long int load_time;
+
+      if (wildcard && fnmatch(wildcard, run->name, 0))
+        continue;
+
+      fprintf(stderr, "Testing %s", run->name);
+
+      memc= memcached_create(NULL);
+      assert(memc);
+
+      rc= memcached_server_push(memc, servers);
+      assert(rc == MEMCACHED_SUCCESS);
+
+      if (run->requires_flush)
+      {
+        memcached_flush(memc, 0);
+        memcached_quit(memc);
+      }
+
+      for (loop= 0; loop < memcached_server_list_count(servers); loop++)
+      {
+        assert(memc->hosts[loop].fd == -1);
+        assert(memc->hosts[loop].cursor_active == 0);
+      }
+
+      if (next->pre)
+      {
+        rc= next->pre(memc);
+
+        if (rc != MEMCACHED_SUCCESS)
+        {
+          fprintf(stderr, "\t\t\t\t\t [ skipping ]\n");
+          goto error;
+        }
+      }
+
+      gettimeofday(&start_time, NULL);
+      failed= run->function(memc);
+      gettimeofday(&end_time, NULL);
+      load_time= timedif(end_time, start_time);
+      if (failed)
+        fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ failed ]\n", load_time / 1000, 
+                load_time % 1000);
+      else
+        fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, 
+                load_time % 1000);
+
+      if (next->post)
+        (void)next->post(memc);
+
+      assert(memc);
+error:
+      memcached_free(memc);
+    }
+  }
+
+  fprintf(stderr, "All tests completed successfully\n\n");
+
+  if (world.destroy)
+    world.destroy(world_ptr);
+
+  return 0;
+}