atomic_mem_cache_store 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+bin/*
+pkg/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,66 @@
+# AtomicMemCacheStore
+
+## Why ?
+
+Anyone caching slow content on a website with moderate to heavy traffic will
+sooner of later be a victim of the [thundering herb issue](http://en.wikipedia.org/wiki/Thundering_herd_problem) also called Dog-pile Effect.
+
+Basically cache invalidation of a high traffic page will trigger several concurrent cache recalculation that could lead to pikes of load and transient slow down of your architecture.
+
+Rails (and any framework relying on active support cache store) does not offer any built-in solution to this problem. You have to make your own based on sweeper, cron and/or periodical cache warming up. This tend to explode your view/model logic across several files and technology and lead to maintenance/debugging nightmare.
+
+## What ?
+
+This gem is a drop-in alternative to active support memcache store that preserve the simplicity of your built-in framework cache methods (action, fragment, Rails.cache) while providing atomic cache invalidation and serving cold cache in the meantime.
+
+Out of the box the cache calculation is made directly in the current process were cache has been invalidated for the first time. But you could override this cache store to support async cache calculation.
+
+## How ?
+
+Install the gem
+
+    gem install atomic_mem_cache_store
+	
+or add it to your Gemfile
+
+	gem 'atomic_mem_cache_store'
+
+Then use it directly
+
+	cache = AtomicMemCacheStore.new
+	cache.write('key', 'value', :expires_in => 10)
+	cache.read('key')
+
+Or for Rails add it in your config/environments/<env>.rb
+
+	config.cache_store = :atomic_mem_cache_store, %w( 127.0.0.1 ), { :namespace => "cache:#{Rails.env}" }
+
+It supports the same parameters as [ActiveSupport::Cache::MemCacheStore](http://apidock.com/rails/ActiveSupport/Cache/MemCacheStore)
+
+## When ?
+
+- You are using memcached
+- If you have high traffic or slow cache recalculation
+- If you use fragment cache with expiry
+- If you use Rails.cache.fetch with expiry
+- If you use caching with expiry and trigger recalculation when you get an empty cache
+
+## Drawbacks
+
+- If you use only memcache cache without expiry, you won't benefit from any improvement as your cache invalidation will be due to LRU algorithm or manual sweeping. This will work as before though.
+
+- This will not prevent your app from thundering herd effect due to LRU key sweeping as in this case the cache value is lost. This is not worse than what you have now, though.
+
+- If you try to access key value directly be careful as you will bypass the atomicity mechanism. (this will work though even if the expiration of the key will be longer than expected).
+
+## TL;DR
+
+Basically unless you are doing weird stuff without your cache store, this should be a drop-in replacement with no real corner cases. Worse that can happen is more query to memcache, and slightly longer expiry on keys.
+
+## License
+
+MIT
+
+## Copyright
+
+Renaud Morvan (nel@w3fu.com)

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+begin
+  require "spec/rake/spectask"  # RSpec 1.3
+
+  desc 'Run all specs in spec directory.'
+  Spec::Rake::SpecTask.new(:spec) do |task|
+    task.libs = ['lib', 'spec']
+    task.spec_files = FileList['spec/**/*_spec.rb']
+  end
+rescue LoadError
+  require "rspec/core/rake_task" # RSpec 2.0
+
+  desc 'Run all specs in spec directory.'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = %w{--colour --format progress}
+    t.pattern = 'spec/**/*_spec.rb'
+  end  
+end
+
+desc 'Default: runs specs.'
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/atomic_mem_cache_store.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "atomic_mem_cache_store/version"
+
+Gem::Specification.new do |s|
+  s.name        = "atomic_mem_cache_store"
+  s.version     = AtomicMemCacheStore::VERSION
+  s.authors     = ["Renaud (Nel) Morvan"]
+  s.email       = ["nel@w3fu.com"]
+  s.homepage    = "https://github.com/nel/atomic_mem_cache_store"
+  s.summary     = %q{Rails memcached store with atomic expiration}
+  s.description = %q{Rails memcached store optimized for the thundering herb issue. This limit cache recalculation to a single process while as long as key is not swept by LRU. Drop-in replacement of Rails memcached store.}
+
+  s.rubyforge_project = "atomic_mem_cache_store"
+
+  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"
+  s.add_runtime_dependency "activesupport", ">2.1"
+  s.add_runtime_dependency "memcache-client"
+end

data/lib/atomic_mem_cache_store.rb

@@ -0,0 +1,48 @@
+require 'active_support'
+
+class AtomicMemCacheStore < ActiveSupport::Cache::MemCacheStore
+  NEWLY_STORED = "STORED\r\n"
+
+  class << self; attr_accessor :grace_period; end
+  @grace_period = 90
+    
+  def read(key, options = nil)
+    result = super
+    
+    if result.present?
+      timer_key = timer_key(key)
+      #check whether the cache is expired
+      if @data.get(timer_key, true).nil?
+        #optimistic lock to avoid concurrent recalculation
+        if @data.add(timer_key, '', self.class.grace_period, true) == NEWLY_STORED
+          #trigger cache recalculation
+          return handle_expired_read(key,result)
+        end
+        #already recalculated or expirated in another process/thread
+      end
+      #key not expired
+    end
+    result
+  end
+
+  def write(key, value, options = nil)
+    expiry = (options && options[:expires_in]) || 0
+    #extend write expiration period and reset expiration timer
+    options[:expires_in] = expiry + 2*self.class.grace_period unless expiry.zero?
+    @data.set(timer_key(key), '', expiry, true)
+    super
+  end
+
+  protected
+  
+  #to be overidden for something else than synchronous cache recalculation
+  def handle_expired_read(key,result)
+    nil
+  end
+
+  private
+  
+  def timer_key(key)
+    "tk:#{key}"
+  end
+end

data/lib/atomic_mem_cache_store/version.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__),'..','atomic_mem_cache_store')
+
+class AtomicMemCacheStore
+  VERSION = File.read(File.join(File.dirname(__FILE__),'..', '..','VERSION') ).strip
+end

data/spec/lib/atomic_mem_cache_store_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe AtomicMemCacheStore do
+  before(:all) do
+    begin
+      @store = AtomicMemCacheStore.new('127.0.0.1', :namespace => "spec-atomic")
+      @store.read('test')
+    rescue MemCache::MemCacheError
+      puts "You need a real memcache server to execute the specs, you can run those test on production server, this won't flush your memcache"
+    end
+  end
+
+  before(:each) do
+    @seed = "#{Time.now.to_i}#{rand(1000000000000000000000000)}"
+    AtomicMemCacheStore.grace_period = 90
+  end
+
+  def prefix_key(value)
+    "#{@seed}#{value}"
+  end
+
+  describe "with expiry" do
+    it "returns nil when key has not been set" do
+      @store.read(prefix_key('unknown')).should be_nil
+    end
+
+    it "returns value when key has been set and is not expired" do
+      key = prefix_key('not-expired')
+      @store.write(key, true, :expires_in => 10)
+      @store.read(key).should be
+    end
+
+    it "returns new value when key is rewriten" do
+      key = prefix_key('not-expired')
+      @store.write(key, 1, :expires_in => 10)
+      @store.write(key, 2, :expires_in => 10)
+      @store.read(key).should be 2 
+    end
+
+    it "returns nil once when key is expired, and then the old value" do
+      key = prefix_key('expired')
+
+      @store.write(key, 1, :expires_in => 1)
+      sleep 2
+      @store.read(key).should be_nil
+      @store.read(key).should be 1
+      @store.read(key).should be 1
+    end
+
+    it "returns nil when 2 times the grace period is passed" do
+      AtomicMemCacheStore.grace_period = 1
+      key = prefix_key('expired')
+
+      @store.write(key, 1, :expires_in => 1)
+      sleep 2
+      @store.read(key).should be_nil
+      @store.read(key).should be 1
+      sleep 2
+      @store.read(key).should be_nil
+    end
+  end
+
+  describe "without expiry" do
+    it "returns nil when key has not been set" do
+      @store.read(prefix_key('unknown')).should be_nil
+    end
+
+    it "returns value when key is set" do
+      key = prefix_key('key-without-expiry')
+
+      @store.write(key, 1)
+      @store.read(key).should be 1
+    end
+
+    it "returns new value when key is rewriten" do
+      key = prefix_key('key-without-expiry')
+
+      @store.write(key, 1)
+      @store.write(key, 2)
+      @store.read(key).should be 2
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+begin
+  require 'spec/autorun'
+rescue LoadError
+  require 'rspec'
+end
+require File.expand_path(File.dirname(__FILE__) + '/../lib/atomic_mem_cache_store')

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: atomic_mem_cache_store
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Renaud (Nel) Morvan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-26 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: memcache-client
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: Rails memcached store optimized for the thundering herb issue. This limit cache recalculation to a single process while as long as key is not swept by LRU. Drop-in replacement of Rails memcached store.
+email: 
+- nel@w3fu.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- atomic_mem_cache_store.gemspec
+- lib/atomic_mem_cache_store.rb
+- lib/atomic_mem_cache_store/version.rb
+- spec/lib/atomic_mem_cache_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nel/atomic_mem_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 
+      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: atomic_mem_cache_store
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Rails memcached store with atomic expiration
+test_files: 
+- spec/lib/atomic_mem_cache_store_spec.rb
+- spec/spec_helper.rb