Mongodb EntityStore

lib/rack/cache/entitystore.rb

@@ -168,6 +168,98 @@ def self.resolve(uri)
     DISK = Disk
     FILE = Disk
 
+    # Base class for mongo entity stores.
+    class Mongodb < EntityStore
+
+      attr_reader :cache
+
+      extend Rack::Utils
+
+      def open(key)
+        data = read(key)
+        data && [data]
+      end
+
+      # Resolving the URI is almost the same as Memcached.
+      # other than needing a database to connect to. Mongo
+      # also needs a connection name, this is currently hard
+      # coded as 'entitystore' but should probably be an ENV
+      # variable.
+      def self.resolve(uri)
+        if uri.respond_to?(:scheme)
+          server = uri.to_s
+          options = parse_query(uri.query)
+          options.keys.each do |key|
+            value =
+              case value = options.delete(key)
+              when 'true' ; true
+              when 'false' ; false
+              else value.to_sym
+              end
+            options[key.to_sym] = value
+          end
+          options[:database] = uri.path.sub(/^\//, '')
+          new server, options
+        else
+          # if the object provided is not a URI, pass it straight through
+          # to the underlying implementation.
+          new uri
+        end
+      end
+
+      def initialize(server="localhost:27017", options={})
+        @cache =
+          if server.respond_to?(:collection)
+            server['entitystore']
+          else
+            # use from_uri to make connecting to the DB simpler. Probably should support
+            # connection pooling and stuff in here too.
+            require 'mongo'
+            ::Mongo::Connection.from_uri(server, options)[options[:database]]['entitystore']
+          end
+      end
+
+      def exist?(key)
+        # use find_one to return a single result and close the cursor
+        !cache.find_one({:key => key}).nil?
+      end
+
+      def read(key)
+        # as all data is being written in binary mode, check if nil, and
+        # return nil if so before converting to a useful format if there
+        # is a record returned.
+        data = cache.find_one({:key => key})
+        if data.nil?
+          nil
+        else
+          # need to call `.to_s` on a mongo binary field to make it useable.
+          data = data['string'].to_s if data
+          data.force_encoding('BINARY') if data.respond_to?(:force_encoding)
+        end
+      end
+
+      def write(body, ttl=nil)
+        buf = StringIO.new
+        key, size = slurp(body){|part| buf.write(part) }
+        # essentially the same as memcached so far, but encode all cached resources
+        # as BSON::Binary instances to ensure they don't break the db encoding
+        string = ::BSON::Binary.new(buf.string)
+        # Call the indexing facility to run in the background every 5 minutes - multiple
+        # calls to this do nothing, so it is safe to call on each write.
+        cache.ensure_index([['key', ::Mongo::ASCENDING]], {background:true})
+        # using `:upsert => true` allows us to override any existing record with that key
+        [key, size] if cache.update({:key => key}, {:key => key, :string => string, :expires => ttl}, {:upsert => true})
+      end
+
+      def purge(key)
+        cache.remove({:key => key})
+        nil
+      end
+    end
+
+    MONGO = Mongodb
+    MONGODB = Mongodb
+
     # Base class for memcached entity stores.
     class MemCacheBase < EntityStore
       # The underlying Memcached instance used to communicate with the

lib/rack/cache/storage.rb

@@ -44,6 +44,8 @@ def create_store(type, uri)
         case
         when defined?(::Dalli) && uri.kind_of?(::Dalli::Client)
           type.const_get(:Dalli).resolve(uri)
+        when defined?(::Mongo) && uri.kind_of?(::Mongo::DB)
+          type.const_get(:Mongodb).resolve(uri)
         when defined?(::Memcached) && uri.respond_to?(:stats)
           type.const_get(:MemCached).resolve(uri)
         else

rack-cache.gemspec

@@ -67,6 +67,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'bacon'
   s.add_development_dependency 'memcached'
   s.add_development_dependency 'dalli'
+  s.add_development_dependency 'mongo'
 
   s.has_rdoc = true
   s.homepage = "http://tomayko.com/src/rack-cache/"

test/entitystore_test.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 require "#{File.dirname(__FILE__)}/spec_setup"
 require 'rack/cache/entitystore'
+require 'rack/cache/metastore'
 
 class Object
   def sha_like?
@@ -211,6 +212,19 @@ def sha_like?
     end
   end
 
+  need_mongodb 'entity store tests' do
+    describe 'Mongodb' do
+      before do
+        @store = Rack::Cache::EntityStore::Mongodb.new($mongodb)
+      end
+      after do
+        @store = nil
+      end
+      behaves_like 'A Rack::Cache::EntityStore Implementation'
+    end
+
+  end
+
 
   need_dalli 'entity store tests' do
     describe 'Dalli' do

test/spec_setup.rb

@@ -1,6 +1,7 @@
 require 'pp'
 require 'tmpdir'
 require 'stringio'
+require 'uri'
 
 [STDOUT, STDERR].each { |io| io.sync = true }
 
@@ -14,8 +15,28 @@
 # Set the MEMCACHED environment variable as follows to enable testing
 # of the MemCached meta and entity stores.
 ENV['MEMCACHED'] ||= 'localhost:11211'
+ENV['MONGODB'] ||= 'localhost:27017'
 $memcached = nil
 $dalli = nil
+$mongodb = nil
+
+def have_mongodb?(server=ENV['MONGODB'])
+  return $mongodb unless $mongodb.nil?
+  require 'mongo'
+  $mongodb = Mongo::Connection.from_uri("mongodb://" + server)['rackcache']
+  $mongodb['test'].insert({:ping => ' '})
+  true
+rescue LoadError => boom
+  warn "mongo library not available. related tests will be skipped."
+  $mongodb = false
+  false
+rescue => boom
+  warn "mongo not working. related tests will be skipped."
+  $mongodb = false
+  false
+end
+
+have_mongodb?
 
 def have_memcached?(server=ENV['MEMCACHED'])
   return $memcached unless $memcached.nil?
@@ -61,6 +82,10 @@ def have_dalli?(server=ENV['MEMCACHED'])
 
 have_dalli?
 
+def need_mongodb(forwhat)
+  yield if have_mongodb?
+end
+
 def need_dalli(forwhat)
   yield if have_dalli?
 end

test/storage_test.rb

@@ -91,4 +91,18 @@
 
   end
 
+  if have_mongodb?
+
+    describe 'Mongo Store URIs' do
+      %w[mongodb:].each do |scheme|
+        it "resolves #{scheme} entity store URIs" do
+          uri = scheme + '//' + ENV['MONGODB'] + "/rackcache"
+          @storage.resolve_entitystore_uri(uri).
+            should.be.kind_of Rack::Cache::EntityStore
+        end
+      end
+    end
+
+  end
+
 end