dalli 2.1.0 → 2.2.0

data/History.md

@@ -1,6 +1,13 @@
 Dalli Changelog
 =====================
 
+2.2.0
+=======
+
+- Add Rack session with\_lock helper, for Rails 4.0 support [#264]
+- Accept connection string in the form of a URL (e.g., memcached://user:pass@hostname:port) [glenngillen]
+- Add touch operation [#228, uzzz]
+
 2.1.0
 =======
 

data/README.md

@@ -49,6 +49,9 @@ Remember, Dalli **requires** memcached 1.4+. You can check the version with `mem
 
     brew install memcached
 
+On Ubuntu you can install it by running:
+
+    apt-get install memcached
 
 You can verify your installation using this piece of code:
 

data/Rakefile

@@ -2,6 +2,8 @@ require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
   test.pattern = 'test/**/test_*.rb'
+  test.warning = true
+  test.verbose = true
 end
 
 Rake::TestTask.new(:bench) do |test|

data/lib/active_support/cache/dalli_store.rb

@@ -94,6 +94,7 @@ module ActiveSupport
         options ||= {}
         name = expanded_key name
 
+        log(:exist, name, options)
         !read_entry(name, options).nil?
       end
 
@@ -101,18 +102,19 @@ module ActiveSupport
         options ||= {}
         name = expanded_key name
 
+        log(:delete, name, options)
         delete_entry(name, options)
       end
 
       # Reads multiple keys from the cache using a single call to the
       # servers for all keys. Keys must be Strings.
       def read_multi(*names)
-        options = names.extract_options!
+        names.extract_options!
         names = names.flatten
         mapping = names.inject({}) { |memo, name| memo[escape(expanded_key(name))] = name; memo }
         instrument(:read_multi, names) do
           results = @data.get_multi(mapping.keys)
-          results.inject({}) do |memo, (inner, value)|
+          results.inject({}) do |memo, (inner, _)|
             entry = results[inner]
             # NB Backwards data compatibility, to be removed at some point
             memo[mapping[inner]] = (entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry)
@@ -162,7 +164,9 @@ module ActiveSupport
       # Clear the entire cache on all memcached servers. This method should
       # be used with care when using a shared cache.
       def clear(options=nil)
-        @data.flush_all
+        instrument(:clear, 'flushing all keys') do
+          @data.flush_all
+        end
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
         raise if @raise_errors
@@ -234,7 +238,7 @@ module ActiveSupport
 
       def escape(key)
         key = key.to_s.dup
-        key = key.force_encoding("BINARY") if key.encoding_aware?
+        key = key.force_encoding("BINARY") if key.respond_to?(:encode)
         key = key.gsub(ESCAPE_KEY_CHARS){ |match| "%#{match.getbyte(0).to_s(16).upcase}" }
         key
       end

data/lib/dalli.rb

@@ -4,7 +4,7 @@ require 'dalli/server'
 require 'dalli/socket'
 require 'dalli/version'
 require 'dalli/options'
-require 'dalli/railtie' if defined?(Rails)
+require 'dalli/railtie' if defined?(::Rails::Railtie)
 
 module Dalli
   # generic error

data/lib/dalli/client.rb

@@ -12,9 +12,8 @@ module Dalli
     #                   :threadsafe => true, :failover => true, :expires_in => 300)
     #
     # servers is an Array of "host:port:weight" where weight allows you to distribute cache unevenly.
-    # Both weight and port are optional.  If you pass in nil, Dalli will default to 'localhost:11211'.
-    # Note that the <tt>MEMCACHE_SERVERS</tt> environment variable will override the servers parameter for use
-    # in managed environments like Heroku.
+    # Both weight and port are optional.  If you pass in nil, Dalli will use the <tt>MEMCACHE_SERVERS</tt>
+    # environment variable or default to 'localhost:11211' if it is not present.
     #
     # Options:
     # - :namespace - prepend each key with this value to provide simple namespacing.
@@ -25,7 +24,7 @@ module Dalli
     #   sending them to memcached.
     #
     def initialize(servers=nil, options={})
-      @servers = env_servers || servers || '127.0.0.1:11211'
+      @servers = servers || env_servers || '127.0.0.1:11211'
       @options = normalize_options(options)
       @ring = nil
     end
@@ -198,6 +197,16 @@ module Dalli
       perform(:decr, key, amt.to_i, ttl, default)
     end
 
+    ##
+    # Touch updates expiration time for a given key.
+    #
+    # Returns true if key exists, otherwise nil.
+    def touch(key, ttl=nil)
+      ttl ||= @options[:expires_in].to_i
+      resp = perform(:touch, key, ttl)
+      resp.nil? ? nil : true
+    end
+
     ##
     # Collect the stats for each server.
     # Returns a hash like { 'hostname:port' => { 'stat1' => 'value1', ... }, 'hostname2:port' => { ... } }
@@ -233,7 +242,14 @@ module Dalli
     def ring
       @ring ||= Dalli::Ring.new(
         Array(@servers).map do |s|
-          Dalli::Server.new(s, @options)
+         server_options = {}
+          if s =~ %r{\Amemcached://}
+            uri = URI.parse(s)
+            server_options[:username] = uri.user
+            server_options[:password] = uri.password
+            s = "#{uri.host}:#{uri.port}"
+          end
+          Dalli::Server.new(s, @options.merge(server_options))
         end, @options
       )
     end

data/lib/dalli/server.rb

@@ -38,6 +38,7 @@ module Dalli
       @sock = nil
       @msg = nil
       @pid = nil
+      @inprogress = nil
     end
 
     # Chokepoint method for instrumentation
@@ -261,6 +262,12 @@ module Dalli
       generic_response
     end
 
+    def touch(key, ttl)
+      req = [REQUEST, OPCODES[:touch], key.bytesize, 4, 0, 0, key.bytesize + 4, 0, 0, ttl, key].pack(FORMAT[:touch])
+      write(req)
+      generic_response
+    end
+
     COMPRESSION_MIN_SIZE = 1024
 
     # http://www.hjp.at/zettel/m/memcached_flags.rxml
@@ -310,7 +317,7 @@ module Dalli
     def cas_response
       header = read(24)
       raise Dalli::NetworkError, 'No response' if !header
-      (extras, type, status, count, _, cas) = header.unpack(CAS_HEADER)
+      (extras, _, status, count, _, cas) = header.unpack(CAS_HEADER)
       data = read(count) if count > 0
       if status == 1
         nil
@@ -331,7 +338,7 @@ module Dalli
     def generic_response(unpack=false)
       header = read(24)
       raise Dalli::NetworkError, 'No response' if !header
-      (extras, type, status, count) = header.unpack(NORMAL_HEADER)
+      (extras, _, status, count) = header.unpack(NORMAL_HEADER)
       data = read(count) if count > 0
       if status == 1
         nil
@@ -353,7 +360,7 @@ module Dalli
       loop do
         header = read(24)
         raise Dalli::NetworkError, 'No response' if !header
-        (key_length, status, body_length) = header.unpack(KV_HEADER)
+        (key_length, _, body_length) = header.unpack(KV_HEADER)
         return hash if key_length == 0
         key = read(key_length)
         value = read(body_length - key_length) if body_length - key_length > 0
@@ -366,7 +373,7 @@ module Dalli
       loop do
         header = read(24)
         raise Dalli::NetworkError, 'No response' if !header
-        (key_length, status, body_length) = header.unpack(KV_HEADER)
+        (key_length, _, body_length) = header.unpack(KV_HEADER)
         return hash if key_length == 0
         flags = read(4).unpack('N')[0]
         key = read(key_length)
@@ -462,6 +469,7 @@ module Dalli
       :auth_negotiation => 0x20,
       :auth_request => 0x21,
       :auth_continue => 0x22,
+      :touch => 0x1C,
     }
 
     HEADER = "CCnCCnNNQ"
@@ -482,6 +490,7 @@ module Dalli
       :prepend => 'a*a*',
       :auth_request => 'a*a*',
       :auth_continue => 'a*a*',
+      :touch => 'Na*',
     }
     FORMAT = OP_FORMAT.inject({}) { |memo, (k, v)| memo[k] = HEADER + v; memo }
 

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '2.1.0'
+  VERSION = '2.2.0'
 end

data/lib/rack/session/dalli.rb

@@ -4,7 +4,7 @@ require 'dalli'
 module Rack
   module Session
     class Dalli < Abstract::ID
-      attr_reader :pool
+      attr_reader :pool, :mutex
 
       DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
         :namespace => 'rack:session',
@@ -12,6 +12,7 @@ module Rack
 
       def initialize(app, options={})
         super
+        @mutex = Mutex.new
         mserv = @default_options[:memcache_server]
         mopts = @default_options.reject{|k,v| !DEFAULT_OPTIONS.include? k }
         @pool = options[:cache] || ::Dalli::Client.new(mserv, mopts)
@@ -25,26 +26,45 @@ module Rack
       end
 
       def get_session(env, sid)
-        unless sid and session = @pool.get(sid)
-          sid, session = generate_sid, {}
-          unless @pool.add(sid, session)
-            raise "Session collision on '#{sid.inspect}'"
+        with_lock(env, [nil, {}]) do
+          unless sid and session = @pool.get(sid)
+            sid, session = generate_sid, {}
+            unless @pool.add(sid, session)
+              raise "Session collision on '#{sid.inspect}'"
+            end
           end
+          [sid, session]
         end
-        [sid, session]
       end
 
       def set_session(env, session_id, new_session, options)
         expiry = options[:expire_after]
         expiry = expiry.nil? ? 0 : expiry + 1
 
-        @pool.set session_id, new_session, expiry
-        session_id
+        with_lock(env, false) do
+          @pool.set session_id, new_session, expiry
+          session_id
+        end
       end
 
       def destroy_session(env, session_id, options)
-        @pool.delete(session_id)
-        generate_sid unless options[:drop]
+        with_lock(env) do
+          @pool.delete(session_id)
+          generate_sid unless options[:drop]
+        end
+      end
+
+      def with_lock(env, default=nil)
+        @mutex.lock if env['rack.multithread']
+        yield
+      rescue Dalli::DalliError, Errno::ECONNREFUSED
+        if $VERBOSE
+          warn "#{self} is unable to find memcached server."
+          warn $!.inspect
+        end
+        default
+      ensure
+        @mutex.unlock if @mutex.locked?
       end
 
     end

data/test/memcached_mock.rb

@@ -78,7 +78,6 @@ module MemcachedMock
           begin
             Process.kill("TERM", pid)
             Process.wait(pid)
-            File.delete(MemcachedMock.tmp_socket_path) if options[:unix]
           rescue Errno::ECHILD, Errno::ESRCH
           end
         end

data/test/test_active_support.rb

@@ -118,7 +118,6 @@ describe 'ActiveSupport' do
       with_activesupport do
         memcached do
           connect
-          x = rand_key
           y = rand_key
           assert_nil @dalli.read(y)
           dres = @dalli.write(y, 123)

data/test/test_dalli.rb

@@ -14,12 +14,12 @@ describe 'Dalli' do
       # Rails.logger.expects :warn
       assert dc.instance_variable_get(:@options)[:compress]
     end
-    
+
     should 'raises error with invalid expires_in' do
       bad_data = [{:bad => 'expires in data'}, Hash, [1,2,3]]
       bad_data.each do |bad|
         assert_raises ArgumentError do
-          dc = Dalli::Client.new('foo', {:expires_in => bad})
+          Dalli::Client.new('foo', {:expires_in => bad})
         end
       end
     end
@@ -282,7 +282,7 @@ describe 'Dalli' do
 
     should 'support the append and prepend operations' do
       memcached do |dc|
-        resp = dc.flush
+        dc.flush
         assert_equal true, dc.set('456', 'xyz', 0, :raw => true)
         assert_equal true, dc.prepend('456', '0')
         assert_equal true, dc.append('456', '9')
@@ -294,6 +294,22 @@ describe 'Dalli' do
       end
     end
 
+    should 'support touch operation' do
+      memcached do |dc|
+        begin
+          dc.flush
+          dc.set 'key', 'value'
+          assert_equal true, dc.touch('key', 10)
+          assert_equal true, dc.touch('key')
+          assert_equal 'value', dc.get('key')
+          assert_nil dc.touch('notexist')
+        rescue Dalli::DalliError => e
+          # This will happen when memcached is in lesser version than 1.4.8
+          assert_equal 'Response error 129: Unknown command', e.message
+        end
+      end
+    end
+
     should 'allow TCP connections to be configured for keepalive' do
       memcached(19122, '', :keepalive => true) do |dc|
         dc.set(:a, 1)
@@ -394,7 +410,7 @@ describe 'Dalli' do
               assert_equal({ 'a' => 9, 'b' => 11 }, cache.get_multi(['a', 'b']))
               inc = cache.incr('cat', 10)
               assert_equal 0, inc % 5
-              dec = cache.decr('cat', 5)
+              cache.decr('cat', 5)
               assert_equal 11, cache.get('b')
             end
           end
@@ -415,7 +431,7 @@ describe 'Dalli' do
         assert_equal 2, dc2.get('namespaced')
       end
     end
-    
+
     should 'truncate cache keys that are too long' do
       memcached do
         @dalli = Dalli::Client.new('localhost:19122', :namespace => 'some:namspace')

data/test/test_failover.rb

@@ -13,7 +13,7 @@ describe 'failover' do
             end
             flunk("Did not timeout")
           end
-        rescue Timeout::Error => e
+        rescue Timeout::Error
         end
 
         assert_equal({:test => '123'}, dc.get("test_123"))

data/test/test_rack_session.rb

@@ -0,0 +1,314 @@
+require 'helper'
+
+require 'rack/session/dalli'
+require 'rack/lint'
+require 'rack/mock'
+require 'thread'
+
+describe Rack::Session::Dalli do
+  session_key = Rack::Session::Dalli::DEFAULT_OPTIONS[:key]
+  session_match = /#{session_key}=([0-9a-fA-F]+);/
+  incrementor = lambda do |env|
+    env["rack.session"]["counter"] ||= 0
+    env["rack.session"]["counter"] += 1
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  end
+  drop_session = Rack::Lint.new(proc do |env|
+    env['rack.session.options'][:drop] = true
+    incrementor.call(env)
+  end)
+  renew_session = Rack::Lint.new(proc do |env|
+    env['rack.session.options'][:renew] = true
+    incrementor.call(env)
+  end)
+  defer_session = Rack::Lint.new(proc do |env|
+    env['rack.session.options'][:defer] = true
+    incrementor.call(env)
+  end)
+  skip_session = Rack::Lint.new(proc do |env|
+    env['rack.session.options'][:skip] = true
+    incrementor.call(env)
+  end)
+  incrementor = Rack::Lint.new(incrementor)
+
+  # test memcache connection
+  Rack::Session::Dalli.new(incrementor)
+
+  it "faults on no connection" do
+    assert_raises Dalli::RingError do
+      rsd = Rack::Session::Dalli.new(incrementor, :memcache_server => 'nosuchserver')
+      rsd.pool.set('ping', '')
+    end
+  end
+
+  it "connects to existing server" do
+    assert_silent do
+      rsd = Rack::Session::Dalli.new(incrementor, :namespace => 'test:rack:session')
+      rsd.pool.set('ping', '')
+    end
+  end
+
+  it "passes options to MemCache" do
+    rsd = Rack::Session::Dalli.new(incrementor, :namespace => 'test:rack:session')
+    assert_equal('test:rack:session', rsd.pool.instance_eval { @options[:namespace] })
+  end
+
+  it "creates a new cookie" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    res = Rack::MockRequest.new(rsd).get("/")
+    assert res["Set-Cookie"].include?("#{session_key}=")
+    assert_equal '{"counter"=>1}', res.body
+  end
+
+  it "determines session from a cookie" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    req = Rack::MockRequest.new(rsd)
+    res = req.get("/")
+    cookie = res["Set-Cookie"]
+    assert_equal '{"counter"=>2}', req.get("/", "HTTP_COOKIE" => cookie).body
+    assert_equal '{"counter"=>3}', req.get("/", "HTTP_COOKIE" => cookie).body
+  end
+
+  it "determines session only from a cookie by default" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    req = Rack::MockRequest.new(rsd)
+    res = req.get("/")
+    sid = res["Set-Cookie"][session_match, 1]
+    assert_equal '{"counter"=>1}', req.get("/?rack.session=#{sid}").body
+    assert_equal '{"counter"=>1}', req.get("/?rack.session=#{sid}").body
+  end
+
+  it "determines session from params" do
+    rsd = Rack::Session::Dalli.new(incrementor, :cookie_only => false)
+    req = Rack::MockRequest.new(rsd)
+    res = req.get("/")
+    sid = res["Set-Cookie"][session_match, 1]
+    assert_equal '{"counter"=>2}', req.get("/?rack.session=#{sid}").body
+    assert_equal '{"counter"=>3}', req.get("/?rack.session=#{sid}").body
+  end
+
+  it "survives nonexistant cookies" do
+    bad_cookie = "rack.session=blarghfasel"
+    rsd = Rack::Session::Dalli.new(incrementor)
+    res = Rack::MockRequest.new(rsd).
+      get("/", "HTTP_COOKIE" => bad_cookie)
+    assert_equal '{"counter"=>1}', res.body
+    cookie = res["Set-Cookie"][session_match]
+    refute_match(/#{bad_cookie}/, cookie)
+  end
+
+  it "maintains freshness" do
+    rsd = Rack::Session::Dalli.new(incrementor, :expire_after => 3)
+    res = Rack::MockRequest.new(rsd).get('/')
+    assert res.body.include?('"counter"=>1')
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(rsd).get('/', "HTTP_COOKIE" => cookie)
+    assert_equal cookie, res["Set-Cookie"]
+    assert res.body.include?('"counter"=>2')
+    puts 'Sleeping to expire session' if $DEBUG
+    sleep 4
+    res = Rack::MockRequest.new(rsd).get('/', "HTTP_COOKIE" => cookie)
+    refute_equal cookie, res["Set-Cookie"]
+    assert res.body.include?('"counter"=>1')
+  end
+
+  it "does not send the same session id if it did not change" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    req = Rack::MockRequest.new(rsd)
+
+    res0 = req.get("/")
+    cookie = res0["Set-Cookie"][session_match]
+    assert_equal '{"counter"=>1}', res0.body
+
+    res1 = req.get("/", "HTTP_COOKIE" => cookie)
+    assert_nil res1["Set-Cookie"]
+    assert_equal '{"counter"=>2}', res1.body
+
+    res2 = req.get("/", "HTTP_COOKIE" => cookie)
+    assert_nil res2["Set-Cookie"]
+    assert_equal '{"counter"=>3}', res2.body
+  end
+
+  it "deletes cookies with :drop option" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    req = Rack::MockRequest.new(rsd)
+    drop = Rack::Utils::Context.new(rsd, drop_session)
+    dreq = Rack::MockRequest.new(drop)
+
+    res1 = req.get("/")
+    session = (cookie = res1["Set-Cookie"])[session_match]
+    assert_equal '{"counter"=>1}', res1.body
+
+    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+    assert_nil res2["Set-Cookie"]
+    assert_equal '{"counter"=>2}', res2.body
+
+    res3 = req.get("/", "HTTP_COOKIE" => cookie)
+    refute_equal session, res3["Set-Cookie"][session_match]
+    assert_equal '{"counter"=>1}', res3.body
+  end
+
+  it "provides new session id with :renew option" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    req = Rack::MockRequest.new(rsd)
+    renew = Rack::Utils::Context.new(rsd, renew_session)
+    rreq = Rack::MockRequest.new(renew)
+
+    res1 = req.get("/")
+    session = (cookie = res1["Set-Cookie"])[session_match]
+    assert_equal '{"counter"=>1}', res1.body
+
+    res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+    new_cookie = res2["Set-Cookie"]
+    new_session = new_cookie[session_match]
+    refute_equal session, new_session
+    assert_equal '{"counter"=>2}', res2.body
+
+    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+    assert_equal '{"counter"=>3}', res3.body
+
+    # Old cookie was deleted
+    res4 = req.get("/", "HTTP_COOKIE" => cookie)
+    assert_equal '{"counter"=>1}', res4.body
+  end
+
+  it "omits cookie with :defer option but still updates the state" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    count = Rack::Utils::Context.new(rsd, incrementor)
+    defer = Rack::Utils::Context.new(rsd, defer_session)
+    dreq = Rack::MockRequest.new(defer)
+    creq = Rack::MockRequest.new(count)
+
+    res0 = dreq.get("/")
+    assert_nil res0["Set-Cookie"]
+    assert_equal '{"counter"=>1}', res0.body
+
+    res0 = creq.get("/")
+    res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    assert_equal '{"counter"=>2}', res1.body
+    res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    assert_equal '{"counter"=>3}', res2.body
+  end
+
+  it "omits cookie and state update with :skip option" do
+    rsd = Rack::Session::Dalli.new(incrementor)
+    count = Rack::Utils::Context.new(rsd, incrementor)
+    skip = Rack::Utils::Context.new(rsd, skip_session)
+    sreq = Rack::MockRequest.new(skip)
+    creq = Rack::MockRequest.new(count)
+
+    res0 = sreq.get("/")
+    assert_nil res0["Set-Cookie"]
+    assert_equal '{"counter"=>1}', res0.body
+
+    res0 = creq.get("/")
+    res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    assert_equal '{"counter"=>2}', res1.body
+    res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    assert_equal '{"counter"=>2}', res2.body
+  end
+
+  it "updates deep hashes correctly" do
+    hash_check = proc do |env|
+      session = env['rack.session']
+      unless session.include? 'test'
+        session.update :a => :b, :c => { :d => :e },
+          :f => { :g => { :h => :i} }, 'test' => true
+      else
+        session[:f][:g][:h] = :j
+      end
+      [200, {}, [session.inspect]]
+    end
+    rsd = Rack::Session::Dalli.new(hash_check)
+    req = Rack::MockRequest.new(rsd)
+
+    res0 = req.get("/")
+    session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
+    ses0 = rsd.pool.get(session_id, true)
+
+    req.get("/", "HTTP_COOKIE" => cookie)
+    ses1 = rsd.pool.get(session_id, true)
+
+    refute_equal ses0, ses1
+  end
+
+  # anyone know how to do this better?
+  it "cleanly merges sessions when multithreaded" do
+    unless $DEBUG
+      assert_equal 1, 1 # fake assertion to appease the mighty bacon
+      next
+    end
+    warn 'Running multithread test for Session::Dalli'
+    rsd = Rack::Session::Dalli.new(incrementor)
+    req = Rack::MockRequest.new(rsd)
+
+    res = req.get('/')
+    assert_equal '{"counter"=>1}', res.body
+    cookie = res["Set-Cookie"]
+    session_id = cookie[session_match, 1]
+
+    delta_incrementor = lambda do |env|
+      # emulate disconjoinment of threading
+      env['rack.session'] = env['rack.session'].dup
+      Thread.stop
+      env['rack.session'][(Time.now.usec*rand).to_i] = true
+      incrementor.call(env)
+    end
+    tses = Rack::Utils::Context.new rsd, delta_incrementor
+    treq = Rack::MockRequest.new(tses)
+    tnum = rand(7).to_i+5
+    r = Array.new(tnum) do
+      Thread.new(treq) do |run|
+        run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+      end
+    end.reverse.map{|t| t.run.join.value }
+    r.each do |request|
+      assert_equal cookie, request['Set-Cookie']
+      assert request.body.include?('"counter"=>2')
+    end
+
+    session = rsd.pool.get(session_id)
+    assert_equal tnum+1, session.size  # counter
+    assert_equal 2, session['counter'] # meeeh
+
+    tnum = rand(7).to_i+5
+    r = Array.new(tnum) do |i|
+      app = Rack::Utils::Context.new rsd, time_delta
+      req = Rack::MockRequest.new app
+      Thread.new(req) do |run|
+        run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+      end
+    end.reverse.map{|t| t.run.join.value }
+    r.each do |request|
+      assert_equal cookie, request['Set-Cookie']
+      assert request.body.include?('"counter"=>3')
+    end
+
+    session = rsd.pool.get(session_id)
+    assert_equal tnum+1, session.size
+    assert_equal 3, session['counter']
+
+    drop_counter = proc do |env|
+      env['rack.session'].delete 'counter'
+      env['rack.session']['foo'] = 'bar'
+      [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+    end
+    tses = Rack::Utils::Context.new rsd, drop_counter
+    treq = Rack::MockRequest.new(tses)
+    tnum = rand(7).to_i+5
+    r = Array.new(tnum) do
+      Thread.new(treq) do |run|
+        run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+      end
+    end.reverse.map{|t| t.run.join.value }
+    r.each do |request|
+      assert_equal cookie, request['Set-Cookie']
+      assert request.body.include?('"foo"=>"bar"')
+    end
+
+    session = rsd.pool.get(session_id)
+    assert_equal r.size+1, session.size
+    assert_nil session['counter']
+    assert_equal 'bar', session['foo']
+  end
+end

data/test/test_sasl.rb

@@ -3,6 +3,13 @@ require 'helper'
 describe 'Sasl' do
 
   context 'a server requiring authentication' do
+    before do
+      @server = mock()
+      @server.stubs(:request).returns(true)
+      @server.stubs(:weight).returns(1)
+      @server.stubs(:hostname).returns("localhost")
+      @server.stubs(:port).returns("19124")
+    end
 
     context 'without authentication credentials' do
       before do
@@ -79,5 +86,21 @@ describe 'Sasl' do
       end
     end
 
+    should 'pass SASL as URI' do
+      Dalli::Server.expects(:new).with("localhost:19124",
+        :username => "testuser", :password => "testtest").returns(@server)
+      dc = Dalli::Client.new('memcached://testuser:testtest@localhost:19124')
+      dc.flush_all
+    end
+
+    should 'pass SASL as ring of URIs' do
+      Dalli::Server.expects(:new).with("localhost:19124",
+        :username => "testuser", :password => "testtest").returns(@server)
+      Dalli::Server.expects(:new).with("otherhost:19125",
+        :username => "testuser2", :password => "testtest2").returns(@server)
+      dc = Dalli::Client.new(['memcached://testuser:testtest@localhost:19124',
+      'memcached://testuser2:testtest2@otherhost:19125'])
+      dc.flush_all
+    end
   end
 end

data/test/test_session_store.rb

@@ -183,7 +183,7 @@ class TestSessionStore < ActionController::IntegrationTest
     def test_expire_after
       with_test_route_set(:expire_after => 1) do
         get '/set_session_value'
-        assert_match /expires/, @response.headers['Set-Cookie']
+        assert_match(/expires/, @response.headers['Set-Cookie'])
 
         sleep(1)
 
@@ -195,7 +195,7 @@ class TestSessionStore < ActionController::IntegrationTest
     def test_expires_in
       with_test_route_set(:expires_in => 1) do
         get '/set_session_value'
-        assert_no_match /expires/, @response.headers['Set-Cookie']
+        assert_no_match(/expires/, @response.headers['Set-Cookie'])
 
         sleep(1)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-23 00:00:00.000000000 Z
+date: 2012-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_shoulda
-  requirement: &70203098892260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70203098892260
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70203098891120 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70203098891120
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70203098890540 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +53,12 @@ dependencies:
         version: '3'
   type: :development
   prerelease: false
-  version_requirements: *70203098890540
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
 description: High performance memcached client for Ruby
 email: mperham@gmail.com
 executables: []
@@ -77,6 +92,7 @@ files:
 - test/test_encoding.rb
 - test/test_failover.rb
 - test/test_network.rb
+- test/test_rack_session.rb
 - test/test_ring.rb
 - test/test_sasl.rb
 - test/test_session_store.rb
@@ -101,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: High performance memcached client for Ruby
@@ -115,6 +131,7 @@ test_files:
 - test/test_encoding.rb
 - test/test_failover.rb
 - test/test_network.rb
+- test/test_rack_session.rb
 - test/test_ring.rb
 - test/test_sasl.rb
 - test/test_session_store.rb