dalli 2.7.0 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e1d2bd1cdadde91a31a3e1311e4189e54b57623
-  data.tar.gz: 6e2fbab2dd27e1cf5f62eef39d7292d1ac6f93b8
+  metadata.gz: b95a4fab254be40a050b417698b0551ffeb5e81d
+  data.tar.gz: c15ffb9b9e417e8188855394a5af9384cc090cc1
 SHA512:
-  metadata.gz: ad6caea0b89835f15f7ddc4fd4ecab66eaa87ed969020c41fae9324da520b3e9f3b15afe53d1b14e515eafcb29cbc76c62267ce12a8c708f525ab2863e62f682
-  data.tar.gz: 8646c41bab51faa972bd16c5e06157c1c201a862f911f3f961b252ce9fd96c1b583345068090b2606f1a302f5d106df072eb7a91acb2ecb1c73464b3ca2f6f58
+  metadata.gz: 3d837cb9c4869b6035a271585e4fbd1a41cd91d6d4f19ff910b99e4364d8c401ebb8a8f366c077e4ef70a2809d3d0f49122a9cae8d90ce81490d58e2b13381dd
+  data.tar.gz: b8f5499ad63ff4e357557d2a68b32a07251da67244c35c3281b3a90afab928bacdef17842ff4cf4cde938920f4f7210f46eb6e8e0795d8eb3381b15ebe92afd5

data/History.md

@@ -1,9 +1,19 @@
 Dalli Changelog
 =====================
 
+2.7.1
+==========
+
+- Rack session will check if servers are up on initialization (arthurnn, #423)
+- Add support for IPv6 addresses in hex form, ie: "[::1]:11211" (dplummer, #428)
+- Add symbol support for namespace (jingkai #431)
+- Support expiration intervals longer than 30 days (leonid-shevtsov #436)
+
 2.7.0
 ==========
 
+- BREAKING CHANGE:
+  Dalli::Client#add and #replace now return a truthy value, not boolean true or false.
 - Multithreading support with dalli\_store:
   Use :pool\_size to create a pool of shared, threadsafe Dalli clients in Rails:
 ```ruby

data/README.md

@@ -94,6 +94,12 @@ config.cache_store = :dalli_store, 'cache-1.example.com', 'cache-2.example.com',
   { :namespace => NAME_OF_RAILS_APP, :expires_in => 1.day, :compress => true }
 ```
 
+If your servers are specified in `ENV["MEMCACHE_SERVERS"]` (e.g. on Heroku when using a third-party hosted addon), simply provide `nil` for the servers:
+
+```ruby
+config.cache_store = :dalli_store, nil, { :namespace => NAME_OF_RAILS_APP, :expires_in => 1.day, :compress => true }
+```
+
 To use Dalli for Rails session storage that times out after 20 minutes, in `config/initializers/session_store.rb`:
 
 For Rails >= 3.2.4:
@@ -124,6 +130,19 @@ add :pool\_size to your `dalli_store` config:
 config.cache_store = :dalli_store, 'cache-1.example.com', { :pool_size => 5 }
 ```
 
+You can then use the Rails cache as normal or check out a Dalli client directly from the pool:
+
+```ruby
+Rails.cache.fetch('foo', :expires_in => 300) do
+  'bar'
+end
+
+Rails.cache.dalli.with do |client|
+  # client is a Dalli::Client instance which you can
+  # use ONLY within this block
+end
+```
+
 
 Configuration
 ------------------------

data/dalli.gemspec

@@ -24,6 +24,6 @@ Gem::Specification.new do |s|
   s.test_files = Dir.glob("test/**/*")
   s.add_development_dependency(%q<minitest>, [">= 4.2.0"])
   s.add_development_dependency(%q<mocha>, [">= 0"])
-  s.add_development_dependency(%q<rails>, ["~> 3"])
+  s.add_development_dependency(%q<rails>, ["~> 4"])
 end
 

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

@@ -32,7 +32,7 @@ module ActionDispatch
       private
 
       def get_session(env, sid)
-        sid ||= generate_sid
+        sid = generate_sid unless sid and !sid.empty?
         begin
           session = @pool.get(sid) || {}
         rescue Dalli::DalliError => ex

data/lib/active_support/cache/dalli_store.rb

@@ -54,6 +54,8 @@ module ActiveSupport
         pool_options[:timeout] = options[:pool_timeout] if options[:pool_timeout]
 
         @options[:compress] ||= @options[:compression]
+
+        addresses.compact!
         servers = if addresses.empty?
                     nil # use the default from Dalli::Client
                   else

data/lib/dalli/cas/client.rb

@@ -33,7 +33,7 @@ module Dalli
 
     ##
     # Set the key-value pair, verifying existing CAS.
-    # Returns the resulting CAS value if succeeded, and false otherwise.
+    # Returns the resulting CAS value if succeeded, and falsy otherwise.
     def set_cas(key, value, cas, ttl=nil, options=nil)
       ttl ||= @options[:expires_in].to_i
       perform(:set, key, value, ttl, cas, options)
@@ -42,17 +42,17 @@ module Dalli
     ##
     # Conditionally add a key/value pair, verifying existing CAS, only if the
     # key already exists on the server.  Returns the new CAS value if the
-    # operation succeeded, or false otherwise.
+    # operation succeeded, or falsy otherwise.
     def replace_cas(key, value, cas, ttl=nil, options=nil)
       ttl ||= @options[:expires_in].to_i
       perform(:replace, key, value, ttl, cas, options)
     end
 
     # Delete a key/value pair, verifying existing CAS.
-    # Returns true if succeeded, and false otherwise.
+    # Returns true if succeeded, and falsy otherwise.
     def delete_cas(key, cas=0)
       perform(:delete, key, cas)
     end
 
   end
-end
+end

data/lib/dalli/client.rb

@@ -105,7 +105,7 @@ module Dalli
 
     ##
     # Conditionally add a key/value pair, if the key does not already exist
-    # on the server.  Returns true if the operation succeeded.
+    # on the server.  Returns truthy if the operation succeeded.
     def add(key, value, ttl=nil, options=nil)
       ttl ||= @options[:expires_in].to_i
       perform(:add, key, value, ttl, options)
@@ -113,7 +113,7 @@ module Dalli
 
     ##
     # Conditionally add a key/value pair, only if the key already exists
-    # on the server.  Returns true if the operation succeeded.
+    # on the server.  Returns truthy if the operation succeeded.
     def replace(key, value, ttl=nil, options=nil)
       ttl ||= @options[:expires_in].to_i
       perform(:replace, key, value, ttl, 0, options)
@@ -212,6 +212,12 @@ module Dalli
       end
     end
 
+    ##
+    ## Make sure memcache servers are alive, or raise an Dalli::RingError
+    def alive!
+      ring.server_for_key("")
+    end
+
     ##
     ## Version of the memcache servers.
     def version
@@ -348,7 +354,8 @@ module Dalli
     end
 
     def namespace
-      @options[:namespace].is_a?(Proc) ? @options[:namespace].call : @options[:namespace]
+      return nil unless @options[:namespace]
+      @options[:namespace].is_a?(Proc) ? @options[:namespace].call.to_s : @options[:namespace].to_s
     end
 
     def normalize_options(opts)

data/lib/dalli/server.rb

@@ -32,7 +32,7 @@ module Dalli
     }
 
     def initialize(attribs, options = {})
-      (@hostname, @port, @weight) = attribs.split(':')
+      (@hostname, @port, @weight) = parse_hostname(attribs)
       @port ||= 11211
       @port = Integer(@port)
       @weight ||= 1
@@ -268,6 +268,7 @@ module Dalli
 
     def set(key, value, ttl, cas, options)
       (value, flags) = serialize(key, value, options)
+      ttl = sanitize_ttl(ttl)
 
       guard_max_value(key, value) do
         req = [REQUEST, OPCODES[multi? ? :setq : :set], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, flags, ttl, key, value].pack(FORMAT[:set])
@@ -278,6 +279,7 @@ module Dalli
 
     def add(key, value, ttl, options)
       (value, flags) = serialize(key, value, options)
+      ttl = sanitize_ttl(ttl)
 
       guard_max_value(key, value) do
         req = [REQUEST, OPCODES[multi? ? :addq : :add], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, flags, ttl, key, value].pack(FORMAT[:add])
@@ -288,6 +290,7 @@ module Dalli
 
     def replace(key, value, ttl, cas, options)
       (value, flags) = serialize(key, value, options)
+      ttl = sanitize_ttl(ttl)
 
       guard_max_value(key, value) do
         req = [REQUEST, OPCODES[multi? ? :replaceq : :replace], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, flags, ttl, key, value].pack(FORMAT[:replace])
@@ -308,26 +311,32 @@ module Dalli
       generic_response
     end
 
-    def decr(key, count, ttl, default)
-      expiry = default ? ttl : 0xFFFFFFFF
+    def decr_incr(opcode, key, count, ttl, default)
+      expiry = default ? sanitize_ttl(ttl) : 0xFFFFFFFF
       default ||= 0
       (h, l) = split(count)
       (dh, dl) = split(default)
-      req = [REQUEST, OPCODES[:decr], key.bytesize, 20, 0, 0, key.bytesize + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[:decr])
+      req = [REQUEST, OPCODES[opcode], key.bytesize, 20, 0, 0, key.bytesize + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[opcode])
       write(req)
       body = generic_response
-      body ? longlong(*body.unpack('NN')) : body
+      body ? body.unpack('Q>').first : body
+    end
+
+    def decr(key, count, ttl, default)
+      decr_incr :decr, key, count, ttl, default
     end
 
     def incr(key, count, ttl, default)
-      expiry = default ? ttl : 0xFFFFFFFF
-      default ||= 0
-      (h, l) = split(count)
-      (dh, dl) = split(default)
-      req = [REQUEST, OPCODES[:incr], key.bytesize, 20, 0, 0, key.bytesize + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[:incr])
-      write(req)
-      body = generic_response
-      body ? longlong(*body.unpack('NN')) : body
+      decr_incr :incr, key, count, ttl, default
+    end
+
+    def write_append_prepend(opcode, key, value)
+      write_generic [REQUEST, OPCODES[opcode], key.bytesize, 0, 0, 0, value.bytesize + key.bytesize, 0, 0, key, value].pack(FORMAT[opcode])
+    end
+
+    def write_generic(bytes)
+      write(bytes)
+      generic_response
     end
 
     def write_noop
@@ -343,15 +352,11 @@ module Dalli
     end
 
     def append(key, value)
-      req = [REQUEST, OPCODES[:append], key.bytesize, 0, 0, 0, value.bytesize + key.bytesize, 0, 0, key, value].pack(FORMAT[:append])
-      write(req)
-      generic_response
+      write_append_prepend :append, key, value
     end
 
     def prepend(key, value)
-      req = [REQUEST, OPCODES[:prepend], key.bytesize, 0, 0, 0, value.bytesize + key.bytesize, 0, 0, key, value].pack(FORMAT[:prepend])
-      write(req)
-      generic_response
+      write_append_prepend :prepend, key, value
     end
 
     def stats(info='')
@@ -361,9 +366,7 @@ module Dalli
     end
 
     def reset_stats
-      req = [REQUEST, OPCODES[:stat], 'reset'.bytesize, 0, 0, 0, 'reset'.bytesize, 0, 0, 'reset'].pack(FORMAT[:stat])
-      write(req)
-      generic_response
+      write_generic [REQUEST, OPCODES[:stat], 'reset'.bytesize, 0, 0, 0, 'reset'.bytesize, 0, 0, 'reset'].pack(FORMAT[:stat])
     end
 
     def cas(key)
@@ -373,15 +376,12 @@ module Dalli
     end
 
     def version
-      req = [REQUEST, OPCODES[:version], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
-      write(req)
-      generic_response
+      write_generic [REQUEST, OPCODES[:version], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
     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
+      ttl = sanitize_ttl(ttl)
+      write_generic [REQUEST, OPCODES[:touch], key.bytesize, 4, 0, 0, key.bytesize + 4, 0, 0, ttl, key].pack(FORMAT[:touch])
     end
 
     # http://www.hjp.at/zettel/m/memcached_flags.rxml
@@ -434,9 +434,7 @@ module Dalli
     end
 
     def data_cas_response
-      header = read(24)
-      raise Dalli::NetworkError, 'No response' if !header
-      (extras, _, status, count, _, cas) = header.unpack(CAS_HEADER)
+      (extras, _, status, count, _, cas) = read_header.unpack(CAS_HEADER)
       data = read(count) if count > 0
       if status == 1
         nil
@@ -463,10 +461,20 @@ module Dalli
       end
     end
 
+    # https://code.google.com/p/memcached/wiki/NewCommands#Standard_Protocol
+    # > An expiration time, in seconds. Can be up to 30 days. After 30 days, is treated as a unix timestamp of an exact date.
+    MAX_ACCEPTABLE_EXPIRATION_INTERVAL = 30*24*60*60 # 30 days
+    def sanitize_ttl(ttl)
+      if ttl > MAX_ACCEPTABLE_EXPIRATION_INTERVAL
+        Dalli.logger.debug "Expiration interval too long for Memcached, converting to an expiration timestamp"
+        Time.now.to_i + ttl
+      else
+        ttl
+      end
+    end
+
     def generic_response(unpack=false)
-      header = read(24)
-      raise Dalli::NetworkError, 'No response' if !header
-      (extras, _, status, count) = header.unpack(NORMAL_HEADER)
+      (extras, _, status, count) = read_header.unpack(NORMAL_HEADER)
       data = read(count) if count > 0
       if status == 1
         nil
@@ -484,9 +492,7 @@ module Dalli
     end
 
     def cas_response
-      header = read(24)
-      raise Dalli::NetworkError, 'No response' if !header
-      (_, _, status, count, _, cas) = header.unpack(CAS_HEADER)
+      (_, _, status, count, _, cas) = read_header.unpack(CAS_HEADER)
       read(count) if count > 0  # this is potential data that we don't care about
       if status == 1
         nil
@@ -502,9 +508,7 @@ module Dalli
     def keyvalue_response
       hash = {}
       loop do
-        header = read(24)
-        raise Dalli::NetworkError, 'No response' if !header
-        (key_length, _, body_length, _) = header.unpack(KV_HEADER)
+        (key_length, _, body_length, _) = read_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
@@ -515,9 +519,7 @@ module Dalli
     def multi_response
       hash = {}
       loop do
-        header = read(24)
-        raise Dalli::NetworkError, 'No response' if !header
-        (key_length, _, body_length, _) = header.unpack(KV_HEADER)
+        (key_length, _, body_length, _) = read_header.unpack(KV_HEADER)
         return hash if key_length == 0
         flags = read(4).unpack('N')[0]
         key = read(key_length)
@@ -548,6 +550,10 @@ module Dalli
       end
     end
 
+    def read_header
+      read(24) || raise(Dalli::NetworkError, 'No response')
+    end
+
     def connect
       Dalli.logger.debug { "Dalli::Server#connect #{hostname}:#{port}" }
 
@@ -569,10 +575,6 @@ module Dalli
       [n >> 32, 0xFFFFFFFF & n]
     end
 
-    def longlong(a, b)
-      (a << 32) | b
-    end
-
     REQUEST = 0x80
     RESPONSE = 0x81
 
@@ -661,9 +663,8 @@ module Dalli
       # negotiate
       req = [REQUEST, OPCODES[:auth_negotiation], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
       write(req)
-      header = read(24)
-      raise Dalli::NetworkError, 'No response' if !header
-      (extras, type, status, count) = header.unpack(NORMAL_HEADER)
+
+      (extras, type, status, count) = read_header.unpack(NORMAL_HEADER)
       raise Dalli::NetworkError, "Unexpected message format: #{extras} #{count}" unless extras == 0 && count > 0
       content = read(count)
       return (Dalli.logger.debug("Authentication not required/supported by server")) if status == 0x81
@@ -676,9 +677,7 @@ module Dalli
       req = [REQUEST, OPCODES[:auth_request], mechanism.bytesize, 0, 0, 0, mechanism.bytesize + msg.bytesize, 0, 0, mechanism, msg].pack(FORMAT[:auth_request])
       write(req)
 
-      header = read(24)
-      raise Dalli::NetworkError, 'No response' if !header
-      (extras, type, status, count) = header.unpack(NORMAL_HEADER)
+      (extras, type, status, count) = read_header.unpack(NORMAL_HEADER)
       raise Dalli::NetworkError, "Unexpected message format: #{extras} #{count}" unless extras == 0 && count > 0
       content = read(count)
       return Dalli.logger.info("Dalli/SASL: #{content}") if status == 0
@@ -688,5 +687,10 @@ module Dalli
       # (step, msg) = sasl.receive('challenge', content)
       # raise Dalli::NetworkError, "Authentication failed" if sasl.failed? || step != 'response'
     end
+
+    def parse_hostname(str)
+      res = str.match(/\A(\[([\h:]+)\]|[^:]+)(:(\d+))?(:(\d+))?\z/)
+      return res[2] || res[1], res[4], res[6]
+    end
   end
 end

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '2.7.0'
+  VERSION = '2.7.1'
 end

data/lib/rack/session/dalli.rb

@@ -16,6 +16,7 @@ module Rack
         mserv = @default_options[:memcache_server]
         mopts = @default_options.reject{|k,v| !DEFAULT_OPTIONS.include? k }
         @pool = options[:cache] || ::Dalli::Client.new(mserv, mopts)
+        @pool.alive!
       end
 
       def generate_sid
@@ -27,7 +28,7 @@ module Rack
 
       def get_session(env, sid)
         with_lock(env, [nil, {}]) do
-          unless sid and session = @pool.get(sid)
+          unless sid and !sid.empty? and session = @pool.get(sid)
             sid, session = generate_sid, {}
             unless @pool.add(sid, session)
               raise "Session collision on '#{sid.inspect}'"
@@ -38,6 +39,7 @@ module Rack
       end
 
       def set_session(env, session_id, new_session, options)
+        return false unless session_id
         expiry = options[:expire_after]
         expiry = expiry.nil? ? 0 : expiry + 1
 

data/test/test_active_support.rb

@@ -371,6 +371,18 @@ describe 'ActiveSupport' do
         @dalli = ActiveSupport::Cache::DalliStore.new('localhost:19122', :expires_in => 1, :namespace => 'foo', :compress => true)
         assert_equal 1, @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:expires_in]
         assert_equal 'foo', @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:namespace]
+        assert_equal ["localhost:19122"], @dalli.instance_variable_get(:@data).instance_variable_get(:@servers)
+      end
+    end
+  end
+
+  it 'handles nil server with additional options' do
+    with_activesupport do
+      memcached do
+        @dalli = ActiveSupport::Cache::DalliStore.new(nil, :expires_in => 1, :namespace => 'foo', :compress => true)
+        assert_equal 1, @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:expires_in]
+        assert_equal 'foo', @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:namespace]
+        assert_equal ["127.0.0.1:11211"], @dalli.instance_variable_get(:@data).instance_variable_get(:@servers)
       end
     end
   end

data/test/test_dalli.rb

@@ -23,6 +23,16 @@ describe 'Dalli' do
         end
       end
     end
+
+    it 'return string type for namespace attribute' do
+      dc = Dalli::Client.new('foo', :namespace => :wunderschoen)
+      assert_equal "wunderschoen", dc.send(:namespace)
+      dc.close
+
+      dc = Dalli::Client.new('foo', :namespace => Proc.new{:wunderschoen})
+      assert_equal "wunderschoen", dc.send(:namespace)
+      dc.close
+    end
   end
 
   describe 'key validation' do
@@ -42,6 +52,13 @@ describe 'Dalli' do
         end
       end
     end
+
+    it 'allow namespace to be a symbol' do
+      memcached(19122, '', :namespace => :wunderschoen) do |dc|
+        dc.set "x" * 251, 1
+        assert 1, dc.get("#{'x' * 200}:md5:#{Digest::MD5.hexdigest('x' * 251)}")
+      end
+    end
   end
 
   it "default to localhost:11211" do
@@ -515,6 +532,13 @@ describe 'Dalli' do
       end
     end
 
+    it "handle nil namespace" do
+      memcached do |dc|
+        dc = Dalli::Client.new('localhost:19122', :namespace => nil)
+        assert_equal 'key', dc.send(:validate_key, 'key')
+      end
+    end
+
     it 'truncate cache keys that are too long' do
       memcached do
         dc = Dalli::Client.new('localhost:19122', :namespace => 'some:namspace')

data/test/test_rack_session.rb

@@ -11,40 +11,51 @@ describe Rack::Session::Dalli do
   before do
     memcached(19129) do
     end
+
+    # test memcache connection
+    Rack::Session::Dalli.new(incrementor)
   end
 
-  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
+  let(:session_key) { Rack::Session::Dalli::DEFAULT_OPTIONS[:key] }
+  let(:session_match) do
+    /#{session_key}=([0-9a-fA-F]+);/
+  end
+  let(:incrementor_proc) do
+    lambda do |env|
+      env["rack.session"]["counter"] ||= 0
+      env["rack.session"]["counter"] += 1
+      Rack::Response.new(env["rack.session"].inspect).to_a
+    end
+  end
+  let(:drop_session) do
+    Rack::Lint.new(proc do |env|
+        env['rack.session.options'][:drop] = true
+        incrementor_proc.call(env)
+      end)
+  end
+  let(:renew_session) do
+    Rack::Lint.new(proc do |env|
+        env['rack.session.options'][:renew] = true
+        incrementor_proc.call(env)
+      end)
+  end
+  let(:defer_session) do
+    Rack::Lint.new(proc do |env|
+        env['rack.session.options'][:defer] = true
+        incrementor_proc.call(env)
+      end)
+  end
+  let(:skip_session) do
+    Rack::Lint.new(proc do |env|
+        env['rack.session.options'][:skip] = true
+        incrementor_proc.call(env)
+      end)
   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)
+  let(:incrementor) { Rack::Lint.new(incrementor_proc) }
 
   it "faults on no connection" do
     assert_raises Dalli::RingError do
-      rsd = Rack::Session::Dalli.new(incrementor, :memcache_server => 'nosuchserver')
-      rsd.pool.set('ping', '')
+      Rack::Session::Dalli.new(incrementor, :memcache_server => 'nosuchserver')
     end
   end
 
@@ -104,6 +115,15 @@ describe Rack::Session::Dalli do
     refute_match(/#{bad_cookie}/, cookie)
   end
 
+  it "survives nonexistant blank cookies" do
+    bad_cookie = "rack.session="
+    rsd = Rack::Session::Dalli.new(incrementor)
+    res = Rack::MockRequest.new(rsd).
+      get("/", "HTTP_COOKIE" => bad_cookie)
+    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('/')

data/test/test_server.rb

@@ -0,0 +1,80 @@
+require 'helper'
+
+describe Dalli::Server do
+  describe 'hostname parsing' do
+    it 'handles no port or weight' do
+      s = Dalli::Server.new('localhost')
+      assert_equal 'localhost', s.hostname
+      assert_equal 11211, s.port
+      assert_equal 1, s.weight
+    end
+
+    it 'handles a port, but no weight' do
+      s = Dalli::Server.new('localhost:11212')
+      assert_equal 'localhost', s.hostname
+      assert_equal 11212, s.port
+      assert_equal 1, s.weight
+    end
+
+    it 'handles a port and a weight' do
+      s = Dalli::Server.new('localhost:11212:2')
+      assert_equal 'localhost', s.hostname
+      assert_equal 11212, s.port
+      assert_equal 2, s.weight
+    end
+
+    it 'handles ipv4 addresses' do
+      s = Dalli::Server.new('127.0.0.1')
+      assert_equal '127.0.0.1', s.hostname
+      assert_equal 11211, s.port
+      assert_equal 1, s.weight
+    end
+
+    it 'handles ipv6 addresses' do
+      s = Dalli::Server.new('[::1]')
+      assert_equal '::1', s.hostname
+      assert_equal 11211, s.port
+      assert_equal 1, s.weight
+    end
+
+    it 'handles ipv6 addresses with port' do
+      s = Dalli::Server.new('[::1]:11212')
+      assert_equal '::1', s.hostname
+      assert_equal 11212, s.port
+      assert_equal 1, s.weight
+    end
+
+    it 'handles ipv6 addresses with port and weight' do
+      s = Dalli::Server.new('[::1]:11212:2')
+      assert_equal '::1', s.hostname
+      assert_equal 11212, s.port
+      assert_equal 2, s.weight
+    end
+
+    it 'handles a FQDN' do
+      s = Dalli::Server.new('my.fqdn.com')
+      assert_equal 'my.fqdn.com', s.hostname
+      assert_equal 11211, s.port
+      assert_equal 1, s.weight
+    end
+
+    it 'handles a FQDN with port and weight' do
+      s = Dalli::Server.new('my.fqdn.com:11212:2')
+      assert_equal 'my.fqdn.com', s.hostname
+      assert_equal 11212, s.port
+      assert_equal 2, s.weight
+    end
+  end
+
+  describe 'ttl translation' do
+    it 'does not translate ttls under 30 days' do
+      s = Dalli::Server.new('localhost')
+      assert_equal s.send(:sanitize_ttl, 30*24*60*60), 30*24*60*60
+    end
+
+    it 'translates ttls over 30 days into timestamps' do
+      s = Dalli::Server.new('localhost')
+      assert_equal s.send(:sanitize_ttl, 30*24*60*60 + 1), Time.now.to_i + 30*24*60*60+1
+    end
+  end
+end

metadata

@@ -1,65 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.7.1
 platform: ruby
 authors:
 - Mike Perham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-07 00:00:00.000000000 Z
+date: 2014-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.0
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '4'
 description: High performance memcached client for Ruby
 email: mperham@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
+- History.md
+- LICENSE
+- Performance.md
+- README.md
+- Rakefile
+- dalli.gemspec
 - lib/action_dispatch/middleware/session/dalli_store.rb
 - lib/active_support/cache/dalli_store.rb
+- lib/dalli.rb
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
@@ -69,15 +77,7 @@ files:
 - lib/dalli/server.rb
 - lib/dalli/socket.rb
 - lib/dalli/version.rb
-- lib/dalli.rb
 - lib/rack/session/dalli.rb
-- LICENSE
-- README.md
-- History.md
-- Rakefile
-- Gemfile
-- dalli.gemspec
-- Performance.md
 - test/benchmark_test.rb
 - test/helper.rb
 - test/memcached_mock.rb
@@ -93,28 +93,29 @@ files:
 - test/test_ring.rb
 - test/test_sasl.rb
 - test/test_serializer.rb
+- test/test_server.rb
 homepage: http://github.com/mperham/dalli
 licenses:
 - MIT
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --charset=UTF-8
+- "--charset=UTF-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: High performance memcached client for Ruby
@@ -134,3 +135,4 @@ test_files:
 - test/test_ring.rb
 - test/test_sasl.rb
 - test/test_serializer.rb
+- test/test_server.rb