dalli 0.9.10 → 0.10.0

data/History.md

@@ -1,6 +1,18 @@
 Dalli Changelog
 =====================
 
+0.10.0
+======
+
+Warning: this release changed how Rails marshals data with Dalli.  Unfortunately previous versions double marshalled values.  It is possible that data stored with previous versions of Dalli will not work with this version.
+
+IT IS HIGHLY RECOMMENDED YOU FLUSH YOUR CACHE BEFORE UPGRADING.
+
+ - Rework how the Rails cache store does value marshalling.
+ - Rework old server version detection to avoid a socket read hang.
+ - Refactor the Rails 2.3 :dalli\_store to be closer to :mem\_cache\_store.
+ - Better documentation for session store config (plukevdh)
+
 0.9.10
 ----
 

data/README.md

@@ -61,10 +61,10 @@ A more comprehensive example (note that we are setting a reasonable default for
     config.cache_store = :dalli_store, 'cache-1.example.com', 'cache-2.example.com',
         :namespace => NAME_OF_RAILS_APP, :expires_in => 1.day, :compress => true, :compress_threshold => 64.kilobytes
 
-In `config/initializers/session_store.rb`:
+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, :key => ...
+    Rails.application.config.session_store :dalli_store, :memcache_server => ['host1', 'host2'], :namespace => 'sessions', :key => '_foundation_session', :expire_after => 30.minutes
 
 
 Usage with Rails 2.3.x

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

@@ -2,10 +2,7 @@ require 'active_support/cache'
 require 'action_dispatch/middleware/session/abstract_store'
 require 'dalli'
 
-# Dalli-based session store for Rails 3.0. Use like so:
-#
-# require 'action_dispatch/middleware/session/dalli_store'
-# config.session_store ActionDispatch::Session::DalliStore, ['cache-1', 'cache-2'], :expire_after => 2.weeks
+# Dalli-based session store for Rails 3.0.
 module ActionDispatch
   module Session
     class DalliStore < AbstractStore
@@ -40,7 +37,7 @@ module ActionDispatch
           begin
             session = @pool.get(sid) || {}
           rescue Dalli::DalliError
-            Rails.logger.warn("Session::DalliStore: #{$!.message}")
+            Rails.logger.warn("Session::DalliStore#get: #{$!.message}")
             session = {}
           end
           [sid, session]
@@ -52,7 +49,7 @@ module ActionDispatch
           @pool.set(sid, session_data, expiry)
           sid
         rescue Dalli::DalliError
-          Rails.logger.warn("Session::DalliStore: #{$!.message}")
+          Rails.logger.warn("Session::DalliStore#set: #{$!.message}")
           false
         end
 
@@ -61,7 +58,7 @@ module ActionDispatch
             @pool.delete(sid)
           end
         rescue Dalli::DalliError
-          Rails.logger.warn("Session::DalliStore: #{$!.message}")
+          Rails.logger.warn("Session::DalliStore#delete: #{$!.message}")
           false
         end
 

data/lib/active_support/cache/dalli_store.rb

@@ -17,6 +17,7 @@ module ActiveSupport
     class DalliStore < Store
 
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/
+      RAW = { :raw => true }
 
       def self.build_mem_cache(*addresses)
         addresses = addresses.flatten
@@ -53,7 +54,7 @@ module ActiveSupport
         options = names.extract_options!
         options = merged_options(options)
         keys_to_names = names.inject({}){|map, name| map[escape_key(namespaced_key(name, options))] = name; map}
-        raw_values = @data.get_multi(keys_to_names.keys, options)
+        raw_values = @data.get_multi(keys_to_names.keys, RAW)
         values = {}
         raw_values.each do |key, value|
           entry = deserialize_entry(value)
@@ -75,7 +76,7 @@ module ActiveSupport
           @data.incr(escape_key(namespaced_key(name, options)), amount, expires_in, initial)
         end
       rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}") if logger
+        logger.error("DalliError: #{e.message}") if logger
         nil
       end
 
@@ -92,7 +93,7 @@ module ActiveSupport
           @data.decr(escape_key(namespaced_key(name, options)), amount, expires_in, initial)
         end
       rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}") if logger
+        logger.error("DalliError: #{e.message}") if logger
         nil
       end
 
@@ -112,17 +113,22 @@ module ActiveSupport
       end
 
       protected
+
+        # This CacheStore impl controls value marshalling so we take special
+        # care to always pass :raw => true to the Dalli API so it does not
+        # double marshal.
+
         # Read an entry from the cache.
         def read_entry(key, options) # :nodoc:
-          deserialize_entry(@data.get(escape_key(key), :raw => true))
+          deserialize_entry(@data.get(escape_key(key), RAW))
         rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
+          logger.error("DalliError: #{e.message}") if logger
           nil
         end
 
         # Write an entry to the cache.
         def write_entry(key, entry, options) # :nodoc:
-          method = options && options[:unless_exist] ? :add : :set
+          method = options[:unless_exist] ? :add : :set
           value = options[:raw] ? entry.value.to_s : entry
           expires_in = options[:expires_in].to_i
           if expires_in > 0 && !options[:raw]
@@ -131,7 +137,7 @@ module ActiveSupport
           end
           @data.send(method, escape_key(key), value, expires_in, options)
         rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
+          logger.error("DalliError: #{e.message}") if logger
           false
         end
 
@@ -139,7 +145,7 @@ module ActiveSupport
         def delete_entry(key, options) # :nodoc:
           @data.delete(escape_key(key))
         rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
+          logger.error("DalliError: #{e.message}") if logger
           false
         end
 
@@ -152,6 +158,8 @@ module ActiveSupport
 
         def deserialize_entry(raw_value)
           if raw_value
+            # FIXME: This is a terrible implementation for performance reasons:
+            # throwing an exception is much slower than some if logic.
             entry = Marshal.load(raw_value) rescue raw_value
             entry.is_a?(Entry) ? entry : Entry.new(entry)
           else

data/lib/active_support/cache/dalli_store23.rb

@@ -45,6 +45,8 @@ module ActiveSupport
       # Reads multiple keys from the cache using a single call to the
       # servers for all keys. Options can be passed in the last argument.
       def read_multi(*names)
+        options = nil
+        options = names.pop if names.last.is_a?(Hash)
         keys_to_names = names.inject({}){|map, name| map[escape_key(name)] = name; map}
         cache_keys = {}
         # map keys to servers
@@ -53,62 +55,24 @@ module ActiveSupport
           cache_keys[cache_key] = key
         end
 
-        values = @data.get_multi keys_to_names.keys
+        values = @data.get_multi(keys_to_names.keys, options)
         results = {}
         values.each do |key, value|
-          results[cache_keys[key]] = Marshal.load value
+          results[cache_keys[key]] = value
         end
         results
       end
 
-      # Increment a cached value. This method uses the memcached incr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
-      def increment(key, amount = 1) # :nodoc:
-        log("incrementing", key, amount)
-        @data.incr(escape_key(key), amount)
-      rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}") if logger
-        nil
-      end
-
-      # Decrement a cached value. This method uses the memcached decr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
-      def decrement(key, amount = 1) # :nodoc:
-        log("decrement", key, amount)
-        @data.decr(escape_key(key), amount)
-      rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}") if logger
-        nil
-      end
-
       def reset
         @data.reset
       end
 
-      # Clear the entire cache on all memcached servers. This method should
-      # be used with care when using a shared cache.
-      def clear
-        @data.flush_all
-      end
-
-      # Get the statistics from the memcached servers.
-      def stats
-        @data.stats
-      end
-
       # Read an entry from the cache.
       def read(key, options = nil) # :nodoc:
         super
-        value = @data.get(escape_key(key), options)
-        return nil if value.nil?
-        value = options && options[:raw] ? value : Marshal.load(value)
-        value
+        @data.get(escape_key(key), options)
       rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}")
+        logger.error("DalliError: #{e.message}")
         nil
       end
 
@@ -121,11 +85,11 @@ module ActiveSupport
       #   the cache. See ActiveSupport::Cache::Store#write for an example.
       def write(key, value, options = nil)
         super
+        value = value.to_s if options && options[:raw]
         method = options && options[:unless_exist] ? :add : :set
-        value = options && options[:raw] ? value.to_s : Marshal.dump(value)
         @data.send(method, escape_key(key), value, expires_in(options), options)
       rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}")
+        logger.error("DalliError: #{e.message}")
         false
       end
 
@@ -133,7 +97,7 @@ module ActiveSupport
         super
         @data.delete(escape_key(key))
       rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}")
+        logger.error("DalliError: #{e.message}")
         false
       end
 
@@ -144,6 +108,30 @@ module ActiveSupport
         !read(key, options).nil?
       end
 
+      # Increment a cached value. This method uses the memcached incr atomic
+      # operator and can only be used on values written with the :raw option.
+      # Calling it on a value not stored with :raw will initialize that value
+      # to zero.
+      def increment(key, amount = 1) # :nodoc:
+        log("incrementing", key, amount)
+        @data.incr(escape_key(key), amount)
+      rescue Dalli::DalliError => e
+        logger.error("DalliError: #{e.message}") if logger
+        nil
+      end
+
+      # Decrement a cached value. This method uses the memcached decr atomic
+      # operator and can only be used on values written with the :raw option.
+      # Calling it on a value not stored with :raw will initialize that value
+      # to zero.
+      def decrement(key, amount = 1) # :nodoc:
+        log("decrement", key, amount)
+        @data.decr(escape_key(key), amount)
+      rescue Dalli::DalliError => e
+        logger.error("DalliError: #{e.message}") if logger
+        nil
+      end
+
       def delete_matched(matcher, options = nil) # :nodoc:
         # don't do any local caching at present, just pass
         # through and let the error happen
@@ -151,6 +139,17 @@ module ActiveSupport
         raise "Not supported by Memcache"
       end
 
+      # Clear the entire cache on all memcached servers. This method should
+      # be used with care when using a shared cache.
+      def clear
+        @data.flush_all
+      end
+
+      # Get the statistics from the memcached servers.
+      def stats
+        @data.stats
+      end
+
       private
 
       # Exists in 2.3.8 but not in 2.3.2 so roll our own version

data/lib/dalli/client.rb

@@ -44,7 +44,7 @@ module Dalli
     def get_multi(*keys)
       return {} if keys.empty?
       options = nil
-      options = keys.pop if keys.last.is_a?(Hash)
+      options = keys.pop if keys.last.is_a?(Hash) || keys.last.nil?
       ring.lock do
         keys.flatten.each do |key|
           perform(:getkq, key)

data/lib/dalli/server.rb

@@ -14,9 +14,7 @@ module Dalli
       @weight ||= 1
       @weight = Integer(@weight)
       @down_at = nil
-      connection
       @version = detect_memcached_version
-      raise NotImplementedError, "Dalli does not support memcached versions < 1.4.0, found #{@version} at #{@hostname}:#{@port}" if @version < '1.4.0'
       Dalli.logger.debug { "#{@hostname}:#{@port} running memcached v#{@version}" }
     end
     
@@ -64,15 +62,26 @@ module Dalli
     private
 
     def detect_memcached_version
+      return "(unknown)" if ENV['SKIP_MEMCACHE_VERSION_CHECK']
+
       # HACK, the server does not appear to have a way to negotiate the protocol.
       # If you ask for the version in text, the socket is immediately locked to the text
-      # protocol.  All we can do is use binary and handle the failure if the server is old.
-      # Alternative suggestions welcome.
-      begin
+      # protocol.  But if we use binary, an old remote server will not respond.  If
+      # the server is using SASL, it will not respond to the text protocol.  Sigh.
+      if username
+        # using SASL, assume the binary protocol will work.
         binary_version
-      rescue Dalli::NetworkError
-        sleep 1
-        text_version
+      else
+        # Use text to determine the remote version, close the socket and open it back up.
+        # Alternative suggestions welcome.
+        version = text_version
+        if version < '1.4.0'
+          Dalli.logger.error "Dalli does not support memcached versions < 1.4.0, found #{version} at #{@hostname}:#{@port}"
+          raise NotImplementedError, "Dalli does not support memcached versions < 1.4.0, found #{version} at #{@hostname}:#{@port}"
+        end
+        close
+        connection
+        version
       end
     end
 
@@ -188,18 +197,18 @@ module Dalli
       cas_response
     end
 
-    def binary_version
-      req = [REQUEST, OPCODES[:version], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
-      write(req)
-      generic_response
-    end
-
     def text_version
       write("version\r\n")
       connection.gets =~ /VERSION (.*)\r\n/
       $1
     end
 
+    def binary_version
+      req = [REQUEST, OPCODES[:version], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
+      write(req)
+      generic_response
+    end
+
     def cas_response
       header = read(24)
       raise Dalli::NetworkError, 'No response' if !header
@@ -450,9 +459,10 @@ module Dalli
       content = read(count, socket)
       return Dalli.logger.info("Dalli/SASL: #{content}") if status == 0
 
-      raise Dalli::NetworkError, "Error authenticating: #{status}" unless status == 0x21
-      (step, msg) = sasl.receive('challenge', content)
-      raise Dalli::NetworkError, "Authentication failed" if sasl.failed? || step != 'response'
+      raise Dalli::DalliError, "Error authenticating: #{status}" unless status == 0x21
+      raise NotImplementedError, "No two-step authentication mechanisms supported"
+      # (step, msg) = sasl.receive('challenge', content)
+      # raise Dalli::NetworkError, "Authentication failed" if sasl.failed? || step != 'response'
     end
   end
 end

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '0.9.10'
+  VERSION = '0.10.0'
 end

data/test/memcached_mock.rb

@@ -78,7 +78,7 @@ module MemcachedMock
           rescue Errno::ECHILD
           end
         end
-        sleep 0.2
+        sleep 0.1
         pid
       end
 

data/test/test_active_support.rb

@@ -7,19 +7,20 @@ class TestActiveSupport < Test::Unit::TestCase
       with_activesupport do
         memcached do
           connect
-          dvalue = @mc.fetch('somekeywithoutspaces', :expires_in => 1.second) { 123 }
-          mvalue = @dalli.fetch('someotherkeywithoutspaces', :expires_in => 1.second) { 123 }
+          mvalue = @mc.fetch('somekeywithoutspaces', :expires_in => 1.second) { 123 }
+          dvalue = @dalli.fetch('someotherkeywithoutspaces', :expires_in => 1.second) { 123 }
+          assert_equal 123, dvalue
           assert_equal mvalue, dvalue
 
           o = Object.new
           o.instance_variable_set :@foo, 'bar'
-          dvalue = @mc.fetch(rand_key, :raw => true) { o }
-          mvalue = @dalli.fetch(rand_key, :raw => true) { o }
+          mvalue = @mc.fetch(rand_key, :raw => true) { o }
+          dvalue = @dalli.fetch(rand_key, :raw => true) { o }
           assert_equal mvalue, dvalue
-          assert_equal o, dvalue
+          assert_equal o, mvalue
 
-          dvalue = @mc.fetch(rand_key) { o }
-          mvalue = @dalli.fetch(rand_key) { o }
+          mvalue = @mc.fetch(rand_key) { o }
+          dvalue = @dalli.fetch(rand_key) { o }
           assert_equal mvalue, dvalue
           assert_equal o, dvalue
         end
@@ -65,6 +66,33 @@ class TestActiveSupport < Test::Unit::TestCase
       end
     end
 
+    should 'support raw read_multi' do
+      with_activesupport do
+        memcached do
+          connect
+          @mc.write("abc", 5, :raw => true)
+          @mc.write("cba", 5, :raw => true)
+          if RAILS_VERSION < '3.0.0'
+            assert_raise ArgumentError do
+              @mc.read_multi("abc", "cba")
+            end
+          else
+            assert_equal({'abc' => '5', 'cba' => '5' }, @mc.read_multi("abc", "cba"))
+          end
+
+          @dalli.write("abc", 5, :raw => true)
+          @dalli.write("cba", 5, :raw => true)
+          if RAILS_VERSION < '3.0.0'
+            assert_raise ArgumentError do
+              @dalli.read_multi("abc", "cba")
+            end
+          else
+            assert_equal({'abc' => '5', 'cba' => '5' }, @dalli.read_multi("abc", "cba"))
+          end
+        end
+      end
+    end
+
     should 'support read, write and delete' do
       with_activesupport do
         memcached do

data/test/test_dalli.rb

@@ -2,7 +2,7 @@ require 'helper'
 require 'memcached_mock'
 
 class TestDalli < Test::Unit::TestCase
-
+  
   should "default to localhost:11211" do
     dc = Dalli::Client.new
     ring = dc.send(:ring)
@@ -323,13 +323,6 @@ class TestDalli < Test::Unit::TestCase
       end
     end
 
-    should 'gracefully handle authentication failures' do
-      memcached(19124, '-S') do |dc|
-        assert_raise Dalli::DalliError, /32/ do
-          dc.set('abc', 123)
-        end
-      end
-    end
 
     should "handle namespaced keys" do
       memcached do |dc|
@@ -342,6 +335,26 @@ class TestDalli < Test::Unit::TestCase
       end
     end
 
+    context 'without authentication credentials' do
+      setup do
+        ENV['MEMCACHE_USERNAME'] = 'testuser'
+        ENV['MEMCACHE_PASSWORD'] = 'wrongpwd'
+      end
+
+      teardown do
+        ENV['MEMCACHE_USERNAME'] = nil
+        ENV['MEMCACHE_PASSWORD'] = nil
+      end
+
+      should 'gracefully handle authentication failures' do
+        memcached(19124, '-S') do |dc|
+          assert_raise Dalli::DalliError, /32/ do
+            dc.set('abc', 123)
+          end
+        end
+      end
+    end
+
     # OSX: Create a SASL user for the memcached application like so:
     #
     # saslpasswd2 -a memcached -c testuser
@@ -360,7 +373,7 @@ class TestDalli < Test::Unit::TestCase
 
       should 'support SASL authentication' do
         memcached(19124, '-S') do |dc|
-          # I get "Dalli::NetworkError: Error authenticating: 32" in OSX
+          # I get "Dalli::DalliError: Error authenticating: 32" in OSX
           # but SASL works on Heroku servers. YMMV.
           assert_equal true, dc.set('abc', 123)
           assert_equal 123, dc.get('abc')

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 9
   - 10
-  version: 0.9.10
+  - 0
+  version: 0.10.0
 platform: ruby
 authors: 
 - Mike Perham
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-13 00:00:00 -07:00
+date: 2010-10-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency