memcached 0.19.2 → 0.19.3

data/CHANGELOG

@@ -1,3 +1,4 @@
+v0.19.3. Add exception_retry_limit and exceptions_to_retry.
 
 v0.19.2. Regenerate SWIG with better configuration options for Linux.
 

data/ext/extconf.rb

@@ -34,11 +34,11 @@ if !ENV["EXTERNAL_LIB"]
       raise "'#{cmd}' failed" unless system(cmd)
 
       puts "Patching libmemcached source."
-      puts(cmd = "patch -p1 < libmemcached.patch")
+      puts(cmd = "patch -p1 -Z < libmemcached.patch")
       raise "'#{cmd}' failed" unless system(cmd)
 
       puts "Patching libmemcached with SASL support."
-      puts(cmd = "patch -p1 < sasl.patch")
+      puts(cmd = "patch -p1 -Z < sasl.patch")
       raise "'#{cmd}' failed" unless system(cmd)
 
       Dir.chdir(BUNDLE_PATH) do        

data/lib/memcached/memcached.rb

@@ -31,7 +31,21 @@ class Memcached
     :verify_key => true,
     :use_udp => false,
     :binary_protocol => false,
-    :credentials => nil
+    :credentials => nil,
+    :exception_retry_limit => 5,
+    :exceptions_to_retry => [
+        Memcached::ServerIsMarkedDead,
+        Memcached::ATimeoutOccurred,
+        Memcached::ConnectionBindFailure,
+        Memcached::ConnectionFailure,
+        Memcached::ConnectionSocketCreateFailure,
+        Memcached::Failure,
+        Memcached::MemoryAllocationFailure,
+        Memcached::ReadFailure,
+        Memcached::ServerError,
+        Memcached::SystemError,
+        Memcached::UnknownReadFailure,
+        Memcached::WriteFailure]
   }
 
 #:stopdoc:
@@ -75,6 +89,8 @@ Valid option parameters are:
 <tt>:binary_protocol</tt>:: Use the binary protocol to reduce query processing overhead. Defaults to false.
 <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.
+<tt>:exception_retry_limit</tt>:: Retry this many times before raising the exception if the exception is in <tt>:exceptions_to_retry</tt>.
+<tt>:exceptions_to_retry</tt>:: Exceptions listed here will be retried <tt>:exception_retry_limit</tt> times before getting raised. 
 
 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.
 
@@ -231,6 +247,12 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
     self
   end
 
+  # Should retry the exception
+  def should_retry(e)
+    options[:exceptions_to_retry].each {|ex_class| return true if e.instance_of?(ex_class)}
+    false
+  end
+
   #:stopdoc:
   alias :dup :clone #:nodoc:
   #:startdoc:
@@ -282,23 +304,34 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
   #
   def set(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
     value = marshal ? Marshal.dump(value) : value.to_s
-    check_return_code(
-      Lib.memcached_set(@struct, key, value, ttl, flags),
-      key
-    )
-  rescue ClientError
-    # FIXME Memcached 1.2.8 occasionally rejects valid sets
-    tried = 1 and retry unless defined?(tried)
-    raise
+    begin
+      check_return_code(
+        Lib.memcached_set(@struct, key, value, ttl, flags),
+        key
+      )
+    rescue => e
+      tries ||= 0
+      retry if e.instance_of?(ClientError) && !tries
+      raise unless tries < options[:exception_retry_limit] && should_retry(e)
+      tries += 1
+      retry 
+    end
   end
 
   # Add a key/value pair. Raises <b>Memcached::NotStored</b> if the key already exists on the server. The parameters are the same as <tt>set</tt>.
   def add(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
     value = marshal ? Marshal.dump(value) : value.to_s
-    check_return_code(
-      Lib.memcached_add(@struct, key, value, ttl, flags),
-      key
-    )
+    begin
+      check_return_code(
+        Lib.memcached_add(@struct, key, value, ttl, flags),
+        key
+      )
+    rescue => e
+      tries ||= 0
+      raise unless tries < options[:exception_retry_limit] && should_retry(e)
+      tries += 1
+      retry 
+    end
   end
 
   # Increment a key's value. Accepts a String <tt>key</tt>. Raises <b>Memcached::NotFound</b> if the key does not exist.
@@ -310,6 +343,11 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
     ret, value = Lib.memcached_increment(@struct, key, offset)
     check_return_code(ret, key)
     value
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry 
   end
 
   # Decrement a key's value. The parameters and exception behavior are the same as <tt>increment</tt>.
@@ -317,6 +355,11 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
     ret, value = Lib.memcached_decrement(@struct, key, offset)
     check_return_code(ret, key)
     value
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry 
   end
 
   #:stopdoc:
@@ -327,10 +370,17 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
   # Replace a key/value pair. Raises <b>Memcached::NotFound</b> if the key does not exist on the server. The parameters are the same as <tt>set</tt>.
   def replace(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
     value = marshal ? Marshal.dump(value) : value.to_s
-    check_return_code(
-      Lib.memcached_replace(@struct, key, value, ttl, flags),
-      key
-    )
+    begin
+      check_return_code(
+         Lib.memcached_replace(@struct, key, value, ttl, flags),
+        key
+      )
+    rescue => e
+      tries ||= 0
+      raise unless tries < options[:exception_retry_limit] && should_retry(e)
+      tries += 1
+      retry 
+    end
   end
 
   # Appends a string to a key's value. Accepts a String <tt>key</tt> and a String <tt>value</tt>. Raises <b>Memcached::NotFound</b> if the key does not exist on the server.
@@ -342,6 +392,11 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
       Lib.memcached_append(@struct, key, value.to_s, IGNORED, IGNORED),
       key
     )
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry 
   end
 
   # Prepends a string to a key's value. The parameters and exception behavior are the same as <tt>append</tt>.
@@ -351,6 +406,11 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
       Lib.memcached_prepend(@struct, key, value.to_s, IGNORED, IGNORED),
       key
     )
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry 
   end
 
   # Reads a key's value from the server and yields it to a block. Replaces the key's value with the result of the block as long as the key hasn't been updated in the meantime, otherwise raises <b>Memcached::NotStored</b>. Accepts a String <tt>key</tt> and a block.
@@ -358,22 +418,37 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
   # Also accepts an optional <tt>ttl</tt> value.
   #
   # CAS stands for "compare and swap", and avoids the need for manual key mutexing. CAS support must be enabled in Memcached.new or a <b>Memcached::ClientError</b> will be raised. Note that CAS may be buggy in memcached itself.
-  #
+  # :retry_on_exceptions does not apply to this method
   def cas(key, ttl=@default_ttl, marshal=true, flags=FLAGS)
     raise ClientError, "CAS not enabled for this Memcached instance" unless options[:support_cas]
 
-    value, flags, ret = Lib.memcached_get_rvalue(@struct, key)
-    check_return_code(ret, key)
+    begin
+      value, flags, ret = Lib.memcached_get_rvalue(@struct, key)
+      check_return_code(ret, key)
+    rescue => e
+      tries_for_get ||= 0
+      raise unless tries_for_get < options[:exception_retry_limit] && should_retry(e)
+      tries_for_get += 1
+      retry 
+    end
+    
     cas = @struct.result.cas
 
     value = Marshal.load(value) if marshal
     value = yield value
     value = Marshal.dump(value) if marshal
 
-    check_return_code(
-      Lib.memcached_cas(@struct, key, value, ttl, flags, cas),
-      key
-    )
+    begin
+      check_return_code(
+        Lib.memcached_cas(@struct, key, value, ttl, flags, cas),
+        key
+      )
+    rescue => e
+      tries_for_cas ||= 0
+      raise unless tries_for_cas < options[:exception_retry_limit] && should_retry(e)
+      tries_for_cas += 1
+      retry 
+    end
   end
 
   alias :compare_and_swap :cas
@@ -386,6 +461,11 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
       Lib.memcached_delete(@struct, key, IGNORED),
       key
     )
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry 
   end
 
   # Flushes all key/value pairs from all the servers.
@@ -393,6 +473,11 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
     check_return_code(
       Lib.memcached_flush(@struct, IGNORED)
     )
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry 
   end
 
 ### Getters
@@ -428,6 +513,11 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
       check_return_code(ret, keys)
       marshal ? Marshal.load(value) : value
     end
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry 
   end
 
   ### Information methods

data/memcached.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "0.19.2"
+  s.version = "0.19.3"
 
   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{2010-03-23}
+  s.date = %q{2010-04-20}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]

data/test/unit/memcached_test.rb

@@ -23,6 +23,7 @@ class MemcachedTest < Test::Unit::TestCase
       :prefix_key => @prefix_key,
       :hash => :default,
       :distribution => :modula,
+      # binary_protocol does not work -- test_get, test_get, test_append, and test_missing_append will fail when it is set to true.
       :binary_protocol => true}
     @binary_protocol_cache = Memcached.new(@servers, @binary_protocol_options)
 
@@ -263,21 +264,21 @@ 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, :exception_retry_limit => 0)
     assert 0.49 < (Benchmark.measure do
       assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
 
-    cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.001, :rcv_timeout => 0.5)
+    cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.001, :rcv_timeout => 0.5, :exception_retry_limit => 0)
     assert 0.49 < (Benchmark.measure do
       assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
 
-    cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.25, :rcv_timeout => 0.25)
+    cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.25, :rcv_timeout => 0.25, :exception_retry_limit => 0)
     assert 0.51 > (Benchmark.measure do
       assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
@@ -289,14 +290,14 @@ class MemcachedTest < Test::Unit::TestCase
 
   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, :exception_retry_limit => 0)
     assert 0.24 < (Benchmark.measure do
       assert_raise(Memcached::ATimeoutOccurred) 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)
+    cache = Memcached.new("localhost:43048:1", :no_block => true, :poll_timeout => 0.25, :rcv_timeout => 0.001, :exception_retry_limit => 0)
     assert 0.24 < (Benchmark.measure do
       assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
@@ -305,7 +306,8 @@ class MemcachedTest < Test::Unit::TestCase
 
     cache = Memcached.new("localhost:43048:1", :no_block => true,
       :poll_timeout => 0.001,
-      :rcv_timeout => 0.25 # No affect in no-block mode
+      :rcv_timeout => 0.25, # No affect in no-block mode
+      :exception_retry_limit => 0
     )
     assert 0.24 > (Benchmark.measure do
       assert_raise(Memcached::ATimeoutOccurred) do
@@ -863,7 +865,8 @@ class MemcachedTest < Test::Unit::TestCase
       :server_failure_limit => 2,
       :retry_timeout => 1,
       :hash_with_prefix_key => false,
-      :hash => :md5
+      :hash => :md5,
+      :exception_retry_limit => 0
     )
 
     # Hit second server up to the server_failure_limit
@@ -897,6 +900,121 @@ class MemcachedTest < Test::Unit::TestCase
     socket.close
   end
 
+  def test_unresponsive_server_retries_greater_than_server_failure_limit
+    socket = stub_server 43041
+
+    cache = Memcached.new(
+      [@servers.last, 'localhost:43041'],
+      :prefix_key => @prefix_key,
+      :auto_eject_hosts => true,
+      :server_failure_limit => 2,
+      :retry_timeout => 1,
+      :hash_with_prefix_key => false,
+      :hash => :md5,
+      :exception_retry_limit => 3
+    )
+
+    key2 = 'test_missing_server'
+    assert_nothing_raised do
+      cache.set(key2, @value)
+      assert_equal cache.get(key2), @value
+    end
+
+    assert_nothing_raised do
+      cache.set(key2, @value)
+      assert_equal cache.get(key2), @value
+    end
+
+    sleep(2)
+
+    assert_nothing_raised do
+      cache.set(key2, @value)
+      assert_equal cache.get(key2), @value
+    end
+
+    socket.close
+  end
+
+  def test_unresponsive_server_retries_equals_server_failure_limit
+    socket = stub_server 43041
+
+    cache = Memcached.new(
+      [@servers.last, 'localhost:43041'],
+      :prefix_key => @prefix_key,
+      :auto_eject_hosts => true,
+      :server_failure_limit => 2,
+      :retry_timeout => 1,
+      :hash_with_prefix_key => false,
+      :hash => :md5,
+      :exception_retry_limit => 3
+    )
+
+    key2 = 'test_missing_server'
+    begin
+      cache.get(key2)
+    rescue => e
+      assert_equal Memcached::ServerIsMarkedDead, e.class
+      assert_match /localhost:43041/, e.message
+    end
+
+    assert_nothing_raised do
+      cache.set(key2, @value)
+      assert_equal cache.get(key2), @value
+    end
+
+    sleep(2)
+
+    begin
+      cache.get(key2)
+    rescue => e
+      assert_equal Memcached::ServerIsMarkedDead, e.class
+      assert_match /localhost:43041/, e.message
+    end
+
+    assert_nothing_raised do
+      cache.set(key2, @value)
+      assert_equal cache.get(key2), @value
+    end
+
+    socket.close
+  end
+
+  def test_unresponsive_server_retries_less_than_server_failure_limit
+    socket = stub_server 43041
+
+    cache = Memcached.new(
+      [@servers.last, 'localhost:43041'],
+      :prefix_key => @prefix_key,
+      :auto_eject_hosts => true,
+      :server_failure_limit => 2,
+      :retry_timeout => 1,
+      :hash_with_prefix_key => false,
+      :hash => :md5,
+      :exception_retry_limit => 1
+    )
+
+    key2 = 'test_missing_server'
+    assert_raise(Memcached::ATimeoutOccurred) { cache.set(key2, @value) }
+    begin
+      cache.get(key2)
+    rescue => e
+      assert_equal Memcached::ServerIsMarkedDead, e.class
+      assert_match /localhost:43041/, e.message
+    end
+
+    sleep(2)
+
+    assert_raise(Memcached::ATimeoutOccurred) { cache.set(key2, @value) }
+    begin
+      cache.get(key2)
+    rescue => e
+      assert_equal Memcached::ServerIsMarkedDead, e.class
+      assert_match /localhost:43041/, e.message
+    end
+
+    socket.close
+  end
+
   def test_missing_server
     cache = Memcached.new(
       [@servers.last, 'localhost:43041'],
@@ -905,7 +1023,8 @@ class MemcachedTest < Test::Unit::TestCase
       :server_failure_limit => 2,
       :retry_timeout => 1,
       :hash_with_prefix_key => false,
-      :hash => :md5
+      :hash => :md5,
+      :exception_retry_limit => 0
     )
 
     # Hit second server up to the server_failure_limit
@@ -946,7 +1065,8 @@ class MemcachedTest < Test::Unit::TestCase
       :auto_eject_hosts => true,
       :distribution => :random,
       :server_failure_limit => 1,
-      :retry_timeout => 1
+      :retry_timeout => 1,
+      :exception_retry_limit => 0 
     )
 
     # Provoke the errors in 'failures'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 19
-  - 2
-  version: 0.19.2
+  - 3
+  version: 0.19.3
 platform: ruby
 authors: 
 - Evan Weaver
@@ -35,7 +35,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2010-03-23 00:00:00 -07:00
+date: 2010-04-20 00:00:00 -07:00
 default_executable: 
 dependencies: []