memcached 0.12 → 0.14

data/lib/memcached.rb

@@ -22,9 +22,8 @@ class Memcached
   Lib = Rlibmemcached
   REQUIRED_VERSION = File.read("#{File.dirname(__FILE__)}/../COMPATIBILITY")[/:: ([\d\.]+)/, 1]
   RECEIVED_VERSION = Lib.memcached_lib_version
-  raise LoadError, "Requires libmemcached #{REQUIRED_VERSION}; you have #{RECEIVED_VERSION}" unless REQUIRED_VERSION == RECEIVED_VERSION
-end  
-
+  STDERR.puts "Warning: libmemcached #{REQUIRED_VERSION} suggested; you have #{RECEIVED_VERSION}." unless REQUIRED_VERSION == RECEIVED_VERSION
+end
 
 require 'memcached/integer'
 require 'memcached/exceptions'

data/lib/memcached/behaviors.rb

@@ -22,39 +22,45 @@ class Memcached
 
   DISTRIBUTION_VALUES = {}
   BEHAVIOR_VALUES.merge!(load_constants("MEMCACHED_DISTRIBUTION_", DISTRIBUTION_VALUES))
-  
-  DIRECT_VALUE_BEHAVIORS = [:retry_timeout, :connect_timeout, :rcv_timeout, :socket_recv_size, :poll_timeout, :socket_send_size]
+
+  DIRECT_VALUE_BEHAVIORS = [:retry_timeout, :connect_timeout, :rcv_timeout, :socket_recv_size, :poll_timeout, :socket_send_size, :server_failure_limit]
+
+  CONVERSION_FACTORS = {
+    :connect_timeout => 1_000_000,
+    :rcv_timeout => 1_000_000,
+    :poll_timeout => 1_000
+  }
 
 #:startdoc:
 
   private
-  
+
   # Set a behavior option for this Memcached instance. Accepts a Symbol <tt>behavior</tt> and either <tt>true</tt>, <tt>false</tt>, or a Symbol for <tt>value</tt>. Arguments are validated and converted into integers for the struct setter method.
   def set_behavior(behavior, value) #:doc:
-    raise ArgumentError, "No behavior #{behavior.inspect}" unless b_id = BEHAVIORS[behavior]    
-    
+    raise ArgumentError, "No behavior #{behavior.inspect}" unless b_id = BEHAVIORS[behavior]
+
     # Scoped validations; annoying
-    msg =  "Invalid behavior value #{value.inspect} for #{behavior.inspect}" 
-    case behavior 
+    msg =  "Invalid behavior value #{value.inspect} for #{behavior.inspect}"
+    case behavior
       when :hash then raise(ArgumentError, msg) unless HASH_VALUES[value]
       when :distribution then raise(ArgumentError, msg) unless DISTRIBUTION_VALUES[value]
-      when *DIRECT_VALUE_BEHAVIORS then raise(ArgumentError, msg) unless value.is_a? Fixnum and value > 0
+      when *DIRECT_VALUE_BEHAVIORS then raise(ArgumentError, msg) unless value.is_a?(Numeric) and value > 0
       else
         raise(ArgumentError, msg) unless BEHAVIOR_VALUES[value]
     end
-    
-    lib_value = BEHAVIOR_VALUES[value] || value    
+
+    lib_value = BEHAVIOR_VALUES[value] || (value * (CONVERSION_FACTORS[behavior] || 1)).to_i
     #STDERR.puts "Setting #{behavior}:#{b_id} => #{value} (#{lib_value})"
-    Lib.memcached_behavior_set(@struct, b_id, lib_value)    
+    Lib.memcached_behavior_set(@struct, b_id, lib_value)
     #STDERR.puts " -> set to #{get_behavior(behavior).inspect}"
-  end  
-  
+  end
+
   # Get a behavior value for this Memcached instance. Accepts a Symbol.
   def get_behavior(behavior)
     raise ArgumentError, "No behavior #{behavior.inspect}" unless b_id = BEHAVIORS[behavior]
-    value = Lib.memcached_behavior_get(@struct, b_id)        
+    value = Lib.memcached_behavior_get(@struct, b_id)
 
-    if BEHAVIOR_VALUES.invert.has_key?(value) 
+    if BEHAVIOR_VALUES.invert.has_key?(value)
       # False, nil are valid values so we can not rely on direct lookups
       case behavior
         # Scoped values; still annoying

data/lib/memcached/memcached.rb

@@ -16,15 +16,18 @@ class Memcached
     :support_cas => false,
     :tcp_nodelay => false,
     :show_backtraces => false,
-    :retry_timeout => 60,
-    :timeout => 0.5,
-    :connect_timeout => 5,
+    :retry_timeout => 30,
+    :timeout => 0.25,
+    :rcv_timeout => nil,
+    :poll_timeout => nil,
+    :connect_timeout => 2,
     :prefix_key => nil,
     :hash_with_prefix_key => true,
     :default_ttl => 604800,
     :default_weight => 8,
     :sort_hosts => false,
-    :failover => false,
+    :auto_eject_hosts => false,
+    :server_failure_limit => 2,
     :verify_key => true
   }
 
@@ -50,21 +53,25 @@ Valid option parameters are:
 <tt>:prefix_key</tt>:: A string to prepend to every key, for namespacing. Max length is 127.
 <tt>:hash</tt>:: The name of a hash function to use. Possible values are: <tt>:crc</tt>, <tt>:default</tt>, <tt>:fnv1_32</tt>, <tt>:fnv1_64</tt>, <tt>:fnv1a_32</tt>, <tt>:fnv1a_64</tt>, <tt>:hsieh</tt>, <tt>:md5</tt>, and <tt>:murmur</tt>. <tt>:default</tt> is the fastest. Use <tt>:md5</tt> for compatibility with other ketama clients.
 <tt>:distribution</tt>:: Either <tt>:modula</tt>, <tt>:consistent_ketama</tt>, <tt>:consistent_wheel</tt>, or <tt>:ketama</tt>. Defaults to <tt>:ketama</tt>.
-<tt>:failover</tt>:: Whether to permanently eject failed hosts from the pool. Defaults to <tt>false</tt>. Note that in the event of a server failure, <tt>:failover</tt> will remap the entire pool unless <tt>:distribution</tt> is set to <tt>:consistent</tt>.
+<tt>:server_failure_limit</tt>:: How many consecutive failures to allow before marking a host as dead. Has no effect unless <tt>:retry_timeout</tt> is also set.
+<tt>:retry_timeout</tt>:: How long to wait until retrying a dead server. Has no effect unless <tt>:server_failure_limit</tt> is non-zero. Defaults to <tt>30</tt>.
+<tt>:auto_eject_hosts</tt>:: Whether to temporarily eject dead hosts from the pool. Defaults to <tt>false</tt>. Note that in the event of an ejection, <tt>:auto_eject_hosts</tt> will remap the entire pool unless <tt>:distribution</tt> is set to <tt>:consistent</tt>.
 <tt>:cache_lookups</tt>:: Whether to cache hostname lookups for the life of the instance. Defaults to <tt>true</tt>.
 <tt>:support_cas</tt>:: Flag CAS support in the client. Accepts <tt>true</tt> or <tt>false</tt>. Defaults to <tt>false</tt> because it imposes a slight performance penalty. Note that your server must also support CAS or you will trigger <b>Memcached::ProtocolError</b> exceptions.
 <tt>:tcp_nodelay</tt>:: Turns on the no-delay feature for connecting sockets. Accepts <tt>true</tt> or <tt>false</tt>. Performance may or may not change, depending on your system.
-<tt>:no_block</tt>:: Whether to use non-blocking, asynchronous IO for writes. Accepts <tt>true</tt> or <tt>false</tt>.
+<tt>:no_block</tt>:: Whether to use pipelining for writes. Accepts <tt>true</tt> or <tt>false</tt>.
 <tt>:buffer_requests</tt>:: Whether to use an internal write buffer. Accepts <tt>true</tt> or <tt>false</tt>. Calling <tt>get</tt> or closing the connection will force the buffer to flush. Note that <tt>:buffer_requests</tt> might not work well without <tt>:no_block</tt> also enabled.
 <tt>:show_backtraces</tt>:: Whether <b>Memcached::NotFound</b> exceptions should include backtraces. Generating backtraces is slow, so this is off by default. Turn it on to ease debugging.
-<tt>:timeout</tt>:: How long to wait for a response from the server. Defaults to 0.5 seconds. Set to <tt>0</tt> if you want to wait forever.
+<tt>:connect_timeout</tt>:: How long to wait for a connection to a server. Defaults to 2 seconds. Set to <tt>0</tt> if you want to wait forever.
+<tt>:timeout</tt>:: How long to wait for a response from the server. Defaults to 0.25 seconds. Set to <tt>0</tt> if you want to wait forever.
+<tt>:poll_timeout</tt>:: How long to wait for a response from the server in the non-blocking select loop. Defaults to 0.25 seconds. Set to <tt>0</tt> if you want to wait forever.
 <tt>:default_ttl</tt>:: The <tt>ttl</tt> to use on set if no <tt>ttl</tt> is specified, in seconds. Defaults to one week. Set to <tt>0</tt> if you want things to never expire.
 <tt>:default_weight</tt>:: The weight to use if <tt>:ketama_weighted</tt> is <tt>true</tt>, but no weight is specified for a server.
 <tt>:hash_with_prefix_key</tt>:: Whether to include the prefix when calculating which server a key falls on. Defaults to <tt>true</tt>.
 <tt>:sort_hosts</tt>:: Whether to force the server list to stay sorted. This defeats consistent hashing and is rarely useful.
 <tt>:verify_key</tt>:: Validate keys before accepting them. Never disable this.
 
-Please note that when non-blocking IO is enabled, setter and deleter methods do not raise on errors. For example, if you try to set an invalid key with <tt>:no_block => true</tt>, it will appear to succeed. The actual setting of the key occurs after libmemcached has returned control to your program, so there is no way to backtrack and raise the exception.
+Please note that when pipelining is enabled, setter and deleter methods do not raise on errors. For example, if you try to set an invalid key with <tt>:no_block => true</tt>, it will appear to succeed. The actual setting of the key occurs after libmemcached has returned control to your program, so there is no way to backtrack and raise the exception.
 
 =end
 
@@ -93,17 +100,9 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
       raise ArgumentError, ":sort_hosts defeats :consistent hashing"
     end
 
-    # Set timeouts
-    if options[:timeout] > 0
-      if options[:no_block]
-        options[:poll_timeout] = (options[:timeout] * 1_000).to_i
-      else
-        options[:poll_timeout] = 1
-        options[:rcv_timeout] = (options[:timeout] * 1_000_000).to_i
-      end
-    elsif options[:no_block]
-      raise ArgumentError, "Can't set :timeout => 0 when :no_block => true."
-    end
+    # Read timeouts
+    options[:rcv_timeout] ||= options[:timeout]
+    options[:poll_timeout] ||= options[:timeout]
 
     # Set the behaviors on the struct
     set_behaviors
@@ -114,7 +113,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
 
     # Set the servers on the struct
     set_servers(servers)
-    
+
     # Not found exceptions
     unless options[:show_backtraces]
       @not_found_instance = NotFound.new
@@ -128,7 +127,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
       inspect_server(server)
     end
   end
-  
+
   # Safely copy this instance. Returns a Memcached instance.
   #
   # <tt>clone</tt> is useful for threading, since each thread must have its own unshared Memcached
@@ -150,6 +149,12 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
     set_servers(current_servers)
   end
 
+  # Disconnect from all currently connected servers
+  def quit
+    Lib.memcached_quit(@struct)
+    self
+  end
+
   #:stopdoc:
   alias :dup :clone #:nodoc:
   #:startdoc:
@@ -184,7 +189,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def set(key, value, ttl=nil, marshal=true, flags=FLAGS)
     value = marshal ? Marshal.dump(value) : value.to_s
     check_return_code(
-      Lib.memcached_set(@struct, key, value, ttl || options[:default_ttl], flags)
+      Lib.memcached_set(@struct, key, value, ttl || options[:default_ttl], flags),
+      key
     )
   end
 
@@ -192,7 +198,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def add(key, value, ttl=nil, marshal=true, flags=FLAGS)
     value = marshal ? Marshal.dump(value) : value.to_s
     check_return_code(
-      Lib.memcached_add(@struct, key, value, ttl || options[:default_ttl], flags)
+      Lib.memcached_add(@struct, key, value, ttl || options[:default_ttl], flags),
+      key
     )
   end
 
@@ -203,14 +210,14 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   # Note that the key must be initialized to an unmarshalled integer first, via <tt>set</tt>, <tt>add</tt>, or <tt>replace</tt> with <tt>marshal</tt> set to <tt>false</tt>.
   def increment(key, offset=1)
     ret, value = Lib.memcached_increment(@struct, key, offset)
-    check_return_code(ret)
+    check_return_code(ret, key)
     value
   end
 
   # Decrement a key's value. The parameters and exception behavior are the same as <tt>increment</tt>.
   def decrement(key, offset=1)
     ret, value = Lib.memcached_decrement(@struct, key, offset)
-    check_return_code(ret)
+    check_return_code(ret, key)
     value
   end
 
@@ -223,7 +230,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def replace(key, value, ttl=nil, marshal=true, flags=FLAGS)
     value = marshal ? Marshal.dump(value) : value.to_s
     check_return_code(
-      Lib.memcached_replace(@struct, key, value, ttl || options[:default_ttl], flags)
+      Lib.memcached_replace(@struct, key, value, ttl || options[:default_ttl], flags),
+      key
     )
   end
 
@@ -233,7 +241,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def append(key, value)
     # Requires memcached 1.2.4
     check_return_code(
-      Lib.memcached_append(@struct, key, value.to_s, IGNORED, IGNORED)
+      Lib.memcached_append(@struct, key, value.to_s, IGNORED, IGNORED),
+      key
     )
   end
 
@@ -241,7 +250,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def prepend(key, value)
     # Requires memcached 1.2.4
     check_return_code(
-      Lib.memcached_prepend(@struct, key, value.to_s, IGNORED, IGNORED)
+      Lib.memcached_prepend(@struct, key, value.to_s, IGNORED, IGNORED),
+      key
     )
   end
 
@@ -259,7 +269,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
     value = marshal ? Marshal.dump(value) : value.to_s
 
     check_return_code(
-      Lib.memcached_cas(@struct, key, value, ttl || options[:default_ttl], flags, @struct.result.cas)
+      Lib.memcached_cas(@struct, key, value, ttl || options[:default_ttl], flags, @struct.result.cas),
+      key
     )
   end
 
@@ -268,7 +279,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   # Deletes a key/value pair from the server. Accepts a String <tt>key</tt>. Raises <b>Memcached::NotFound</b> if the key does not exist.
   def delete(key)
     check_return_code(
-      Lib.memcached_delete(@struct, key, IGNORED)
+      Lib.memcached_delete(@struct, key, IGNORED),
+      key
     )
   end
 
@@ -295,13 +307,13 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
     if keys.is_a? Array
       # Multi get
       ret = Lib.memcached_mget(@struct, keys);
-      check_return_code(ret)
+      check_return_code(ret, keys)
 
       hash = {}
       keys.size.times do
         value, key, flags, ret = Lib.memcached_fetch_rvalue(@struct)
         break if ret == Lib::MEMCACHED_END
-        check_return_code(ret)
+        check_return_code(ret, key)
         value = Marshal.load(value) if marshal
         # Assign the value
         hash[key] = value
@@ -310,7 +322,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
     else
       # Single get
       value, flags, ret = Lib.memcached_get_rvalue(@struct, keys)
-      check_return_code(ret)
+      check_return_code(ret, keys)
       value = Marshal.load(value) if marshal
       value
     end
@@ -318,6 +330,12 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
 
   ### Information methods
 
+  # Return the server used by a particular key.
+  def server_by_key(key)
+    ret = Lib.memcached_server_by_key(@struct, key)    
+    inspect_server(ret.first) if ret.is_a?(Array)
+  end
+
   # Return a Hash of statistics responses from the set of servers. Each value is an array with one entry for each server, in the same order the servers were defined.
   def stats
     stats = Hash.new([])
@@ -335,7 +353,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
            @struct,
            Lib.memcached_select_stat_at(@struct, stat_struct, index),
            key)
-         check_return_code(ret)
+         check_return_code(ret, key)
 
          value = case value
            when /^\d+\.\d+$/: value.to_f
@@ -355,38 +373,40 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
 
   private
 
-  # Checks the return code from Rlibmemcached against the exception list. Raises the corresponding exception if the return code is not Memcached::Success or Memcached::ActionQueued. Accepts an integer return code.
-  def check_return_code(ret) #:doc:
-    return if ret == 0 or # Lib::MEMCACHED_SUCCESS
-      ret == Lib::MEMCACHED_BUFFERED
+  # Checks the return code from Rlibmemcached against the exception list. Raises the corresponding exception if the return code is not Memcached::Success or Memcached::ActionQueued. Accepts an integer return code and an optional key, for exception messages.
+  def check_return_code(ret, key = nil) #:doc:
+    return if ret == 0 # Lib::MEMCACHED_SUCCESS
+    return if ret == Lib::MEMCACHED_BUFFERED
 
-    # SystemError; eject from the pool
     if ret == Lib::MEMCACHED_NOTFOUND and !options[:show_backtraces]
       raise @not_found_instance
-    elsif options[:failover] and (ret == Lib::MEMCACHED_UNKNOWN_READ_FAILURE or ret == Lib::MEMCACHED_ERRNO)
-      failed = sweep_servers
-      raise EXCEPTIONS[ret], "Server #{failed} failed permanently"
     else
-      raise EXCEPTIONS[ret], ""
+      message = "Key #{inspect_keys(key, (detect_failure if ret == Lib::MEMCACHED_SERVER_MARKED_DEAD)).inspect}"
+      if ret == Lib::MEMCACHED_ERRNO and key.is_a?(String)
+        server = Lib.memcached_server_by_key(@struct, key)
+        message = "Errno #{server.first.cached_errno}. #{message}"
+      end
+      raise EXCEPTIONS[ret], message
     end
   end
 
-  # Eject the first dead server we find from the pool and reset the struct
-  def sweep_servers
-    # XXX This method is annoying, but necessary until we get Lib.memcached_delete_server or equivalent.
-    server_structs.each do |server|
-      if server.next_retry > Time.now
-        server_name = inspect_server(server)
-        current_servers = servers
-        current_servers.delete(server_name)
-        reset(current_servers)
-        return server_name
-      end
+  # Turn an array of keys into a hash of keys to servers.
+  def inspect_keys(keys, server = nil)
+    Hash[*Array(keys).map do |key|
+      [key, server || server_by_key(key)]
+    end.flatten]
+  end
+
+  # Find which server failed most recently.
+  def detect_failure
+    time = Time.now
+    server = server_structs.detect do |server|
+      server.next_retry > time
     end
-    "(unknown)"
+    inspect_server(server) if server
   end
 
-  # Set the servers on the struct
+  # Set the servers on the struct.
   def set_servers(servers)
     Array(servers).each_with_index do |server, index|
       unless server.is_a? String and server =~ /^[\w\d\.-]+(:\d{1,5}){0,2}$/
@@ -399,14 +419,14 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
     @servers = send(:servers)
   end
 
-  # Set the behaviors on the struct from the current options
+  # Set the behaviors on the struct from the current options.
   def set_behaviors
     BEHAVIORS.keys.each do |behavior|
       set_behavior(behavior, options[behavior]) if options.key?(behavior)
     end
   end
 
-  # Set the callbacks on the struct from the current options
+  # Set the callbacks on the struct from the current options.
   def set_callbacks
     # Only support prefix_key for now
     if options[:prefix_key]
@@ -416,10 +436,10 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
       Lib.memcached_callback_set(@struct, Lib::MEMCACHED_CALLBACK_PREFIX_KEY, options[:prefix_key])
     end
   end
-  
-  # Stringify an opaque server struct
+
+  # Stringify an opaque server struct.
   def inspect_server(server)
-    "#{server.hostname}:#{server.port}#{":#{server.weight}" if options[:ketama_weighted]}"  
+    "#{server.hostname}:#{server.port}#{":#{server.weight}" if options[:ketama_weighted]}"
   end
 
 end

data/memcached.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "0.12"
+  s.version = "0.14"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]
   s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
-  s.date = %q{2008-12-02}
+  s.date = %q{2009-02-02}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]

data/test/unit/memcached_test.rb

@@ -72,7 +72,9 @@ class MemcachedTest < Test::Unit::TestCase
   def test_options_are_set
     Memcached::DEFAULTS.merge(@nb_options).each do |key, expected|
       value = @nb_cache.options[key]
-      assert(expected == value, "#{key} should be #{expected} but was #{value}")
+      unless key == :rcv_timeout or key == :poll_timeout
+        assert(expected == value, "#{key} should be #{expected} but was #{value}")
+      end
     end
   end
 
@@ -94,14 +96,14 @@ class MemcachedTest < Test::Unit::TestCase
     assert_raise(ArgumentError) { Memcached.new "local host:43043:1" }
   end
 
-  def test_initialize_with_resolvable_hosts
-    host = `hostname`.chomp
-    cache = Memcached.new ["#{host}:43042"]
-    assert_equal host, cache.send(:server_structs).first.hostname
-
-    cache.set(key, @value)
-    assert_equal @value, cache.get(key)
-  end
+#  def test_initialize_with_resolvable_hosts
+#    host = `hostname`.chomp
+#    cache = Memcached.new("#{host}:43042")
+#    assert_equal host, cache.send(:server_structs).first.hostname
+#
+#    cache.set(key, @value)
+#    assert_equal @value, cache.get(key)
+#  end
 
   def test_initialize_with_invalid_options
     assert_raise(ArgumentError) do
@@ -218,29 +220,53 @@ class MemcachedTest < Test::Unit::TestCase
 
   def test_get_with_server_timeout
     socket = stub_server 43047
-    cache = Memcached.new(
-      "localhost:43047:1",
-      :timeout => 0.5
-    )
+    cache = Memcached.new("localhost:43047:1", :timeout => 0.5)
     assert 0.49 < (Benchmark.measure do
       assert_raise(Memcached::UnknownReadFailure) do
         result = cache.get key
       end
     end).real
+
+    cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.001, :rcv_timeout => 0.5)
+    assert 0.49 < (Benchmark.measure do
+      assert_raise(Memcached::UnknownReadFailure) do
+        result = cache.get key
+      end
+    end).real
+
+    cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.25, :rcv_timeout => 0.25)
+    assert 0.4 > (Benchmark.measure do
+      assert_raise(Memcached::UnknownReadFailure) do
+        result = cache.get key
+      end
+    end).real
   end
 
   def test_get_with_no_block_server_timeout
     socket = stub_server 43048
-    cache = Memcached.new(
-      "localhost:43048:1",
-      :no_block => true,
-      :timeout => 0.25
-    )
+    cache = Memcached.new("localhost:43048:1", :no_block => true, :timeout => 0.25)
+    assert 0.24 < (Benchmark.measure do
+      assert_raise(Memcached::UnknownReadFailure) do
+        result = cache.get key
+      end
+    end).real
+
+    cache = Memcached.new("localhost:43048:1", :no_block => true, :poll_timeout => 0.25, :rcv_timeout => 0.001)
     assert 0.24 < (Benchmark.measure do
       assert_raise(Memcached::UnknownReadFailure) do
         result = cache.get key
       end
     end).real
+
+    cache = Memcached.new("localhost:43048:1", :no_block => true,
+      :poll_timeout => 0.001,
+      :rcv_timeout => 0.25 # No affect in no-block mode
+    )
+    assert 0.24 > (Benchmark.measure do
+      assert_raise(Memcached::UnknownReadFailure) do
+        result = cache.get key
+      end
+    end).real
   end
 
   def test_get_with_prefix_key
@@ -617,14 +643,14 @@ class MemcachedTest < Test::Unit::TestCase
 
   def test_key_too_long
     key = "x"*251
-    assert_raises(Memcached::ClientError) do
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
       @cache.set key, @value
     end
-    assert_raises(Memcached::ClientError) do
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
       @cache.get(key)
     end
 
-    assert_raises(Memcached::ClientError) do
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
       @cache.get([key])
     end
   end
@@ -727,12 +753,14 @@ class MemcachedTest < Test::Unit::TestCase
 
   # Server removal and consistent hashing
 
-  def test_dying_server
+  def test_missing_server
     socket = stub_server 43041  
     cache = Memcached.new(
       [@servers.last, 'localhost:43041'],
       :prefix_key => @prefix_key,
-      :failover => true,
+      :auto_eject_hosts => true,
+      :server_failure_limit => 1,
+      :retry_timeout => 1,
       :hash_with_prefix_key => false,
       :hash => :md5
     )
@@ -746,7 +774,15 @@ class MemcachedTest < Test::Unit::TestCase
     key2 = 'test_missing_server'
     assert_raise(Memcached::UnknownReadFailure) do
       cache.set(key2, @value)
+    end
+
+    # Hit second server again
+    key2 = 'test_missing_server'
+    begin
       cache.get(key2)
+    rescue => e
+      assert_equal Memcached::ServerIsMarkedDead, e.class
+      assert_match /localhost:43041/, e.message
     end
 
     # Hit first server on retry
@@ -754,13 +790,14 @@ class MemcachedTest < Test::Unit::TestCase
       cache.set(key2, @value)
       cache.get(key2)
     end
-  end
-
-  def test_sweep_servers_with_missing_server_first
-    cache = Memcached.new(['127.0.0.1:00000'] + @servers)
-    assert_nothing_raised do
-      cache.send(:sweep_servers)
-    end
+    
+    sleep(2)
+    
+    # Hit second server again after restore, expect same failure
+    key2 = 'test_missing_server'
+    assert_raise(Memcached::UnknownReadFailure) do
+      cache.set(key2, @value)
+    end        
   end
 
   def test_consistent_hashing
@@ -811,6 +848,13 @@ class MemcachedTest < Test::Unit::TestCase
     end
     threads.each {|thread| thread.join}
   end
+  
+  # Hash
+  
+  def test_hash
+    assert_equal 3157003241, 
+      Rlibmemcached.memcached_generate_hash_rvalue("test", Rlibmemcached::MEMCACHED_HASH_FNV1_32)
+  end  
 
   # Memory cleanup