localmemcache 0.0.1 → 0.2.0

data/src/lmc_valloc.h

@@ -11,7 +11,13 @@ typedef struct {
   size_t total_free_mem;
   size_t free_mem;
   size_t largest_chunk;
-} mem_status_t;
+} lmc_mem_status_t;
+
+typedef struct {
+   int op_id;
+   size_t p1;
+   size_t p2;
+} lmc_log_descriptor_t;
 
 typedef struct {
   size_t first_free;
@@ -20,12 +26,26 @@ typedef struct {
   size_t magic;
   size_t va_hash;
   int locked;
-} mem_descriptor_t;
+  lmc_log_descriptor_t log;
+} lmc_mem_descriptor_t;
+
+typedef struct {
+  size_t next;
+  size_t size;
+} lmc_mem_chunk_descriptor_t;
 
 
 size_t lmc_valloc(void *base, size_t size);
 void lmc_free(void *base, size_t chunk);
-mem_status_t lmc_status(void *base, char *where);
+lmc_mem_status_t lmc_status(void *base, char *where);
 int is_lmc_already_initialized(void *base);
 void lmc_init_memory(void *ptr, size_t size);
+
+int lmc_um_mark_allocated(void *base, char *bf, size_t va);
+char *lmc_um_new_mem_usage_bitmap(void *base);
+int lmc_um_find_leaks(void *base, char *bf);
+
+lmc_log_descriptor_t *lmc_log_op(void *base, int opid);
+void lmc_log_finish(void *base);
+
 #endif

data/src/localmemcache.c

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2009, Sven C. Koehler
+ */
+
 #include "localmemcache.h"
 #include <stdio.h>
 #include <string.h>
@@ -5,10 +9,10 @@
 #include "lmc_shm.h"
 
 int lmc_set_lock_flag(void *base, lmc_error_t *e) {
-  mem_descriptor_t *md = base;
+  lmc_mem_descriptor_t *md = base;
   if (md->locked != 0) {
-    strncpy(e->error_str, "Failed to lock shared memory region--"
-        "may be corrupt.", 1023); 
+    lmc_handle_error_with_err_string("lmc_set_lock_flag",
+        "Failed to lock shared memory--may be corrupt!", "ShmLockFailed", e);
     return 0;
   } else {
     md->locked = 1;
@@ -17,10 +21,11 @@ int lmc_set_lock_flag(void *base, lmc_error_t *e) {
 }
 
 int lmc_release_lock_flag(void *base, lmc_error_t *e) {
-  mem_descriptor_t *md = base;
+  lmc_mem_descriptor_t *md = base;
   if (md->locked != 1) {
-    strncpy(e->error_str, "Shared memory region appears to be unlocked already"
-        "--may be corrupt.", 1023); 
+    lmc_handle_error_with_err_string("lmc_release_lock_flag",
+        "Shared memory appears to be unlocked already--may be corrupt!", 
+        "ShmUnlockFailed", e);
     return 0;
   } else {
     md->locked = 0;
@@ -28,46 +33,93 @@ int lmc_release_lock_flag(void *base, lmc_error_t *e) {
   return 1;
 }
 
+void lmc_clean_namespace_string(char *result, const char* original) {
+  size_t n = strlen(original);
+  if (n > 256) { n = 256; }
+  const char *s = original;
+  char *d = result;
+  char ch;
+  for (; n--; d++, s++) { 
+    ch = *s;
+    if ((ch >= 'a' && ch <= 'z') || 
+        (ch >= 'A' && ch <= 'Z')) {
+      *d = ch;
+    } else {
+      *d = '-';
+    }
+  }
+  *d = 0x0;
+}
+
 int local_memcache_clear_namespace(const char *namespace, int repair, 
     lmc_error_t *e) {
-  lmc_clean_namespace(namespace, e);
+  char clean_ns[1024];
+  lmc_clean_namespace_string((char *)clean_ns, namespace);
+  lmc_clean_namespace((char *)clean_ns, e);
   if (repair) { 
-    lmc_lock_t *l = lmc_lock_init(namespace, 1, e);
+    lmc_lock_t *l = lmc_lock_init((char *)clean_ns, 1, e);
     lmc_lock_repair(l);
     free(l);
+    char check_lock_name[1024];
+    snprintf((char *)&check_lock_name, 1023, "%s-check", (char *)clean_ns);
+    lmc_lock_t *check_l;
+    check_l =  lmc_lock_init(check_lock_name, 1, e);
+    lmc_lock_repair(check_l);
+    free(check_l);
   }
   return 1;
 }
 
-local_memcache_t *local_memcache_create(const char *namespace, size_t size,
-    lmc_error_t* e) {
+local_memcache_t *__local_memcache_create(const char *namespace, size_t size, 
+    int force, int *ok, lmc_error_t* e) {
+  int d;
+  if (!ok) { ok = &d; }
+  *ok = 1;
   local_memcache_t *lmc = calloc(1, sizeof(local_memcache_t));
   if (!lmc || (lmc->namespace = strdup(namespace)) == NULL) return NULL;
   lmc->size = size;
   if ((lmc->lock = lmc_lock_init(lmc->namespace, 1, e)) == NULL) goto failed;
-  if (!lmc_is_lock_working(lmc->lock, e)) {
-    strncpy(e->error_str, "Failed to lock shared memory!", 1023); 
+  int retry_counter = 0;
+retry:
+  if (retry_counter++ > 10) {
+    lmc_handle_error_with_err_string("local_memcache_create",
+        "Too many retries: Failed to repair shared memory!", 
+        "ShmLockFailed", e);
     goto failed;
   }
+  if (!lmc_is_lock_working(lmc->lock, e)) {
+    if (!force) {
+      if (local_memcache_check_namespace(namespace, e))  goto retry;
+      lmc_handle_error_with_err_string("local_memcache_create",
+          "Failed to repair shared memory!", "ShmLockFailed", e);
+      goto failed;
+    } 
+    *ok = 0;
+  }
   {
-    if (!lmc_lock_obtain("local_memcache_create", lmc->lock, &lmc->error)) 
+    if (*ok && !lmc_lock_obtain("local_memcache_create", lmc->lock, &lmc->error)) 
         goto failed;
     if ((lmc->shm = lmc_shm_create(lmc->namespace, lmc->size, 0, e)) == NULL) 
         goto release_and_fail;
     lmc->base = lmc->shm->base;
-    if (is_lmc_already_initialized(lmc->base)) {
-      if (!lmc_set_lock_flag(lmc->base, e)) goto release_and_fail;
-      mem_descriptor_t *md = lmc->base;
+    if (!*ok || is_lmc_already_initialized(lmc->base)) {
+      if (*ok && !lmc_set_lock_flag(lmc->base, e)) { 
+        if (!force)  goto release_and_fail;
+        *ok = 0;
+      }
+      lmc_mem_descriptor_t *md = lmc->base;
       lmc->va_hash = md->va_hash;
     } else {
       lmc_init_memory(lmc->base, lmc->size);
-      mem_descriptor_t *md = lmc->base;
+      lmc_mem_descriptor_t *md = lmc->base;
       if ((md->va_hash = ht_hash_create(lmc->base, e)) == 0) 
           goto unlock_and_fail;
       lmc->va_hash = md->va_hash;
     }
-    lmc_release_lock_flag(lmc->base, e);
-    lmc_lock_release("local_memcache_create", lmc->lock, e);
+    if (*ok) { 
+      lmc_release_lock_flag(lmc->base, e);
+      lmc_lock_release("local_memcache_create", lmc->lock, e); 
+    }
   }
   return lmc;
 
@@ -76,12 +128,106 @@ unlock_and_fail:
 release_and_fail:
    lmc_lock_release("local_memcache_create", lmc->lock, e);
 failed:
+  *ok = 0;
   free(lmc);
   return NULL;
 }
 
+local_memcache_t *local_memcache_create(const char *namespace, double size_mb, 
+    lmc_error_t* e) {  
+  char clean_ns[1024];
+  double s = size_mb == 0.0 ? 1024.0 : size_mb;
+  size_t si = s * 1024 * 1024;
+  //printf("size: %f, s: %f, si: %zd\n", size_mb, s, si);
+  lmc_clean_namespace_string((char *)clean_ns, namespace);
+  return __local_memcache_create((char *)clean_ns, si, 0, 0, e);
+}
+
+int local_memcache_check_namespace(const char *namespace, lmc_error_t *e) {
+  char clean_ns[1024];
+  lmc_clean_namespace_string((char *)clean_ns, namespace);
+  char check_lock_name[1024];
+  snprintf((char *)check_lock_name, 1023, "%s-check", (char *)clean_ns);
+
+  if (!lmc_does_namespace_exist((char *)clean_ns)) { 
+    lmc_clear_namespace_lock(check_lock_name);
+    lmc_clear_namespace_lock(namespace);
+    printf("namespace '%s' does not exist!\n", (char *)clean_ns);
+    return 1;
+  }
+
+  lmc_lock_t *check_l;
+  if ((check_l = lmc_lock_init(check_lock_name, 1, e)) == NULL)  {
+    lmc_handle_error_with_err_string("lmc_lock_init", 
+        "Unable to initialize lock for checking namespace", "LockError", e);
+    return 0;
+  }
+  if (!lmc_lock_obtain_mandatory("local_memcache_check_namespace", 
+      check_l, e))  goto check_lock_failed;
+  lmc_mem_descriptor_t *md = 0;
+  size_t ns_size = lmc_namespace_size((char *)clean_ns);
+  int ok;
+  local_memcache_t *lmc = __local_memcache_create((char *)clean_ns, ns_size, 
+      1, &ok, e);
+  if (!lmc) {
+    printf("WOAH: lmc == 0!\n");
+    goto failed;
+  }
+  md = lmc->base;
+  if (!ok) {
+    printf("[lmc] Auto repairing namespace '%s'\n", namespace);
+    if (!md->locked) goto release;
+    if (md->log.op_id == 0) goto unlock_and_release;
+    if (ht_redo(lmc->base, md->va_hash, &md->log, e)) goto unlock_and_release;
+    goto failed;
+  }
+  goto release_but_no_lock_correction;
+
+unlock_and_release:
+  if (md) {
+    if (!ht_check_memory(lmc->base, md->va_hash)) goto failed;
+    md->locked = 0;
+  }
+release:
+  {
+    int v; 
+    sem_getvalue(lmc->lock->sem, &v);
+    if (v == 0) {
+      lmc_lock_release("local_memcache_create", lmc->lock, e);
+    }
+  }
+release_but_no_lock_correction:
+  local_memcache_free(lmc, e);
+  lmc_lock_release("local_memcache_check_namespace", check_l, e);
+  free(check_l);
+  return 1;
+failed:
+  lmc_handle_error_with_err_string("local_memcache_check_namespace",
+      "Unable to recover namespace", "RecoveryFailed", e);
+  local_memcache_free(lmc, e);
+  lmc_lock_release("local_memcache_check_namespace", check_l, e);
+check_lock_failed:
+  free(check_l);
+  printf("[lmc] Failed to repair namespace '%s'\n", namespace);
+  return 0;
+}
+
+
 int lmc_lock_shm_region(const char *who, local_memcache_t *lmc) {
-  if (!lmc_lock_obtain(who, lmc->lock, &lmc->error)) return 0;
+  int r;
+  int retry_counter = 0;
+retry:
+  if (retry_counter++ > 10) {
+    printf("[lmc] Too many retries: Cannot repair namespace '%s'\n", 
+        lmc->namespace);
+    return 0;
+  }
+  r = lmc_lock_obtain(who, lmc->lock, &lmc->error);
+  if (!r && (strcmp(lmc->error.error_type, "LockTimedOut") == 0)) {
+    if (local_memcache_check_namespace(lmc->namespace, &lmc->error))  goto retry;
+    printf("[lmc] Cannot repair namespace '%s'\n", lmc->namespace);
+  }
+  if (!r) return 0;
   if (!lmc_set_lock_flag(lmc->base, &lmc->error)) {
     lmc_lock_release(who, lmc->lock, &lmc->error);
     return 0;
@@ -96,35 +242,51 @@ int lmc_unlock_shm_region(const char *who, local_memcache_t *lmc) {
   return r;
 }
 
-char *local_memcache_get(local_memcache_t *lmc, const char *key) {
+const char *__local_memcache_get(local_memcache_t *lmc, 
+    const char *key, size_t n_key, size_t *n_value) {
   if (!lmc_lock_shm_region("local_memcache_get", lmc)) return 0;
-  char *r = ht_get(lmc->base, lmc->va_hash, key);
-  if (!lmc_unlock_shm_region("local_memcache_get", lmc)) return 0;
+  const char *r = ht_get(lmc->base, lmc->va_hash, key, n_key, n_value);
   return r;
 }
 
+char *local_memcache_get_new(local_memcache_t *lmc, 
+    const char *key, size_t n_key, size_t *n_value) {
+  const char *r = __local_memcache_get(lmc, key, n_key, n_value);
+  char *new_s = malloc(*n_value);
+  memcpy(new_s, r, *n_value);
+  if (!lmc_unlock_shm_region("local_memcache_get_new", lmc)) return 0;
+  return new_s;
+}
+
 int local_memcache_set(local_memcache_t *lmc, 
-   const char *key, const char* value) {
+   const char *key, size_t n_key, const char* value, size_t n_value) {
   if (!lmc_lock_shm_region("local_memcache_set", lmc)) return 0;
-  int r = ht_set(lmc->base, lmc->va_hash, key, value, &lmc->error);
-  if (!lmc_unlock_shm_region("local_memcache_get", lmc)) return 0;
+  int r = ht_set(lmc->base, lmc->va_hash, key, n_key, value, n_value, 
+      &lmc->error);
+  if (!lmc_unlock_shm_region("local_memcache_set", lmc)) return 0;
   return r;
 }
 
-int local_memcache_delete(local_memcache_t *lmc, char *key) {
+int local_memcache_delete(local_memcache_t *lmc, char *key, size_t n_key) {
   if (!lmc_lock_shm_region("local_memcache_delete", lmc)) return 0;
-  int r = ht_delete(lmc->base, lmc->va_hash, key);
+  int r = ht_delete(lmc->base, lmc->va_hash, key, n_key);
   if (!lmc_unlock_shm_region("local_memcache_delete", lmc)) return 0;
   return r;
 }
 
-int local_memcache_free(local_memcache_t *lmc) {
-  lmc_error_t e;
+int local_memcache_free(local_memcache_t *lmc, lmc_error_t *e) {
   if (!lmc_lock_shm_region("local_memcache_free", lmc)) return 0;
   int r = ht_hash_destroy(lmc->base, lmc->va_hash);
   if (!lmc_unlock_shm_region("local_memcache_free", lmc)) return 0;
-  lmc_shm_destroy(lmc->shm, &e);
+  lmc_shm_destroy(lmc->shm, e);
   free(lmc->namespace);
   free(lmc->lock);
   return r;
 }
+
+int local_memcache_iterate(local_memcache_t *lmc, void *ctx, ITERATOR_P(iter)) {
+  if (!lmc_lock_shm_region("local_memcache_iterate", lmc)) return 0;
+  int r = ht_hash_iterate(lmc->base, lmc->va_hash, ctx, iter);
+  if (!lmc_unlock_shm_region("local_memcache_iterate", lmc)) return 0;
+  return r;
+}

data/src/localmemcache.h

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2009, Sven C. Koehler
+ */
+
 #ifndef _LOCAL_MEMCACHE_INCLUDED_
 #define _LOCAL_MEMCACHE_INCLUDED_
 
@@ -6,6 +10,7 @@
 #include "lmc_shm.h"
 #include "lmc_lock.h"
 #include "lmc_error.h"
+#include "lmc_common.h"
 
 #define LOCAL_MEMCACHE_FAILED 0
 #define LOCAL_MEMCACHE_SUCCESS 1
@@ -21,13 +26,20 @@ typedef struct {
   lmc_error_t error;
 } local_memcache_t;
 
-local_memcache_t *local_memcache_create(const char *namespace, size_t size,
+local_memcache_t *local_memcache_create(const char *namespace, double size_mb,
     lmc_error_t *e);
-char *local_memcache_get(local_memcache_t *lmc, const char *key);
-int local_memcache_set(local_memcache_t *lmc, const char *key, const char* value);
-int local_memcache_delete(local_memcache_t *lmc, char *key);
-int local_memcache_free(local_memcache_t *lmc);
+char *local_memcache_get_new(local_memcache_t *lmc, const char *key, 
+    size_t n_key, size_t *n_value);
+int local_memcache_set(local_memcache_t *lmc, const char *key, size_t n_key, 
+    const char* value, size_t n_value);
+int local_memcache_delete(local_memcache_t *lmc, char *key, size_t n_key);
+int local_memcache_free(local_memcache_t *lmc, lmc_error_t *e);
+int local_memcache_iterate(local_memcache_t *lmc, void *ctx, ITERATOR_P(iter));
 int local_memcache_clear_namespace(const char *namespace, int repair, 
     lmc_error_t *e);
+int local_memcache_check_namespace(const char *namespace, lmc_error_t *e);
+
+const char *__local_memcache_get(local_memcache_t *lmc, 
+    const char *key, size_t n_key, size_t *n_value);
 
 #endif

data/src/ruby-binding/localmemcache.rb

@@ -9,6 +9,16 @@ require 'rblocalmemcache'
 #
 class LocalMemCache
 
+  class LocalMemCacheError < StandardError; end
+  class ShmError < LocalMemCacheError; end
+  class MemoryPoolFull < LocalMemCacheError; end
+  class LockError < LocalMemCacheError; end
+  class LockTimedOut < LocalMemCacheError; end
+  class OutOfMemoryError < LocalMemCacheError; end
+  class RecoveryFailed < LocalMemCacheError; end
+  class ShmLockFailed < LocalMemCacheError; end
+  class ShmUnlockFailed < LocalMemCacheError; end
+
   #  Creates a new handle for accessing a shared memory region.
   #
   #  LocalMemCache.new :namespace=>"foo", :size_mb=> 1
@@ -17,9 +27,9 @@ class LocalMemCache
   #  The size_mb defaults to 1024 (1 GB).
   #
   def self.new(options)
-    o = { :size_mb => 1024 }.update(options || {})
+    o = { :size_mb => 0 }.update(options || {})
     raise "Missing mandatory option ':namespace'" if !o[:namespace]
-    _new(o[:namespace].gsub("/", "-"), (o[:size_mb].to_f * 1024 * 1024).to_i );
+    _new(o[:namespace].to_s, o[:size_mb].to_f);
   end
 
   # Deletes the given namespaces, removing semaphores if necessary.
@@ -27,6 +37,6 @@ class LocalMemCache
   # processes.
   #
   def self.clear_namespace(namespace, repair = false) 
-    _clear_namespace(namespace, repair)
+    _clear_namespace(namespace.to_s, repair)
   end
 end

data/src/ruby-binding/rblocalmemcache.c

@@ -8,42 +8,83 @@
 /* :nodoc: */
 long long_value(VALUE i) { return NUM2LONG(rb_Integer(i)); }
 /* :nodoc: */
+double double_value(VALUE i) { return NUM2DBL(i); }
+/* :nodoc: */
 VALUE num2string(long i) { return rb_big2str(rb_int2big(i), 10); }
 /* :nodoc: */
 char *rstring_ptr(VALUE s) { 
   char* r = NIL_P(s) ? "nil" : RSTRING_PTR(rb_String(s)); 
   return r ? r : "nil";
 }
+
+size_t rstring_length(VALUE s) { 
+  size_t r = NIL_P(s) ? 0 : RSTRING_LEN(rb_String(s)); 
+  return r;
+}
 /* :nodoc: */
-static VALUE ruby_string(char *s) { return s ? rb_str_new2(s) : Qnil; }
+static VALUE ruby_string(const char *s) { return s ? rb_str_new2(s) : Qnil; }
 /* :nodoc: */
 int bool_value(VALUE v) { return v == Qtrue; }
 
-static VALUE LocalMemCacheError;
+static VALUE lmc_ruby_string2(const char *s, size_t l) { 
+  return s ? rb_str_new(s, l) : Qnil; 
+}
+
+static VALUE lmc_ruby_string(const char *s) { 
+  return lmc_ruby_string2(s + sizeof(size_t), *(size_t *) s);
+}
+
+
+static VALUE LocalMemCache;
 
 /* :nodoc: */
-void raise_exception(VALUE error_klass, lmc_error_t *e) {
-  rb_raise(error_klass, e->error_str);
+void raise_exception(lmc_error_t *e) {
+  VALUE eid = rb_intern(e->error_type);
+  VALUE k = rb_const_get(LocalMemCache, eid);
+  rb_raise(k, e->error_str);
 }
 
 /* :nodoc: */
-static VALUE LocalMemCache__new2(VALUE klass, VALUE namespace, VALUE size) {
+static VALUE LocalMemCache__new2(VALUE klass, VALUE namespace, VALUE size_mb) {
   lmc_error_t e;
   local_memcache_t *lmc = local_memcache_create(rstring_ptr(namespace), 
-      long_value(size), &e);
-  if (!lmc) { raise_exception(LocalMemCacheError, &e); }
+      double_value(size_mb), &e);
+  if (!lmc) { raise_exception(&e); }
   return Data_Wrap_Struct(klass, NULL, local_memcache_free, lmc);
 }
 
 /* :nodoc: */
-static VALUE LocalMemCache__clear_namespace(VALUE klass, VALUE ns, VALUE repair) {
+static VALUE LocalMemCache__clear_namespace(VALUE klass, VALUE ns, 
+    VALUE repair) {
   lmc_error_t e;
   if (!local_memcache_clear_namespace(rstring_ptr(ns), bool_value(repair), &e)) {
-    raise_exception(LocalMemCacheError, &e); 
+    raise_exception(&e); 
   }
   return Qnil;
 }
 
+/* :nodoc: */
+static VALUE LocalMemCache__check_namespace(VALUE klass, VALUE ns) {
+  lmc_error_t e;
+  if (!local_memcache_check_namespace(rstring_ptr(ns), &e)) {
+    raise_exception(&e); 
+  }
+  return Qnil;
+}
+
+/* :nodoc: */
+static VALUE LocalMemCache__enable_test_crash(VALUE klass) {
+  srand(getpid());
+  lmc_test_crash_enabled = 1;
+  return Qnil;
+}
+
+/* :nodoc: */
+static VALUE LocalMemCache__disable_test_crash(VALUE klass) {
+  lmc_test_crash_enabled = 0;
+  return Qnil;
+}
+
 /* :nodoc: */
 local_memcache_t *get_LocalMemCache(VALUE obj) {
   local_memcache_t *lmc;
@@ -59,8 +100,12 @@ local_memcache_t *get_LocalMemCache(VALUE obj) {
  *  Retrieve value from hashtable.
  */
 static VALUE LocalMemCache__get(VALUE obj, VALUE key) {
-  return ruby_string(local_memcache_get(get_LocalMemCache(obj), 
-      rstring_ptr(key)));
+  size_t l;
+  const char* r = __local_memcache_get(get_LocalMemCache(obj), 
+      rstring_ptr(key), rstring_length(key), &l);
+  VALUE rr = lmc_ruby_string2(r, l);
+  lmc_unlock_shm_region("local_memcache_get", get_LocalMemCache(obj));
+  return rr;
 }
 
 /* 
@@ -73,8 +118,9 @@ static VALUE LocalMemCache__get(VALUE obj, VALUE key) {
 
 static VALUE LocalMemCache__set(VALUE obj, VALUE key, VALUE value) {
   local_memcache_t *lmc = get_LocalMemCache(obj);
-  if (!local_memcache_set(lmc, rstring_ptr(key), rstring_ptr(value))) { 
-    raise_exception(LocalMemCacheError, &lmc->error); 
+  if (!local_memcache_set(lmc, rstring_ptr(key), rstring_length(key), 
+      rstring_ptr(value), rstring_length(value))) { 
+    raise_exception(&lmc->error); 
   }
   return Qnil;
 }
@@ -87,7 +133,7 @@ static VALUE LocalMemCache__set(VALUE obj, VALUE key, VALUE value) {
  */
 static VALUE LocalMemCache__delete(VALUE obj, VALUE key) {
   return local_memcache_delete(get_LocalMemCache(obj), 
-      rstring_ptr(key));
+      rstring_ptr(key), rstring_length(key));
   return Qnil;
 }
 
@@ -98,22 +144,66 @@ static VALUE LocalMemCache__delete(VALUE obj, VALUE key) {
  *  Releases hashtable.
  */
 static VALUE LocalMemCache__close(VALUE obj) {
-  local_memcache_free(get_LocalMemCache(obj));
+  lmc_error_t e;
+  if (!local_memcache_free(get_LocalMemCache(obj), &e)) raise_exception(&e);
   return Qnil;
 }
 
-static VALUE LocalMemCache;
+typedef struct {
+  VALUE ary;
+} lmc_ruby_iter_collect_keys;
+
+int lmc_ruby_iter(void *ctx, const char* key, const char* value) {
+  lmc_ruby_iter_collect_keys *data = ctx;
+  rb_ary_push(data->ary, lmc_ruby_string(key));
+  return 1;
+}
+
+static VALUE __LocalMemCache__keys(VALUE d) {
+  VALUE obj = rb_ary_entry(d, 0);
+  VALUE r = rb_ary_entry(d, 1);
+  lmc_ruby_iter_collect_keys data;
+  data.ary = r;
+  int success = local_memcache_iterate(get_LocalMemCache(obj), 
+      (void *) &data, lmc_ruby_iter);
+  if (!success) { return Qnil; }
+}
+
+/* 
+ *  call-seq:
+ *     lmc.keys()   ->   array or nil
+ *
+ *  Returns a list of keys.
+ */
+static VALUE LocalMemCache__keys(VALUE obj) {
+  VALUE d = rb_ary_new();
+  rb_ary_push(d, obj);
+  rb_ary_push(d, rb_ary_new());
+  int error = 0;
+  rb_protect(__LocalMemCache__keys, d, &error);
+  if (error) {
+    lmc_unlock_shm_region("local_memcache_iterate", get_LocalMemCache(obj));
+    rb_exc_raise(ruby_errinfo);
+  }
+  return rb_ary_entry(d, 1);
+}
 
 void Init_rblocalmemcache() {
-  LocalMemCacheError = rb_define_class("LocalMemCacheError", rb_eStandardError);
   LocalMemCache = rb_define_class("LocalMemCache", rb_cObject);
   rb_define_singleton_method(LocalMemCache, "_new", LocalMemCache__new2, 2);
   rb_define_singleton_method(LocalMemCache, "_clear_namespace", 
       LocalMemCache__clear_namespace, 2);
+  rb_define_singleton_method(LocalMemCache, "check_namespace", 
+      LocalMemCache__check_namespace, 1);
+  rb_define_singleton_method(LocalMemCache, "disable_test_crash", 
+      LocalMemCache__disable_test_crash, 0);
+  rb_define_singleton_method(LocalMemCache, "enable_test_crash", 
+      LocalMemCache__enable_test_crash, 0);
   rb_define_method(LocalMemCache, "get", LocalMemCache__get, 1);
   rb_define_method(LocalMemCache, "[]", LocalMemCache__get, 1);
   rb_define_method(LocalMemCache, "delete", LocalMemCache__delete, 1);
   rb_define_method(LocalMemCache, "set", LocalMemCache__set, 2);
   rb_define_method(LocalMemCache, "[]=", LocalMemCache__set, 2);
+  rb_define_method(LocalMemCache, "keys", LocalMemCache__keys, 0);
   rb_define_method(LocalMemCache, "close", LocalMemCache__close, 0);
 }

data/src/tests/allocfailure

@@ -0,0 +1,15 @@
+#! /bin/sh
+D=`dirname $0`
+DIR=`cd $D; pwd`
+script=$DIR/allocfailure.rb
+
+export CFLAGS=-DDO_TEST_ALLOC_FAILURE
+make -C .. clean && make -C .. && make -C ../ruby-binding && 
+ruby extconf.rb && make clean && make
+
+if test "x$1" = "x-d"; then
+  irb -r $script
+else
+  #valgrind --leak-check=full --tool=memcheck ruby $script
+  ruby $script
+fi

data/src/tests/allocfailure.rb

@@ -0,0 +1,20 @@
+$DIR=File.dirname(__FILE__)
+['.', '..', '../ruby-binding/'].each {|p| $:.unshift File.join($DIR, p) }
+
+require 'localmemcache'
+
+LocalMemCache.clear_namespace("alloc-failure-test", true);
+
+
+  LocalMemCache.enable_test_crash
+  $lm2 = LocalMemCache.new :namespace=>"alloc-failure-test"
+  2000000.times {
+    begin
+      r = rand(10000).to_s
+      $lm2.set(r, r)
+      $lm2.get(r)
+    rescue Exception => e
+      puts "e: #{e.to_s}"
+    end
+  }
+