memcached-seanl 0.19.5.1

data/ext/libmemcached.patch

@@ -0,0 +1,270 @@
+
+diff --git a/libmemcached-0.32/libmemcached/memcached_response.c b/libmemcached/libmemcached/memcached_response.c
+--- a/libmemcached-0.32/libmemcached/memcached_response.c
++++ b/libmemcached/libmemcached/memcached_response.c
+@@ -496,6 +496,8 @@
+     case PROTOCOL_BINARY_RESPONSE_E2BIG:
+     case PROTOCOL_BINARY_RESPONSE_EINVAL:
+     case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
++      rc= MEMCACHED_NOTSTORED;
++      break;
+     case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
+     case PROTOCOL_BINARY_RESPONSE_ENOMEM:
+     default:
+diff --git a/libmemcached-0.32/libmemcached/memcached.c b/libmemcached/libmemcached/memcached.c
+--- a/libmemcached-0.32/libmemcached/memcached.c
++++ b/libmemcached/libmemcached/memcached.c
+@@ -50,6 +50,9 @@ void memcached_free(memcached_st *ptr)
+   if (ptr->continuum)
+     ptr->call_free(ptr, ptr->continuum);
+ 
++  if (ptr->live_host_indices)
++    ptr->call_free(ptr, ptr->live_host_indices);
++
+   if (ptr->is_allocated)
+     ptr->call_free(ptr, ptr);
+   else
+diff --git a/libmemcached-0.32/libmemcached/memcached.h b/libmemcached/libmemcached/memcached.h
+--- a/libmemcached-0.32/libmemcached/memcached.h
++++ b/libmemcached/libmemcached/memcached.h
+@@ -112,6 +112,9 @@ struct memcached_st {
+   memcached_trigger_delete_key delete_trigger;
+   char prefix_key[MEMCACHED_PREFIX_KEY_MAX_SIZE];
+   uint32_t number_of_replicas;
++  uint32_t number_of_live_hosts;
++  uint32_t *live_host_indices;
++  uint32_t live_host_indices_size;
+ };
+ 
+ LIBMEMCACHED_API
+diff --git a/libmemcached-0.32/libmemcached/memcached_connect.c b/libmemcached/libmemcached/memcached_connect.c
+--- a/libmemcached-0.32/libmemcached/memcached_connect.c
++++ b/libmemcached/libmemcached/memcached_connect.c
+@@ -273,7 +272,6 @@ static memcached_return network_connect(memcached_server_st *ptr)
+           (void)fcntl(ptr->fd, F_SETFL, flags & ~O_NONBLOCK);
+ 
+         WATCHPOINT_ASSERT(ptr->cursor_active == 0);
+-        ptr->server_failure_counter= 0;
+         return MEMCACHED_SUCCESS;
+       }
+       use = use->ai_next;
+@@ -282,21 +280,13 @@ static memcached_return network_connect(memcached_server_st *ptr)
+ 
+   if (ptr->fd == -1)
+   {
+-    /* Failed to connect. schedule next retry */
+-    if (ptr->root->retry_timeout)
+-    {
+-      struct timeval next_time;
+-
+-      if (gettimeofday(&next_time, NULL) == 0)
+-        ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
+-    }
+-    ptr->server_failure_counter+= 1;
++    ptr->server_failure_counter ++;
+     if (ptr->cached_errno == 0)
+       return MEMCACHED_TIMEOUT;
++      
+     return MEMCACHED_ERRNO; /* The last error should be from connect() */
+   }
+ 
+-  ptr->server_failure_counter= 0;
+   return MEMCACHED_SUCCESS; /* The last error should be from connect() */
+ }
+ 
+@@ -315,7 +305,7 @@ memcached_return memcached_connect(memcached_server_st *ptr)
+     gettimeofday(&next_time, NULL);
+ 
+     /* if we've had too many consecutive errors on this server, mark it dead. */
+-    if (ptr->server_failure_counter > ptr->root->server_failure_limit)
++    if (ptr->server_failure_counter >= ptr->root->server_failure_limit)
+     {
+       ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
+       ptr->server_failure_counter= 0;
+diff --git a/libmemcached-0.32/libmemcached/memcached_get.h b/libmemcached/libmemcached/memcached_get.h
+diff --git a/libmemcached-0.32/libmemcached/memcached_hash.c b/libmemcached/libmemcached/memcached_hash.c
+index 129d761..3a7fa55 100644
+--- a/libmemcached-0.32/libmemcached/memcached_hash.c
++++ b/libmemcached/libmemcached/memcached_hash.c
+@@ -11,6 +11,7 @@ static uint32_t FNV_32_PRIME= 16777619;
+ /* Prototypes */
+ static uint32_t internal_generate_hash(const char *key, size_t key_length);
+ static uint32_t internal_generate_md5(const char *key, size_t key_length);
++uint32_t memcached_live_host_index(memcached_st *ptr, uint32_t num);
+ 
+ uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm)
+ {
+@@ -146,10 +144,10 @@ static uint32_t dispatch_host(memcached_st *ptr, uint32_t hash)
+         right= begin;
+       return right->index;
+     } 
+-  case MEMCACHED_DISTRIBUTION_MODULA:
+-    return hash % ptr->number_of_hosts;
++  case MEMCACHED_DISTRIBUTION_MODULA:  
++    return memcached_live_host_index(ptr, hash);
+   case MEMCACHED_DISTRIBUTION_RANDOM:
+-    return (uint32_t) random() % ptr->number_of_hosts;
++    return memcached_live_host_index(ptr, (uint32_t) random());
+   default:
+     WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
+     return hash % ptr->number_of_hosts;
+@@ -201,6 +199,19 @@ uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_
+   return dispatch_host(ptr, hash);
+ }
+ 
++uint32_t memcached_live_host_index(memcached_st *ptr, uint32_t num)
++{
++  if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS)) {
++    if (ptr->number_of_live_hosts > 0) {
++      return ptr->live_host_indices[num % ptr->number_of_live_hosts];
++    } else {
++      return 0;  /* FIXME:  we should do something different if every server's dead, but I dunno what. */
++    }
++  } else {
++    return num % ptr->number_of_hosts;
++  }
++}
++
+ static uint32_t internal_generate_hash(const char *key, size_t key_length)
+ {
+   const char *ptr= key;
+diff --git a/libmemcached-0.32/libmemcached/memcached_hosts.c b/libmemcached/libmemcached/memcached_hosts.c
+--- a/libmemcached-0.32/libmemcached/memcached_hosts.c
++++ b/libmemcached/libmemcached/memcached_hosts.c
+@@ -7,6 +7,7 @@ static memcached_return server_add(memcached_st *ptr, const char *hostname,
+                                    uint32_t weight,
+                                    memcached_connection type);
+ memcached_return update_continuum(memcached_st *ptr);
++memcached_return update_live_host_indices(memcached_st *ptr);
+ 
+ static int compare_servers(const void *p1, const void *p2)
+ {
+@@ -44,8 +45,12 @@ memcached_return run_distribution(memcached_st *ptr)
+   case MEMCACHED_DISTRIBUTION_MODULA:
+     if (ptr->flags & MEM_USE_SORT_HOSTS)
+       sort_hosts(ptr);
++    if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS))
++      update_live_host_indices(ptr);
+     break;
+   case MEMCACHED_DISTRIBUTION_RANDOM:
++    if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS))
++      update_live_host_indices(ptr);
+     break;
+   default:
+     WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
+@@ -85,6 +90,46 @@ static uint32_t ketama_server_hash(const char *key, unsigned int key_length, int
+     | (results[0 + alignment * 4] & 0xFF);
+ }
+ 
++memcached_return update_live_host_indices(memcached_st *ptr)
++{
++  uint32_t host_index;
++  struct timeval now;
++  uint32_t i = 0;
++  memcached_server_st *list;
++
++  if (gettimeofday(&now, NULL) != 0)
++  {
++    ptr->cached_errno = errno;
++    return MEMCACHED_ERRNO;
++  }
++
++  if (ptr->live_host_indices == NULL) {
++    ptr->live_host_indices = (uint32_t *)ptr->call_malloc(ptr, sizeof(uint32_t) * ptr->number_of_hosts);
++    ptr->live_host_indices_size = ptr->number_of_live_hosts;
++  }
++
++  /* somehow we added some hosts.  Shouldn't get here much, if at all. */
++  if (ptr->live_host_indices_size < ptr->number_of_hosts ) {
++    ptr->live_host_indices = (uint32_t *)ptr->call_realloc(ptr, ptr->live_host_indices,  sizeof(uint32_t) * ptr->number_of_hosts);
++    ptr->live_host_indices_size = ptr->number_of_live_hosts;
++  }
++
++  if (ptr->live_host_indices == NULL)
++    return MEMCACHED_FAILURE;
++
++  list = ptr->hosts;
++  for (host_index= 0; host_index < ptr->number_of_hosts; ++host_index)
++    {
++      if (list[host_index].next_retry <= now.tv_sec) {
++        ptr->live_host_indices[i++] = host_index;
++      } else if (ptr->next_distribution_rebuild == 0 || list[host_index].next_retry < ptr->next_distribution_rebuild) {
++          ptr->next_distribution_rebuild= list[host_index].next_retry;
++      }
++    }
++  ptr->number_of_live_hosts = i;
++  return MEMCACHED_SUCCESS;
++}
++
+ static int continuum_item_cmp(const void *t1, const void *t2)
+ {
+   memcached_continuum_item_st *ct1= (memcached_continuum_item_st *)t1;
+@@ -111,8 +156,8 @@ memcached_return update_continuum(memcached_st *ptr)
+   uint32_t pointer_per_server= MEMCACHED_POINTS_PER_SERVER;
+   uint32_t pointer_per_hash= 1;
+   uint64_t total_weight= 0;
+-  uint64_t is_ketama_weighted= 0;
+-  uint64_t is_auto_ejecting= 0;
++  uint32_t is_ketama_weighted= 0;
++  uint32_t is_auto_ejecting= 0;
+   uint32_t points_per_server= 0;
+   uint32_t live_servers= 0;
+   struct timeval now;
+diff --git a/libmemcached-0.32/libmemcached/memcached_storage.c b/libmemcached/libmemcached/memcached_storage.c
+index ecefc56..ee79a7e 100644
+--- a/libmemcached-0.32/libmemcached/memcached_storage.c
++++ b/libmemcached/libmemcached/memcached_storage.c
+@@ -135,22 +135,16 @@ static inline memcached_return memcached_send(memcached_st *ptr,
+   }
+ 
+   if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
+-  {
+-    rc= MEMCACHED_WRITE_FAILURE;
+-    goto error;
+-  }
++    return MEMCACHED_WRITE_FAILURE;
+ 
+   /* Send command header */
+   rc=  memcached_do(&ptr->hosts[server_key], buffer, write_length, 0);
+   if (rc != MEMCACHED_SUCCESS)
+-    goto error;
++    return rc;
+ 
+   /* Send command body */
+   if ((sent_length= memcached_io_write(&ptr->hosts[server_key], value, value_length, 0)) == -1)
+-  {
+-    rc= MEMCACHED_WRITE_FAILURE;
+-    goto error;
+-  }
++    return MEMCACHED_WRITE_FAILURE;
+ 
+   if ((ptr->flags & MEM_BUFFER_REQUESTS) && verb == SET_OP)
+     to_write= 0;
+@@ -158,10 +152,7 @@ static inline memcached_return memcached_send(memcached_st *ptr,
+     to_write= 1;
+ 
+   if ((sent_length= memcached_io_write(&ptr->hosts[server_key], "\r\n", 2, to_write)) == -1)
+-  {
+-    rc= MEMCACHED_WRITE_FAILURE;
+-    goto error;
+-  }
++    return MEMCACHED_WRITE_FAILURE;
+ 
+   if (ptr->flags & MEM_NOREPLY)
+     return (to_write == 0) ? MEMCACHED_BUFFERED : MEMCACHED_SUCCESS;
+@@ -170,15 +161,8 @@ static inline memcached_return memcached_send(memcached_st *ptr,
+     return MEMCACHED_BUFFERED;
+ 
+   rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+-
+   if (rc == MEMCACHED_STORED)
+-    return MEMCACHED_SUCCESS;
+-  else 
+-    return rc;
+-
+-error:
+-  memcached_io_reset(&ptr->hosts[server_key]);
+-
++    return MEMCACHED_SUCCESS;  
+   return rc;
+ }

data/ext/rlibmemcached.i

@@ -0,0 +1,230 @@
+%module rlibmemcached
+%{
+#include <libmemcached/visibility.h>
+#include <libmemcached/memcached.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"
+
+// Register libmemcached's struct free function to prevent memory leaks
+%freefunc memcached_st "memcached_free";
+%freefunc memcached_server_st "memcached_server_free";
+
+// %trackobjects; // Doesn't fix any interesting leaks
+
+//// Input maps
+
+%apply unsigned short { uint8_t };
+%apply unsigned int { uint16_t };
+%apply unsigned long { uint32_t flags, uint32_t offset, uint32_t weight };
+%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) {
+  int i;
+  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 ++) {
+    Check_Type(RARRAY_PTR($input)[i], T_STRING);
+    $2[i] = RSTRING_LEN(RARRAY_PTR($input)[i]);
+    $1[i] = StringValuePtr(RARRAY_PTR($input)[i]);
+  }
+}
+%typemap(in) (char **keys, size_t *key_length, unsigned int number_of_keys) {
+  int i;
+  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 ++) {
+    Check_Type(RARRAY_PTR($input)[i], T_STRING);
+    $2[i] = RSTRING_LEN(RARRAY_PTR($input)[i]);
+    $1[i] = StringValuePtr(RARRAY_PTR($input)[i]);
+  }
+}
+%typemap(freearg) (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) {
+ $1 = STR2CSTR($input);
+ $2 = (size_t) RSTRING_LEN($input);
+};
+
+// Void type strings without lengths for prefix_key callback
+%typemap(in) (void *data) {
+  if ( (size_t) RSTRING_LEN($input) == 0) {
+    $1 = NULL;
+  } else {
+    $1 = STR2CSTR($input);
+  }
+};
+
+%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) {
+ $3 = $1 = STR2CSTR($input);
+ $4 = $2 = (size_t) RSTRING_LEN($input);
+};
+
+
+//// 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);
+};
+
+// Void type strings without lengths for prefix_key callback
+// Currently not used by the gem
+%typemap(out) (void *) {
+ $result = rb_str_new2($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;
+}; 
+%typemap(argout) (char *key, size_t *key_length) {
+  // Pushes an empty string when *key_length == 0
+  rb_ary_push($result, rb_str_new($1, *$2)); 
+}
+
+// Array of strings
+
+%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"
+
+//// Custom C functions
+
+//// Manual wrappers
+
+// Single get. SWIG likes to use SWIG_FromCharPtr instead of SWIG_FromCharPtrAndSize because 
+// of the retval/argout split, so it truncates return values with \0 in them. 
+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) {
+  VALUE ret;  
+  size_t value_length;
+  char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
+  ret = rb_str_new(value, value_length);
+  free(value);
+  return ret;
+};
+%}
+
+// 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;
+  VALUE result = rb_ary_new();
+  
+  char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
+  if (value == NULL) {
+    rb_ary_push(result, Qnil);
+  } else {
+    VALUE ret = rb_str_new(value, value_length);
+    rb_ary_push(result, ret);
+    free(value);
+  }
+  return result;
+};
+%}
+
+// We need to wrap this so it doesn't leak memory. SWIG doesn't want to automatically free. We could
+// maybe use a 'ret' %typemap, but this is ok.
+VALUE memcached_stat_get_rvalue(memcached_st *ptr, memcached_stat_st *stat, char *key, memcached_return *error);
+%{
+VALUE memcached_stat_get_rvalue(memcached_st *ptr, memcached_stat_st *stat, char *key, memcached_return *error) {
+  char *str;
+  VALUE ret;
+  str = memcached_stat_get_value(ptr, stat, key, error);
+  ret = rb_str_new2(str);
+  free(str);
+  return ret;
+};
+%}
+
+// 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");
+  }
+%}
+