mongo_cache_store 0.2.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mongo_cache_store.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kevin McGrath
+
+MIT License
+
+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/README.md

@@ -0,0 +1,102 @@
+# MongoCacheStore
+
+A MongoDB cache store for ActiveSupport 3
+
+## Description
+
+MongoCacheStore uses pluggable backends to expose MongoDB as a cache store to ActiveSupport applications.  Each backend allows the application to customize how the cache operates.  Support is available for standard, capped and TTL collections.
+
+**WARNING** This gem is in the early stages of development and should be treated as such.  Checking the version of the gem will help with what could be many changes to the backends, options, etc...
+
+While in beta, the major version will always be 0.  The minor version will be increased for anything that breaks the current API.  The patch version will be increased for all changes within a minor revision that add to or fix the current release without changing how the gem is configured or used. 
+
+
+## Backends
+
+A Backend controls how MongoDB collections are used and manipulated as a cache store.
+
+MongoCacheStore ships with 4 backends, TTL, Capped, Standard and MultiTTL.
+
+Planned: GridFS
+  * For very large entries.   Ex: Generate a large report (PDF, DOC, etc...), keep it around for a limited amount of time and have it automatically flush upon expiration.
+
+
+The major difference between each backend involves how entries are flushed.  The core driver will always respect ActiveSupport's *:expires_in* parameter for hits and misses whether the entry has actually been flushed from the backend or not. 
+
+#### Core Options
+From ActiveSupport
+* :namespace
+* :expires_in
+
+For MongoCacheStore
+* :db - A Mongo::DB instance
+* :db_name - Name of database to be created.  Only used if *db* is not set
+* :connection - A Mongo::Connection. Only used if *db* is not set. Defaults to Mongo::Connection.new()
+* serialize: (*:always*, :on\_fail, :never)
+  * :always (default) - Serialize all entries
+  * :on\_fail - Try to save the entry in a native MongoDB format.  If that fails, then serialize the entry. 
+  * :never - only save the entry if it can be saved natively by MongoDB.
+  * *NOTE:* Without serialization class structures and instances that cannot be converted to a native MongoDB type will not be stored.  Also, without serialization MongoDB converts all symbols to strings.  Therefore a hash with symbols as keys will have strings as keys when read.
+
+
+### TTL
+Entries are kept in a namespaced TTL collection that will automatically flush any entries as they pass their expiration time.  This keeps the size of the cache in check over time. 
+  
+* *Requires MongoDB 2.0 or higher*
+
+#### Options
+No Extra options
+
+### Standard
+Entreis are kept in a namespaced MongoDB collection. In a standard collection entries are only flushed from the collection with an explicit delete call or if auto_flush is enabled.  If auto_flush is enabled the cache will flush all expired entries when auto\_flush\_threshold is reached.  The threshold is based on a set number of cache instance writes. 
+
+#### Options
+* auto_flush: (*true*|false)
+* auto\_flush\_threshold: *10_000*
+ 
+
+### Capped (TODO)
+This should only be used if limiting the size of the cache is the greatest concern.  Entries are flushed from the cache on a FIFO basis, regardless of the entries expiration time.  Delete operations set an entry to expired, but it will not be flushed until it is automatically removed by MongoDB.
+
+
+### MultiTTL
+Entries are stored in multiple namespaced TTL collections. A namespaced TTL collection is created for each unique expiration time.  For example all entries with an expiration time of 300 seconds will be kept in the same collection while entries with a 900 second expiration time will be kept in another.  This requires the use of a *key index* collection that keeps track of which TTL collection a entry resides in. 
+
+#### Downsides
+  * Cache set operations require 2 MongoDB write calls.  One for the key index, one for the TTL collection. (unless *use_index* is false, see below)
+  * Cache read operations will require 1 or 2 MongoDB calls depending on whether the 'expires_in' option is set for the read.
+
+#### Benefits
+  * Ability to flush cache based on expire time (TODO)
+
+#### Options
+use\_index: (*true*, false)
+  * This should only be set to *false* if all fetch and/or read operations are passed the *:expires_in* option.  If so, this will eliminate the need for the key index collection and only one write and one read operation is necessary. 
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mongo_cache_store'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongo_cache_store
+
+## Usage
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/active_support/cache/mongo_cache_store.rb

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+require "mongo_cache_store/version"
+require "mongo"
+require "active_support/cache"
+
+module ActiveSupport
+  module Cache
+
+    class MongoCacheStore < Store
+
+      def initialize (backend=:Standard, options = {})
+       
+        options = {
+          :db_name => 'cache_store',
+          :db => nil,
+          :namespace => nil,
+          :connection => nil,
+          :serialize => :always
+        }.merge(options) 
+
+        @db = options.delete :db
+
+        if (@db.nil?)
+          @db = Mongo::DB.new(options[:db_name], options[:connection] || Mongo::Connection.new)
+        end 
+
+        extend ActiveSupport::Cache::MongoCacheStore::Backend.const_get(backend)
+
+        build_backend(options)
+
+        super(options)
+
+      end
+    end
+  end
+end
+
+require "active_support/cache/mongo_cache_store/backend/capped"
+require "active_support/cache/mongo_cache_store/backend/standard"
+require "active_support/cache/mongo_cache_store/backend/ttl"
+require "active_support/cache/mongo_cache_store/backend/multi_ttl"

data/lib/active_support/cache/mongo_cache_store/backend/base.rb

@@ -0,0 +1,111 @@
+# -*- encoding : utf-8 -*-
+
+module ActiveSupport
+  module Cache
+    class MongoCacheStore
+      module Backend
+        # Base methods used by all MongoCacheStore backends 
+        module Base 
+
+          # No public methods are defined for this module
+
+          private 
+
+            def expand_key(key)
+              return key 
+            end
+
+            def namespaced_key(key, options)
+              return key 
+            end
+
+            def read_entry(key,options)
+              col = get_collection(options)
+
+              safe_rescue do 
+                query = {
+                  :_id => key,
+                  :expires_at => {
+                    '$gt' => Time.now 
+                  }
+                }
+
+                response = col.find_one(query)
+                return nil if response.nil?
+
+                entry_options = {
+                  :compressed => response[:compressed],
+                  :expires_in => response[:expires_in] 
+                }
+                if response['serialized']
+                  r_value = response['value'].to_s
+                else
+                  r_value = Marshal.dump(response['value'])
+                end
+                ActiveSupport::Cache::Entry.create(r_value,response[:created_at],entry_options)
+              end
+            end
+
+
+            def write_entry(key,entry,options)
+              col = get_collection(options)
+              serialize = options[:serialize] == :always ? true : false
+              try_cnt = 0
+
+              save_doc = {
+                :_id => key,
+                :created_at => Time.at(entry.created_at),
+                :expires_in => entry.expires_in,
+                :expires_at => entry.expires_in.nil? ? Time.utc(9999) : Time.at(entry.expires_at),
+                :compressed => entry.compressed?,
+                :serialized => serialize,
+                :value      => serialize ? BSON::Binary.new(entry.raw_value) : entry.value 
+              }.merge(options[:xentry] || {})
+              #puts save_doc.inspect
+
+              safe_rescue do
+                begin
+                  col.save(save_doc)
+                rescue BSON::InvalidDocument => ex
+                  if (options[:serialize] == :on_fail and try_cnt < 2)
+                    save_doc[:serialized] = true
+                    save_doc[:value] = BSON::Binary.new(entry.raw_value)
+                    try_cnt += 1
+                    retry 
+                  end
+                end
+              end
+            end
+
+            def delete_entry(key,options)
+              col = get_collection(options)
+              safe_rescue do
+                col.remove({'_id' => key})
+              end
+            end
+          
+            def get_collection_name(options = {})
+              name_parts = ['cache'] 
+              name_parts.push(backend_name)
+              name_parts.push options[:namespace] unless options[:namespace].nil?
+              return name_parts.join('.')
+            end
+
+            def get_collection(options)
+              return options[:collection] if options[:collection].is_a? Mongo::Collection
+            end
+
+            def safe_rescue
+              begin
+                yield
+              rescue => e
+                warn e
+                logger.error("FileStoreError (#{e}): #{e.message}") if logger 
+                false
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/cache/mongo_cache_store/backend/capped.rb

@@ -0,0 +1,44 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_support/cache/mongo_cache_store/backend/base'
+
+module ActiveSupport
+  module Cache
+    class MongoCacheStore
+      module Backend
+        # MongoCacheStoreBackend for capped collections 
+        #  
+        # == Capped Collections
+        #
+        module Capped
+          include Base
+
+          def clear(options = {})
+            col = get_collection(options) 
+            ret = safe_rescue do
+              col.update({},{:expires_at => Time.new})
+            end
+            ret ? true : false
+          end
+
+          private 
+
+          def backend_name
+            "capped"
+          end
+
+          def get_collection(options)
+            @db[get_collection_name(options)]
+          end
+
+          def delete_entry(key,options)
+            col = get_collection(options)
+            safe_rescue do
+              col.update({:_id => key}, {:expires_at => Time.new})
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/cache/mongo_cache_store/backend/multi_ttl.rb

@@ -0,0 +1,136 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_support/cache/mongo_cache_store/backend/base'
+
+
+module ActiveSupport
+  module Cache
+    class MongoCacheStore
+      module Backend
+        # MongoCacheStoreBackend for TTL collections 
+        #  
+        # == Time To Live (TTL) collections 
+        #
+        module MultiTTL
+          include Base
+
+          alias :get_collection_prefix :get_collection_name
+
+          def clear(options = {})
+            @db.collection_names.each do |cname|
+              prefix = get_collection_prefix
+              if prefix.match(/^cache/) and cname.match(/^#{get_collection_prefix(options)}/)
+                safe_rescue do
+                  @db[cname].drop
+                end
+              end
+            end
+            true
+          end
+
+          protected
+
+          def read_entry(key, options)
+            if options[:expires_in]
+              options[:collection] = get_collection(options)
+            else
+              options[:collection] = get_collection_from_index(key,options)
+            end
+
+            super(key, options)
+          end
+
+
+          def write_entry(key, entry, options)
+            options[:collection] = get_collection(options)
+
+            super(key, entry, options)
+
+            if (options[:use_index])
+              ki  = get_key_index_collection(options)
+              indexed = safe_rescue do
+                ki.save({
+                  :_id => key,
+                  :collection => options[:collection].name,
+                  :expires_at => entry.expires_at
+                })
+              end
+            end
+
+          end
+
+          def delete_entry(key, options)
+            options[:collection] = get_collection_from_index(key,options)
+            super(key, options)
+          end
+
+
+          private 
+
+          def backend_name
+            "multi_ttl"
+          end
+
+          def get_collection(options)
+
+            col = super 
+            return col unless col.nil?
+
+            name_parts = [get_collection_prefix(options)]
+            expires_in = options[:expires_in]
+            name_parts.push expires_in.nil? ? 'forever' : expires_in.to_i
+            collection_name = name_parts.join('.')
+
+            collection = @collection_map[collection_name]
+
+            collection ||= create_collection(collection_name, expires_in) 
+            return collection
+          end
+
+
+          def get_key_index_collection(options)
+            name_parts = [get_collection_prefix(options)]
+            name_parts.push options[:namespace] unless options[:namespace].nil?
+            name_parts.push 'key_index'
+
+            col = @db[name_parts.join('.')]
+            col.ensure_index('expires_at',{ expireAfterSeconds: 0})
+            return col
+          end
+
+          def get_collection_from_index(key,options)
+            if (options[:use_index])
+              ki  = get_key_index_collection(options)
+
+              options[:collection] = safe_rescue do  
+                response = ki.find_one({
+                  :_id => key,
+                })
+                return nil if response.nil?
+
+                return @db[response['collection']]
+              end
+            end
+            nil
+          end
+
+
+          def create_collection(name, expires_in)
+            collection = @db[name]
+            collection.ensure_index('created_at',{ expireAfterSeconds: expires_in.to_i }) unless expires_in.nil?
+            return collection
+          end
+
+          def build_backend(options)
+            options.replace({
+              :use_index => true
+            }.merge(options)) 
+
+            @collection_map = {}
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_support/cache/mongo_cache_store/backend/standard.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_support/cache/mongo_cache_store/backend/base'
+
+
+module ActiveSupport
+  module Cache
+    class MongoCacheStore
+      module Backend
+        # MongoCacheStoreBackend for standard collections 
+        #  
+        # == Standard collections 
+        #
+        module Standard
+          include Base
+
+          def clear(options = {})
+            col = get_collection(options) 
+            ret = safe_rescue do
+              col.remove
+            end
+            ret ? true : false
+          end
+
+          private 
+
+          def backend_name
+            "standard"
+          end
+
+          def get_collection(options)
+            @db[get_collection_name(options)]
+          end
+
+          def write_entry(key, entry, options)
+            ret = super
+            @write_cnt += 1
+            if options[:auto_flush] and @write_cnt > options[:auto_flush_threshold]
+              safe_rescue do
+                col = get_collection(options)
+                col.delete({
+                  :expires_at => {
+                    '$gt' => Time.now 
+                  }
+                })
+              end
+              @write_cnt = 0
+            end
+            return ret
+          end
+
+          def build_backend(options)
+            options.replace({
+              :auto_flush => true,
+              :auto_flush_threshold => 10_000,
+              :collection => nil
+            }.merge(options))
+
+            @write_cnt = 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/cache/mongo_cache_store/backend/ttl.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_support/cache/mongo_cache_store/backend/base'
+
+module ActiveSupport
+  module Cache
+    class MongoCacheStore
+      module Backend
+        # MongoCacheStoreBackend for OneTTL collections 
+        #  
+        # == OneTTL collections 
+        #
+        module TTL
+          include Base
+
+          def clear(options = {})
+            col = get_collection(options) 
+            ret = safe_rescue do
+              col.remove
+            end
+            ret ? true : false
+          end
+
+          protected
+
+          def write_entry(key,entry,options)
+
+            # Set all time based entries here.
+            # This ensures all fields are based on the same Time
+            now = Time.now 
+            options[:xentry] = {
+              :created_at   => now,
+              :expires_at   => entry.expires_in.nil? ? Time.utc(9999) : now + entry.expires_in.to_i
+            }
+
+            super(key,entry,options)
+          end
+
+
+          private 
+
+          def backend_name
+            "ttl"
+          end
+
+          def get_collection(options)
+            return @collection if @collection.is_a? Mongo::Collection
+            collection = super 
+            return collection unless collection.nil?
+
+            collection = @db[get_collection_name(options)]
+            collection.ensure_index('expires_at',{ expireAfterSeconds: 0 })
+            @collection = collection
+          end
+
+          def build_backend(options)
+
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/mongo_cache_store/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding : utf-8 -*-
+module MongoCacheStore
+  VERSION = "0.2.0"
+end

data/mongo_cache_store.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongo_cache_store/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "mongo_cache_store"
+  gem.version       = MongoCacheStore::VERSION
+  gem.authors       = ["Kevin McGrath"]
+  gem.email         = ["kmcgrath@baknet.com"]
+  gem.description   = %q{A MongoDB ActiveSupport Cache}
+  gem.summary       = %q{A MongoDB ActiveSupport Cache}
+  gem.homepage      = "https://github.com/kmcgrath/mongo_cache_store"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'mongo'
+  gem.add_dependency 'activesupport'
+  gem.add_development_dependency 'rspec'
+end

data/spec/active_support/cache/mongo_cache_store_spec.rb

@@ -0,0 +1,160 @@
+# -*- encoding : utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+
+class MongoCacheStoreTestSaveClass
+
+  attr_reader :set_me
+  def initialize(set_me)
+    @set_me = set_me
+  end
+
+end
+
+
+module ActiveSupport 
+  module Cache
+    class MongoCacheStoreTest
+      shared_examples "a cache store" do
+        describe "Caching" do
+      
+          it "can write values" do
+            @store.write('forever!', 'I live forever!')
+            @store.fetch('forever!').should == "I live forever!"
+          end
+
+          it "can expire" do
+            @store.fetch 'testkey', expires_in: 2.minutes do 
+              "I will expire."
+            end
+            @store.exist?("testkey").should == true
+
+            sleep 60
+
+            response = @store.fetch 'testkey'
+            response.should == "I will expire."
+
+            sleep 120 
+
+            response = @store.fetch 'testkey'
+            response.should == nil
+          end
+
+          it "can cache a hash" do
+            @store.write('hashme',
+              {"1"=>{:name=>"Uptime", :zenoss_instance=>"cust", :path=>"/zport/RenderServer/render?gopts=k4VJvRM2K1Dahl3RzJWcqoicTSIz0QJ1Ja10idqC412ptG5_lrmcroRy3BDIqioB561tB4UjtjSg1ib_YaGOXBWOEHBhPbEmA6ZXXjd8LiIOmItqTDZjuFkZvOV38_CF_YEi7t9xUtFKOIxibyVo67jzbyK6P-ORc7i07rK5GUYeA2CnJxm4UDCNKcKRpDCzmdzR-NwcOp0w55KH8YeU6NpgHyM_tpu8G42d7nBQebs1DKvn20sktezqy_LiIizKk3eMzDW-c8w1EZTESWa4rIihXfHrrv9PNxvCw41wU9f3dxQt2c3OFfhSx6riSUbeVsUNEo6s_35KdKJkbr6rEZaaxL2RGR47eLBzifIcZAg="}, "2"=>{:name=>"CPU Utilization", :zenoss_instance=>"cust", :path=>"/zport/RenderServer/render?gopts=WN-Oc9wB_CFbVKzzN75ij-qQcZ6lSOC3jj_ALTzkdMEZ_EzgcvfWOdU7vmlrm9MFY6zrOUeW2Z_uzyJkhRrl_81bVs96xoa7y2S29NVU_oSIIxQj1rUElV04u3wGRXnEbfyYPjLp0m6QEDOthqCs3SLcc7jKkCI15V0Js1b6FpFleWdmO9dCMLvKqdBiE-yhSjfwPS7Rh0wPLAoxXTyIkFFHHBXIu_g69_xnESZhYz0rAWn0W0Ag5N46LuNqwbzW1PwIfczY1Hqw2iKQAq1C4fMry3DNiQvnRmUZdF_w11quhIo-XccH1em3iopVdyy6ik83vMvJN3DfhLUbXcZjnA=="}, "3"=>{:name=>"Memory Utilization", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=_E6b8KAZjy9xzEYtckX_RDQOsGfIRZnG5WRu7ekbUIlsgWmNZNJ8AgEfr7AM0rV6lZMC4PzCPacRN1zeVQ-nHgTBBDbq4sIQuUMl3ETW9DRM2wgjrmnCRwcl7Dz_qGL6PWkhsJzhQ231SuNi7pM6mDw8dbE_pmZ3F6xKa7_8frJLWoMGLji8sIklFf45YckRkIohkMsffZKMsIspx8JEOvR9mP24vGs0Wv4gRXxqFoE1FlgchuKf2KDvWbwp92RrdOmhOAqMxHWmNA2faAC75072ao9bf6UnxZUu5WFUcNsvJJFcEl2U30TEX5vyjf_9C-1Rvnyf8Q6ajvRKA1VNIl6fpItv8dsKTNViX27RWsI="}, "4"=>{:name=>"Swap", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=nBpbINZ6hhzV8IUJq49zWOTsQ4hX5F5ZGPyoHZ6KWPUx_4Xk0_URWbZPQO4yicu14u81lDFqfRCoFTwofkA0NJIqoOQfAx2gWrwbE7RtulqYeMol47KWQpSITLSV4Mkh1Sbp9VZqpc4YVjiu1EvWSOIHCeUPXZPSBWFh0R2VoPB_VutBricdimwkvRsHbU9-BlKyJcT-_vEnTMi2MHlB3iKWY329OkN-J2chI3MtoLvSw9sN2LJbrO4ynFQPX4WFY9D18Zhv1bzOapn0XcCsxj88XHZ2eZeEZ0uv33_9EKSVxKtOOYo3Y08mjEKduOme"}, "5"=>{:name=>"Load Average", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=0y-dExjiyMFT0yWeOf-FR3hBIgIVZZortlKSFUETQYjwMuSDfhB-JhsEYI-feAC0Bmh5T8fZQRuYi5MkD3C2S6Qwd_kzvPrjwxCfxjTaQzidN-DxlWjqTkTfZ-AiPQ3F8JVXr-8kP8ZA10XDcV2VpIHJwZatzxDBVk7isEdKAXEJm-1X_TY7BCdU9uFlcBT1XGEYESM5anyR3282Z77yiYX6PsUcoPwFtLzg1l6Ql8cda8n4d2zLK4ZBX5G25ZQoC0MAmHZPyXRIsI-GGZjKcvXHjZ350tEpyvPiSX8a7PG-dRtWIGEEecM9czU3MF5Xzl-qOVfoRWc8pmlc-5E37Z5TcAoZpUHSlssJdjwoLfOlhFkLGyAVZpVXRCVRWdXNxilLS9N4GbuIEqhsEILyM0MzPvEHwPO3rcPSlzcS4s_SXnjp6XLg2bB6NZjAvbz5Vyb6OPg-8b9C-MmzcpWzVHzP5nYo9RVPR_lpFcmOBUSO_cJO22pIqqMyn1vXbtVz"}, "6"=>{:name=>"Paging", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=N7sjMwpMD3JE0ZNya07IgWj6t7yn7uX4GJ1XHlmyhRcqcea0HpfXTen6ptASVAZIvWT7fW4kufkvtNBsxKfDMX9JMzqoR-kpfWqoRRfI3eGmqYecg6gcQgXSEnu5Mzf4r-lbo1_Cqp8dYuSmC37uWrKi0gTWVr54ZmQ6w4dSymQ4xSkCH2-MO1X8wxZdtm804NJy6yQ4l7JZYBkWD9rABoPhVfZq4mZpHmZN27UlbK14Z9R3EEF6MG0jKCbJ7gJVEjpOoX_y5ka4S3aRULFSByrZIA290_ZMO21DAnsJbJyMXAEP9r8UanaotdVrPLSOXJkYD4WvdcdDeZ3wMtvdL42oHdhwLDyG9J8i9GkcvwsU04MlTTl270LkX31HJjxjB8IChpDke-9LEmxG_1icmGcAcWr26gTk9HOULwTyso4sX_ZqqCnrrnRRQLCpCZtlqxIB9iAMUtSdkEUdZlsAuw=="}},
+              expires_in: 1.hour
+            )
+
+            hash = @store.read('hashme')
+            hash["1"].should be_a_kind_of(Hash)
+
+          end
+
+          it "can cache class instances" do
+            @store.fetch 'my_class', expires_in: 30.seconds do
+              MongoCacheStoreTestSaveClass.new('what did i say?')
+            end
+
+            my_class = @store.fetch 'my_class'
+            my_class.set_me.should == 'what did i say?'
+          end
+
+          it "can use a hash as a key" do
+            hash_key = {
+              :class_name => 'my_class',
+              :option2 => 2
+            }
+
+            miss_key = {
+              :class_name => 'my_class',
+              :option2 => 1
+            }
+
+            hit_key = {
+              :class_name => 'my_class',
+              :option2 => 2
+            }
+
+
+            @store.fetch(hash_key, expires_in: 30.seconds) do
+              MongoCacheStoreTestSaveClass.new('what did i say?')
+            end
+
+            my_class = @store.fetch(hash_key)
+            my_class.set_me.should == 'what did i say?'
+
+            my_class = @store.fetch(hit_key)
+            my_class.set_me.should == 'what did i say?'
+
+            my_class = @store.fetch(miss_key)
+            my_class.should == nil
+           
+          end
+
+          after(:all) do
+            @store.clear
+          end 
+        end
+      end
+
+
+      describe MongoCacheStore do
+        describe "initializing" do
+          it "can take a Mongo::DB object" do
+            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
+            store = ActiveSupport::Cache::MongoCacheStore.new(:TTL, :db => db)
+          end
+        end
+
+        describe "TTL Caching" do
+          it_behaves_like "a cache store" 
+          before(:all) do
+            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
+            @store = ActiveSupport::Cache::MongoCacheStore.new(:TTL, :db => db)
+          end
+        end
+
+        describe "TTL Caching On Fail Serialization" do
+          it_behaves_like "a cache store" 
+          before(:all) do
+            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
+            @store = ActiveSupport::Cache::MongoCacheStore.new(:TTL, :db => db, :serialize => :on_fail)
+          end
+        end
+
+        describe "MultiTTL Caching" do
+          it_behaves_like "a cache store" 
+          before(:all) do
+            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
+            @store = ActiveSupport::Cache::MongoCacheStore.new(:MultiTTL, :db => db)
+          end
+        end
+
+        describe "MultiTTL Caching On Fail Serialization" do
+          it_behaves_like "a cache store" 
+          before(:all) do
+            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
+            @store = ActiveSupport::Cache::MongoCacheStore.new(:MultiTTL, :db => db, :serialize => :on_fail)
+          end
+        end
+
+        describe "Standard Caching" do
+          it_behaves_like "a cache store"
+          before(:all) do
+            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
+            @store = ActiveSupport::Cache::MongoCacheStore.new(:Standard, :db => db)
+          end
+        end
+
+        describe "Standard Caching On Fail Serialization" do
+          it_behaves_like "a cache store"
+          before(:all) do
+            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
+            @store = ActiveSupport::Cache::MongoCacheStore.new(:Standard, :db => db, :serialize => :on_fail)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'active_support/cache/mongo_cache_store'
+require 'rspec' 

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: mongo_cache_store
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Kevin McGrath
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A MongoDB ActiveSupport Cache
+email:
+- kmcgrath@baknet.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/active_support/cache/mongo_cache_store.rb
+- lib/active_support/cache/mongo_cache_store/backend/base.rb
+- lib/active_support/cache/mongo_cache_store/backend/capped.rb
+- lib/active_support/cache/mongo_cache_store/backend/multi_ttl.rb
+- lib/active_support/cache/mongo_cache_store/backend/standard.rb
+- lib/active_support/cache/mongo_cache_store/backend/ttl.rb
+- lib/mongo_cache_store/version.rb
+- mongo_cache_store.gemspec
+- spec/active_support/cache/mongo_cache_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kmcgrath/mongo_cache_store
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A MongoDB ActiveSupport Cache
+test_files:
+- spec/active_support/cache/mongo_cache_store_spec.rb
+- spec/spec_helper.rb