atomic_mem_cache_store 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77ba4d9c1bc102bcbde344a6d09967c1e39ffbb1
-  data.tar.gz: 01b0150dca2282c8552ed32e5fc61871e2b075d0
+  metadata.gz: 3d0b40d56a1ff47b39cc4c91ecb5e0f20191b3b0
+  data.tar.gz: 8468c58414e2629320a7e9be9d92baf085fa1ec0
 SHA512:
-  metadata.gz: ed9fa3ba3fdb4ffb7f43f23178043ce7d632213f3b456c8c670095c9b43d30911dbf6e57a7a03151e04363b1d83ae88ee6b13252177548f985d04cfe50ec0597
-  data.tar.gz: 0424e91427c574aec7d0e75a439ac195ad990f8d1d4b80dcdd4b39174f5995f5245df2aeb7804c0e02c46f553a6482a5ebc73586c738e104ac1ff60a7e686cb4
+  metadata.gz: b2fd8b0d3d5ef67121c1291b68e936c9a99693483337b215b7fbe2c5b09f37bf422823d28350f1e1d11a48643a00e7bd02466e32256dc95f99aece25612eb207
+  data.tar.gz: 0c1f63889d399a11b9272bcb95a0c384d38b48a62d82e3f0931f70597386bc63fa56c9653fdaf1215deb572863089e04f8ab0f3df3b52251cb083fad7171e560

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7
+  - ree
+services: memcached

data/README.md

@@ -1,9 +1,9 @@
-# AtomicMemCacheStore
+# AtomicMemCacheStore [![Build Status](https://travis-ci.org/nel/atomic_mem_cache_store.png?branch=master)](https://travis-ci.org/nel/atomic_mem_cache_store)
 
 ## 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.
+sooner of later be a victim of the [thundering herd 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.
 
@@ -23,17 +23,27 @@ Install the gem
 	
 or add it to your Gemfile
 
-	gem 'atomic_mem_cache_store'
+    gem 'atomic_mem_cache_store'
 
 Then use it directly
+  
+    cache = AtomicMemCacheStore.new
+    cache.write('key', 'value', :expires_in => 10)
+    cache.read('key')
 
-	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}" }
+
+If you want to use Dalli instead, do the following:
+
+    cache = AtomicDalliStore.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}" }
+    config.cache_store = :atomic_dalli_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)
 

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.0

data/atomic_mem_cache_store.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   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.description = %q{Rails memcached store optimized for the thundering herd 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"
 
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec"
   s.add_development_dependency "rake"
   s.add_development_dependency "iconv"
-  s.add_runtime_dependency "activesupport", "~>2.1"
-  s.add_runtime_dependency "memcache-client"
+  s.add_development_dependency "dalli", "~> 1.0.4"
+  s.add_development_dependency "memcache-client"
+  s.add_runtime_dependency "activesupport", "~> 2.1"
 end

data/lib/atomic_dalli_store.rb

@@ -0,0 +1,10 @@
+require 'dalli'
+require 'dalli/memcache-client'
+require 'active_support/cache/dalli_store23'
+require 'atomic_store'
+
+class AtomicDalliStore < ActiveSupport::Cache::DalliStore
+  RAW_ARG = { :raw => true }
+
+  include AtomicStore
+end

data/lib/atomic_mem_cache_store.rb

@@ -1,49 +1,8 @@
 require 'active_support'
+require 'atomic_store'
 
 class AtomicMemCacheStore < ActiveSupport::Cache::CompressedMemCacheStore
-  VERSION = File.read(File.join(File.dirname(__FILE__),'..','VERSION') ).strip
-  NEWLY_STORED = "STORED\r\n"
+  RAW_ARG = true
 
-  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
+  include AtomicStore
 end

data/lib/atomic_store.rb

@@ -0,0 +1,55 @@
+module AtomicStore
+  VERSION = File.read(File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+  NEWLY_STORED = "STORED\r\n"
+
+  module ClassMethods
+    attr_accessor :grace_period
+  end
+
+  @grace_period = 90
+
+  def self.included(base)
+    @raw_arg = base::RAW_ARG
+    base.extend(ClassMethods)
+  end
+
+  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, @raw_arg) == 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, @raw_arg)
+    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/spec/lib/atomic_dalli_store_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe AtomicDalliStore do
+  it_behaves_like 'an atomic store'
+end

data/spec/lib/atomic_mem_cache_store_spec.rb

@@ -1,83 +1,5 @@
 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
+  it_behaves_like 'an atomic store'
 end

data/spec/spec_helper.rb

@@ -6,3 +6,5 @@ rescue LoadError
   require 'rspec'
 end
 require File.expand_path(File.dirname(__FILE__) + '/../lib/atomic_mem_cache_store')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/atomic_dalli_store')
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}

data/spec/support/shared_atomic_store_spec.rb

@@ -0,0 +1,83 @@
+shared_examples "an atomic store" do
+
+  before(:all) do
+    begin
+      @store = described_class.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)}"
+    described_class.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
+      described_class.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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atomic_mem_cache_store
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Renaud (Nel) Morvan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-29 00:00:00.000000000 Z
+date: 2013-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: dalli
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.1'
-  type: :runtime
+        version: 1.0.4
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 1.0.4
 - !ruby/object:Gem::Dependency
   name: memcache-client
   requirement: !ruby/object:Gem::Requirement
@@ -73,14 +73,28 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Rails memcached store optimized for the thundering herb issue. This limit
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Rails memcached store optimized for the thundering herd 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:
@@ -90,14 +104,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - README.md
 - Rakefile
 - VERSION
 - atomic_mem_cache_store.gemspec
+- lib/atomic_dalli_store.rb
 - lib/atomic_mem_cache_store.rb
+- lib/atomic_store.rb
+- spec/lib/atomic_dalli_store_spec.rb
 - spec/lib/atomic_mem_cache_store_spec.rb
 - spec/spec_helper.rb
+- spec/support/shared_atomic_store_spec.rb
 homepage: https://github.com/nel/atomic_mem_cache_store
 licenses: []
 metadata: {}
@@ -117,10 +136,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: atomic_mem_cache_store
-rubygems_version: 2.0.3
+rubygems_version: 2.1.2
 signing_key: 
 specification_version: 4
 summary: Rails memcached store with atomic expiration
 test_files:
+- spec/lib/atomic_dalli_store_spec.rb
 - spec/lib/atomic_mem_cache_store_spec.rb
 - spec/spec_helper.rb
+- spec/support/shared_atomic_store_spec.rb