dalli 1.0.1 → 1.0.2

data/History.md

@@ -1,6 +1,15 @@
 Dalli Changelog
 =====================
 
+1.0.2
+=======
+
+ - Allow browser session cookies (blindsey)
+ - Compatibility fixes (mwynholds)
+ - Add backwards compatibility module for memcache-client, require 'dalli/memcache-client'.  It makes
+   Dalli more compatible with memcache-client and prints out a warning any time you do something that 
+   is no longer supported so you can fix your code.
+
 1.0.1
 =======
 

data/Performance.md

@@ -2,68 +2,34 @@ Performance
 ====================
 
 Caching is all about performance, so I carefully track Dalli performance to ensure no regressions.
-Times are from a Unibody MBP 2.4Ghz Core 2 Duo running Snow Leopard.
+Times are from a Unibody MBP 2.4Ghz Core i5 running Snow Leopard.
 
 You can optionally use kgio to give Dalli a small, 10-20% performance boost: gem install kgio.
 
 *memcache-client*:
 
-    Testing 1.8.5 with ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
-                                         user     system      total        real
-    set:plain:memcache-client        2.070000   0.590000   2.660000 (  2.669744)
-    set:ruby:memcache-client         2.150000   0.570000   2.720000 (  2.734616)
-    get:plain:memcache-client        2.240000   0.400000   2.640000 (  2.675747)
-    get:ruby:memcache-client         2.290000   0.380000   2.670000 (  2.682108)
-    multiget:ruby:memcache-client    1.030000   0.140000   1.170000 (  1.174503)
-    missing:ruby:memcache-client     1.900000   0.370000   2.270000 (  2.282264)
-    mixed:ruby:memcache-client       4.430000   0.950000   5.380000 (  5.420251)
+	Testing 1.8.5 with ruby 1.9.2p136 (2010-12-25 revision 30365) [x86_64-darwin10.6.0]
+	                                     user     system      total        real
+	set:plain:memcache-client        1.950000   0.320000   2.270000 (  2.271513)
+	set:ruby:memcache-client         2.040000   0.310000   2.350000 (  2.355625)
+	get:plain:memcache-client        2.160000   0.330000   2.490000 (  2.499911)
+	get:ruby:memcache-client         2.310000   0.340000   2.650000 (  2.659208)
+	multiget:ruby:memcache-client    1.050000   0.130000   1.180000 (  1.168383)
+	missing:ruby:memcache-client     2.050000   0.320000   2.370000 (  2.384290)
+	mixed:ruby:memcache-client       4.440000   0.660000   5.100000 (  5.148145)
 
 *dalli*:
 
-    Testing 0.9.0 with ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
-                                         user     system      total        real
-    set:plain:dalli                  1.610000   0.360000   1.970000 (  2.032947)
-    set:ruby:dalli                   1.690000   0.360000   2.050000 (  2.108120)
-    get:plain:dalli                  1.710000   0.400000   2.110000 (  2.123895)
-    get:ruby:dalli                   1.760000   0.390000   2.150000 (  2.170964)
-    multiget:ruby:dalli              0.950000   0.310000   1.260000 (  1.269679)
-    missing:ruby:dalli               1.650000   0.380000   2.030000 (  2.054383)
-    mixed:ruby:dalli                 3.470000   0.750000   4.220000 (  4.323265)
-
-    Testing 0.9.4 with ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
-                                         user     system      total        real
-    set:plain:dalli                  1.380000   0.350000   1.730000 (  1.818374)
-    set:ruby:dalli                   1.460000   0.320000   1.780000 (  1.851925)
-    get:plain:dalli                  1.420000   0.350000   1.770000 (  1.866443)
-    get:ruby:dalli                   1.570000   0.380000   1.950000 (  2.028747)
-    multiget:ruby:dalli              0.870000   0.300000   1.170000 (  1.295592)
-    missing:ruby:dalli               1.420000   0.370000   1.790000 (  1.925094)
-    mixed:ruby:dalli                 2.800000   0.680000   3.480000 (  3.820694)
-
-    Testing 0.11.1 with ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
-    Using standard socket IO
-                                         user     system      total        real
-    set:plain:dalli                  1.570000   0.380000   1.950000 (  1.990252)
-    setq:plain:dalli                 0.460000   0.140000   0.600000 (  0.600362)
-    set:ruby:dalli                   1.630000   0.380000   2.010000 (  2.050056)
-    get:plain:dalli                  1.710000   0.410000   2.120000 (  2.156428)
-    get:ruby:dalli                   1.680000   0.410000   2.090000 (  2.120228)
-    multiget:ruby:dalli              0.860000   0.310000   1.170000 (  1.182857)
-    missing:ruby:dalli               1.540000   0.390000   1.930000 (  1.976637)
-    mixed:ruby:dalli                 3.300000   0.810000   4.110000 (  4.166230)
-    mixedq:ruby:dalli                2.530000   0.640000   3.170000 (  3.214916)
-    incr:ruby:dalli                  0.540000   0.140000   0.680000 (  0.691829)
-
-    Testing 0.11.1 with ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
-    Using kgio socket IO
-                                         user     system      total        real
-    set:plain:dalli                  0.800000   0.370000   1.170000 (  1.694842)
-    setq:plain:dalli                 0.460000   0.150000   0.610000 (  0.618146)
-    set:ruby:dalli                   0.860000   0.370000   1.230000 (  1.760995)
-    get:plain:dalli                  0.910000   0.390000   1.300000 (  1.860499)
-    get:ruby:dalli                   0.900000   0.390000   1.290000 (  1.809426)
-    multiget:ruby:dalli              0.720000   0.300000   1.020000 (  1.044887)
-    missing:ruby:dalli               0.770000   0.400000   1.170000 (  1.649516)
-    mixed:ruby:dalli                 1.750000   0.760000   2.510000 (  3.563845)
-    mixedq:ruby:dalli                1.730000   0.650000   2.380000 (  2.883827)
-    incr:ruby:dalli                  0.280000   0.130000   0.410000 (  0.603845)
+	Using kgio socket IO
+	Testing 1.0.1 with ruby 1.9.2p136 (2010-12-25 revision 30365) [x86_64-darwin10.6.0]
+	                                     user     system      total        real
+	set:plain:dalli                  0.840000   0.300000   1.140000 (  1.516160)
+	setq:plain:dalli                 0.510000   0.120000   0.630000 (  0.634174)
+	set:ruby:dalli                   0.880000   0.300000   1.180000 (  1.549591)
+	get:plain:dalli                  0.970000   0.330000   1.300000 (  1.621385)
+	get:ruby:dalli                   0.970000   0.340000   1.310000 (  1.622811)
+	multiget:ruby:dalli              0.800000   0.250000   1.050000 (  1.453479)
+	missing:ruby:dalli               0.820000   0.330000   1.150000 (  1.453847)
+	mixed:ruby:dalli                 1.850000   0.640000   2.490000 (  3.189240)
+	mixedq:ruby:dalli                1.820000   0.530000   2.350000 (  2.611830)
+	incr:ruby:dalli                  0.310000   0.110000   0.420000 (  0.545641)

data/README.md

@@ -29,6 +29,7 @@ So a few notes.  Dalli:
  4. is approx 700 lines of Ruby.  memcache-client is approx 1250 lines.
  5. supports SASL for use in managed environments, e.g. Heroku.
  6. provides proper failover with recovery and adjustable timeouts
+ 7. has a backwards-compatibility mode for people migrating from memcache-client (see Upgrade.md).
 
 
 Installation and Usage

data/Upgrade.md

@@ -4,6 +4,17 @@ Upgrading from memcache-client
 Dalli is not meant to be 100% compatible with memcache-client, there are a few minor differences in the API.
 
 
+Compatibility Layer
+----------------------
+
+Enable memcache-client compatibility in your application when upgrading by requiring this when
+initalizing your app:
+
+    require 'dalli/memcache-client'
+
+This will print out warnings if your code is using the old memcache-client API style, explained below.
+
+
 Marshalling
 ---------------
 
@@ -31,3 +42,4 @@ In memcache-client, `set(key, value)` normally returns "STORED\r\n".  This is an
     set
     add
     replace
+    delete

data/lib/action_controller/session/dalli_store.rb

@@ -37,7 +37,7 @@ begin
 
           def set_session(env, sid, session_data)
             options = env['rack.session.options']
-            expiry  = options[:expire_after] || 0
+            expiry  = options[:expire_after]
             @pool.set(sid, session_data, expiry)
             return true
           rescue Dalli::DalliError

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

@@ -45,7 +45,7 @@ module ActionDispatch
 
         def set_session(env, sid, session_data, options = nil)
           options ||= env[ENV_SESSION_OPTIONS_KEY]
-          expiry  = options[:expire_after] || 0
+          expiry  = options[:expire_after]
           @pool.set(sid, session_data, expiry)
           sid
         rescue Dalli::DalliError

data/lib/dalli/client.rb

@@ -24,6 +24,19 @@ module Dalli
     def initialize(servers=nil, options={})
       @servers = env_servers || servers || 'localhost:11211'
       @options = { :expires_in => 0 }.merge(options)
+      self.extend(Dalli::Client::MemcacheClientCompatibility) if Dalli::Client.compatibility_mode
+    end
+
+    ##
+    # Turn on compatibility mode, which mixes in methods in memcache_client_compatibility.rb
+    # This value is set to true in memcache-client.rb.
+    def self.compatibility_mode
+      @compatibility_mode ||= false
+    end
+
+    def self.compatibility_mode=(compatibility_mode)
+      require 'dalli/compatibility'
+      @compatibility_mode = compatibility_mode
     end
     
     #
@@ -107,6 +120,7 @@ module Dalli
     end
 
     def set(key, value, ttl=nil, options=nil)
+      raise "Invalid API usage, please require 'dalli/memcache-client' for compatibility, see Upgrade.md" if options == true
       ttl ||= @options[:expires_in]
       perform(:set, key, value, ttl, options)
     end

data/lib/dalli/compatibility.rb

@@ -0,0 +1,52 @@
+class Dalli::Client
+
+  module MemcacheClientCompatibility
+
+    def initialize(*args)
+      Dalli.logger.error("Starting Dalli in memcache-client compatibility mode")
+      super(*args)
+    end
+
+    def set(key, value, ttl = nil, options = nil)
+      if options == true || options == false
+        Dalli.logger.error("Dalli: please use set(key, value, ttl, :raw => boolean): #{caller[0]}")
+        options = { :raw => options }
+      end
+      super(key, value, ttl, options) ? "STORED\r\n" : "NOT_STORED\r\n"
+
+    end
+
+    def add(key, value, ttl = nil, options = nil)
+      if options == true || options == false
+        Dalli.logger.error("Dalli: please use add(key, value, ttl, :raw => boolean): #{caller[0]}")
+        options = { :raw => options }
+      end
+      super(key, value, ttl, options) ? "STORED\r\n" : "NOT_STORED\r\n"
+    end
+
+    def replace(key, value, ttl = nil, options = nil)
+      if options == true || options == false
+        Dalli.logger.error("Dalli: please use replace(key, value, ttl, :raw => boolean): #{caller[0]}")
+        options = { :raw => options }
+      end
+      super(key, value, ttl, options) ? "STORED\r\n" : "NOT_STORED\r\n"
+    end
+
+    # Dalli does not unmarshall data that does not have the marshalled flag set so we need
+    # to unmarshall manually any marshalled data originally put in memcached by memcache-client.
+    # Peek at the data and see if it looks marshalled.
+    def get(key, options = nil)
+      value = super(key, options)
+      if value && value.is_a?(String) && !options && value.size > 2 &&
+              bytes = value.unpack('cc') && bytes[0] == 4 && bytes[1] == 8
+        return Marshal.load(value) rescue value
+      end
+      value
+    end
+
+    def delete(key)
+      super(key) ? "DELETED\r\n" : "NOT_DELETED\r\n"
+    end
+  end
+
+end

data/lib/dalli/memcache-client.rb

@@ -0,0 +1 @@
+Dalli::Client.compatibility_mode = true

data/lib/dalli/server.rb

@@ -147,7 +147,7 @@ module Dalli
     end
 
     def set(key, value, ttl, options)
-      (value, flags) = serialize(value, options)
+      (value, flags) = serialize(key, value, options)
 
       req = [REQUEST, OPCODES[multi? ? :setq : :set], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, flags, ttl, key, value].pack(FORMAT[:set])
       write(req)
@@ -155,7 +155,7 @@ module Dalli
     end
 
     def add(key, value, ttl, cas, options)
-      (value, flags) = serialize(value, options)
+      (value, flags) = serialize(key, value, options)
 
       req = [REQUEST, OPCODES[multi? ? :addq : :add], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, flags, ttl, key, value].pack(FORMAT[:add])
       write(req)
@@ -163,7 +163,7 @@ module Dalli
     end
     
     def replace(key, value, ttl, options)
-      (value, flags) = serialize(value, options)
+      (value, flags) = serialize(key, value, options)
       req = [REQUEST, OPCODES[multi? ? :replaceq : :replace], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, flags, ttl, key, value].pack(FORMAT[:replace])
       write(req)
       generic_response unless multi?
@@ -249,7 +249,7 @@ module Dalli
     FLAG_MARSHALLED = 0x1
     FLAG_COMPRESSED = 0x2
 
-    def serialize(value, options=nil)
+    def serialize(key, value, options=nil)
       marshalled = false
       value = unless options && options[:raw]
         marshalled = true
@@ -262,7 +262,7 @@ module Dalli
         value = Zlib::Deflate.deflate(value)
         compressed = true
       end
-      raise Dalli::DalliError, "Value too large, memcached can only store #{@options[:value_max_bytes]} of data per key" if value.bytesize > @options[:value_max_bytes]
+      raise Dalli::DalliError, "Value too large, memcached can only store #{@options[:value_max_bytes]} bytes per key [key: #{key}, size: #{value.bytesize}]" if value.bytesize > @options[:value_max_bytes]
       flags = 0
       flags |= FLAG_COMPRESSED if compressed
       flags |= FLAG_MARSHALLED if marshalled

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/test/test_compatibility.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestCompatibility < Test::Unit::TestCase
+
+  def setup
+    require 'dalli/memcache-client'
+  end
+
+  context 'dalli in memcache-client mode' do
+
+    should 'handle old raw flag to set/add/replace' do
+      memcached do |dc|
+        assert_equal "STORED\r\n", dc.set('abc', 123, 5, true)
+        assert_equal '123', dc.get('abc', true)
+
+        assert_equal "NOT_STORED\r\n", dc.add('abc', 456, 5, true)
+        assert_equal '123', dc.get('abc', true)
+
+        assert_equal "STORED\r\n", dc.replace('abc', 456, 5, false)
+        assert_equal 456, dc.get('abc', false)
+
+        assert_equal "DELETED\r\n", dc.delete('abc')
+        assert_equal "NOT_DELETED\r\n", dc.delete('abc')
+      end
+    end
+
+  end
+
+  def teardown
+    Dalli::Client.compatibility_mode = false
+  end
+
+end

data/test/test_session_store.rb

@@ -182,19 +182,44 @@ class TestSessionStore < ActionController::IntegrationTest
         assert_not_equal session_id, cookies['_session_id']
       end
     end
+
+    def test_expire_after
+      with_test_route_set(:expire_after => 1) do
+        get '/set_session_value'
+        assert_match /expires/, @response.headers['Set-Cookie']
+
+        sleep(1)
+
+        get '/get_session_value'
+        assert_equal 'foo: nil', response.body
+      end
+    end
+
+    def test_expires_in
+      with_test_route_set(:expires_in => 1) do
+        get '/set_session_value'
+        assert_no_match /expires/, @response.headers['Set-Cookie']
+
+        sleep(1)
+
+        get '/get_session_value'
+        assert_equal 'foo: nil', response.body
+      end
+    end
   rescue LoadError, RuntimeError
     $stderr.puts "Skipping TestSessionStore tests. Start memcached and try again."
   end
 
   private
-    def with_test_route_set
+    def with_test_route_set(options = {})
+      options = {:key => '_session_id'}.merge(options)
       with_routing do |set|
         set.draw do |map|
           match ':action', :to => ::TestSessionStore::TestController
         end
 
         @app = self.class.build_app(set) do |middleware|
-          middleware.use ActionDispatch::Session::DalliStore, :key => '_session_id'
+          middleware.use ActionDispatch::Session::DalliStore, options
           middleware.delete "ActionDispatch::ShowExceptions"
         end
 
@@ -202,4 +227,4 @@ class TestSessionStore < ActionController::IntegrationTest
       end
     end
 end
-end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - Mike Perham
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-05 00:00:00 -08:00
+date: 2011-02-03 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -87,6 +87,8 @@ files:
 - lib/active_support/cache/dalli_store.rb
 - lib/active_support/cache/dalli_store23.rb
 - lib/dalli/client.rb
+- lib/dalli/compatibility.rb
+- lib/dalli/memcache-client.rb
 - lib/dalli/options.rb
 - lib/dalli/ring.rb
 - lib/dalli/server.rb
@@ -106,6 +108,7 @@ files:
 - test/helper.rb
 - test/memcached_mock.rb
 - test/test_active_support.rb
+- test/test_compatibility.rb
 - test/test_dalli.rb
 - test/test_encoding.rb
 - test/test_failover.rb
@@ -151,6 +154,7 @@ test_files:
 - test/helper.rb
 - test/memcached_mock.rb
 - test/test_active_support.rb
+- test/test_compatibility.rb
 - test/test_dalli.rb
 - test/test_encoding.rb
 - test/test_failover.rb