mcmire-cache 0.3.4

data/lib/cache/memcached_rails.rb

@@ -0,0 +1,34 @@
+require 'cache/memcached'
+
+module Cache::MemcachedRails
+  def self.extended(base)
+    base.extend Cache::Memcached
+    base.extend Override
+  end
+
+  module Override
+    def _exist?(k)
+      thread_metal.exist? k
+    end
+
+    def _get(k)
+      thread_metal.get k
+    end
+
+    def _get_multi(ks)
+      thread_metal.get_multi ks
+    end
+
+    def _cas(k, ttl, &blk)
+      if _valid_ttl?(ttl)
+        thread_metal.cas k, ttl, &blk
+      else
+        thread_metal.cas k, &blk
+      end
+    end
+
+    def _delete(k)
+      thread_metal.delete k
+    end
+  end
+end

data/lib/cache/nothing.rb

@@ -0,0 +1,20 @@
+
+module Cache::Nothing
+  def _get(k); end
+
+  def _get_multi(ks); {}; end
+
+  def _set(k, v, ttl); end
+
+  def _fetch(k, ttl)
+    yield if block_given?
+  end
+
+  def _delete(k); end
+
+  def _flush; end
+
+  def _exist?(k); end
+
+  def _stats; end
+end

data/lib/cache/redis.rb

@@ -0,0 +1,44 @@
+module Cache::Redis
+  def after_fork
+    @metal.client.reconnect
+  end
+
+  def _get(k)
+    if cached_v = @metal.get(k) and cached_v.is_a?(String)
+      Marshal.load cached_v
+    end
+  end
+
+  def _get_multi(ks)
+    ks.inject({}) do |memo, k|
+      if v = _get(k)
+        memo[k] = v
+      end
+      memo
+    end
+  end
+
+  def _set(k, v, ttl)
+    if _valid_ttl?(ttl)
+      @metal.setex k, ttl, Marshal.dump(v)
+    else
+      @metal.set k, Marshal.dump(v)
+    end
+  end
+
+  def _delete(k)
+    @metal.del k
+  end
+
+  def _flush
+    @metal.flushdb
+  end
+
+  def _exist?(k)
+    @metal.exists k
+  end
+
+  def _stats
+    @metal.info
+  end
+end

data/lib/cache/redis_namespace.rb

@@ -0,0 +1,7 @@
+require 'cache/redis'
+
+module Cache::RedisNamespace
+  def self.extended(base)
+    base.extend Cache::Redis
+  end
+end

data/lib/cache/version.rb

@@ -0,0 +1,3 @@
+class Cache
+  VERSION = "0.3.4"
+end

data/mcmire-cache.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/cache/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "mcmire-cache"
+  s.version     = Cache::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Seamus Abshere","Christoph Grabo", "Elliot Winkler"]
+  s.email       = ["seamus@abshere.net","chris@dinarrr.com", "elliot.winkler@gmail.com"]
+  s.homepage    = "https://github.com/seamusabshere/cache"
+  s.summary     = %q{A unified cache handling interface inspired by libraries like ActiveSupport::Cache::Store, Perl's Cache::Cache, CHI, etc.}
+  s.description = %q{Wraps memcached, redis(-namespace), memcache-client, dalli and handles their weirdnesses, including forking}
+
+  s.rubyforge_project = "cache"
+
+  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"]
+end
+

data/test/helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'test/unit'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'cache'
+
+if ::Bundler.definition.specs['ruby-debug19'].first or ::Bundler.definition.specs['ruby-debug'].first
+  require 'ruby-debug'
+end
+
+require 'shared_tests'
+
+class TestCase < Test::Unit::TestCase
+  def raw_client_class
+    raise NotImplementedError, "You must add a #raw_client_class method to your test case"
+  end
+
+  def raw_client
+    raw_client_class.new
+  end
+
+  def cache
+    @cache ||= Cache.new(raw_client).tap {|c| c.flush }
+  end
+end
+
+ENV['CACHE_DEBUG'] = 'true'

data/test/profile/benchmark.rb

@@ -0,0 +1,258 @@
+# sabshere 2/22/11 thanks to memcached
+HERE = File.dirname(__FILE__)
+$LOAD_PATH << "#{HERE}/../../lib/"
+UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached') 
+
+require 'cache'
+require 'benchmark'
+require 'rubygems'
+require 'ruby-debug' if ENV['DEBUG']
+begin; require 'memory'; rescue LoadError; end
+
+puts `uname -a`
+puts `ruby -v`
+puts `env | egrep '^RUBY'`
+puts "Ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
+
+[ ["memcached", "memcached"], 
+  # ["remix-stash", "remix/stash"], 
+  # ["astro-remcached", "remcached"], # Clobbers the "Memcached" constant
+  ["memcache-client", "memcache"],
+  ["cache", "cache"],
+  ["kgio", "kgio"],
+  ["dalli","dalli"]].each do |gem_name, requirement|
+  require requirement
+  gem gem_name
+  puts "Loaded #{gem_name} #{Gem.loaded_specs[gem_name].version.to_s rescue nil}"
+end
+
+# class Remix::Stash
+#   # Remix::Stash API doesn't let you set servers
+#   @@clusters = {:default => Remix::Stash::Cluster.new(['127.0.0.1:43042', '127.0.0.1:43043'])}
+# end
+
+class Dalli::ClientCompat < Dalli::Client
+  def set(*args)
+    super(*args[0..2])
+  end
+  def get(*args)
+    super(args.first)
+  end
+  def get_multi(*args)
+    super(args.first)
+  end
+  def append(*args)
+    super
+  rescue Dalli::DalliError
+  end
+  def prepend(*args)
+    super
+  rescue Dalli::DalliError
+  end  
+end
+
+# class Cache::Compat < Cache
+#   def set(*args)
+#     super(*args[0..2])
+#   end
+#   def get(*args)
+#     super(args.first)
+#   end
+# end
+
+class Bench
+
+  def initialize(loops = nil, stack_depth = nil)
+    @loops = (loops || 20000).to_i
+    @stack_depth = (stack_depth || 0).to_i
+    
+    puts "Loops is #{@loops}"
+    puts "Stack depth is #{@stack_depth}"
+        
+    @m_value = Marshal.dump(
+      @small_value = ["testing"])    
+    @m_large_value = Marshal.dump(
+      @large_value = [{"test" => "1", "test2" => "2", Object.new => "3", 4 => 4, "test5" => 2**65}] * 2048)
+
+    puts "Small value size is: #{@m_value.size} bytes"
+    puts "Large value size is: #{@m_large_value.size} bytes"
+
+    @keys = [
+      @k1 = "Short",
+      @k2 = "Sym1-2-3::45" * 8,
+      @k3 = "Long" * 40,
+      @k4 = "Medium" * 8,
+      @k5 = "Medium2" * 8,
+      @k6 = "Long3" * 40]
+    
+    reset_servers
+    reset_clients
+    
+    Benchmark.bm(36) do |x| 
+      @benchmark = x 
+    end
+  end
+
+  def run(level = @stack_depth)
+    level > 0 ? run(level - 1) : run_without_recursion
+  end
+  
+  private
+  
+  def reset_servers
+    # Kill memcached
+    system("killall -9 memcached")
+
+    # Start memcached
+    verbosity = (ENV['DEBUG'] ? "-vv" : "")
+    log = "/tmp/memcached.log"
+    memcached = ENV['MEMCACHED_COMMAND'] || 'memcached'
+    system ">#{log}"
+
+    # TCP memcached
+    (43042..43046).each do |port|
+      cmd = "#{memcached} #{verbosity} -U 0 -p #{port} >> #{log} 2>&1 &"
+      raise "'#{cmd}' failed to start" unless system(cmd)
+    end
+    # UDP memcached
+    (43052..43053).each do |port|
+      cmd = "#{memcached} #{verbosity} -U #{port} -p 0 >> #{log} 2>&1 &"
+      raise "'#{cmd}' failed to start" unless system(cmd)
+    end
+    # Domain socket memcached
+    (0..1).each do |i|
+      cmd = "#{memcached} -M -s #{UNIX_SOCKET_NAME}#{i} #{verbosity} >> #{log} 2>&1 &"
+      raise "'#{cmd}' failed to start" unless system(cmd)
+    end
+  end
+  
+  def reset_clients
+    @clients = {
+       "cache:libm:bin" => Cache.wrap(Memcached.new(['127.0.0.1:43042', '127.0.0.1:43043'], :buffer_requests => false, :no_block => false, :namespace => "namespace", :binary_protocol => true)),
+       "cache:dalli:bin" => Cache.wrap(Dalli::Client.new(['127.0.0.1:43042', '127.0.0.1:43043'], :marshal => false, :threadsafe => false)),
+       "libm:ascii" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+       "libm:ascii:pipeline" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :no_block => true, :buffer_requests => true, :noreply => true, :namespace => "namespace"),
+       "libm:ascii:udp" => Memcached::Rails.new(
+         ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"],
+         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+       "libm:bin" => Memcached::Rails.new(
+          ['127.0.0.1:43042', '127.0.0.1:43043'],
+          :buffer_requests => false, :no_block => false, :namespace => "namespace", :binary_protocol => true),
+       "libm:bin:buffer" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :no_block => true, :buffer_requests => true, :namespace => "namespace", :binary_protocol => true),
+       "mclient:ascii" => MemCache.new(['127.0.0.1:43042', '127.0.0.1:43043']),
+       # "stash:bin" => Remix::Stash.new(:root),
+       "dalli:bin" => Dalli::ClientCompat.new(['127.0.0.1:43042', '127.0.0.1:43043'], :marshal => false, :threadsafe => false)}
+  end
+  
+  
+  def benchmark_clients(test_name, clients = @clients)
+    clients.keys.sort.each do |client_name|
+      next if client_name == "stash" and test_name == "set-large" # Don't let stash break the world
+      client = clients[client_name]
+      begin
+        yield client
+        @benchmark.report("#{test_name}: #{client_name}") { @loops.times { yield client } }
+      rescue Exception => e
+        puts "#{test_name}:#{client_name} => #{e.inspect}"
+        reset_clients
+      end
+    end
+    puts
+  end
+  
+  def benchmark_hashes(hashes, test_name)
+    hashes.each do |hash_name, int|
+      @m = Memcached::Rails.new(:hash => hash_name)
+      @benchmark.report("#{test_name}:#{hash_name}") do
+        (@loops * 5).times { yield int }
+      end
+    end  
+  end
+  
+  def run_without_recursion
+    benchmark_clients("set") do |c|
+      c.set @k1, @m_value, 0, true
+      c.set @k2, @m_value, 0, true
+      c.set @k3, @m_value, 0, true
+    end
+
+    benchmark_clients("get") do |c|
+      c.get @k1, true
+      c.get @k2, true
+      c.get @k3, true
+    end
+    
+    # benchmark_clients("get-multi") do |c|
+    #   c.get_multi @keys, true
+    # end
+    # 
+    # benchmark_clients("append") do |c|
+    #   c.append @k1, @m_value
+    #   c.append @k2, @m_value
+    #   c.append @k3, @m_value
+    # end    
+    # 
+    # benchmark_clients("prepend") do |c|
+    #   c.prepend @k1, @m_value
+    #   c.prepend @k2, @m_value
+    #   c.prepend @k3, @m_value
+    # end       
+  
+    benchmark_clients("delete") do |c|    
+      c.delete @k1
+      c.delete @k2
+      c.delete @k3
+    end
+    
+    benchmark_clients("get-missing") do |c|
+      c.get @k1
+      c.get @k2
+      c.get @k3
+    end
+
+    # benchmark_clients("append-missing") do |c|
+    #   c.append @k1, @m_value
+    #   c.append @k2, @m_value
+    #   c.append @k3, @m_value
+    # end
+    # 
+    # benchmark_clients("prepend-missing") do |c|
+    #   c.prepend @k1, @m_value
+    #   c.prepend @k2, @m_value
+    #   c.prepend @k3, @m_value
+    # end
+    
+    benchmark_clients("set-large") do |c|
+      c.set @k1, @m_large_value, 0, true
+      c.set @k2, @m_large_value, 0, true
+      c.set @k3, @m_large_value, 0, true
+    end
+
+    benchmark_clients("get-large") do |c|
+      c.get @k1, true
+      c.get @k2, true
+      c.get @k3, true
+    end
+     
+    benchmark_hashes(Memcached::HASH_VALUES, "hash") do |i|
+      Rlibmemcached.memcached_generate_hash_rvalue(@k1, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k2, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k3, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k4, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k5, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k6, i)    
+    end
+  end
+end
+
+Bench.new(ENV["LOOPS"], ENV["STACK_DEPTH"]).run
+
+Process.memory.each do |key, value|
+  puts "#{key}: #{value/1024.0}M"
+end if Process.respond_to? :memory

data/test/shared_tests.rb

@@ -0,0 +1,169 @@
+module SharedTests
+  def test_metal
+    assert_equal raw_client_class, cache.metal.class
+  end
+
+  def test_wrap_twice
+    c = Cache.new(Cache.new(raw_client))
+    assert_equal raw_client_class, c.metal.class
+  end
+
+  def test_wrap_absurd
+    c = Cache.new(Cache.new(Cache.new(raw_client)))
+    assert_equal raw_client_class, c.metal.class
+  end
+
+  def test_get
+    assert_equal nil, cache.get('hello')
+    cache.set 'hello', 'world'
+    assert_equal 'world', cache.get('hello')
+  end
+
+  def test_set
+    assert_nothing_raised do
+      cache.set 'hello', 'world'
+    end
+  end
+
+  def test_set_with_ttl
+    cache.set 'hello', 'world', 1
+    assert_equal 'world', cache.get('hello')
+    sleep 2
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_set_with_zero_ttl_meaning_eternal
+    cache.set 'hello', 'world', 0
+    assert_equal 'world', cache.get('hello')
+    sleep 1
+    assert_equal 'world', cache.get('hello')
+  end
+
+  def test_delete
+    cache.set 'hello', 'world'
+    assert_equal 'world', cache.get('hello')
+    cache.delete 'hello'
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_flush
+    cache.set 'hello', 'world'
+    assert cache.exist?('hello')
+    cache.flush
+    assert !cache.exist?('hello')
+  end
+
+  def test_exist
+    assert !cache.exist?('hello')
+    cache.set 'hello', 'world'
+    assert cache.exist?('hello')
+  end
+
+  def test_exists
+    assert !cache.exists?('hello')
+    cache.set 'hello', 'world'
+    assert cache.exists?('hello')
+  end
+
+  # This is not working with the Dalli client
+  #def test_exist_key_with_nil_value
+  #  assert !cache.exist?('hello')
+  #  cache.set 'hello', nil
+  #  assert cache.exist?('hello')
+  #end
+
+  def test_stats
+    assert_nothing_raised do
+      cache.stats
+    end
+  end
+
+  def test_fetch
+    assert_equal nil, cache.fetch('hello')
+    assert_equal 'world', cache.fetch('hello') { 'world' }
+  end
+
+  def test_fetch_with_false_boolean
+    assert_equal nil, cache.fetch('hello')
+    assert_equal false, cache.fetch('hello') { false }
+  end
+
+  def test_fetch_with_expires_in
+    assert_equal 'world', cache.fetch('hello', :expires_in => 5) { 'world' }
+  end
+
+  def test_fetch_with_expires_in_stringified
+    assert_equal 'world', cache.fetch('hello', 'expires_in' => 5) { 'world' }
+  end
+
+  def test_fetch_with_ignored_options
+    assert_equal 'world', cache.fetch('hello', :foo => 'bar') { 'world' }
+  end
+
+  def test_cas
+    toggle = lambda do |current|
+      current == 'on' ? 'off' : 'on'
+    end
+
+    cache.set 'lights', 'on'
+    assert_equal 'on', cache.get('lights')
+    cache.cas 'lights', &toggle
+    assert_equal 'off', cache.get('lights')
+    cache.cas 'lights', &toggle
+    assert_equal 'on', cache.get('lights')
+    cache.cas 'lights', &toggle
+    assert_equal 'off', cache.get('lights')
+  end
+
+  def test_write
+    cache.write 'hello', 'world'
+    assert_equal 'world', cache.get('hello')
+  end
+
+  def test_write_with_expires_in
+    cache.write 'hello', 'world', :expires_in => 1
+    assert_equal 'world', cache.get('hello')
+    sleep 2
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_write_with_ignored_options
+    cache.write 'hello', 'world', :foobar => 'bazboo'
+    assert_equal 'world', cache.get('hello')
+  end
+
+  def test_read
+    cache.set 'hello', 'world'
+    assert_equal 'world', cache.read('hello')
+  end
+
+  def test_increment
+    assert !cache.exist?('high-fives')
+    assert_equal 1, cache.increment('high-fives')
+    assert_equal 1, cache.get('high-fives')
+    assert_equal 2, cache.increment('high-fives')
+    assert_equal 2, cache.get('high-fives')
+  end
+
+  def test_decrement
+    assert !cache.exist?('high-fives')
+    assert_equal -1, cache.decrement('high-fives')
+    assert_equal -1, cache.get('high-fives')
+    assert_equal -2, cache.decrement('high-fives')
+    assert_equal -2, cache.get('high-fives')
+  end
+
+  def test_get_multi
+    cache.set 'hello', 'world'
+    cache.set 'privyet', 'mir'
+    assert_equal({ 'hello' => 'world', 'privyet' => 'mir'}, cache.get_multi('hello', 'privyet', 'yoyoyo'))
+  end
+
+  # https://github.com/fauna/memcached/pull/50
+  def test_get_set_behavior
+    cache.flush
+    cache.get 'get_set'
+    cache.set 'get_set', 'go'
+    assert_equal 'go', cache.get('get_set')
+  end
+end