caffeine 0.0.2

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2006 Fredrik Roos, Adocca AB
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,66 @@
+
+
+begin
+  require 'rubygems'
+  require 'rake/clean'
+  require 'rake/testtask'
+  require 'rake/gempackagetask'
+rescue Exception
+  nil
+end
+
+NAME = 'caffeine'
+VERS = '0.0.2'
+
+FILES_COMMON = FileList['Rakefile', 'lib/**/*.rb'] 
+FILES_EXT = FileList['ext/*.c']
+CLEAN.include ['ext/tags', 'ext/*.so', 'ext/*.o', 'ext/Makefile', 'ext/mkmf.log']
+LICENSE = FileList['LICENSE']
+
+desc "Does a full compile, test run"
+task :default => [:test]
+
+desc "Packages up Caffeine"
+task :package => [:clean]
+
+desc "Run all the tests"
+Rake::TestTask.new do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/test_*.rb']
+    t.verbose = true
+end
+
+if defined? Gem
+  spec = Gem::Specification.new do |s|
+    s.name        = NAME
+    s.version     = VERS
+    s.summary     = 'A Ruby binding for libmemcache + extra functionality (namespaces)'
+    s.requirements << 'libmemcache'
+    s.requirements << 'libuuid'
+    s.files       = FILES_COMMON + FILES_EXT + LICENSE
+    s.extensions  = ['ext/extconf.rb']
+    s.test_files  = FileList['test/test_*.rb']
+    #s.has_rdoc    = true
+    #s.extra_rdoc_files = FileList['README', 'CHANGES', 'TODO']
+    #s.rdoc_options = RDOC_OPTS
+    s.author      = 'Fredrik Roos'
+    s.email       = 'fredrik.roos@adocca.com'
+    s.homepage    = 'http://adocca-plugins.rubyforge.org'
+    s.rubyforge_project = "adocca-plugins"
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar_gz = true
+    pkg.need_zip = true
+  end
+
+end  # defined? Gem
+
+task :install do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS}}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end

data/ext/caffeine.c

@@ -0,0 +1,906 @@
+#define _GNU_SOURCE
+#ifdef f
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include <uuid/uuid.h>
+#include <openssl/md5.h>
+#include <memcache.h>
+#include <ruby.h>
+
+// Datatypes
+//
+
+// Caffeine namespace
+VALUE mCaffeine = Qnil;
+
+// The MemCache class
+VALUE cMemCache = Qnil;
+
+// the not found symbol :MemCache_no_such_entry
+VALUE sMemCache_NotFound = Qnil;
+
+// Exception class
+VALUE eMemCacheError = Qnil;
+VALUE eMemCacheNotFound = Qnil;
+
+// debug flag
+
+int debug_output;
+
+#define DBG(args...) if (debug_output) fprintf(stderr, args);
+
+// Ruby methods
+VALUE MemCache_alloc(VALUE class);
+VALUE MemCache_initialize(VALUE self, VALUE opts);
+VALUE MemCache_set_servers(VALUE self, VALUE servers);
+VALUE MemCache_get(int argc, VALUE *args, VALUE self);
+VALUE MemCache_set(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_add(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_replace(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_synchronize(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_lock(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_flush(VALUE self);
+VALUE MemCache_disconnect(VALUE self);
+VALUE MemCache_check(VALUE self, VALUE key);
+VALUE MemCache_delete(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_inc(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_dec(int argc, VALUE *argv, VALUE self);
+VALUE MemCache_invalidate_namespace(VALUE self, VALUE namespace);
+
+// Internal datatypes
+
+// The MemCache class
+// Holds a memcache context and the namespace
+// and an instance id for the locking
+typedef struct _memcache
+{
+  struct memcache *mc;
+  char *namespace;
+  char instance_id[64];
+} Memcache;
+
+// A chunk of memory for the memory pool
+typedef struct _memchunk
+{
+  void *mem;
+  ssize_t available;
+  struct _memchunk *next;
+} Memchunk;
+
+typedef struct _memcache_request
+{
+  char *key;
+  ssize_t keylen;
+  int num_chunks;
+  Memcache *mc; // put in here to avoid passing it around
+  Memchunk * first_chunk;
+  Memchunk * current_chunk;
+} MemcacheRequest;
+
+// Holds a pair of strings
+// Used for the namespace stuff
+typedef struct _key_pair
+{
+  char *first;
+  char *last;
+} KeyPair;
+
+// Represents a namespace
+// (An array of strings, really)
+typedef struct _namespace
+{
+  ssize_t len;
+  ssize_t head;
+  char **segments;
+} Namespace;
+
+// Various internal functions
+
+// MemcacheRequest instantiation
+static MemcacheRequest *  memcache_request_for_key(VALUE self, VALUE key);
+static MemcacheRequest *  memcache_request_create(VALUE self);
+
+// Mempool implementation
+static Memchunk *         alloc_chunk(size_t size);
+static void               memcache_request_free(MemcacheRequest *);
+
+// Key generation and namespaces
+static char *             key_for_value(MemcacheRequest *mr, VALUE key);
+static char *             key_from_namespace(MemcacheRequest *mr, Namespace *ns);
+static char *             namespace_pop_item(Namespace *ns);
+static char *             namespace_shift_item(Namespace *ns);
+
+// Utility functions
+static char *             key_from_segments(MemcacheRequest *mr, ...);
+static Namespace *        namespace_from_array(MemcacheRequest *mr, VALUE ary);
+static KeyPair *          key_pair_from_namespace(MemcacheRequest *mr,  Namespace * namespace, char * appendage);
+static char *             md5_digest(MemcacheRequest *mp, const char *input);
+static void               get_lock_options(VALUE options, int *expiry, int *timeout);
+
+// Memcache utility functions
+static int                store_cmd(int cmd, int argc, VALUE *argv, VALUE self);
+static int                str_add(struct memcache *mc, const char *key, char *value, int expiry);
+static int                str_cmp(struct memcache *mc, const char *key, char *cmpvalue);
+static int                do_request(struct memcache *mc, const char *key, void *val, ssize_t size);
+static int                lock(Memcache *mc, const char *key, int expiry, int timeout);
+
+// Demarshalling
+static VALUE              load_result(void *result, size_t result_len);
+
+// Debug stuff
+static void               verify_string(char * in);
+static int                validate_key(char *str);
+static void               nospace(char *str);
+static int                isnum(char *str, size_t len);
+
+// Initializion function
+// Define the class and its methods
+void Init_caffeine()
+{
+  // Init namespace and classes
+  mCaffeine = rb_define_module("Caffeine");
+
+  cMemCache = rb_define_class_under(mCaffeine, "MemCache", rb_cObject);
+  eMemCacheError = rb_define_class_under(mCaffeine, "MemCacheError", rb_eRuntimeError);
+  eMemCacheNotFound = rb_define_class_under(mCaffeine, "MemCacheNotFound", rb_eRuntimeError);
+  sMemCache_NotFound = ID2SYM(rb_intern("MemCache_no_such_entry"));
+
+  rb_define_alloc_func(cMemCache, MemCache_alloc);
+  rb_define_method(cMemCache, "initialize", MemCache_initialize, 1);
+  // and so on
+  rb_define_method(cMemCache, "get", MemCache_get, -1);
+  rb_define_alias(cMemCache, "[]", "get");
+  rb_define_method(cMemCache, "set", MemCache_set, -1);
+  rb_define_alias(cMemCache, "[]=", "set");
+  rb_define_method(cMemCache, "add", MemCache_set, -1);
+  rb_define_method(cMemCache, "replace", MemCache_set, -1);
+  rb_define_method(cMemCache, "servers=", MemCache_set_servers, 1);
+  rb_define_method(cMemCache, "disconnect", MemCache_disconnect, 0);
+  rb_define_method(cMemCache, "invalidate_namespace", MemCache_invalidate_namespace, 1);
+  rb_define_method(cMemCache, "inc", MemCache_inc, -1);
+  rb_define_method(cMemCache, "dec", MemCache_dec, -1);
+  rb_define_method(cMemCache, "synchronize", MemCache_synchronize, -1);
+  rb_define_method(cMemCache, "lock", MemCache_lock, -1);
+  rb_define_method(cMemCache, "unlock", MemCache_delete, -1);
+  rb_define_method(cMemCache, "flush", MemCache_flush, 0);
+  rb_define_method(cMemCache, "check", MemCache_check, 1);
+  rb_define_method(cMemCache, "delete", MemCache_delete, -1);
+
+  debug_output = getenv("CAFFEINE_DEBUG") ? 1 : 0;
+}
+
+// The Ruby GC wants a function to deallocate C-defined objects
+// Since rails keeps a reference around to its cache objects during
+// its entire lifetime this will never be called in a Rails setting,
+// it's here for completeness.
+void memcache_free(void *mc)
+{
+  DBG("Disconnecting from memcache\n");
+  mc_server_disconnect_all(((Memcache *)mc)->mc);
+  free(((Memcache *)mc)->namespace);
+  mc_free(((Memcache *)mc)->mc);
+  free(mc);
+}
+
+// This is called by the default Object#new to allocate space for the
+// object 
+VALUE MemCache_alloc(VALUE class)
+{
+  Memcache * mc; 
+  return Data_Make_Struct(cMemCache, Memcache, 0, memcache_free, mc);
+}
+
+// Constructor
+VALUE MemCache_initialize(VALUE self, VALUE opts)
+{
+  Memcache * mc;
+  uuid_t uuid;
+  VALUE namespace;
+  // Convert the self pointer (ruby VALUE) to a C struct
+  Data_Get_Struct(self, Memcache, mc);
+
+  // Initialize the libmemcache context
+  mc->mc = mc_new();
+
+  // this is unsupported, but the only way i found to turn of verbose logging
+  // IOW, libmemcache sucks donkey balls
+  mc_global_ctxt()->MCM_ERR_MASK |= (MC_ERR_LVL_INFO | MC_ERR_LVL_NOTICE);
+
+  // Right now we don't support any options beyond :namespace
+  // It's required so we are using a default if none is provided
+  if ((namespace = rb_hash_aref(opts, ID2SYM(rb_intern("namespace")))) != Qnil)
+    mc->namespace = strdup(StringValuePtr(namespace));
+  else
+    mc->namespace = strdup("caffeine_default_ns");
+
+  // Generate the instance id
+  uuid_generate(uuid);
+  uuid_unparse(uuid, mc->instance_id);
+
+  return Qnil;
+}
+
+// Accessor to the MemCache#servers= method.
+// So far this is a write-only attribute
+// Note that assigning a new array will not remove the
+// previously defined servers.
+VALUE MemCache_set_servers(VALUE self, VALUE servers)
+{
+  int i;
+  Memcache *mc;
+  Data_Get_Struct(self, Memcache, mc);
+
+  Check_Type(servers, T_ARRAY);
+
+  for (i = 0; i < RARRAY(servers)->len; i++)
+    mc_server_add4(mc->mc, STR2CSTR(rb_ary_entry(servers, i)));
+
+  return Qnil;
+}
+
+// Explicit disconnect
+VALUE MemCache_disconnect(VALUE self)
+{
+  Memcache *mc;
+  Data_Get_Struct(self, Memcache, mc);
+  DBG("Disconnecting from memcache\n");
+  mc_server_disconnect_all(mc->mc);
+  return Qnil;
+}
+
+// The MemCache#get method. The parameter is either an
+// Array, in which case we do a namespace lookup, or 
+// a string for normal memcached lookup
+// Symbols are converted to string
+VALUE MemCache_get(int argc, VALUE *args, VALUE self)
+{
+  // This allocates the necessary data structures for a request
+  // and performs all the namespace magic. All methods that take
+  // a key does this.
+  MemcacheRequest * mr;
+  struct memcache_req *req = mc_req_new();
+  struct memcache_res *res[argc];
+  VALUE return_obj;
+  int tmp;
+
+  if (argc < 1)
+    rb_raise(rb_eRuntimeError, "Caffeine::MemCache#get(*args) takes at least one argument");
+  else if (argc > 1)
+    return_obj = rb_ary_new();
+   
+  for (tmp = 0; tmp < argc; tmp++) {
+    mr = memcache_request_for_key(self, args[tmp]);
+    res[tmp] = mc_req_add(req, mr->key, strlen(mr->key));
+    memcache_request_free(mr);
+    DBG("%d: GET %s\n", tmp, mr->key);
+  }
+
+  mc_get(mr->mc->mc, req);
+
+  for (tmp = 0; tmp < argc; tmp++) {
+    if (res[tmp]->val) {
+      DBG("%d: Got %d bytes\n", tmp, res[tmp]->size);
+      if (argc == 1)
+	return_obj = load_result(res[tmp]->val, res[tmp]->size);
+      else
+	rb_ary_push(return_obj, load_result(res[tmp]->val, res[tmp]->size));
+    } else {
+      DBG("%d: No value for key\n", tmp);
+      if (argc == 1)
+	return_obj = sMemCache_NotFound;
+      else
+	rb_ary_push(return_obj, sMemCache_NotFound);
+    }
+    mc_res_free(req, res[tmp]);
+  }
+
+  mc_req_free(req);
+
+  return return_obj;
+}
+
+// Storage methods
+
+#define MC_CMD_SET 0
+#define MC_CMD_ADD 1
+#define MC_CMD_REPLACE 2
+
+const char * store_commands[] = {"SET", "ADD", "REPLACE"};
+
+// All the storage methods wrap the store_cmd function,
+// passing the storage methods
+
+VALUE MemCache_set(int argc, VALUE *argv, VALUE self)
+{
+  store_cmd(MC_CMD_SET, argc, argv, self);
+  return Qnil;
+}
+
+VALUE MemCache_add(int argc, VALUE *argv, VALUE self)
+{
+  store_cmd(MC_CMD_ADD, argc, argv, self);
+  return Qnil;
+}
+
+VALUE MemCache_replace(int argc, VALUE *argv, VALUE self)
+{
+  store_cmd(MC_CMD_REPLACE, argc, argv, self);
+  return Qnil;
+}
+
+// Used by all storage methods
+static int store_cmd(int cmd, int argc, VALUE *argv, VALUE self)
+{
+  MemcacheRequest * mr; 
+  VALUE key, value, expiry, marshaled;
+  char number_as_string[64];
+  void * data;
+  size_t data_len;
+  int retval;
+  rb_scan_args(argc, argv, "21", &key, &value, &expiry);
+  mr = memcache_request_for_key(self, key);
+
+  DBG("%s %s\n", store_commands[cmd], mr->key);
+
+  // Numbers are stored in raw form (for some reason), so there's
+  // no marshalling
+  if (TYPE(value) == T_FIXNUM)
+  {
+      sprintf(number_as_string, "%d", FIX2INT(value));
+      data = number_as_string;
+      data_len = strlen(data);
+  } else {
+      marshaled = rb_marshal_dump(value, Qnil);
+      data = RSTRING(marshaled)->ptr;
+      data_len = RSTRING(marshaled)->len;
+  }
+
+  switch(cmd)
+  {
+    case MC_CMD_SET:
+      retval = mc_set(mr->mc->mc, mr->key, mr->keylen, data, data_len, NIL_P(expiry) ? 0 : FIX2INT(expiry), 0);
+      break;
+    case MC_CMD_ADD:
+      retval = mc_add(mr->mc->mc, mr->key, mr->keylen, data, data_len, NIL_P(expiry) ? 0 : FIX2INT(expiry), 0);
+      break;
+    case MC_CMD_REPLACE:
+      retval = mc_replace(mr->mc->mc, mr->key, mr->keylen, data, data_len, NIL_P(expiry) ? 0 : FIX2INT(expiry), 0);
+      break;
+  }
+
+  memcache_request_free(mr);
+  return retval;
+}
+
+
+// MemCache#invalidate_namespace
+VALUE MemCache_invalidate_namespace(VALUE self, VALUE namespace)
+{
+  MemcacheRequest * mr = memcache_request_create(self);
+  char *key;
+
+  // The rest of the code assumes that namespace is an array
+  // If namespace is a string, create a one element array,
+  // and put the string in there
+  if (TYPE(namespace) == T_STRING)
+  {
+    VALUE ary = rb_ary_new2(1);
+    rb_ary_push(ary, namespace);
+    namespace = ary;
+  }
+
+  key = key_from_segments(mr, key_pair_from_namespace(mr, namespace_from_array(mr, namespace), NULL)->last, NULL);
+
+  DBG("Invalidating namespace key: %s\n", key);
+
+  mc_incr(mr->mc->mc, key, strlen(key), 1);
+  // XXX check  retval
+  memcache_request_free(mr);
+  return Qnil;
+}
+
+// MemCache#inc
+VALUE MemCache_inc(int argc, VALUE *argv, VALUE self)
+{
+  MemcacheRequest * mr;
+  VALUE key, amount;
+  int ret;
+  rb_scan_args(argc, argv, "11", &key, &amount);
+  mr = memcache_request_for_key(self, key);
+  ret = rb_fix_new(mc_incr(mr->mc->mc, mr->key, mr->keylen, NIL_P(amount) ? 1 : FIX2INT(amount)));
+  memcache_request_free(mr);
+  return ret;
+}
+
+// MemCache#dec
+VALUE MemCache_dec(int argc, VALUE *argv, VALUE self)
+{
+  MemcacheRequest * mr;
+  VALUE key, amount;
+  int ret;
+  rb_scan_args(argc, argv, "11", &key, &amount);
+  mr = memcache_request_for_key(self, key);
+  ret = rb_fix_new(mc_decr(mr->mc->mc, mr->key, mr->keylen, NIL_P(amount) ? 1 : FIX2INT(amount)));
+  memcache_request_free(mr);
+  return ret;
+}
+
+#define TRANS_MAX_TRIES 5
+
+// Does some magic with a key unique per thread and host
+// to implement atomic operations
+VALUE MemCache_lock(int argc, VALUE *argv, VALUE self)
+{
+  MemcacheRequest * mr; 
+  VALUE retval = Qnil;
+  VALUE key, options;
+  int expiry, timeout;
+
+  rb_scan_args(argc, argv, "11", &key, &options);
+  mr = memcache_request_for_key(self, key);
+  get_lock_options(options, &expiry, &timeout);
+
+  retval = lock(mr->mc, mr->key, expiry, timeout) ? Qtrue : Qfalse;
+
+  memcache_request_free(mr);
+  return retval;
+}
+
+static void get_lock_options(VALUE options, int *expiry, int *timeout)
+{
+  if (NIL_P(options))
+  {
+    *expiry = 0;
+    *timeout = 0;
+  } else {
+    VALUE r_expiry = rb_hash_aref(options, ID2SYM(rb_intern("expiry")));
+    VALUE r_timeout = rb_hash_aref(options, ID2SYM(rb_intern("timeout")));
+
+    *expiry = NIL_P(r_expiry) ? 0 : FIX2INT(r_expiry);
+    *timeout = NIL_P(r_timeout) ? 0 : FIX2INT(r_timeout);
+  }
+}
+
+static int lock(Memcache *mc, const char *key, int expiry, int timeout)
+{
+  int tries = 0, locked_now = 0, locked_earlier = 0;
+  time_t start;
+
+  start = time(NULL);
+
+  // as long as add fails (key exists - from another host/thread)
+  // and the existing key differs from ours keep trying TRANS_MAX_TRIES times
+
+  //fprintf(stderr, "Attempting lock - expiry: %d - timeout: %d\n", expiry, timeout);
+
+  while (!(locked_now = !str_add(mc->mc, key, mc->instance_id, expiry)) &&
+      !(locked_earlier = !str_cmp(mc->mc, key, mc->instance_id)) &&
+      (timeout == 0 || (time(NULL) - start) < timeout))
+  {
+    //fprintf(stderr, "Retrying lock - time: %d - timeout: %d\n", (time(NULL) - start), timeout);
+    sleep(1);
+  }
+
+  return locked_now || locked_earlier;
+}
+
+VALUE MemCache_synchronize(int argc, VALUE *argv, VALUE self)
+{
+  MemcacheRequest * mr; 
+  VALUE retval = Qnil;
+  VALUE key, options;
+  int expiry, timeout;
+
+  rb_scan_args(argc, argv, "11", &key, &options);
+  mr = memcache_request_for_key(self, key);
+  get_lock_options(options, &expiry, &timeout);
+
+  if (lock(mr->mc, mr->key, expiry, timeout))
+  {
+    retval = rb_yield(Qnil);
+    mc_delete(mr->mc->mc, mr->key, mr->keylen, 0);
+  } else {
+    rb_raise(eMemCacheError, "Could not obtain lock");
+  }
+  return retval;
+}
+
+// MemCache#flush
+VALUE MemCache_flush(VALUE self)
+{
+  MemcacheRequest *mr = memcache_request_create(self);
+  DBG("Flushing memcache\n");
+  mc_flush_all(mr->mc->mc); // deal with error
+  memcache_request_free(mr);
+  return Qnil;
+}
+
+// MemCache#check
+// Check if a value exists on the server
+VALUE MemCache_check(VALUE self, VALUE key)
+{
+  MemcacheRequest * mr = memcache_request_for_key(self, key);
+  void *value;
+  VALUE retval;
+
+  if ((value = mc_aget(mr->mc->mc, mr->key, mr->keylen)))
+    retval = Qtrue;
+  else
+    retval = Qfalse;
+
+  free(value);
+  memcache_request_free(mr);
+  return retval;
+}
+
+// MemCache#delete
+// Delete an object on server (yes, really)
+VALUE MemCache_delete(int argc, VALUE *argv, VALUE self)
+{
+  MemcacheRequest * mr;
+  VALUE key, hold;
+  rb_scan_args(argc, argv, "11", &key, &hold);
+  mr = memcache_request_for_key(self, key);
+  mc_delete(mr->mc->mc, mr->key, mr->keylen, NIL_P(hold) ? 0 : FIX2INT(hold));
+
+  memcache_request_free(mr);
+  return Qnil;
+}
+
+
+// ruby+C stuff
+#define CHUNK_SIZE 8192 * 32
+
+
+// Takes a char* and returns a ruby object
+// Handles the case where the string is only numbers
+// without demarshalling
+static VALUE load_result(void *result, size_t result_len)
+{
+  char * result_string = (char *)result;
+
+  if (isnum(result_string, result_len))
+    return rb_fix_new(atoi(result_string));
+  else
+    return rb_marshal_load(rb_str_new(result, result_len));
+}
+
+
+// Allocates the data structure used during a request.
+// Also extracts the C struct from the self value
+static MemcacheRequest * memcache_request_create(VALUE self)
+{
+  MemcacheRequest * mr = ALLOC(MemcacheRequest);
+  Data_Get_Struct(self, Memcache, mr->mc);
+
+  mr->first_chunk = mr->current_chunk = alloc_chunk(0);
+  mr->key = NULL;
+  mr->keylen = 0;
+  mr->num_chunks = 1;
+
+  //printf("%d bytes allocated\n", CHUNK_SIZE);
+
+  return mr;
+}
+
+// Create a MemCache request and the generated key 
+static MemcacheRequest * memcache_request_for_key(VALUE self, VALUE key)
+{
+  MemcacheRequest * mr = memcache_request_create(self);
+  mr->key = key_for_value(mr, key);
+  mr->keylen = strlen(mr->key);
+  return mr;
+}
+
+
+// Decides if we want to have a normal memcached key or need
+// to do namespace key generation
+static char * key_for_value(MemcacheRequest *mr, VALUE key)
+{
+  if (TYPE(key) == T_ARRAY && RARRAY(key)->len == 1)
+    key = rb_ary_entry(key, 0);
+
+  switch (TYPE(key))
+  {
+    case T_SYMBOL:
+      key = rb_str_new2(rb_id2name(SYM2ID(key)));
+    case T_STRING:
+      // Just concatenate the base namespace with the key
+      return key_from_segments(mr, mr->mc->namespace, md5_digest(mr, StringValuePtr(key)), NULL);
+    case T_ARRAY:
+      // Arrays are namespace keys proceed with processing
+      return key_from_namespace(mr, namespace_from_array(mr, key));
+    default:
+      rb_raise(rb_eTypeError, "Key must be String, Symbol or Array");
+      return NULL;
+  }
+}
+
+
+// Chunked memory allocation implementation
+// malloc() style function, allocate an arbitrary amount of memory
+static void * memcache_request_alloc(MemcacheRequest *mr, ssize_t size) 
+{
+  // Allocate a new chunk if we are out of space in the current one
+  if (size > mr->current_chunk->available)
+    mr->current_chunk = mr->current_chunk->next = alloc_chunk(size);
+
+  mr->current_chunk->available -= size;
+  return mr->current_chunk->mem + CHUNK_SIZE - mr->current_chunk->available - size;
+}
+
+// Allocates one chunk of at least CHUNK_SIZE bytes
+static Memchunk * alloc_chunk(size_t size)
+{
+  Memchunk * mc = ALLOC(Memchunk);
+  size = size > CHUNK_SIZE ? size : CHUNK_SIZE;
+  mc->available = size;
+  mc->mem = ALLOC_N(char, size);
+  mc->next = NULL;
+  return mc;
+}
+
+// Takes a ruby array and creates a Namespace struct (sort of a C array wrapper)
+static Namespace * namespace_from_array(MemcacheRequest *mr, VALUE ary)
+{
+  Namespace * ns = memcache_request_alloc(mr, sizeof(Namespace));
+  int i;
+
+  ns->len = RARRAY(ary)->len;
+  ns->segments = memcache_request_alloc(mr, sizeof(char *) * ns->len);
+  ns->head = 0;
+
+  for (i = 0; i < ns->len; i++)
+  {
+    VALUE rb_item = rb_ary_entry(ary, i);
+    char * item = md5_digest(mr, StringValueCStr(rb_item));
+    ns->segments[i] = memcache_request_alloc(mr, strlen(item) + 1);
+    strcpy(ns->segments[i], item);
+  }
+  return ns;
+}
+
+// Pure C stuff
+
+static void verify_string(char * in)
+{
+    // debug code
+    char *ccp;
+    ccp = in;
+    while (*ccp)
+    {
+      if(!(isalnum(*ccp) || *ccp == ':'))
+        abort();
+      ccp++;
+    }
+}
+
+// Take a variable number of arguments and concatenate them, 
+// separated by colons.
+// Like SOME_ARRAY.join(':') 
+static char * key_from_segments(MemcacheRequest *mr, ...)
+{
+  va_list args;
+  char * current;
+  char * ret;
+  ssize_t tot_len = 0;
+  char *cp;
+  int tmp;
+
+  va_start(args, mr);
+
+  // Calculate needed storage
+  while ((current = va_arg(args, char*)))
+  {
+    // Current string + tailing colon or null terminator
+    tot_len += strlen(current) + 1;
+  }
+
+  if (tot_len == 0)
+    return NULL;
+
+  va_end(args);
+  ret = memcache_request_alloc(mr, tot_len);
+  cp = ret;
+
+  va_start(args, mr);
+
+  while ((current = va_arg(args, char*)))
+  {
+    tmp = strlen(current);
+    mempcpy(cp, current, tmp);
+    cp += tmp;
+    *(cp++) = ':';
+  }
+  ret[tot_len-1] = '\0';
+
+  return ret;
+}
+
+// Generates a key from a namespace array
+static char * key_from_namespace(MemcacheRequest *mr, Namespace *ns)
+{
+  // does not work with single item ns
+  char *key = namespace_pop_item(ns);
+  return key_from_segments(mr, mr->mc->namespace, 
+      md5_digest(mr, key_pair_from_namespace(mr, ns, NULL)->first), key, NULL);
+}
+
+// Convenience function to create a pair from its args
+static KeyPair * key_pair_from_strings(MemcacheRequest *mr, char *first, char *last)
+{
+  KeyPair *nk = memcache_request_alloc(mr, sizeof(KeyPair));
+  nk->first = first;
+  nk->last = last;
+  return nk;
+}
+
+#define NAMESPACE_KEY_PREFIX "caffeine_namespace"
+#define SALT_MAXLEN_HEX 17
+#define SALT_MAXLEN_DEC 32
+
+
+// Takes a key and and store a random number on the server using it.
+// If it's already there, return that key instead.
+static char * put_salt(MemcacheRequest *mr, const char *key)
+{
+  char * rand_hex = memcache_request_alloc(mr, SALT_MAXLEN_HEX);
+  char rand_number[SALT_MAXLEN_DEC];
+
+  DBG("salt key is %s\n", key);
+
+  sprintf(rand_number, "%ld", random());
+
+  // str_add returns 0 on stored
+  if (str_add(mr->mc->mc, key, rand_number, 0))
+  {
+    // server already had value
+    // maybe check this, however unlikely it is that it'll fail ...
+    do_request(mr->mc->mc, key, rand_number, SALT_MAXLEN_DEC);
+  }
+
+  sprintf(rand_hex, "%016x", atol(rand_number));
+
+  return rand_hex;
+}
+
+// This is where all the namespace magic happens. A recursive function, lots of magic.
+// need documentation
+static KeyPair * key_pair_from_namespace(MemcacheRequest *mr,  Namespace * namespace, char * appendage)
+{
+  char *next_part = namespace_shift_item(namespace);
+  char *salt, *next_key;
+
+  if (appendage) {
+    next_part = key_from_segments(mr, appendage, next_part, NULL);
+  }
+
+  next_key = key_from_segments(mr, NAMESPACE_KEY_PREFIX, next_part, NULL);
+
+  // make sure it exists in memcache
+  salt = put_salt(mr, next_key);
+  
+  if (namespace->head >= namespace->len)
+  {
+    // ["#{next_part}:#{salt}", next_key]
+    return key_pair_from_strings(mr, key_from_segments(mr, next_part, salt, NULL), next_key);
+  } else {
+    KeyPair * last_part = key_pair_from_namespace(mr, namespace, next_part);
+    // [ "#{next_part}:#{salt}:#{last_part.first}", last_part.last ]
+    return key_pair_from_strings(mr, key_from_segments(mr, next_part, salt, last_part->first, NULL), last_part->last);
+  }
+}
+
+// helperzzz
+
+// Add a string to the server - 0 is stored
+static int str_add(struct memcache *mc, const char *key, char *value, int expiry)
+{
+  return mc_add(mc, (char *)key, strlen(key), value, strlen(value) + 1, expiry, 0);
+}
+
+// Compare a string with a string on the server
+static int str_cmp(struct memcache *mc, const char *key, char *cmpvalue)
+{
+  int ret;
+  char stored_value[512];
+  if (!do_request(mc, key, stored_value, 512))
+    ret = strcmp(stored_value, cmpvalue);
+  else
+    ret = -1;
+  return ret;
+}
+
+// Fetch a value from the server using a user supplied memory chunk
+static int do_request(struct memcache *mc, const char *key, void *val, ssize_t size)
+{
+  struct memcache_req *req = mc_req_new();
+  struct memcache_res *res = mc_req_add(req, (char *)key, strlen(key));
+  res->size = size;
+  res->val = val;
+  mc_res_free_on_delete(res, 0);
+  mc_get(mc, req);
+  mc_req_free(req);
+  if (res->size == 0)
+    return -1;
+  else
+    return 0;
+}
+
+// Pop the last item from the namespace array and update the pointer
+static char * namespace_pop_item(Namespace *ns)
+{
+  if (ns->head == ns->len)
+    return NULL;
+
+  return ns->segments[ns->len---1];
+}
+
+// Pop the first item
+static char * namespace_shift_item(Namespace *ns)
+{
+  if (ns->head == ns->len)
+    return NULL;
+
+  return ns->segments[ns->head++];
+}
+
+// Free all the memory chunks used for this request
+static void memcache_request_free(MemcacheRequest *mr)
+{
+  Memchunk *iter, *next;
+
+  for(iter = mr->first_chunk; iter; iter = next)
+  {
+    next = iter->next;
+    iter->next = NULL;
+    free(iter->mem);
+    free(iter);
+    mr->num_chunks--;
+    //printf("%d bytes deallocated, %d left\n", CHUNK_SIZE, CHUNK_SIZE * mr->num_chunks);
+  }
+  mr->current_chunk = NULL;
+
+  free(mr);
+}
+
+static char * md5_digest(MemcacheRequest *mr, const char *input)
+{
+  unsigned char *digest = memcache_request_alloc(mr, MD5_DIGEST_LENGTH);
+  char *hexdigest = memcache_request_alloc(mr, MD5_DIGEST_LENGTH * 2 + 1);
+  MD5(input, strlen(input), digest);
+  snprintf(hexdigest, MD5_DIGEST_LENGTH * 2, /* Don't forget to trig all my stuff! */ "%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x",
+      digest[0],digest[1],digest[2],digest[3],digest[4],digest[5],digest[6],digest[7],digest[8],
+      digest[9],digest[10],digest[11],digest[12],digest[13],digest[14],digest[15]);
+  //fprintf(stderr, "Created hash %s from key \"%s\"\n", hexdigest, input);
+  return hexdigest;
+}
+
+// Check if a memory area consists of digits
+static int isnum(char *str, size_t len)
+{
+  char *cp = str;
+  while(cp < str + len)
+  {
+    if (!isdigit(*cp))
+      return 0;
+    cp++;
+  }
+  return 1;
+}
+
+static int validate_key(char *str)
+{
+  char *cp = str;
+  while(*cp)
+  {
+    if (*cp == ' ')
+      printf("Invalid key: %s\n", str);
+    cp++;
+  }
+}
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,24 @@
+require 'mkmf'
+
+$CFLAGS = '-ggdb -O0 -Df'
+#$CFLAGS = '-O3'
+
+extension_name = 'caffeine'
+
+def die
+  puts "STOP, HAMMERTIME: I can't touch this!"
+  exit 1
+end
+
+# Check for libmemcache
+die unless have_library('memcache', 'mc_new')
+# Check for libuuid
+die unless have_library('uuid', 'uuid_generate')
+# Check for openssl (for MD5 generation)
+die unless have_library('ssl')
+
+dir_config extension_name
+create_makefile extension_name
+
+
+ 

data/lib/caffeine_fragment_store.rb

@@ -0,0 +1,29 @@
+module ActionController
+  module Caching
+    module Fragments
+      class CaffeineStore
+        def initialize(cache_instance)
+          @cache = cache_instance
+        end
+
+        def read(name, options = {})
+          begin
+            @cache.get(name, options[:expiry] || 0)
+          rescue Caffeine::MemCacheNotFound
+            nil
+          end
+        end
+
+        def write(name, value, options = nil)
+          @cache.set(name, value)
+        end
+
+        def delete(name, options = nil)
+          @cache.delete(name)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/rails_helpers.rb

@@ -0,0 +1,67 @@
+module ActionView
+  module Helpers
+    module CacheHelper
+      def cache_value_erb(name, expiry = 0, &block)
+        cache(name, :expiry => expiry)
+      end
+      # Override the default to allow passing of options
+      # WHY THE FUCK isn't this done already in rails????
+      def cache(name = {}, options = {}, &block)
+        @controller.cache_erb_fragment(block, name, options)
+      end
+    end
+  end
+end
+
+module Caffeine
+  module CacheHelpers
+    def cache_defined?
+      (defined? $DISABLE_CACHE && $DISABLE_CACHE) || !(defined? CACHE)
+    end
+
+    def cache_value(name, expiry = 0, &block)
+      return default unless cache_defined?
+
+      begin
+        CACHE.get(name)
+      rescue Caffeine::MemCacheNotFound
+        result = block.call
+        CACHE.set key, result, expiry
+        result
+      end
+
+      return result
+    end
+
+    def cache_read(name, default = nil)
+      return default unless cache_defined?
+
+      begin
+        CACHE.get(name)
+      rescue Caffeine::MemCacheNotFound
+        default
+      end
+    end
+
+    def cache_check(name)
+      return false unless cache_defined?
+      CACHE.check(key)
+    end
+
+    alias :cache_check, :check_cached_value
+
+    def cache_delete(name, hold = 0)
+      return unless cache_defined?
+      CACHE.delete(key, hold)
+    end
+
+    def expire_cached_namespace(ns)
+      return unless cache_defined?
+      CACHE.invalidate_namespace(ns)
+    end
+
+    alias :expire_cached_value, :cache_delete
+
+  end
+end
+

data/test/test_caffeine.rb

@@ -0,0 +1,80 @@
+
+require 'test/unit'
+require 'rubygems'
+require 'caffeine'
+#require 'adocca_memcache'
+
+class TestCaffeine < Test::Unit::TestCase
+
+  def get_cache_instance
+    cache = Caffeine::MemCache.new :namespace => 'caffeinetest'
+    cache.servers = ["localhost:11211"]
+    return cache
+  end
+
+  def setup
+    @cache = get_cache_instance
+    @cache.flush
+  end
+
+#  def teardown
+#  end
+
+  def test_basic
+    # ruby value
+    @cache.set "foo", :somevalue
+    assert_equal :somevalue, @cache.get("foo")
+
+    # MemCache#check
+    assert_equal true, @cache.check("foo")
+    @cache.delete "foo"
+    assert_equal false, @cache.check("foo")
+
+    # integer value
+    @cache.set "foo2", 100
+    assert_equal 100, @cache.get("foo2")
+  end
+
+  def test_multi_key
+    @cache.set "burK", "bajs"
+    @cache.set "bork", "kiss"
+    @cache.set "hehu", "hoj"
+    assert_equal(["bajs","kiss","hoj"], @cache.get("burK", "bork", "hehu"))
+    @cache.set ["2","4","0","1"], "bingo"
+    @cache.set ["4","4","0","11"], "was a dog"
+    assert_equal(["bingo","was a dog"], @cache.get(["2","4","0","1"], ["4","4","0","11"]))
+  end
+
+  def test_namespaces
+    @cache.set ["ns1", "ns2", "ns3", "item"], :somevalue
+    @cache.set ["ns1", "ns2", "item2"], :othervalue
+    @cache.set ["ns1", "item3"], :yetanothervalue
+    @cache.set ["ns1", "item4"], :lastvalue
+    assert_equal :somevalue, @cache.get(["ns1", "ns2", "ns3", "item"])
+    @cache.invalidate_namespace ["ns1", "ns2", "ns3"]
+    assert_equal(:MemCache_no_such_entry, @cache.get(["ns1", "ns2", "ns3", "item"]))
+    assert_equal :othervalue, @cache.get(["ns1", "ns2", "item2"])
+    @cache.set ["ns1", "ns2", "ns3", "item"], :somevalue
+    assert_equal :somevalue, @cache.get(["ns1", "ns2", "ns3", "item"])
+    @cache.invalidate_namespace ["ns1", "ns2"]
+    assert_equal(:MemCache_no_such_entry, @cache.get(["ns1", "ns2", "ns3", "item"]))
+    assert_equal :yetanothervalue, @cache.get(["ns1", "item3"])
+    assert_equal :lastvalue, @cache.get(["ns1", "item4"])
+    @cache.invalidate_namespace ["ns1"]
+    assert_equal(:MemCache_no_such_entry, @cache.get(["ns1", "item3"]))
+    assert_equal(:MemCache_no_such_entry, @cache.get(["ns1", "item4"]))
+  end
+
+  def test_lock
+    assert @cache.lock("testlock", :timeout => 10)
+    cache2 = get_cache_instance
+    assert !cache2.lock("testlock", :timeout => 2) # will block
+    @cache.unlock "testlock"
+    assert_not_nil cache2.lock("testlock")
+    cache2.unlock "testlock"
+
+    assert @cache.lock("testlock")
+    assert_raises(Caffeine::MemCacheError) { cache2.synchronize("testlock", :timeout => 2) { sleep(1) } } 
+    @cache.unlock "testlock"
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: caffeine
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Fredrik Roos
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-22 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: fredrik.roos@adocca.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/caffeine_fragment_store.rb
+- lib/rails_helpers.rb
+- ext/caffeine.c
+- LICENSE
+has_rdoc: false
+homepage: http://adocca-plugins.rubyforge.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- libmemcache
+- libuuid
+rubyforge_project: adocca-plugins
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A Ruby binding for libmemcache + extra functionality (namespaces)
+test_files: 
+- test/test_caffeine.rb