dalli 2.0.3 → 2.0.4

data/History.md

@@ -1,6 +1,16 @@
 Dalli Changelog
 =====================
 
+2.0.4
+=======
+
+- Dalli no longer needs to be reset after Unicorn/Passenger fork [#208]
+- Add option to re-raise errors rescued in the session and cache stores. [pitr, #200]
+- DalliStore#fetch called the block if the cached value == false [#205]
+- DalliStore should have accessible options [#195]
+- Add silence and mute support for DalliStore [#207]
+- Tracked down and fixed socket corruption due to Timeout [#146]
+
 2.0.3
 =======
 

data/README.md

@@ -86,38 +86,9 @@ To use Dalli for Rails session storage, in `config/initializers/session_store.rb
     require 'action_dispatch/middleware/session/dalli_store'
     Rails.application.config.session_store :dalli_store, :memcache_server => ['host1', 'host2'], :namespace => 'sessions', :key => '_foundation_session', :expire_after => 30.minutes
 
-Dalli does not support Rails 2.x any longer.
-
-
-Usage with Passenger
-------------------------
-
-Put this at the bottom of `config/environment.rb`:
-
-    if defined?(PhusionPassenger)
-      PhusionPassenger.on_event(:starting_worker_process) do |forked|
-        # Reset Rails's object cache
-        # Only works with DalliStore
-        Rails.cache.reset if forked
+Both cache and session stores support `:raise_errors` parameter, which propagates exceptions (e.g. if all memcache servers are down) instead of silently hiding errors.
 
-        # Reset Rails's session store
-        # If you know a cleaner way to find the session store instance, please let me know
-        ObjectSpace.each_object(ActionDispatch::Session::DalliStore) { |obj| obj.reset }
-      end
-    end
-
-Usage with Unicorn
------------------------
-
-Modify the `after_fork` block in your unicorn config file:
-
-    after\_fork do |server, worker|
-      Rails.cache.reset if Rails.cache.respond_to?(:reset)
-
-      # Reset Rails's session store
-      # If you know a cleaner way to find the session store instance, please let me know
-      ObjectSpace.each_object(ActionDispatch::Session::DalliStore) { |obj| obj.reset }
-    end
+Dalli does not support Rails 2.x any longer.
 
 
 Configuration
@@ -151,6 +122,10 @@ Features and Changes
 
 By default, Dalli is thread-safe.  Disable thread-safety at your own peril.
 
+Dalli does not need anything special in Unicorn/Passenger since 2.0.4.
+It will detect sockets shared with child processes and gracefully reopen the
+socket.
+
 Note that Dalli does not require ActiveSupport or Rails.  You can safely use it in your own Ruby projects.
 
 

data/lib/action_dispatch/middleware/session/dalli_store.rb

@@ -20,6 +20,8 @@ module ActionDispatch
         end
         @namespace = @default_options[:namespace]
 
+        @raise_errors = !!@default_options[:raise_errors]
+
         super
       end
 
@@ -49,6 +51,7 @@ module ActionDispatch
         sid
       rescue Dalli::DalliError
         Rails.logger.warn("Session::DalliStore#set: #{$!.message}")
+        raise if @raise_errors
         false
       end
 
@@ -57,6 +60,7 @@ module ActionDispatch
           @pool.delete(session_id)
         rescue Dalli::DalliError
           Rails.logger.warn("Session::DalliStore#destroy_session: #{$!.message}")
+          raise if @raise_errors
         end
         return nil if options[:drop]
         generate_sid
@@ -68,6 +72,7 @@ module ActionDispatch
         end
       rescue Dalli::DalliError
         Rails.logger.warn("Session::DalliStore#destroy: #{$!.message}")
+        raise if @raise_errors
         false
       end
 

data/lib/active_support/cache/dalli_store.rb

@@ -6,6 +6,23 @@ module ActiveSupport
   module Cache
     class DalliStore
 
+      attr_reader :silence, :options
+      alias_method :silence?, :silence
+
+      # Silence the logger.
+      def silence!
+        @silence = true
+        self
+      end
+
+      # Silence the logger within a block.
+      def mute
+        previous_silence, @silence = defined?(@silence) && @silence, true
+        yield
+      ensure
+        @silence = previous_silence
+      end
+
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/
 
       # Creates a new DalliStore object, with the given memcached server
@@ -20,9 +37,11 @@ module ActiveSupport
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
-        options[:compress] ||= options[:compression]
+        @options = options.dup
+        @options[:compress] ||= @options[:compression]
+        @raise_errors = !!@options[:raise_errors]
         addresses << 'localhost:11211' if addresses.empty?
-        @data = Dalli::Client.new(addresses, options)
+        @data = Dalli::Client.new(addresses, @options)
       end
 
       def fetch(name, options=nil)
@@ -35,7 +54,7 @@ module ActiveSupport
             end
           end
 
-          if entry
+          if !entry.nil?
             instrument(:fetch_hit, name, options) { |payload| }
             entry
           else
@@ -68,7 +87,7 @@ module ActiveSupport
 
       def exist?(name, options=nil)
         options ||= {}
-        !!read_entry(name, options)
+        !read_entry(name, options).nil?
       end
 
       def delete(name, options=nil)
@@ -107,6 +126,7 @@ module ActiveSupport
         end
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
+        raise if @raise_errors
         nil
       end
 
@@ -124,6 +144,7 @@ module ActiveSupport
         end
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
+        raise if @raise_errors
         nil
       end
 
@@ -151,6 +172,7 @@ module ActiveSupport
         entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
+        raise if @raise_errors
         nil
       end
 
@@ -161,6 +183,7 @@ module ActiveSupport
         @data.send(method, escape(key), value, expires_in, options)
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
+        raise if @raise_errors
         false
       end
 
@@ -169,6 +192,7 @@ module ActiveSupport
         @data.delete(escape(key))
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
+        raise if @raise_errors
         false
       end
 
@@ -195,7 +219,7 @@ module ActiveSupport
       end
 
       def log(operation, key, options=nil)
-        return unless logger && logger.debug?
+        return unless logger && logger.debug? && !silence?
         logger.debug("Cache #{operation}: #{key}#{options.blank? ? "" : " (#{options.inspect})"}")
       end
 

data/lib/dalli/server.rb

@@ -37,10 +37,12 @@ module Dalli
       @options = DEFAULTS.merge(options)
       @sock = nil
       @msg = nil
+      @pid = nil
     end
 
     # Chokepoint method for instrumentation
     def request(op, *args)
+      verify_state
       raise Dalli::NetworkError, "#{hostname}:#{port} is down: #{@error} #{@msg}" unless alive?
       begin
         send(op, *args)
@@ -80,6 +82,8 @@ module Dalli
       return unless @sock
       @sock.close rescue nil
       @sock = nil
+      @pid = nil
+      @inprogress = false
     end
 
     def lock!
@@ -92,6 +96,11 @@ module Dalli
 
     private
 
+    def verify_state
+      failure! if @inprogress
+      failure! if @pid && @pid != Process.pid
+    end
+
     def failure!
       Dalli.logger.info { "#{hostname}:#{port} failed (count: #{@fail_count})" }
 
@@ -368,19 +377,23 @@ module Dalli
 
     def write(bytes)
       begin
-        @sock.write(bytes)
+        @inprogress = true
+        result = @sock.write(bytes)
+        @inprogress = false
+        result
       rescue SystemCallError, Timeout::Error
         failure!
-        retry
       end
     end
 
     def read(count)
       begin
-        @sock.readfull(count)
+        @inprogress = true
+        data = @sock.readfull(count)
+        @inprogress = false
+        data
       rescue SystemCallError, Timeout::Error, EOFError
         failure!
-        retry
       end
     end
 
@@ -388,6 +401,7 @@ module Dalli
       Dalli.logger.debug { "Dalli::Server#connect #{hostname}:#{port}" }
 
       begin
+        @pid = Process.pid
         @sock = KSocket.open(hostname, port, options)
         @version = version # trigger actual connect
         sasl_authentication if need_auth?
@@ -397,7 +411,6 @@ module Dalli
       rescue SystemCallError, Timeout::Error, EOFError, SocketError
         # SocketError = DNS resolution failure
         failure!
-        retry
       end
     end
 

data/lib/dalli/socket.rb

@@ -16,6 +16,7 @@ begin
     def self.open(host, port, options = {})
       addr = Socket.pack_sockaddr_in(port, host)
       sock = start(addr)
+      sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
       sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
       sock.options = options
       sock.kgio_wait_writable
@@ -49,6 +50,7 @@ rescue LoadError
     def self.open(host, port, options = {})
       Timeout.timeout(options[:socket_timeout]) do
         sock = new(host, port)
+        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
         sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
         sock.options = { :host => host, :port => port }.merge(options)
         sock

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '2.0.3'
+  VERSION = '2.0.4'
 end

data/test/test_active_support.rb

@@ -4,7 +4,23 @@ require 'helper'
 describe 'ActiveSupport' do
   context 'active_support caching' do
 
-    should 'dalli_store operations should handle nil options' do
+    should 'have accessible options' do
+      @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 5.minutes, :frob => 'baz')
+      assert_equal 'baz', @dalli.options[:frob]
+    end
+
+    should 'allow mute and silence' do
+      @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122')
+      @dalli.mute do
+        assert_equal true, @dalli.write('foo', 'bar', nil)
+        assert_equal 'bar', @dalli.read('foo', nil)
+      end
+      refute @dalli.silence?
+      @dalli.silence!
+      assert_equal true, @dalli.silence?
+    end
+
+    should 'handle nil options' do
       @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122')
       assert_equal true, @dalli.write('foo', 'bar', nil)
       assert_equal 'bar', @dalli.read('foo', nil)
@@ -30,6 +46,10 @@ describe 'ActiveSupport' do
 
           dvalue = @dalli.fetch(rand_key) { o }
           assert_equal o, dvalue
+
+          @dalli.write('false', false)
+          dvalue = @dalli.fetch('false') { flunk }
+          assert_equal false, dvalue
         end
       end
     end
@@ -133,6 +153,21 @@ describe 'ActiveSupport' do
       end
     end
 
+    should 'support exist command' do
+      with_activesupport do
+        memcached do
+          connect
+          @dalli.write(:foo, 'a')
+          @dalli.write(:false_value, false)
+
+          assert_equal true, @dalli.exist?(:foo)
+          assert_equal true, @dalli.exist?(:false_value)
+
+          assert_equal false, @dalli.exist?(:bar)
+        end
+      end
+    end
+
     should 'support other esoteric commands' do
       with_activesupport do
         memcached do
@@ -141,14 +176,39 @@ describe 'ActiveSupport' do
           assert_equal 1, ds.keys.size
           assert ds[ds.keys.first].keys.size > 0
 
-          assert_equal true, @dalli.write(:foo, 'a')
-          assert_equal true, @dalli.exist?(:foo)
-          assert_equal false, @dalli.exist?(:bar)
-
           @dalli.reset
         end
       end
     end
+
+    should 'respect "raise_errors" option' do
+      with_activesupport do
+        memcached(29125) do
+          @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:29125')
+          @dalli.write 'foo', 'bar'
+          assert_equal @dalli.read('foo'), 'bar'
+
+          memcached_kill(29125)
+
+          assert_equal @dalli.read('foo'), nil
+
+          @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:29125', :raise_errors => true)
+
+          exception = [Dalli::RingError, { :message => "No server available" }]
+
+          assert_raises(*exception) { @dalli.read 'foo' }
+          assert_raises(*exception) { @dalli.read 'foo', :raw => true }
+          assert_raises(*exception) { @dalli.write 'foo', 'bar' }
+          assert_raises(*exception) { @dalli.exist? 'foo' }
+          assert_raises(*exception) { @dalli.increment 'foo' }
+          assert_raises(*exception) { @dalli.decrement 'foo' }
+          assert_raises(*exception) { @dalli.delete 'foo' }
+          assert_equal @dalli.read_multi('foo', 'bar'), {}
+          assert_raises(*exception) { @dalli.delete 'foo' }
+          assert_raises(*exception) { @dalli.fetch('foo') { 42 } }
+        end
+      end
+    end
   end
 
   should 'handle crazy characters from far-away lands' do

data/test/test_dalli.rb

@@ -127,6 +127,20 @@ describe 'Dalli' do
       end
     end
 
+    should "support the fetch operation with falsey values" do
+      memcached do |dc|
+        dc.flush
+
+        dc.set("fetch_key", false)
+        res = dc.fetch("fetch_key") { flunk "fetch block called" }
+        assert_equal false, res
+
+        dc.set("fetch_key", nil)
+        res = dc.fetch("fetch_key") { "bob" }
+        assert_equal 'bob', res
+      end
+    end
+
     should "support the cas operation" do
       memcached do |dc|
         dc.flush

data/test/test_failover.rb

@@ -1,6 +1,27 @@
 require 'helper'
 
-describe 'FailOver' do
+describe 'failover' do
+
+  describe 'timeouts' do
+    should 'not lead to corrupt sockets' do
+      memcached(29125) do
+        dc = Dalli::Client.new ['localhost:29125']
+        begin
+          Timeout.timeout 0.01 do
+            1_000.times do
+              dc.set("test_123", {:test => "123"})
+            end
+            flunk("Did not timeout")
+          end
+        rescue Timeout::Error => e
+        end
+
+        assert_equal({:test => '123'}, dc.get("test_123"))
+      end
+    end
+  end
+
+
   context 'assuming some bad servers' do
 
     should 'silently reconnect if server hiccups' do

data/test/test_session_store.rb

@@ -12,6 +12,8 @@ class Foo
 end
 
 class TestSessionStore < ActionController::IntegrationTest
+  include MemcachedMock::Helper
+
   class TestController < ActionController::Base
     def no_session_access
       head :ok
@@ -201,6 +203,42 @@ class TestSessionStore < ActionController::IntegrationTest
         assert_equal 'foo: nil', response.body
       end
     end
+
+    def test_without_raise_errors_option
+      memcached(29125) do
+        with_test_route_set(:memcache_server => '127.0.0.1:29125') do
+          get '/set_session_value'
+          assert_response :success
+
+          get '/get_session_value'
+          assert_response :success
+          assert_equal 'foo: "bar"', response.body
+
+          memcached_kill(29125)
+
+          get '/get_session_value'
+          assert_response :success
+          assert_equal 'foo: nil', response.body
+        end
+      end
+    end
+
+    def test_with_raise_errors_option
+      memcached(29125) do
+        with_test_route_set(:memcache_server => '127.0.0.1:29125', :raise_errors => true) do
+          get '/set_session_value'
+          assert_response :success
+
+          memcached_kill(29125)
+
+          exception = [Dalli::RingError, { :message => "No server available" }]
+
+          assert_raises(*exception) { get '/get_session_value' }
+          assert_raises(*exception) { get '/set_session_value' }
+          assert_raises(*exception) { get '/call_reset_session' }
+        end
+      end
+    end
   rescue LoadError, RuntimeError
     $stderr.puts "Skipping SessionStore tests. Start memcached and try again: #{$!.message}"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-14 00:00:00.000000000 Z
+date: 2012-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_shoulda
-  requirement: &70360909279380 !ruby/object:Gem::Requirement
+  requirement: &70263471981140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70360909279380
+  version_requirements: *70263471981140
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70360909278440 !ruby/object:Gem::Requirement
+  requirement: &70263471980400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70360909278440
+  version_requirements: *70263471980400
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70360909277240 !ruby/object:Gem::Requirement
+  requirement: &70263471979400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +43,7 @@ dependencies:
         version: '3'
   type: :development
   prerelease: false
-  version_requirements: *70360909277240
+  version_requirements: *70263471979400
 description: High performance memcached client for Ruby
 email: mperham@gmail.com
 executables: []