dalli 0.10.1 → 0.11.0

data/History.md

@@ -1,6 +1,20 @@
 Dalli Changelog
 =====================
 
+0.11.0
+======
+
+Warning: this release changes how Dalli marshals data.  I do not guarantee compatibility until 1.0 but I will increment the minor version every time a release breaks compatibility until 1.0.
+
+IT IS HIGHLY RECOMMENDED YOU FLUSH YOUR CACHE BEFORE UPGRADING.
+
+ - multi() now works reentrantly.
+ - Added new Dalli::Client option for default TTLs, :expires_in, defaults to 0 (aka forever).
+ - Added new Dalli::Client option, :compression, to enable auto-compression of values.
+ - Refactor how Dalli stores data on the server.  Values are now tagged
+   as "marshalled" or "compressed" so they can be automatically deserialized
+   without the client having to know how they were stored.
+
 0.10.1
 ======
 

data/README.md

@@ -113,8 +113,6 @@ Features and Changes
 
 Dalli is **NOT** 100% API compatible with memcache-client.  If you have code which uses the MemCache API directly, it will likely need small tweaks.  Method parameters and return values changed slightly.  See Upgrade.md for more detail.
 
-I've removed support for key namespaces and automatic pruning of keys longer than 250 characters.  ActiveSupport::Cache implements these features so there is little need for Dalli to reinvent them.
-
 By default, Dalli is thread-safe.  Disable thread-safety at your own peril.
 
 Note that Dalli does not require ActiveSupport or Rails.  You can safely use it in your own Ruby projects.

data/dalli.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.test_files = Dir.glob("test/**/*")
   s.add_development_dependency(%q<shoulda>, [">= 0"])
   s.add_development_dependency(%q<mocha>, [">= 0"])
-  s.add_development_dependency(%q<rails>, [">= 3.0.0"])
+  s.add_development_dependency(%q<rails>, [">= 3.0.1"])
   s.add_development_dependency(%q<memcache-client>, [">= 1.8.5"])
 end
 

data/lib/dalli.rb

@@ -4,7 +4,7 @@ require 'dalli/server'
 require 'dalli/version'
 require 'dalli/options'
 
-unless String.respond_to?(:bytesize)
+unless ''.respond_to?(:bytesize)
   class String
     alias_method :bytesize, :size
   end

data/lib/dalli/client.rb

@@ -4,20 +4,25 @@ module Dalli
     ##
     # Dalli::Client is the main class which developers will use to interact with
     # the memcached server.  Usage:
-    # <pre>
-    # Dalli::Client.new(['localhost:11211:10', 'cache-2.example.com:11211:5', '192.168.0.1:22122:5'], 
-    #                   :threadsafe => true, :failover => true)
-    # </pre>
+    # 
+    #   Dalli::Client.new(['localhost:11211:10', 'cache-2.example.com:11211:5', '192.168.0.1:22122:5'], 
+    #                   :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.
+    # 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.
     #
     # Options:
-    #   :failover - if a server is down, store the value on another server.  Default: true.
-    #   :threadsafe - ensure that only one thread is actively using a socket at a time. Default: true.
+    # - :failover - if a server is down, look for and store values on another server in the ring.  Default: true.
+    # - :threadsafe - ensure that only one thread is actively using a socket at a time. Default: true.
+    # - :expires_in - default TTL in seconds if you do not pass TTL as a parameter to an individual operation, defaults to 0 or forever
+    # - :compression - defaults to false, if true Dalli will compress values larger than 100 bytes before
+    #    sending them to memcached.
     #
     def initialize(servers=nil, options={})
       @servers = env_servers || servers || 'localhost:11211'
-      @options = options
+      @options = { :expires_in => 0 }.merge(options)
     end
     
     #
@@ -30,10 +35,10 @@ module Dalli
     # pipelined as Dalli will use 'quiet' operations where possible.
     # Currently supports the set, add, replace and delete operations.
     def multi
-      Thread.current[:multi] = true
+      old, Thread.current[:dalli_multi] = Thread.current[:dalli_multi], true
       yield
     ensure
-      Thread.current[:multi] = nil
+      Thread.current[:dalli_multi] = old
     end
 
     def get(key, options=nil)
@@ -54,7 +59,8 @@ module Dalli
       end
     end
 
-    def fetch(key, ttl=0, options=nil)
+    def fetch(key, ttl=nil, options=nil)
+      ttl ||= @options[:expires_in]
       val = get(key, options)
       if val.nil? && block_given?
         val = yield
@@ -63,25 +69,29 @@ module Dalli
       val
     end
 
-    def cas(key, ttl=0, options=nil, &block)
+    def cas(key, ttl=nil, options=nil, &block)
+      ttl ||= @options[:expires_in]
       (value, cas) = perform(:cas, key)
       value = (!value || value == 'Not found') ? nil : deserialize(value, options)
       if value
         newvalue = block.call(value)
-        perform(:add, key, serialize(newvalue, options), ttl, cas)
+        perform(:add, key, serialize(newvalue, options), ttl, cas, options)
       end
     end
 
-    def set(key, value, ttl=0, options=nil)
-      perform(:set, key, serialize(value, options), ttl)
+    def set(key, value, ttl=nil, options=nil)
+      ttl ||= @options[:expires_in]
+      perform(:set, key, serialize(value, options), ttl, options)
     end
     
-    def add(key, value, ttl=0, options=nil)
-      perform(:add, key, serialize(value, options), ttl, 0)
+    def add(key, value, ttl=nil, options=nil)
+      ttl ||= @options[:expires_in]
+      perform(:add, key, serialize(value, options), ttl, 0, options)
     end
 
-    def replace(key, value, ttl=0, options=nil)
-      perform(:replace, key, serialize(value, options), ttl)
+    def replace(key, value, ttl=nil, options=nil)
+      ttl ||= @options[:expires_in]
+      perform(:replace, key, serialize(value, options), ttl, options)
     end
 
     def delete(key)
@@ -116,8 +126,9 @@ module Dalli
     # If default is nil, the counter must already exist or the operation
     # will fail and will return nil.  Otherwise this method will return
     # the new value for the counter.
-    def incr(key, amt=1, ttl=0, default=nil)
+    def incr(key, amt=1, ttl=nil, default=nil)
       raise ArgumentError, "Positive values only: #{amt}" if amt < 0
+      ttl ||= @options[:expires_in]
       perform(:incr, key, amt, ttl, default)
     end
 
@@ -131,8 +142,9 @@ module Dalli
     # If default is nil, the counter must already exist or the operation
     # will fail and will return nil.  Otherwise this method will return
     # the new value for the counter.
-    def decr(key, amt=1, ttl=0, default=nil)
+    def decr(key, amt=1, ttl=nil, default=nil)
       raise ArgumentError, "Positive values only: #{amt}" if amt < 0
+      ttl ||= @options[:expires_in]
       perform(:decr, key, amt, ttl, default)
     end
 
@@ -153,19 +165,21 @@ module Dalli
     def ring
       @ring ||= Dalli::Ring.new(
         Array(@servers).map do |s|
-          Dalli::Server.new(s)
+          Dalli::Server.new(s, @options)
         end, @options
       )
     end
 
     def serialize(value, options)
-      options && options[:raw] ? value.to_s : ::Marshal.dump(value)
+      value
+#      options && options[:raw] ? value.to_s : ::Marshal.dump(value)
     end
 
     def deserialize(value, options)
-      options && options[:raw] ? value : ::Marshal.load(value)
-    rescue TypeError
-      raise Dalli::DalliError, "Invalid marshalled data in memcached: #{value}"
+      value
+    #   options && options[:raw] ? value : ::Marshal.load(value)
+    # rescue TypeError
+    #   raise Dalli::DalliError, "Invalid marshalled data in memcached: #{value}"
     end
 
     def env_servers

data/lib/dalli/server.rb

@@ -1,5 +1,6 @@
 require 'socket'
 require 'timeout'
+require 'zlib'
 
 module Dalli
   class Server
@@ -7,7 +8,7 @@ module Dalli
     attr_accessor :port
     attr_accessor :weight
     
-    def initialize(attribs)
+    def initialize(attribs, options=nil)
       (@hostname, @port, @weight) = attribs.split(':')
       @port ||= 11211
       @port = Integer(@port)
@@ -15,6 +16,7 @@ module Dalli
       @weight = Integer(@weight)
       @down_at = nil
       @version = detect_memcached_version
+      @options = options
       Dalli.logger.debug { "#{@hostname}:#{@port} running memcached v#{@version}" }
     end
     
@@ -28,8 +30,9 @@ module Dalli
         raise
       rescue Exception => ex
         Dalli.logger.error "Unexpected exception in Dalli: #{ex.class.name}: #{ex.message}"
+        Dalli.logger.error "This is a bug in Dalli, please enter an issue in Github if it does not already exist."
         Dalli.logger.error ex.backtrace.join("\n\t")
-        down!
+        down!(true)
       end
     end
 
@@ -42,8 +45,8 @@ module Dalli
         connection
         true
       rescue Dalli::NetworkError => dne
-        Dalli.logger.info("Unable to connect to #{hostname}:#{port}: #{dne.message}")
-        down!
+        Dalli.logger.info(dne.message)
+        false
       end
     end
 
@@ -85,15 +88,21 @@ module Dalli
       end
     end
 
-    def down!
+    def down!(toss_exception=false)
       close
       @down_at = Time.now.to_i
-      @msg = $!.message
+      @msg = @msg || ($! && $!.message) || ''
+      raise Dalli::NetworkError, "#{self.hostname}:#{self.port} is currently down: #{@msg}" if toss_exception
       nil
     end
 
+    def up!
+      @down_at = nil
+      @msg = nil
+    end
+
     def multi?
-      Thread.current[:multi]
+      Thread.current[:dalli_multi]
     end
 
     ONE_MB = 1024 * 1024
@@ -101,7 +110,7 @@ module Dalli
     def get(key)
       req = [REQUEST, OPCODES[:get], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:get])
       write(req)
-      generic_response
+      generic_response(true)
     end
 
     def getkq(key)
@@ -109,40 +118,41 @@ module Dalli
       write(req)
     end
 
-    def set(key, value, ttl)
-      raise Dalli::DalliError, "Value too large, memcached can only store 1MB of data per key" if value.bytesize > ONE_MB
+    def set(key, value, ttl, options)
+      (value, flags) = serialize(value, options)
 
-      req = [REQUEST, OPCODES[multi? ? :setq : :set], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, 0, ttl, key, value].pack(FORMAT[:set])
+      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)
       generic_response unless multi?
     end
 
-    def flush(ttl)
-      req = [REQUEST, OPCODES[:flush], 0, 4, 0, 0, 4, 0, 0, 0].pack(FORMAT[:flush])
-      write(req)
-      generic_response
-    end
+    def add(key, value, ttl, cas, options)
+      (value, flags) = serialize(value, options)
 
-    def add(key, value, ttl, cas)
-      raise Dalli::DalliError, "Value too large, memcached can only store 1MB of data per key" if value.bytesize > ONE_MB
-
-      req = [REQUEST, OPCODES[multi? ? :addq : :add], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, 0, ttl, key, value].pack(FORMAT[:add])
+      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)
       generic_response unless multi?
     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])
+    def replace(key, value, ttl, options)
+      (value, flags) = serialize(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
+      generic_response unless multi?
     end
-    
+
     def delete(key)
       req = [REQUEST, OPCODES[multi? ? :deleteq : :delete], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:delete])
       write(req)
       generic_response unless multi?
     end
 
+    def flush(ttl)
+      req = [REQUEST, OPCODES[:flush], 0, 4, 0, 0, 4, 0, 0, 0].pack(FORMAT[:flush])
+      write(req)
+      generic_response
+    end
+
     def decr(key, count, ttl, default)
       expiry = default ? ttl : 0xFFFFFFFF
       default ||= 0
@@ -173,16 +183,16 @@ module Dalli
       multi_response
     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])
+    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
     end
 
-    def replace(key, value, ttl)
-      req = [REQUEST, OPCODES[multi? ? :replaceq : :replace], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, 0, ttl, key, value].pack(FORMAT[:replace])
+    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 unless multi?
+      generic_response
     end
 
     def stats(info='')
@@ -209,6 +219,44 @@ module Dalli
       generic_response
     end
 
+    COMPRESSION_MIN_SIZE = 100
+
+    # http://www.hjp.at/zettel/m/memcached_flags.rxml
+    # Looks like most clients use bit 0 to indicate native language serialization
+    # and bit 1 to indicate gzip compression.
+    FLAG_MARSHALLED = 0x1
+    FLAG_COMPRESSED = 0x2
+
+    def serialize(value, options=nil)
+      marshalled = false
+      value = unless options && options[:raw]
+        marshalled = true
+        Marshal.dump(value)
+      else
+        value.to_s
+      end
+      compressed = false
+      if @options[:compression] && value.bytesize >= COMPRESSION_MIN_SIZE
+        value = Zlib::Deflate.deflate(value)
+        compressed = true
+      end
+      raise Dalli::DalliError, "Value too large, memcached can only store 1MB of data per key" if value.bytesize > ONE_MB
+      flags = 0
+      flags |= FLAG_COMPRESSED if compressed
+      flags |= FLAG_MARSHALLED if marshalled
+      [value, flags]
+    end
+
+    def deserialize(value, flags)
+      value = Zlib::Inflate.inflate(value) if (flags & FLAG_COMPRESSED) != 0
+      value = Marshal.load(value) if (flags & FLAG_MARSHALLED) != 0
+      value
+    rescue TypeError
+      raise DalliError, "Unable to unmarshal value: '#{value}'"
+    rescue Zlib::Error
+      raise DalliError, "Unable to uncompress value: '#{value}'"      
+    end
+
     def cas_response
       header = read(24)
       raise Dalli::NetworkError, 'No response' if !header
@@ -219,12 +267,18 @@ module Dalli
       elsif status != 0
         raise Dalli::DalliError, "Response error #{status}: #{RESPONSE_CODES[status]}"
       elsif data
-        data = data[extras..-1] if extras != 0
+        flags = data[0...extras].unpack('N')[0]
+        value = data[extras..-1]
+        data = deserialize(value, flags)
       end
       [data, cas]
     end
 
-    def generic_response
+    CAS_HEADER = '@4CCnNNQ'
+    NORMAL_HEADER = '@4CCnN'
+    KV_HEADER = '@2n@6nN'
+
+    def generic_response(unpack=false)
       header = read(24)
       raise Dalli::NetworkError, 'No response' if !header
       (extras, type, status, count) = header.unpack(NORMAL_HEADER)
@@ -236,7 +290,9 @@ module Dalli
       elsif status != 0
         raise Dalli::DalliError, "Response error #{status}: #{RESPONSE_CODES[status]}"
       elsif data
-        extras != 0 ? data[extras..-1] : data
+        flags = data[0...extras].unpack('N')[0]
+        value = data[extras..-1]
+        unpack ? deserialize(value, flags) : value
       else
         true
       end
@@ -262,10 +318,10 @@ module Dalli
         raise Dalli::NetworkError, 'No response' if !header
         (key_length, status, body_length) = header.unpack(KV_HEADER)
         return hash if key_length == 0
-        read(4)
+        flags = read(4).unpack('N')[0]
         key = read(key_length)
         value = read(body_length - key_length - 4) if body_length - key_length - 4 > 0
-        hash[key] = value
+        hash[key] = deserialize(value, flags)
       end
     end
 
@@ -278,24 +334,26 @@ module Dalli
         end
 
         # All this ugly code to ensure proper Socket connect timeout
-        addr = Socket.getaddrinfo(self.hostname, nil)
-        sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
         begin
-          sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
-        rescue Errno::EINPROGRESS
-          resp = IO.select(nil, [sock], nil, TIMEOUT)
+          addr = Socket.getaddrinfo(self.hostname, nil)
+          sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
           begin
             sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
-          rescue Errno::EISCONN
-            ;
-          rescue
-            raise Dalli::NetworkError, "#{self.hostname}:#{self.port} is currently down: #{$!.message}"
+          rescue Errno::EINPROGRESS
+            resp = IO.select(nil, [sock], nil, TIMEOUT)
+            begin
+              sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
+            rescue Errno::EISCONN
+            end
           end
+        rescue
+          down!(true)
         end
         # end ugly code
 
         sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
         sasl_authentication(sock) if Dalli::Server.need_auth?
+        up!
         sock
       end
     end
@@ -303,9 +361,8 @@ module Dalli
     def write(bytes)
       begin
         connection.write(bytes)
-      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF
-        down!
-        raise Dalli::NetworkError, $!.class.name
+      rescue SystemCallError
+        down!(true)
       end
     end
 
@@ -325,9 +382,8 @@ module Dalli
           end
         end
         value
-      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL, Timeout::Error, EOFError
-        down!
-        raise Dalli::NetworkError, "#{$!.class.name}: #{$!.message}"
+      rescue SystemCallError, Timeout::Error, EOFError
+        down!(true)
       end
     end
 
@@ -339,10 +395,6 @@ module Dalli
       (a << 32) | b
     end
 
-    CAS_HEADER = '@4CCnNNQ'
-    NORMAL_HEADER = '@4CCnN'
-    KV_HEADER = '@2n@6nN'
-
     REQUEST = 0x80
     RESPONSE = 0x81
     
@@ -465,4 +517,4 @@ module Dalli
       # raise Dalli::NetworkError, "Authentication failed" if sasl.failed? || step != 'response'
     end
   end
-end
+end

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '0.10.1'
+  VERSION = '0.11.0'
 end

data/test/test_dalli.rb

@@ -222,10 +222,7 @@ class TestDalli < Test::Unit::TestCase
         assert_equal true, dc.prepend('456', '0')
         assert_equal true, dc.append('456', '9')
         assert_equal '0xyz9', dc.get('456', :raw => true)
-
-        assert_raises Dalli::DalliError do
-          assert_equal '0xyz9', dc.get('456')
-        end
+        assert_equal '0xyz9', dc.get('456')
 
         assert_equal false, dc.append('nonexist', 'abc')
         assert_equal false, dc.prepend('nonexist', 'abc')
@@ -323,7 +320,6 @@ class TestDalli < Test::Unit::TestCase
       end
     end
 
-
     should "handle namespaced keys" do
       memcached do |dc|
         dc = Dalli::Client.new('localhost:19122', :namespace => 'a')
@@ -335,6 +331,20 @@ class TestDalli < Test::Unit::TestCase
       end
     end
 
+    context 'with compression' do
+      should 'allow large values' do
+        memcached do |dc|
+          dalli = Dalli::Client.new(dc.instance_variable_get(:@servers), :compression => true)
+
+          value = "0"*1024*1024
+          assert_raise Dalli::DalliError, /too large/ do
+            dc.set('verylarge', value)
+          end
+          dalli.set('verylarge', value)
+        end
+      end
+    end
+
     context 'without authentication credentials' do
       setup do
         ENV['MEMCACHE_USERNAME'] = 'testuser'
@@ -382,5 +392,44 @@ class TestDalli < Test::Unit::TestCase
       end
     end
 
+    context 'in low memory conditions' do
+
+      should 'handle error response correctly' do
+        memcached(19125, '-m 1 -M') do |dc|
+          failed = false
+          value = "1234567890"*100
+          1_000.times do |idx|
+            begin
+              assert_equal true, dc.set(idx, value)
+            rescue Dalli::DalliError
+              failed = true
+              assert((800..900).include?(idx), "unexpected failure on iteration #{idx}")
+              break
+            end
+          end
+          assert failed, 'did not fail under low memory conditions'
+        end
+      end
+
+      should 'fit more values with compression' do
+        memcached(19126, '-m 1 -M') do |dc|
+          dalli = Dalli::Client.new('localhost:19126', :compression => true)
+          failed = false
+          value = "1234567890"*1000
+          10_000.times do |idx|
+            begin
+              assert_equal true, dalli.set(idx, value)
+            rescue Dalli::DalliError
+              failed = true
+              assert((6000..7000).include?(idx), "unexpected failure on iteration #{idx}")
+              break
+            end
+          end
+          assert failed, 'did not fail under low memory conditions'
+        end
+      end
+
+    end
+
   end
 end

data/test/test_encoding.rb

@@ -25,7 +25,7 @@ class TestEncoding < Test::Unit::TestCase
         key = 'foo'
         assert dc.set(key, 'bar', 1)
         assert_equal 'bar', dc.get(key)
-        sleep 1.1
+        sleep 2
         assert_equal nil, dc.get(key)
       end
     end

data/test/test_network.rb

@@ -18,7 +18,7 @@ class TestNetwork < Test::Unit::TestCase
 
       should 'handle connection reset' do
         memcached_mock(lambda {|sock| sock.close }) do
-          assert_error Dalli::NetworkError, /ECONNRESET|EOFError/ do
+          assert_error Dalli::NetworkError, /Connection reset|end of file/ do
             dc = Dalli::Client.new('localhost:19123')
             dc.get('abc')
           end
@@ -27,7 +27,7 @@ class TestNetwork < Test::Unit::TestCase
 
       should 'handle malformed response' do
         memcached_mock(lambda {|sock| sock.write('123') }) do
-          assert_error Dalli::NetworkError, /EOFError/ do
+          assert_error Dalli::NetworkError, /end of file/ do
             dc = Dalli::Client.new('localhost:19123')
             dc.get('abc')
           end
@@ -36,7 +36,7 @@ class TestNetwork < Test::Unit::TestCase
 
       should 'handle connect timeouts' do
         memcached_mock(lambda {|sock| sleep(0.6); sock.close }, :delayed_start) do
-          assert_error Dalli::NetworkError, /Timeout::Error/ do
+          assert_error Dalli::NetworkError, /IO timeout/ do
             dc = Dalli::Client.new('localhost:19123')
             dc.get('abc')
           end
@@ -45,7 +45,7 @@ class TestNetwork < Test::Unit::TestCase
 
       should 'handle read timeouts' do
         memcached_mock(lambda {|sock| sleep(0.6); sock.write('giraffe') }) do
-          assert_error Dalli::NetworkError, /Timeout::Error/ do
+          assert_error Dalli::NetworkError, /IO timeout/ do
             dc = Dalli::Client.new('localhost:19123')
             dc.get('abc')
           end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 10
-  - 1
-  version: 0.10.1
+  - 11
+  - 0
+  version: 0.11.0
 platform: ruby
 authors: 
 - Mike Perham
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-22 00:00:00 -07:00
+date: 2010-11-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,8 +54,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 1
+        version: 3.0.1
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency