vinted-memcached 1.8.0

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;
+}

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

@@ -0,0 +1,46 @@
+/*
+  Structures for generic tests.
+*/
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <libmemcached/memcached.h>
+#include <stdio.h>
+
+typedef struct world_st world_st;
+typedef struct collection_st collection_st;
+typedef struct test_st test_st;
+
+typedef enum {
+  TEST_SUCCESS= 0, /* Backwards compatibility */
+  TEST_FAILURE,
+  TEST_MEMORY_ALLOCATION_FAILURE,
+  TEST_MAXIMUM_RETURN /* Always add new error code before */
+} test_return;
+
+struct test_st {
+  const char *name;
+  unsigned int requires_flush;
+  test_return (*function)(memcached_st *memc);
+};
+
+struct collection_st {
+  const char *name;
+  memcached_return (*pre)(memcached_st *memc);
+  memcached_return (*post)(memcached_st *memc);
+  test_st *tests;
+};
+
+struct world_st {
+  collection_st *collections;
+  void *(*create)(void);
+  void (*destroy)(void *collection_object);
+};
+
+/* How we make all of this work :) */
+void get_world(world_st *world);
+
+#ifdef	__cplusplus
+}
+#endif

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

@@ -0,0 +1,76 @@
+/*
+  Sample test application.
+*/
+#include <assert.h>
+#include <libmemcached/memcached.h>
+#include <stdio.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 "test.h"
+#include "server.h"
+
+/* Prototypes */
+test_return set_test(memcached_st *memc);
+void *world_create(void);
+void world_destroy(void *p);
+
+test_return set_test(memcached_st *memc)
+{
+  memcached_return rc;
+  const char *key= "foo";
+  const char *value= "when we sanitize";
+
+  rc= memcached_set(memc, key, strlen(key), 
+                    value, strlen(value),
+                    (time_t)0, (uint32_t)0);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+  return TEST_SUCCESS;
+}
+
+test_st tests[] ={
+  {"set", 1, set_test },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"udp", 0, 0, tests},
+  {0, 0, 0, 0}
+};
+
+#define SERVERS_TO_CREATE 1
+
+void *world_create(void)
+{
+  server_startup_st *construct;
+
+  construct= (server_startup_st *)malloc(sizeof(server_startup_st));
+  memset(construct, 0, sizeof(server_startup_st));
+  construct->count= SERVERS_TO_CREATE;
+  construct->udp= 1;
+  server_startup(construct);
+
+  return construct;
+}
+
+void world_destroy(void *p)
+{
+  server_startup_st *construct= (server_startup_st *)p;
+  memcached_server_st *servers= (memcached_server_st *)construct->servers;
+  memcached_server_list_free(servers);
+
+  server_shutdown(construct);
+  free(construct);
+}
+
+void get_world(world_st *world)
+{
+  world->collections= collection;
+  world->create= world_create;
+  world->destroy= world_destroy;
+}

data/ext/rlibmemcached.i

@@ -0,0 +1,258 @@
+%module rlibmemcached
+%{
+#include <libmemcached/visibility.h>
+#include <libmemcached/memcached.h>
+#include <libmemcached/memcached_exist.h>
+%}
+
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_server_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_stat_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_string_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_result_st;
+
+%include "typemaps.i"
+%include "libmemcached/visibility.h"
+
+//// Memory management
+
+// Register libmemcached's struct free function to prevent memory leaks
+%freefunc memcached_st "memcached_free";
+%freefunc memcached_stat_st "memcached_stat_free";
+%freefunc memcached_server_st "memcached_server_free";
+
+// Register which functions generate new objects
+%newobject memcached_create;
+%newobject memcached_clone;
+%newobject memcached_stat_get_value;
+// %newobject memcached_stat;
+
+// %trackobjects; // Doesn't fix any interesting leaks
+
+//// Input maps
+
+%apply unsigned short { uint8_t };
+%apply unsigned int { uint16_t };
+%apply unsigned int { uint32_t server_failure_counter };
+%apply unsigned int { uint32_t user_spec_len };
+%apply unsigned long { uint32_t flags, uint32_t offset, uint32_t weight, time_t expiration };
+%apply unsigned long long { uint64_t data, uint64_t cas };
+
+// Array of strings map for multiget
+%typemap(in) (const char **keys, size_t *key_length, size_t number_of_keys) {
+  unsigned int i;
+  VALUE str;
+  Check_Type($input, T_ARRAY);
+  $3 = (unsigned int) RARRAY_LEN($input);
+  $2 = (size_t *) malloc(($3+1)*sizeof(size_t));
+  $1 = (char **) malloc(($3+1)*sizeof(char *));
+  for(i = 0; i < $3; i ++) {
+    str = rb_string_value(&RARRAY_PTR($input)[i]);
+    $1[i] = RSTRING_PTR(str);
+    $2[i] = RSTRING_LEN(str);
+  }
+}
+
+%typemap(freearg) (const char **keys, size_t *key_length, size_t number_of_keys) {
+   free($1);
+   free($2);
+}
+
+// Generic strings
+%typemap(in) (const char *str, size_t len) {
+  VALUE str;
+  str = rb_string_value(&$input);
+  $1 = RSTRING_PTR(str);
+  $2 = RSTRING_LEN(str);
+};
+
+// Void type strings without lengths for prefix_key callback
+%typemap(in) (void *data) {
+  VALUE str;
+  str = rb_string_value(&$input);
+  if (RSTRING_LEN(str) == 0) {
+    $1 = NULL;
+  } else {
+    $1 = RSTRING_PTR(str);
+  }
+};
+
+%apply (const char *str, size_t len) {
+  (const char *namespace, size_t namespace_length),
+  (const char *key, size_t key_length),
+  (const char *value, size_t value_length)
+};
+
+// Key strings with same master key
+// This will have to go if people actually want to set the master key separately
+%typemap(in) (const char *master_key, size_t master_key_length, const char *key, size_t key_length) {
+  VALUE str;
+  str = rb_string_value(&$input);
+  $3 = $1 = RSTRING_PTR(str);
+  $4 = $2 = RSTRING_LEN(str);
+};
+
+//// Output maps
+
+%apply unsigned short *OUTPUT {memcached_return *error}
+%apply unsigned int *OUTPUT {uint32_t *flags}
+%apply size_t *OUTPUT {size_t *value_length}
+%apply unsigned long long *OUTPUT {uint64_t *value}
+
+// Uint64
+%typemap(out) (uint64_t) {
+  $result = ULL2NUM($1);
+};
+
+// Uint32
+%typemap(out) (uint32_t) {
+ $result = UINT2NUM($1);
+};
+
+// String for memcached_fetch
+%typemap(in, numinputs=0) (char *key, size_t *key_length) {
+  char string[256];
+  size_t length = 0;
+  $1 = string;
+  $2 = &length;
+};
+
+// Strings with lengths
+%typemap(argout) (char *key, size_t *key_length) {
+  rb_ary_push($result, rb_str_new($1, *$2));
+}
+
+// Array of strings
+// Only used by memcached_stat_get_keys() and not performance-critical
+%typemap(out) (char **) {
+  int i;
+  VALUE ary = rb_ary_new();
+  $result = rb_ary_new();
+
+  for(i=0; $1[i] != NULL; i++) {
+    rb_ary_store(ary, i, rb_str_new2($1[i]));
+  }
+  rb_ary_push($result, ary);
+  free($1);
+};
+
+//// SWIG includes, for functions, constants, and structs
+
+%include "libmemcached/visibility.h"
+%include "libmemcached/memcached.h"
+%include "libmemcached/memcached_constants.h"
+%include "libmemcached/memcached_get.h"
+%include "libmemcached/memcached_storage.h"
+%include "libmemcached/memcached_result.h"
+%include "libmemcached/memcached_server.h"
+%include "libmemcached/memcached_sasl.h"
+%include "libmemcached/memcached_touch.h"
+%include "libmemcached/memcached_exist.h"
+
+//// Custom C functions
+
+VALUE rb_str_new_by_ref(char *ptr, long len);
+%{
+VALUE rb_str_new_by_ref(char *ptr, long len)
+{
+#ifdef OBJSETUP
+    NEWOBJ(str, struct RString);
+    OBJSETUP(str, rb_cString, T_STRING);
+    #ifdef RSTRING_NOEMBED
+        /* Ruby 1.9 */
+        str->as.heap.ptr = ptr;
+        str->as.heap.len = len;
+        str->as.heap.aux.capa = len + 1;
+        // Set STR_NOEMBED
+        FL_SET(str, FL_USER1);
+    #else
+        /* Ruby 1.8 */
+        str->ptr = ptr;
+        str->len = len;
+        str->aux.capa = 0;
+    #endif
+#else
+    /* Rubinius, JRuby */
+    VALUE str = rb_str_new(ptr, len);
+    free(ptr);
+#endif
+    return (VALUE)str;
+}
+%}
+
+//// Manual wrappers
+
+// Single get
+VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
+  size_t value_length = 0;
+  char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
+  return rb_str_new_by_ref(value, value_length);
+};
+%}
+
+VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
+  size_t value_length = 0;
+  char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
+  return rb_str_new_by_ref(value, value_length);
+};
+%}
+
+VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
+  size_t value_length = 0;
+  char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
+  return rb_str_new_by_ref(value, value_length);
+};
+%}
+
+// Multi get
+VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
+  size_t value_length = 0;
+  VALUE ary = rb_ary_new();
+  *key_length = 0;
+  if (error) *error = MEMCACHED_TIMEOUT; // timeouts leave error uninitialized
+  char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
+  VALUE str = rb_str_new_by_ref(value, value_length);
+  rb_ary_push(ary, str);
+  return ary;
+};
+%}
+
+// Ruby isn't aware that the pointer is an array... there is probably a better way to do this
+memcached_server_st *memcached_select_server_at(memcached_st *in_ptr, int index);
+%{
+memcached_server_st *memcached_select_server_at(memcached_st *in_ptr, int index) {
+  return &(in_ptr->hosts[index]);
+};
+%}
+
+// Same, but for stats
+memcached_stat_st *memcached_select_stat_at(memcached_st *in_ptr, memcached_stat_st *stat_ptr, int index);
+%{
+memcached_stat_st *memcached_select_stat_at(memcached_st *in_ptr, memcached_stat_st *stat_ptr, int index) {
+  return &(stat_ptr[index]);
+};
+%}
+
+// Wrap only hash function
+// Uint32
+VALUE memcached_generate_hash_rvalue(const char *key, size_t key_length, memcached_hash hash_algorithm);
+%{
+VALUE memcached_generate_hash_rvalue(const char *key, size_t key_length,memcached_hash hash_algorithm) {
+  return UINT2NUM(memcached_generate_hash_value(key, key_length, hash_algorithm));
+};
+%}
+
+// Initialization for SASL
+%init %{
+  if (sasl_client_init(NULL) != SASL_OK) {
+    fprintf(stderr, "Failed to initialized SASL.\n");
+  }
+%}