cache_migration 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/README.md

@@ -0,0 +1,40 @@
+cache_migration
+===============
+
+CacheMigration is an ActiveSupport::Cache::Store implementation to aid in the transition between a hot cache server and a new cold cache server.
+
+If you don't have a process for warming a new cache server, this process can be difficult. Switching your application "cold-turkey" to a new cache server can have a detrimental effect on performance and usability.
+
+The CacheMigration gem will allow you to keep both the old and new cache servers online for a transition period, while the new cache server gradually becomes warmed through normal usage.
+
+During the transition period, all writes will be sent to both cache servers.
+
+When a read occurs, CacheMigration will first try to read from the new server. If there is a miss, the gem will fall back to the old server. If there is a hit on the new server, the data will be written back to the new server, thus warming it.
+
+After enough time, when the new cache server is sufficiently warm, you can remove this gem and move back to using your normal cache interface. The old servers can be safely taken offline.
+
+Gemfile
+
+```ruby
+gem 'cache_migration'
+```
+
+production.rb
+
+```ruby
+require 'active_support/cache/dalli_store'
+
+old_cache = ActiveSupport::Cache::DalliStore.new(
+    ENV["OLD_MEMCACHE_SERVERS"].split(","),
+    :username => ENV['OLD_MEMCACHE_USERNAME'],
+    :password => ENV['OLD_MEMCACHE_PASSWORD'])
+
+new_cache = ActiveSupport::Cache::DalliStore.new(
+    ENV["NEW_MEMCACHE_SERVERS"].split(","),
+    :username => ENV['NEW_MEMCACHE_USERNAME'],
+    :password => ENV['NEW_MEMCACHE_PASSWORD'])
+
+config.cache_store = CacheMigration.new(new_cache, old_cache)
+```
+
+This gem was designed to work with DalliStore, but it should work with any API compliant cache store.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+  t.warning = true
+end
+
+task :default => :test

data/cache_migration.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |gem|
+  gem.name          = "cache_migration"
+  gem.version       = '0.0.1'
+  gem.authors       = ["Jonathan Baudanza"]
+  gem.email         = ["jon@jonb.org"]
+  gem.description   = %q{ActiveSupport::Cache::Store implementation to help migrating caches}
+  gem.summary       = %q{ActiveSupport::Cache::Store implementation to help migrating caches}
+  gem.homepage      = "https://github.com/jbaudanza/cache_migration"
+
+  gem.add_dependency('activesupport', '>= 3.0.0')
+
+  gem.files         = `git ls-files`.split($/).collect{ |str| str[0] == '"' ? eval(str) : str }
+  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"]
+end

data/lib/cache_migration.rb

@@ -0,0 +1,82 @@
+require 'active_support/cache'
+
+class CacheMigration
+  attr_accessor :new_cache, :old_cache
+
+  def initialize(new_cache, old_cache)
+    @new_cache = new_cache
+    @old_cache = old_cache
+  end
+
+  def fetch(name, options=nil)
+    @new_cache.fetch(name, options) do
+      @old_cache.fetch(name, options) do
+        yield
+      end
+    end
+  end
+
+  def read(name, options=nil)
+    value = @new_cache.read(name, options)
+    if !value
+      value = @old_cache.read(name, options)
+      if value
+        @new_cache.write(name, value, options)
+      end
+    end
+    value
+  end
+
+  def write(name, value, options=nil)
+    @new_cache.write(name, value, options)
+    @old_cache.write(name, value, options)
+  end
+
+  def exist?(name, options=nil)
+    @new_cache.exist?(name, options) || @old_cache.exist?(name, options)
+  end
+
+  def delete(name, options=nil)
+    @new_cache.delete(name, options)
+    @old_cache.delete(name, options)
+  end
+
+  def read_multi(*names)
+    @new_cache.read_multi(*names).tap do |result|
+      if result.length < names.length
+        result.reverse_merge!(@old_cache.read_multi(*names))
+      end
+    end
+  end
+
+  def fetch_multi(*names, &proc)
+    @new_cache.fetch_multi(*names) do |key|
+      @old_cache.fetch(key, &proc)
+    end
+  end
+
+  def clear(options = nil)
+    @new_cache.clear(options)
+    @old_cache.clear(options)
+  end
+
+  def cleanup(options = nil)
+    @new_cache.cleanup(options)
+    @old_cache.cleanup(options)
+  end
+
+  def increment(name, amount = 1, options = nil)
+    @new_cache.increment(name, amount, options)
+    @old_cache.increment(name, amount, options)
+  end
+
+  def decrement(name, amount = 1, options = nil)
+    @new_cache.decrement(name, amount, options)
+    @old_cache.decrement(name, amount, options)
+  end
+
+  def delete_matched(matcher, options = nil)
+    @new_cache.delete_matched(matcher, options)
+    @old_cache.delete_matched(matcher, options)
+  end
+end

data/test/cache_migration_test.rb

@@ -0,0 +1,83 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'cache_migration'
+require 'active_support/cache/memory_store'
+
+class CacheMigrationTest < MiniTest::Unit::TestCase
+  def setup
+    @old_cache = ActiveSupport::Cache::MemoryStore.new
+    @new_cache = ActiveSupport::Cache::MemoryStore.new
+    @migration = CacheMigration.new(@new_cache, @old_cache)
+  end
+
+  def test_it_writes_to_both_caches
+    @migration.write('hello', 'world')
+    assert_equal 'world', @old_cache.read('hello')
+    assert_equal 'world', @new_cache.read('hello')
+  end
+
+  def test_hit
+    @new_cache.write('hello', 'world')
+    assert_equal 'world', @migration.read('hello')
+  end
+
+  def test_half_miss
+    @old_cache.write('hello', 'world')
+    assert_equal 'world', @migration.read('hello')
+    assert_equal 'world', @new_cache.read('hello')
+  end
+
+  def test_full_miss
+    assert_nil @migration.read('hello')
+  end
+
+  def test_exists
+    @old_cache.write('hello', 'world')
+    @new_cache.write('foo', 'bar')
+
+    assert @migration.exist?('hello')
+    assert @migration.exist?('foo')
+    assert !@migration.exist?('goodbye')
+  end
+
+  def test_fetch
+    @migration.fetch('hello') { 'world' }
+    assert_equal 'world', @old_cache.read('hello')
+    assert_equal 'world', @new_cache.read('hello')
+  end
+
+  def test_delete
+    @old_cache.write('hello', 'world')
+    @new_cache.write('hello', 'world')
+    @migration.delete('hello')
+    assert_nil @new_cache.read('hello')
+    assert_nil @old_cache.read('hello')
+  end
+
+  def test_read_multi
+    @new_cache.write('hello', 'world')
+    @old_cache.write('foo', 'bar')
+
+    expected = {'hello' => 'world', 'foo' => 'bar'}
+
+    assert_equal expected, @migration.read_multi('foo', 'hello')
+  end
+
+  # Commenting this test out because MemoryStore won't support fetch_multi
+  # until Rails 4.1
+  # def test_fetch_multi
+  #   expected = {'hello' => 'world', 'foo' => 'bar'}
+
+  #   @migration.fetch_multi('hello', 'world') do |key|
+  #     case key
+  #     when 'hello'; 'world'
+  #     when 'foo'; 'bar'
+  #     end
+  #   end
+
+  #   assert_equal 'world', @old_cache.read('hello')
+  #   assert_equal 'world', @new_cache.read('hello')
+  #   assert_equal 'foo', @old_cache.read('black')
+  #   assert_equal 'foo', @new_cache.read('black')
+  # end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: cache_migration
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Baudanza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-26 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2157760900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157760900
+description: ActiveSupport::Cache::Store implementation to help migrating caches
+email:
+- jon@jonb.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- cache_migration.gemspec
+- lib/cache_migration.rb
+- test/cache_migration_test.rb
+has_rdoc: true
+homepage: https://github.com/jbaudanza/cache_migration
+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.6.2
+signing_key: 
+specification_version: 3
+summary: ActiveSupport::Cache::Store implementation to help migrating caches
+test_files:
+- test/cache_migration_test.rb