libmemcached_store 0.2.3 → 0.6.0

data/lib/libmemcached_store.rb

@@ -1,2 +1,2 @@
 require 'active_support/cache/libmemcached_store'
-require 'active_support/cache/compressed_libmemcached_store'
+require 'action_dispatch/session/libmemcached_store'

data/lib/memcached/get_with_flags.rb

@@ -0,0 +1,42 @@
+#
+# Allow get method to returns value + entry's flags
+# This is useful to set compression flag.
+#
+module GetWithFlags
+  def get(keys, marshal=true, with_flags=false)
+    if keys.is_a? Array
+      # Multi get
+      ret = Memcached::Lib.memcached_mget(@struct, keys);
+      check_return_code(ret, keys)
+
+      hash, flags_hash = {}, {}
+      value, key, flags, ret = Memcached::Lib.memcached_fetch_rvalue(@struct)
+      while ret != 21 do # Lib::MEMCACHED_END
+        if ret == 0 # Lib::MEMCACHED_SUCCESS
+          hash[key] = value
+          flags_hash[key] = flags if with_flags
+        elsif ret != 16 # Lib::MEMCACHED_NOTFOUND
+          check_return_code(ret, key)
+        end
+        value, key, flags, ret = Memcached::Lib.memcached_fetch_rvalue(@struct)
+      end
+      if marshal
+        hash.each do |key, value|
+          hash[key] = Marshal.load(value)
+        end
+      end
+      with_flags ? [hash, flags_hash] : hash
+    else
+      # Single get
+      value, flags, ret = Memcached::Lib.memcached_get_rvalue(@struct, keys)
+      check_return_code(ret, keys)
+      value =  Marshal.load(value) if marshal
+      with_flags ? [value, flags] : value
+    end
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module LibmemcachedStore
+  VERSION = "0.6.0"
+end

data/libmemcached_store.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "libmemcached_store"
+  s.version     = LibmemcachedStore::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "ActiveSupport 3+ cache store for the C-based libmemcached client"
+  s.email       = "cocchi.c@gmail.com"
+  s.homepage    = "http://github.com/ccocchi/libmemcached_store"
+  s.description = %q{An ActiveSupport cache store that uses the C-based libmemcached client through
+      Evan Weaver's Ruby/SWIG wrapper, memcached. libmemcached is fast, lightweight,
+      and supports consistent hashing, non-blocking IO, and graceful server failover.}
+  s.authors     = ["Christopher Cocchi-Perrier", "Ben Hutton", "Jeffrey Hardy"]
+
+  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_dependency("memcached", ">= 0")
+
+  s.add_development_dependency('rack')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('activesupport', '>= 3')
+  s.add_development_dependency('actionpack', '>= 3')
+end
+

data/test/action_dispatch/abstract_unit.rb

@@ -0,0 +1,43 @@
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'action_controller'
+require 'action_dispatch/routing'
+require 'action_dispatch/middleware/head'
+require 'action_dispatch/testing/assertions'
+require 'action_dispatch/testing/test_process'
+require 'action_dispatch/testing/integration'
+
+SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
+
+class RoutedRackApp
+  attr_reader :routes
+
+  def initialize(routes, &blk)
+    @routes = routes
+    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
+  end
+
+  def call(env)
+    @stack.call(env)
+  end
+end
+
+class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
+  def self.build_app(routes = nil)
+    RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
+      if defined?(ActionDispatch::PublicExceptions)
+        middleware.use "ActionDispatch::ShowExceptions", ActionDispatch::PublicExceptions.new("/dev/null")
+        middleware.use "ActionDispatch::DebugExceptions"
+      else
+        middleware.use "ActionDispatch::ShowExceptions"
+      end
+      middleware.use "ActionDispatch::Callbacks"
+      middleware.use "ActionDispatch::ParamsParser"
+      middleware.use "ActionDispatch::Cookies"
+      middleware.use "ActionDispatch::Flash"
+      middleware.use "ActionDispatch::Head"
+      yield(middleware) if block_given?
+    end
+  end
+end

data/test/action_dispatch/libmemcached_store_test.rb

@@ -0,0 +1,200 @@
+require 'test_helper'
+require File.expand_path('../abstract_unit', __FILE__)
+require 'action_dispatch/session/libmemcached_store'
+
+class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
+  class TestController < ActionController::Base
+    def no_session_access
+      head :ok
+    end
+
+    def set_session_value
+      session[:foo] = "bar"
+      head :ok
+    end
+
+    def set_serialized_session_value
+      session[:foo] = SessionAutoloadTest::Foo.new
+      head :ok
+    end
+
+    def get_session_value
+      render :text => "foo: #{session[:foo].inspect}"
+    end
+
+    def get_session_id
+      render :text => "#{request.session_options[:id]}"
+    end
+
+    def call_reset_session
+      session[:bar]
+      reset_session
+      session[:bar] = "baz"
+      head :ok
+    end
+
+    def self._routes
+      SharedTestRoutes
+    end
+  end
+
+  def test_setting_and_getting_session_value
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: "bar"', response.body
+    end
+  end
+
+  def test_getting_nil_session_value
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+    end
+  end
+
+  def test_getting_session_value_after_session_reset
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_cookie = cookies.send(:hash_for)['_session_id']
+
+      get '/call_reset_session'
+      assert_response :success
+      assert_not_equal [], headers['Set-Cookie']
+
+      cookies << session_cookie # replace our new session_id with our old, pre-reset session_id
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body, "data for this session should have been obliterated from memcached"
+    end
+  end
+
+  def test_getting_from_nonexistent_session
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+      assert_nil cookies['_session_id'], "should only create session on write, not read"
+    end
+  end
+
+  def test_setting_session_value_after_session_reset
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_id = cookies['_session_id']
+
+      get '/call_reset_session'
+      assert_response :success
+      assert_not_equal [], headers['Set-Cookie']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+
+      get '/get_session_id'
+      assert_response :success
+      assert_not_equal session_id, response.body
+    end
+  end
+
+  def test_getting_session_id
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_id = cookies['_session_id']
+
+      get '/get_session_id'
+      assert_response :success
+      assert_equal session_id, response.body, "should be able to read session id without accessing the session hash"
+    end
+  end
+
+  def test_deserializes_unloaded_class
+    with_test_route_set do
+      with_autoload_path "session_autoload_test" do
+        get '/set_serialized_session_value'
+        assert_response :success
+        assert cookies['_session_id']
+      end
+      with_autoload_path "session_autoload_test" do
+        get '/get_session_id'
+        assert_response :success
+      end
+      with_autoload_path "session_autoload_test" do
+        get '/get_session_value'
+        assert_response :success
+        assert_equal 'foo: #<SessionAutoloadTest::Foo bar:"baz">', response.body, "should auto-load unloaded class"
+      end
+    end
+  end
+
+  def test_doesnt_write_session_cookie_if_session_id_is_already_exists
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal nil, headers['Set-Cookie'], "should not resend the cookie again if session_id cookie is already exists"
+    end
+  end
+
+  def test_prevents_session_fixation
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+      session_id = cookies['_session_id']
+
+      reset!
+
+      get '/set_session_value', :_session_id => session_id
+      assert_response :success
+      assert_not_equal session_id, cookies['_session_id']
+    end
+  end
+
+  private
+
+  def with_test_route_set
+    with_routing do |set|
+      set.draw do
+        match ':action', :to => TestController
+      end
+
+      @app = self.class.build_app(set) do |middleware|
+        middleware.use ActionDispatch::Session::LibmemcachedStore, :key => '_session_id'
+        middleware.delete "ActionDispatch::ShowExceptions"
+      end
+
+      yield
+    end
+  end
+
+  def with_autoload_path(path)
+    path = File.join(File.dirname(__FILE__), "../fixtures", path)
+    if ActiveSupport::Dependencies.autoload_paths.include?(path)
+      yield
+    else
+      begin
+        ActiveSupport::Dependencies.autoload_paths << path
+        yield
+      ensure
+        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
+        ActiveSupport::Dependencies.clear
+      end
+    end
+  end
+end

data/test/active_support/libmemcached_store_test.rb

@@ -0,0 +1,341 @@
+# encoding: utf-8
+
+require 'test_helper'
+require 'memcached'
+require 'active_support'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/object/duplicable'
+require 'active_support/cache/libmemcached_store'
+
+# Make it easier to get at the underlying cache options during testing.
+class ActiveSupport::Cache::LibmemcachedStore
+  def client_options
+    @cache.options
+  end
+end
+
+class MockUser
+  def cache_key
+    'foo'
+  end
+end
+
+module CacheStoreBehavior
+  def test_fetch_without_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:write_entry).never
+    assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_cache_miss
+    @cache.expects(:write_entry).with('foo', 'baz', nil)
+    assert_equal 'baz', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_forced_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:read_entry).never
+    @cache.expects(:write_entry).with('foo', 'baz', force: true)
+    assert_equal 'baz', @cache.fetch('foo', force: true) { 'baz' }
+  end
+
+  def test_fetch_with_cached_false
+    @cache.write('foo', false)
+    refute @cache.fetch('foo') { raise }
+  end
+
+  def test_fetch_with_raw_object
+    o = Object.new
+    o.instance_variable_set :@foo, 'bar'
+    assert_equal o, @cache.fetch('foo', raw: true) { o }
+  end
+
+  def test_fetch_with_cache_key
+    u = MockUser.new
+    @cache.write(u.cache_key, 'bar')
+    assert_equal 'bar', @cache.fetch(u) { raise }
+  end
+
+  def test_should_read_and_write_strings
+    assert @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_should_read_and_write_hash
+    assert @cache.write('foo', { a: 'b' })
+    assert_equal({ a: 'b' }, @cache.read('foo'))
+  end
+
+  def test_should_read_and_write_integer
+    assert @cache.write('foo', 1)
+    assert_equal 1, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_nil
+    assert @cache.write('foo', nil)
+    assert_equal nil, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_false
+    assert @cache.write('foo', false)
+    assert_equal false, @cache.read('foo')
+  end
+
+  def test_read_and_write_compressed_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_write_should_overwrite
+    @cache.write('foo', 'bar')
+    @cache.write('foo', 'baz')
+    assert_equal 'baz', @cache.read('foo')
+  end
+
+  def test_write_compressed_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1, :raw => true)
+    assert_equal Zlib::Deflate.deflate('bar'), @cache.instance_variable_get(:@cache).get('foo', false)
+  end
+
+  def test_read_miss
+    assert_nil @cache.read('foo')
+  end
+
+  def test_read_should_return_a_different_object_id_each_time_it_is_called
+    @cache.write('foo', 'bar')
+    refute_equal @cache.read('foo').object_id, @cache.read('foo').object_id
+  end
+
+  def test_read_multi
+    @cache.write('foo', 'bar')
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_read_multi_with_array
+    @cache.write('foo', 'bar')
+    @cache.write('fu', 'baz')
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi(['foo', 'fu']))
+  end
+
+  def test_read_multi_with_raw
+    @cache.write('foo', 'bar', :raw => true)
+    @cache.write('fu', 'baz', :raw => true)
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_read_multi_with_compress
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
+    @cache.write('fu', 'baz', :compress => true, :compress_threshold => 1)
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_cache_key
+    o = MockUser.new
+    @cache.write(o, 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_param_as_cache_key
+    obj = Object.new
+    def obj.to_param
+      'foo'
+    end
+    @cache.write(obj, 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_array_as_cache_key
+    @cache.write([:fu, 'foo'], 'bar')
+    assert_equal 'bar', @cache.read('fu/foo')
+  end
+
+  def test_hash_as_cache_key
+    @cache.write({:foo => 1, :fu => 2}, 'bar')
+    assert_equal 'bar', @cache.read('foo=1/fu=2')
+  end
+
+  def test_keys_are_case_sensitive
+    @cache.write('foo', 'bar')
+    assert_nil @cache.read('FOO')
+  end
+
+  def test_keys_with_spaces
+    assert_equal 'baz', @cache.fetch('foo bar') { 'baz' }
+  end
+
+  def test_exist
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    refute @cache.exist?('bar')
+  end
+
+  def test_delete
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    assert @cache.delete('foo')
+    refute @cache.exist?('foo')
+  end
+
+  def test_delete_with_unexistent_key
+    @cache.expects(:log_error).never
+    refute @cache.exist?('foo')
+    refute @cache.delete('foo')
+  end
+
+  def test_store_objects_should_be_immutable
+    @cache.write('foo', 'bar')
+    @cache.read('foo').gsub!(/.*/, 'baz')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_original_store_objects_should_not_be_immutable
+    bar = 'bar'
+    @cache.write('foo', bar)
+    assert_equal 'baz', bar.gsub!(/r/, 'z')
+  end
+
+  def test_crazy_key_characters
+    crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
+    assert @cache.write(crazy_key, "1", :raw => true)
+    assert_equal "1", @cache.read(crazy_key)
+    assert_equal "1", @cache.fetch(crazy_key)
+    assert @cache.delete(crazy_key)
+    refute @cache.exist?(crazy_key)
+    assert_equal "2", @cache.fetch(crazy_key, :raw => true) { "2" }
+    assert_equal 3, @cache.increment(crazy_key)
+    assert_equal 2, @cache.decrement(crazy_key)
+  end
+
+  def test_really_long_keys
+    key = "a" * 251
+    assert @cache.write(key, "bar")
+    assert_equal "bar", @cache.read(key)
+    assert_equal "bar", @cache.fetch(key)
+    assert_nil @cache.read("#{key}x")
+    assert_equal({key => "bar"}, @cache.read_multi(key))
+    assert @cache.delete(key)
+    refute @cache.exist?(key)
+    assert @cache.write(key, '2', :raw => true)
+    assert_equal 3, @cache.increment(key)
+    assert_equal 2, @cache.decrement(key)
+  end
+
+  def test_really_long_keys_with_namespace
+    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, :expires_in => 60, :namespace => 'namespace')
+    @cache.silence!
+    test_really_long_keys
+  end
+
+  def test_clear
+    @cache.write("foo", "bar")
+    @cache.clear
+    assert_nil @cache.read("foo")
+  end
+
+  def test_clear_with_options
+    @cache.write("foo", "bar")
+    @cache.clear(:some_option => true)
+    assert_nil @cache.read("foo")
+  end
+end
+
+module CacheIncrementDecrementBehavior
+  def test_increment
+    @cache.write('foo', '1', :raw => true)
+    assert_equal 1, @cache.read('foo').to_i
+    assert_equal 2, @cache.increment('foo')
+    assert_equal 2, @cache.read('foo').to_i
+    assert_equal 3, @cache.increment('foo')
+    assert_equal 3, @cache.read('foo').to_i
+  end
+
+  def test_decrement
+    @cache.write('foo', '3', :raw => true)
+    assert_equal 3, @cache.read('foo').to_i
+    assert_equal 2, @cache.decrement('foo')
+    assert_equal 2, @cache.read('foo').to_i
+    assert_equal 1, @cache.decrement('foo')
+    assert_equal 1, @cache.read('foo').to_i
+  end
+
+  def test_increment_decrement_non_existing_keys
+    @cache.expects(:log_error).never
+    assert_nil @cache.increment('foo')
+    assert_nil @cache.decrement('bar')
+  end
+end
+
+module CacheCompressBehavior
+  def test_read_and_write_compressed_small_data
+    @cache.write('foo', 'bar', :compress => true)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    value = Marshal.load(raw_value) rescue raw_value
+    assert_equal 'bar', value
+  end
+
+  def test_read_and_write_compressed_large_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    assert_equal 'bar', Marshal.load(Zlib::Inflate.inflate(raw_value))
+  end
+end
+
+class LibmemcachedStoreTest < MiniTest::Unit::TestCase
+  include CacheStoreBehavior
+  include CacheIncrementDecrementBehavior
+
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, expires_in: 60)
+    @cache.clear
+    @cache.silence!
+  end
+
+  def test_should_identify_cache_store
+    assert_kind_of ActiveSupport::Cache::LibmemcachedStore, @cache
+  end
+
+  def test_should_set_server_addresses_to_nil_if_none_are_given
+    assert_equal [], @cache.addresses
+  end
+
+  def test_should_set_custom_server_addresses
+    store = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost', '192.168.1.1'
+    assert_equal %w(localhost 192.168.1.1), store.addresses
+  end
+
+  def test_should_enable_consistent_ketema_hashing_by_default
+    assert_equal :consistent_ketama, @cache.client_options[:distribution]
+  end
+
+  def test_should_not_enable_non_blocking_io_by_default
+    assert_equal false, @cache.client_options[:no_block]
+  end
+
+  def test_should_not_enable_server_failover_by_default
+    assert_nil @cache.client_options[:failover]
+  end
+
+  def test_should_allow_configuration_of_custom_options
+    options = { client: { tcp_nodelay: true, distribution: :modula } }
+
+    store = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost', options
+
+    assert_equal :modula, store.client_options[:distribution]
+    assert_equal true, store.client_options[:tcp_nodelay]
+  end
+
+  def test_should_allow_mute_and_silence
+    cache = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost'
+    cache.mute do
+      assert cache.write('foo', 'bar')
+      assert_equal 'bar', cache.read('foo')
+    end
+    refute cache.silence?
+    cache.silence!
+    assert cache.silence?
+  end
+end