memcached 1.2.6 → 1.2.7

data/ext/libmemcached-0.32/clients/client_options.h

@@ -0,0 +1,32 @@
+#ifndef __CLIENT_OPTIONS_H__
+#define __CLIENT_OPTIONS_H__
+
+typedef struct memcached_help_text_st memcached_help_text_st;
+
+typedef enum {
+  OPT_SERVERS= 's',
+  OPT_VERSION= 'V',
+  OPT_HELP= 'h',
+  OPT_VERBOSE= 'v',
+  OPT_DEBUG= 'd',
+  OPT_ANALYZE= 'a',
+  OPT_FLAG= 257,
+  OPT_EXPIRE,
+  OPT_SET,
+  OPT_REPLACE,
+  OPT_ADD,
+  OPT_SLAP_EXECUTE_NUMBER,
+  OPT_SLAP_INITIAL_LOAD,
+  OPT_SLAP_TEST,
+  OPT_SLAP_CONCURRENCY,
+  OPT_SLAP_NON_BLOCK,
+  OPT_SLAP_TCP_NODELAY,
+  OPT_FLUSH,
+  OPT_HASH,
+  OPT_BINARY,
+  OPT_UDP,
+  OPT_USERNAME,
+  OPT_PASSWD
+} memcached_options;
+
+#endif /* CLIENT_OPTIONS */

data/ext/libmemcached-0.32/clients/execute.c

@@ -0,0 +1,64 @@
+/*
+  Execute a memcached_set() a set of pairs.
+  Return the number of rows set.
+*/
+
+#include "libmemcached/common.h"
+
+#include "execute.h"
+
+unsigned int execute_set(memcached_st *memc, pairs_st *pairs, unsigned int number_of)
+{
+  memcached_return rc;
+  unsigned int x;
+  unsigned int pairs_sent;
+
+  for (x= 0, pairs_sent= 0; x < number_of; x++)
+  {
+    rc= memcached_set(memc, pairs[x].key, pairs[x].key_length,
+                      pairs[x].value, pairs[x].value_length,
+                      0, 0);
+    if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
+      fprintf(stderr, "Failured on insert of %.*s\n", 
+              (unsigned int)pairs[x].key_length, pairs[x].key);
+    else
+      pairs_sent++;
+  }
+
+  return pairs_sent;
+}
+
+/*
+  Execute a memcached_get() on a set of pairs.
+  Return the number of rows retrieved.
+*/
+unsigned int execute_get(memcached_st *memc, pairs_st *pairs, unsigned int number_of)
+{
+  memcached_return rc;
+  unsigned int x;
+  unsigned int retrieved;
+
+
+  for (retrieved= 0,x= 0; x < number_of; x++)
+  {
+    char *value;
+    size_t value_length;
+    uint32_t flags;
+    unsigned int fetch_key;
+
+    fetch_key= (unsigned int)random() % number_of;
+
+    value= memcached_get(memc, pairs[fetch_key].key, pairs[fetch_key].key_length,
+                         &value_length, &flags, &rc);
+
+    if (rc != MEMCACHED_SUCCESS)
+      fprintf(stderr, "Failured on read of %.*s\n", 
+              (unsigned int)pairs[fetch_key].key_length, pairs[fetch_key].key);
+    else
+      retrieved++;
+
+    free(value);
+  }
+
+  return retrieved;
+}

data/ext/libmemcached-0.32/clients/execute.h

@@ -0,0 +1,5 @@
+#include "libmemcached/memcached.h"
+#include "generator.h"
+
+unsigned int execute_set(memcached_st *memc, pairs_st *pairs, unsigned int number_of);
+unsigned int execute_get(memcached_st *memc, pairs_st *pairs, unsigned int number_of);

data/ext/libmemcached-0.32/clients/generator.c

@@ -0,0 +1,74 @@
+#include "libmemcached/common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "generator.h"
+
+/* Use this for string generation */
+static const char ALPHANUMERICS[]=
+  "0123456789ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstuvwxyz";
+
+#define ALPHANUMERICS_SIZE (sizeof(ALPHANUMERICS)-1)
+
+static size_t get_alpha_num(void)
+{
+  return (size_t)random() % ALPHANUMERICS_SIZE;
+}
+
+static void get_random_string(char *buffer, size_t size)
+{
+  char *buffer_ptr= buffer;
+
+  while (--size)
+    *buffer_ptr++= ALPHANUMERICS[get_alpha_num()];
+  *buffer_ptr++= ALPHANUMERICS[get_alpha_num()];
+}
+
+void pairs_free(pairs_st *pairs)
+{
+  uint32_t x;
+
+  if (!pairs)
+    return;
+
+  /* We free until we hit the null pair we stores during creation */
+  for (x= 0; pairs[x].key; x++)
+  {
+    free(pairs[x].key);
+    free(pairs[x].value);
+  }
+
+  free(pairs);
+}
+
+pairs_st *pairs_generate(uint64_t number_of, size_t value_length)
+{
+  unsigned int x;
+  pairs_st *pairs= calloc((size_t)(number_of + 1), sizeof(pairs_st));
+
+  if (!pairs)
+    goto error;
+
+  for (x= 0; x < number_of; x++)
+  {
+    pairs[x].key= (char *)calloc(100, sizeof(char));
+    if (!pairs[x].key)
+      goto error;
+    get_random_string(pairs[x].key, 100);
+    pairs[x].key_length= 100;
+
+    pairs[x].value= (char *)calloc(value_length, sizeof(char));
+    if (!pairs[x].value)
+      goto error;
+    get_random_string(pairs[x].value, value_length);
+    pairs[x].value_length= value_length;
+  }
+
+  return pairs;
+error:
+    fprintf(stderr, "Memory Allocation failure in pairs_generate.\n");
+    exit(0);
+}

data/ext/libmemcached-0.32/clients/generator.h

@@ -0,0 +1,20 @@
+/*
+  Code to generate data to be pushed into memcached
+*/
+
+#ifndef __GENERATOR_H__
+#define __GENERATOR_H__
+
+typedef struct pairs_st pairs_st;
+
+struct pairs_st {
+  char *key;
+  size_t key_length;
+  char *value;
+  size_t value_length;
+};
+
+pairs_st *pairs_generate(uint64_t number_of, size_t value_length);
+void pairs_free(pairs_st *pairs);
+
+#endif

data/ext/libmemcached-0.32/clients/memcat.c

@@ -0,0 +1,178 @@
+#include "libmemcached/common.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <libmemcached/memcached.h>
+
+#include "utilities.h"
+
+#define PROGRAM_NAME "memcat"
+#define PROGRAM_DESCRIPTION "Cat a set of key values to stdout."
+
+
+/* Prototypes */
+void options_parse(int argc, char *argv[]);
+
+static int opt_binary= 0;
+static int opt_verbose= 0;
+static int opt_displayflag= 0;
+static char *opt_servers= NULL;
+static char *opt_hash= NULL;
+static char *opt_username;
+static char *opt_passwd;
+
+int main(int argc, char *argv[])
+{
+  memcached_st *memc;
+  char *string;
+  size_t string_length;
+  uint32_t flags;
+  memcached_return rc;
+  memcached_server_st *servers;
+
+  options_parse(argc, argv);
+
+  if (!opt_servers)
+  {
+    char *temp;
+
+    if ((temp= getenv("MEMCACHED_SERVERS")))
+      opt_servers= strdup(temp);
+    else
+    {
+      fprintf(stderr, "No Servers provided\n");
+      exit(1);
+    }
+  }
+
+  memc= memcached_create(NULL);
+  process_hash_option(memc, opt_hash);
+
+  servers= memcached_servers_parse(opt_servers);
+
+  memcached_server_push(memc, servers);
+  memcached_server_list_free(servers);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+                         (uint64_t)opt_binary);
+
+  if (!initialize_sasl(memc, opt_username, opt_passwd))
+  {
+    memcached_free(memc);
+    return 1;
+  }
+
+  while (optind < argc) 
+  {
+    string= memcached_get(memc, argv[optind], strlen(argv[optind]),
+                          &string_length, &flags, &rc);
+    if (rc == MEMCACHED_SUCCESS) 
+    {
+      if (opt_displayflag)
+      {
+        if (opt_verbose)
+          printf("key: %s\nflags: ", argv[optind]);
+        printf("%x\n", flags);
+      }
+      else 
+      {
+        if (opt_verbose)
+          printf("key: %s\nflags: %x\nlength: %zu\nvalue: ",
+                 argv[optind], flags, string_length);
+        printf("%.*s\n", (int)string_length, string);
+        free(string);
+      }
+    }
+    else if (rc != MEMCACHED_NOTFOUND)
+    {
+      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");
+    }
+    optind++;
+  }
+
+  memcached_free(memc);
+
+  if (opt_servers)
+    free(opt_servers);
+  if (opt_hash)
+    free(opt_hash);
+
+  shutdown_sasl();
+
+  return 0;
+}
+
+
+void options_parse(int argc, char *argv[])
+{
+  int option_index= 0;
+  int option_rv;
+
+  memcached_programs_help_st help_options[]=
+  {
+    {0},
+  };
+
+  static struct option long_options[]=
+    {
+      {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
+      {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+      {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
+      {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
+      {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
+      {(OPTIONSTRING)"flag", no_argument, &opt_displayflag, OPT_FLAG},
+      {(OPTIONSTRING)"hash", required_argument, NULL, OPT_HASH},
+      {(OPTIONSTRING)"binary", no_argument, NULL, OPT_BINARY},
+      {(OPTIONSTRING)"username", required_argument, NULL, OPT_USERNAME},
+      {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD},
+      {0, 0, 0, 0},
+    };
+
+  while (1) 
+  {
+    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    if (option_rv == -1) break;
+    switch (option_rv)
+    {
+    case 0:
+      break;
+    case OPT_BINARY:
+      opt_binary = 1;
+      break;
+    case OPT_VERBOSE: /* --verbose or -v */
+      opt_verbose = OPT_VERBOSE;
+      break;
+    case OPT_DEBUG: /* --debug or -d */
+      opt_verbose = OPT_DEBUG;
+      break;
+    case OPT_VERSION: /* --version or -V */
+      version_command(PROGRAM_NAME);
+      break;
+    case OPT_HELP: /* --help or -h */
+      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      break;
+    case OPT_SERVERS: /* --servers or -s */
+      opt_servers= strdup(optarg);
+      break;
+    case OPT_HASH:
+      opt_hash= strdup(optarg);
+      break;
+    case OPT_USERNAME:
+      opt_username= optarg;
+      break;
+    case OPT_PASSWD:
+      opt_passwd= optarg;
+      break;
+    case '?':
+      /* getopt_long already printed an error message. */
+      exit(1);
+    default:
+      abort();
+    }
+  }
+}

data/ext/libmemcached-0.32/clients/memcp.c

@@ -0,0 +1,251 @@
+#include "libmemcached/common.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <strings.h>
+#include <string.h>
+
+#include <libmemcached/memcached.h>
+
+#include "client_options.h"
+#include "utilities.h"
+
+#define PROGRAM_NAME "memcp"
+#define PROGRAM_DESCRIPTION "Copy a set of files to a memcached cluster."
+
+/* Prototypes */
+void options_parse(int argc, char *argv[]);
+
+static int opt_binary=0;
+static int opt_verbose= 0;
+static char *opt_servers= NULL;
+static char *opt_hash= NULL;
+static int opt_method= OPT_SET;
+static uint32_t opt_flags= 0;
+static time_t opt_expires= 0;
+static char *opt_username;
+static char *opt_passwd;
+
+int main(int argc, char *argv[])
+{
+  memcached_st *memc;
+  memcached_return rc;
+  memcached_server_st *servers;
+
+  options_parse(argc, argv);
+
+  memc= memcached_create(NULL);
+  process_hash_option(memc, opt_hash);
+
+  if (!opt_servers)
+  {
+    char *temp;
+
+    if ((temp= getenv("MEMCACHED_SERVERS")))
+      opt_servers= strdup(temp);
+    else
+    {
+      fprintf(stderr, "No Servers provided\n");
+      exit(1);
+    }
+  }
+
+  if (opt_servers)
+    servers= memcached_servers_parse(opt_servers);
+  else
+    servers= memcached_servers_parse(argv[--argc]);
+
+  memcached_server_push(memc, servers);
+  memcached_server_list_free(servers);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+                         (uint64_t)opt_binary);
+  if (!initialize_sasl(memc, opt_username, opt_passwd))
+  {
+    memcached_free(memc);
+    return 1;
+  }
+
+  while (optind < argc) 
+  {
+    struct stat sbuf;
+    int fd;
+    char *ptr;
+    ssize_t read_length;
+    char *file_buffer_ptr;
+
+    fd= open(argv[optind], O_RDONLY);
+    if (fd < 0)
+    {
+      fprintf(stderr, "memcp: %s: %s\n", argv[optind], strerror(errno));
+      optind++;
+      continue;
+    }
+
+    (void)fstat(fd, &sbuf);
+
+    ptr= rindex(argv[optind], '/');
+    if (ptr)
+      ptr++;
+    else
+      ptr= argv[optind];
+
+    if (opt_verbose) 
+    {
+      static const char *opstr[] = { "set", "add", "replace" };
+      printf("op: %s\nsource file: %s\nlength: %zu\n"
+	     "key: %s\nflags: %x\nexpires: %llu\n",
+	     opstr[opt_method - OPT_SET], argv[optind], (size_t)sbuf.st_size,
+	     ptr, opt_flags, (unsigned long long)opt_expires);
+    }
+
+    if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL)
+    {
+      fprintf(stderr, "malloc: %s\n", strerror(errno)); 
+      exit(1);
+    }
+
+    if ((read_length= read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1)
+    {
+      fprintf(stderr, "read: %s\n", strerror(errno)); 
+      exit(1);
+    }
+
+    if (read_length != sbuf.st_size)
+    {
+      fprintf(stderr, "Failure reading from file\n");
+      exit(1);
+    }
+
+    if (opt_method == OPT_ADD)
+      rc= memcached_add(memc, ptr, strlen(ptr),
+                        file_buffer_ptr, (size_t)sbuf.st_size,
+			opt_expires, opt_flags);
+    else if (opt_method == OPT_REPLACE)
+      rc= memcached_replace(memc, ptr, strlen(ptr),
+			    file_buffer_ptr, (size_t)sbuf.st_size,
+			    opt_expires, opt_flags);
+    else
+      rc= memcached_set(memc, ptr, strlen(ptr),
+                        file_buffer_ptr, (size_t)sbuf.st_size,
+                        opt_expires, opt_flags);
+
+    if (rc != MEMCACHED_SUCCESS)
+    {
+      fprintf(stderr, "memcp: %s: memcache error %s", 
+	      ptr, memcached_strerror(memc, rc));
+      if (memc->cached_errno)
+	fprintf(stderr, " system error %s", strerror(memc->cached_errno));
+      fprintf(stderr, "\n");
+    }
+
+    free(file_buffer_ptr);
+    close(fd);
+    optind++;
+  }
+
+  memcached_free(memc);
+
+  if (opt_servers)
+    free(opt_servers);
+  if (opt_hash)
+    free(opt_hash);
+  shutdown_sasl();
+
+  return 0;
+}
+
+void options_parse(int argc, char *argv[])
+{
+  int option_index= 0;
+  int option_rv;
+
+  memcached_programs_help_st help_options[]=
+  {
+    {0},
+  };
+
+  static struct option long_options[]=
+    {
+      {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
+      {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+      {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
+      {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
+      {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
+      {(OPTIONSTRING)"flag", required_argument, NULL, OPT_FLAG},
+      {(OPTIONSTRING)"expire", required_argument, NULL, OPT_EXPIRE},
+      {(OPTIONSTRING)"set",  no_argument, NULL, OPT_SET},
+      {(OPTIONSTRING)"add",  no_argument, NULL, OPT_ADD},
+      {(OPTIONSTRING)"replace",  no_argument, NULL, OPT_REPLACE},
+      {(OPTIONSTRING)"hash", required_argument, NULL, OPT_HASH},
+      {(OPTIONSTRING)"binary", no_argument, NULL, OPT_BINARY},
+      {(OPTIONSTRING)"username", required_argument, NULL, OPT_USERNAME},
+      {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD},
+      {0, 0, 0, 0},
+    };
+
+  while (1) 
+  {
+    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+
+    if (option_rv == -1) break;
+
+    switch (option_rv)
+    {
+    case 0:
+      break;
+    case OPT_BINARY:
+      opt_binary = 1;
+      break;
+    case OPT_VERBOSE: /* --verbose or -v */
+      opt_verbose = OPT_VERBOSE;
+      break;
+    case OPT_DEBUG: /* --debug or -d */
+      opt_verbose = OPT_DEBUG;
+      break;
+    case OPT_VERSION: /* --version or -V */
+      version_command(PROGRAM_NAME);
+      break;
+    case OPT_HELP: /* --help or -h */
+      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      break;
+    case OPT_SERVERS: /* --servers or -s */
+      opt_servers= strdup(optarg);
+      break;
+    case OPT_FLAG: /* --flag */
+      opt_flags= (uint32_t)strtol(optarg, (char **)NULL, 16);
+      break;
+    case OPT_EXPIRE: /* --expire */
+      opt_expires= (time_t)strtoll(optarg, (char **)NULL, 10);
+      break;
+    case OPT_SET:
+      opt_method= OPT_SET;
+      break;
+    case OPT_REPLACE:
+      opt_method= OPT_REPLACE;
+      break;
+    case OPT_ADD:
+      opt_method= OPT_ADD;
+    case OPT_HASH:
+      opt_hash= strdup(optarg);
+      break;
+     case OPT_USERNAME:
+      opt_username= optarg;
+      break;
+    case OPT_PASSWD:
+      opt_passwd= optarg;
+      break;
+    case '?':
+      /* getopt_long already printed an error message. */
+      exit(1);
+    default:
+      abort();
+    }
+  }
+}