cachetastic-memcache-pool 0.1.0

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+log
+coverage
+.rvmrc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cachetastic-dalli.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc 'Default: run specs.'
+task :default => :spec

data/cachetastic-memcache-pool.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cachetastic/adapters/memcache_pool/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cachetastic-memcache-pool"
+  s.version     = Cachetastic::Adapters::MemcachePool::VERSION
+  s.authors     = ["Jason Wadsworth"]
+  s.email       = ["jason@gazelle.com"]
+  s.homepage    = ""
+  s.summary     = %q{Cachetastic Memcached Adapter with Connection Pooling}
+  s.description = %q{Cachetastic Memcached Adapter with Connection Pooling}
+
+  s.rubyforge_project = "cachetastic-memcache-pool"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.add_development_dependency "rcov", "~> 0.9.0"
+
+  s.add_runtime_dependency "cachetastic", "~> 3.0.0"
+  s.add_runtime_dependency "memcache-client", "~> 1.8.5"
+end

data/lib/cachetastic/adapters/memcache_pool.rb

@@ -0,0 +1,4 @@
+require 'memcache'
+require 'cachetastic'
+require 'cachetastic/adapters/memcache_pool/version'
+require 'cachetastic/adapters/memcache_pool/adapter'

data/lib/cachetastic/adapters/memcache_pool/adapter.rb

@@ -0,0 +1,149 @@
+module Cachetastic # :nodoc:
+  module Adapters
+    module MemcachePool
+      # An adapter to cache objects to the file system.
+      # 
+      # This adapter supports the following configuration settings,
+      # in addition to the default settings:
+      # 
+      #   configatron.cachetastic.defaults.servers = ['127.0.0.1:11211']
+      #   configatron.cachetastic.defaults.mc_options = {:c_threshold => 10_000,
+      #                                                  :compression => true,
+      #                                                  :debug => false,
+      #                                                  :readonly => false,
+      #                                                  :urlencode => false}
+      #   configatron.cachetastic.delete_delay = 0
+      # 
+      # The <tt>servers</tt> setting defines an <tt>Array</tt> of Mecached
+      # servers, represented as "<host>:<port>".
+      # 
+      # The <tt>mc_options</tt> setting is a <tt>Hash</tt> of settings required
+      # by Memcached. See the Memcached documentation for more information on
+      # what the settings mean.
+      # 
+      # The <tt>delete_delay</tt> setting tells Memcached how long to wait
+      # before it deletes the object. This is not the same as <tt>expiry_time</tt>.
+      # It is only used when the <tt>delete</tt> method is called.
+      # 
+      # See <tt>Cachetastic::Adapters::Base</tt> for a list of public API
+      # methods.
+      class Adapter < Cachetastic::Adapters::Base
+        
+        def initialize(klass) # :nodoc:
+          define_accessor(:servers)
+          define_accessor(:mc_options)
+          define_accessor(:delete_delay)
+          self.delete_delay = 0
+          self.servers = ['127.0.0.1:11211']
+          self.mc_options = {:c_threshold => 10_000,
+                             :compression => true,
+                             :debug => false,
+                             :readonly => false,
+                             :urlencode => false}
+          super
+          connection
+        end
+        
+        def get(key) # :nodoc:
+          connection.get(transform_key(key), false)
+        end # get
+        
+        def set(key, value, expiry_time = configatron.cachetastic.defaults.default_expiry) # :nodoc:
+          connection.set(transform_key(key), marshal(value), expiry_time, false)
+        end # set
+        
+        def delete(key) # :nodoc:
+          connection.delete(transform_key(key), self.delete_delay)
+        end # delete
+        
+        def expire_all # :nodoc:
+          increment_version
+          return nil
+        end # expire_all
+        
+        def transform_key(key) # :nodoc:
+          namespace + ':' + key.to_s.hexdigest
+        end
+        
+        # Return <tt>false</tt> if the connection to Memcached is
+        # either <tt>nil</tt> or not active.
+        def valid?
+          return false if @_mc_connection.nil?
+          return false unless @_mc_connection.active?
+          return true
+        end
+        
+        private
+        def connection
+          self.class.data_connection(self)
+        end
+
+        def ns_connection
+          self.class.ns_connection(self)
+        end
+
+        def increment_version
+          name = self.klass.name
+          v = get_version
+          ns_connection.set(name, v + 1)
+        end
+
+        def get_version
+          name = self.klass.name
+          v = ns_connection.get(name)
+          if v.nil?
+            ns_connection.set(name, 1)
+            v = 1
+          end
+          v
+        end
+        
+        def namespace
+          @_ns_version = get_version
+          "#{self.klass.name}.#{@_ns_version}"
+        end
+
+        class << self
+          # JDW: TODO: Extract all of this into a MemCachePool class, and add the ability to do true thread-safe pooling
+          def reset_connections
+            @_connections_by_klass = {}
+            @_connections_by_digest = {}
+            @_ns_connections_by_klass = {}
+            @_ns_connections_by_digest = {}
+          end
+
+          def connection_digest(adapter)
+            {:servers => adapter.servers, :mc_options => adapter.mc_options}.to_s.hexdigest
+          end
+
+          def data_connection(adapter)
+            @_connections_by_klass   ||= {}
+            @_connections_by_digest  ||= {}
+            return get_connection(adapter, @_connections_by_klass, @_connections_by_digest, nil)
+          end
+
+          def ns_connection(adapter)
+            @_ns_connections_by_klass   ||= {}
+            @_ns_connections_by_digest  ||= {}
+            return get_connection(adapter, @_ns_connections_by_klass, @_ns_connections_by_digest, :namespace_versions)
+          end
+
+          def get_connection(adapter, connections_by_class, connections_by_digest, namespace)
+            matching_connection = connections_by_class[adapter.klass.name]
+            if !matching_connection || !matching_connection.active?
+              digest = connection_digest(adapter)
+              matching_connection = connections_by_digest[digest]
+              if !matching_connection || !matching_connection.active?
+                matching_connection = MemCache.new(adapter.servers, adapter.mc_options.merge(:namespace => namespace))
+              end
+              connections_by_digest[digest] = matching_connection
+            end
+            connections_by_class[adapter.klass.name] = matching_connection
+            matching_connection
+          end
+        end
+
+      end # Adapter
+    end # MemcachePool
+  end # Adapters
+end # Cachetastic

data/lib/cachetastic/adapters/memcache_pool/version.rb

@@ -0,0 +1,7 @@
+module Cachetastic
+  module Adapters
+    module MemcachePool
+      VERSION = "0.1.0"
+    end
+  end
+end

data/spec/cachetastic/adapters/memcache_pool/adapter_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Cachetastic::Adapters::MemcachePool::Adapter do
+  before(:each) do
+    configatron.temp_start
+    configatron.cachetastic.defaults.adapter = Cachetastic::Adapters::MemcachePool::Adapter
+    clear_test_cache_keys
+  end
+
+  before(:each) do
+    pending 'JDW: This is an integration test. It requires a memcached server to be running on localhost:11211'
+  end
+
+  after(:each) do
+    Cachetastic::Adapters::MemcachePool::Adapter.reset_connections
+    configatron.temp_end
+  end
+
+  class FakeCacheClass; end
+  class AnotherFakeCacheClass; end
+
+  def clear_test_cache_keys
+    # Clear namespace values
+    cache_classes = [FakeCacheClass, AnotherFakeCacheClass]
+    ns_connection = memcached_connection(:namespace_versions)
+    cache_classes.each do |cache_classs|
+      ns_connection.delete(cache_classs.name)
+    end
+
+    # Clear data values
+    data_connection = memcached_connection(nil)
+    cache_classes.each do |cache_class|
+      %w{key1 key2}.each do |key|
+        (1..2).each do |version|
+          data_connection.delete("#{cache_class.name}.${version}:#{key.to_s.hexdigest}")
+        end
+     end
+    end
+  end 
+ 
+  def expect_connection_creation(namespace)
+    mock_cache = mock(MemCache, :get => nil, :active? => true)
+    MemCache.should_receive(:new) do |servers, options|
+      servers.should == ['127.0.0.1:11211']
+      options[:namespace].should == namespace
+      mock_cache
+    end
+    mock_cache
+  end
+
+  def memcached_connection(namespace)
+    servers = ['127.0.0.1:11211']
+    mc_options = {
+      :c_threshold => 10_000,
+      :compression => true,
+      :debug       => true,
+      :readonly    => false,
+      :urlencode   => false,
+      :namespace   => namespace
+    }
+    MemCache.new(servers, mc_options)
+  end
+
+  def check_memcached(key, expected_value, namespace = nil)
+    mc = memcached_connection(namespace)
+    mc.get(key.hexdigest).should == expected_value
+  end
+
+  it "should set a value in memcached" do
+    adapter = Cachetastic::Adapters::MemcachePool::Adapter.new(FakeCacheClass)
+    adapter.set('test-key', 'test-value', 10)
+    
+    check_memcached('test-key', 'test-value', "#{FakeCacheClass.name}.1")
+  end
+
+  it "should get a value in memcached" do
+    memcached_connection(nil).set("#{FakeCacheClass.name}.1:#{'key1'.hexdigest}", 'value1', 86400, false)
+
+    adapter = Cachetastic::Adapters::MemcachePool::Adapter.new(FakeCacheClass)
+    adapter.get('key1').should == 'value1'
+  end
+
+  it "should delete a value in memcached" do
+    key = "#{FakeCacheClass.name}.1:#{'key1'.hexdigest}"
+    conn = memcached_connection(nil)
+    conn.set(key, 'value1', 86400, false)
+
+    adapter = Cachetastic::Adapters::MemcachePool::Adapter.new(FakeCacheClass)
+    adapter.delete('key1')
+    conn.get('key').should be_nil
+  end
+
+  it "should not see the old value in memcached after expire_all is called" do
+    memcached_connection(nil).set("#{FakeCacheClass.name}.1:#{'key1'.hexdigest}", 'value1', 86400, false)
+
+    adapter = Cachetastic::Adapters::MemcachePool::Adapter.new(FakeCacheClass)
+    adapter.get('key1').should == 'value1'
+    adapter.expire_all
+    adapter.get('key1').should be_nil
+  end
+
+  it "should create a namespace connection and a data connection" do
+    data_connection = expect_connection_creation(nil)
+    ns_connection = expect_connection_creation(:namespace_versions)
+
+    ns_connection.should_receive(:set).with(FakeCacheClass.name, 1)
+    data_connection.should_receive(:set).with("#{FakeCacheClass.name}.1:#{'key1'.hexdigest}", "value1", 86400, false)
+
+    cache = Cachetastic::Adapters::MemcachePool::Adapter.new(FakeCacheClass)
+    cache.set('key1', 'value1')
+  end
+
+  it "should create only one namespace and data connection for caches with the same configuration" do
+    data_connection = expect_connection_creation(nil)
+    ns_connection = expect_connection_creation(:namespace_versions)
+
+    ns_connection.should_receive(:set).with(FakeCacheClass.name, 1)
+    data_connection.should_receive(:set).with("#{FakeCacheClass.name}.1:#{'key1'.hexdigest}", "value1", 86400, false)
+    cache1 = Cachetastic::Adapters::MemcachePool::Adapter.new(FakeCacheClass)
+    cache1.set('key1', 'value1')
+
+    ns_connection.should_receive(:set).with(AnotherFakeCacheClass.name, 1)
+    data_connection.should_receive(:set).with("#{AnotherFakeCacheClass.name}.1:#{'key2'.hexdigest}", "value2", 86400, false)
+    cache2 = Cachetastic::Adapters::MemcachePool::Adapter.new(AnotherFakeCacheClass)
+    cache2.set('key2', 'value2')
+  end
+
+  it "should create a new namespace connection if the configuration is different" do
+    configatron.cachetastic.fake_cache_class.mc_options = {:c_threshold => 20_000}
+
+    data_connection1 = expect_connection_creation(nil)
+    data_connection1.should_receive(:set).with("#{FakeCacheClass.name}.1:#{'key1'.hexdigest}", "value1", 86400, false)
+    ns_connection1 = expect_connection_creation(:namespace_versions)
+    ns_connection1.should_receive(:set).with(FakeCacheClass.name, 1)
+
+    cache1 = Cachetastic::Adapters::MemcachePool::Adapter.new(FakeCacheClass)
+    cache1.set('key1', 'value1')
+
+
+    data_connection2 = expect_connection_creation(nil)
+    data_connection2.should_receive(:set).with("#{AnotherFakeCacheClass.name}.1:#{'key2'.hexdigest}", "value2", 86400, false)
+    ns_connection2 = expect_connection_creation(:namespace_versions)
+    ns_connection2.should_receive(:set).with(AnotherFakeCacheClass.name, 1)
+    cache2 = Cachetastic::Adapters::MemcachePool::Adapter.new(AnotherFakeCacheClass)
+    cache2.set('key2', 'value2')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec'
+require 'cachetastic/adapters/memcache_pool'

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: cachetastic-memcache-pool
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jason Wadsworth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-21 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 9
+        - 0
+        version: 0.9.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cachetastic
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: memcache-client
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 1
+        - 8
+        - 5
+        version: 1.8.5
+  type: :runtime
+  version_requirements: *id004
+description: Cachetastic Memcached Adapter with Connection Pooling
+email: 
+- jason@gazelle.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README
+- Rakefile
+- cachetastic-memcache-pool.gemspec
+- lib/cachetastic/adapters/memcache_pool.rb
+- lib/cachetastic/adapters/memcache_pool/adapter.rb
+- lib/cachetastic/adapters/memcache_pool/version.rb
+- spec/cachetastic/adapters/memcache_pool/adapter_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cachetastic-memcache-pool
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Cachetastic Memcached Adapter with Connection Pooling
+test_files: 
+- spec/cachetastic/adapters/memcache_pool/adapter_spec.rb
+- spec/spec_helper.rb