memcache-client 1.7.0 → 1.7.1

data/FAQ.rdoc

@@ -0,0 +1,24 @@
+= Memcache-client FAQ
+
+== Does memcache-client work with Ruby 1.9?
+
+Yes, Ruby 1.9 is supported.  The test suite should pass completely on 1.8.6 and 1.9.1.
+
+
+== I'm seeing "execution expired" or "time's up!" errors, what's that all about?
+
+memcache-client 1.6.x+ now has socket operations timed out by default.  This is to prevent
+the Ruby process from hanging if memcached or starling get into a bad state, which has been
+seen in production by both 37signals and FiveRuns.  The default timeout is 0.5 seconds, which
+should be more than enough time under normal circumstances.  It's possible to hit a storm of
+concurrent events which cause this timer to expire: a large Ruby VM can cause the GC to take
+a while, while also storing a large (500k-1MB value), for example.
+
+You can increase the timeout or disable them completely with the following configuration:
+
+  Rails:
+  config.cache_store = :mem_cache_store, 'server1', 'server2', { :timeout => nil } # no timeout
+
+  native:
+  MemCache.new ['server1', 'server2'], { :timeout => 1.0 } # 1 second timeout
+

data/History.rdoc

@@ -1,3 +1,17 @@
+= 1.7.1
+
+* Performance optimizations: 
+  * Rely on higher performance operating system socket timeouts for low-level socket 
+    read/writes where possible, instead of the (slower) SystemTimer or (slowest,
+    unreliable) Timeout libraries.
+  * the native binary search is back!  The recent performance tuning made the binary search 
+    a bottleneck again so it had to return.  It uses RubyInline to compile the native extension and 
+    silently falls back to pure Ruby if anything fails.  Make sure you run:
+    `gem install RubyInline` if you want ultimate performance.
+  * the changes make memcache-client 100% faster than 1.7.0 in my performance test on Ruby 1.8.6: 
+    15 sec -> 8 sec.
+* Fix several logging issues.
+
 = 1.7.0 (2009-03-08)
 
 * Go through the memcached protocol document and implement any commands not already implemented:

data/README.rdoc

@@ -1,6 +1,6 @@
 = memcache-client
 
-A pure ruby library for accessing memcached.
+A ruby library for accessing memcached.
 
 Source:
 
@@ -26,7 +26,8 @@ Or with multiple servers:
 == Tuning memcache-client
 
 The MemCache.new method takes a number of options which can be useful at times.  Please
-read the source comments there for an overview.
+read the source comments there for an overview.  If you are using Ruby 1.8.x and using
+multiple memcached servers, you should install the RubyInline gem for ultimate performance.
 
 
 == Using memcache-client with Rails
@@ -43,3 +44,7 @@ Eric Hodel and the seattle.rb crew.
 Email::        mailto:mperham@gmail.com
 Twitter::      mperham[http://twitter.com/mperham]
 WWW::          http://mikeperham.com
+
+If my work on memcache-client is something you support, please take a moment to
+recommend me at WWR[http://workingwithrails.com/person/10797-mike-perham].  I'm not
+asking for money, just a electronic "thumbs up".

data/lib/continuum_native.rb

@@ -0,0 +1,41 @@
+module Continuum
+
+  class << self
+
+    # Native extension to perform the binary search within the continuum
+    # space.  There's a pure ruby version in memcache.rb so this is purely
+    # optional for performance and only necessary if you are using multiple
+    # memcached servers.
+    begin
+      require 'inline'
+      inline do |builder|
+        builder.c <<-EOM
+        int binary_search(VALUE ary, unsigned int r) {
+            int upper = RARRAY_LEN(ary) - 1;
+            int lower = 0;
+            int idx = 0;
+            ID value = rb_intern("value");
+
+            while (lower <= upper) {
+                idx = (lower + upper) / 2;
+
+                VALUE continuumValue = rb_funcall(RARRAY_PTR(ary)[idx], value, 0);
+                unsigned int l = NUM2UINT(continuumValue);
+                if (l == r) {
+                    return idx;
+                }
+                else if (l > r) {
+                    upper = idx - 1;
+                }
+                else {
+                    lower = idx + 1;
+                }
+            }
+            return upper;
+        }
+        EOM
+      end
+    rescue Exception => e
+    end
+  end
+end

data/lib/memcache.rb

@@ -33,7 +33,7 @@ class MemCache
   ##
   # The version of MemCache you are using.
 
-  VERSION = '1.7.0'
+  VERSION = '1.7.1'
 
   ##
   # Default options for the cache object.
@@ -223,7 +223,7 @@ class MemCache
 
   def get(key, raw = false)
     with_server(key) do |server, cache_key|
-      logger.debug { "get #{key} from #{server.inspect}: #{value ? value.to_s.size : 'nil'}" } if logger
+      logger.debug { "get #{key} from #{server.inspect}" } if logger
       value = cache_get server, cache_key
       return nil if value.nil?
       value = Marshal.load value unless raw
@@ -333,12 +333,11 @@ class MemCache
     with_server(key) do |server, cache_key|
 
       value = Marshal.dump value unless raw
-      data = value.to_s
-      logger.debug { "set #{key} to #{server.inspect}: #{data.size}" } if logger
+      logger.debug { "set #{key} to #{server.inspect}: #{value.to_s.size}" } if logger
 
-      raise MemCacheError, "Value too large, memcached can only store 1MB of data per key" if data.size > ONE_MB
+      raise MemCacheError, "Value too large, memcached can only store 1MB of data per key" if value.to_s.size > ONE_MB
 
-      command = "set #{cache_key} 0 #{expiry} #{data.size}#{noreply}\r\n#{data}\r\n"
+      command = "set #{cache_key} 0 #{expiry} #{value.to_s.size}#{noreply}\r\n#{value}\r\n"
 
       with_socket_management(server) do |socket|
         socket.write command
@@ -380,11 +379,10 @@ class MemCache
     updated = yield value
 
     with_server(key) do |server, cache_key|
-      logger.debug { "cas #{key} to #{server.inspect}: #{data.size}" } if logger
 
       value = Marshal.dump updated unless raw
-      data = value.to_s
-      command = "cas #{cache_key} 0 #{expiry} #{value.size} #{token}#{noreply}\r\n#{value}\r\n"
+      logger.debug { "cas #{key} to #{server.inspect}: #{value.to_s.size}" } if logger
+      command = "cas #{cache_key} 0 #{expiry} #{value.to_s.size} #{token}#{noreply}\r\n#{value}\r\n"
 
       with_socket_management(server) do |socket|
         socket.write command
@@ -720,7 +718,7 @@ class MemCache
 
   def gets(key, raw = false)
     with_server(key) do |server, cache_key|
-      logger.debug { "gets #{key} from #{server.inspect}: #{value ? value.to_s.size : 'nil'}" } if logger
+      logger.debug { "gets #{key} from #{server.inspect}" } if logger
       result = with_socket_management(server) do |socket|
         socket.write "gets #{cache_key}\r\n"
         keyline = socket.gets # "VALUE <key> <flags> <bytes> <cas token>\r\n"
@@ -822,7 +820,7 @@ class MemCache
 
       block.call(socket)
 
-    rescue SocketError, Timeout::Error => err
+    rescue SocketError, Errno::EAGAIN, Timeout::Error => err
       logger.warn { "Socket failure: #{err.message}" } if logger
       server.mark_dead(err)
       handle_error(server, err)
@@ -921,13 +919,6 @@ class MemCache
 
   class Server
 
-    ##
-    # The amount of time to wait to establish a connection with a memcached
-    # server.  If a connection cannot be established within this time limit,
-    # the server will be marked as down.
-
-    CONNECT_TIMEOUT = 0.25
-
     ##
     # The amount of time to wait before attempting to re-establish a
     # connection with a server that is marked dead.
@@ -1011,14 +1002,11 @@ class MemCache
 
       # Attempt to connect if not already connected.
       begin
-        @sock = @timeout ? TCPTimeoutSocket.new(@host, @port, @timeout) : TCPSocket.new(@host, @port)
-
-        if Socket.constants.include? 'TCP_NODELAY' then
-          @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-        end
+        @sock = connect_to(@host, @port, @timeout)
+        @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
         @retry  = nil
         @status = 'CONNECTED'
-      rescue SocketError, SystemCallError, IOError, Timeout::Error => err
+      rescue SocketError, SystemCallError, IOError => err
         logger.warn { "Unable to open socket: #{err.class.name}, #{err.message}" } if logger
         mark_dead err
       end
@@ -1026,6 +1014,33 @@ class MemCache
       return @sock
     end
 
+    def connect_to(host, port, timeout=nil)
+      addr = Socket.getaddrinfo(host, nil)
+      sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+
+      if timeout
+        secs = Integer(timeout)
+        usecs = Integer((timeout - secs) * 1_000_000)
+        optval = [secs, usecs].pack("l_2")
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+
+        # Socket timeouts don't work for more complex IO operations
+        # like gets which lay on top of read.  We need to fall back to
+        # the standard Timeout mechanism.
+        sock.instance_eval <<-EOR
+          alias :blocking_gets :gets
+          def gets
+            MemCacheTimer.timeout(#{timeout}) do
+              self.blocking_gets
+            end
+          end
+        EOR
+      end
+      sock.connect(Socket.pack_sockaddr_in(port, addr[0][3]))
+      sock
+    end
+
     ##
     # Close the connection to the memcached server targeted by this
     # object.  The server is not considered dead.
@@ -1059,51 +1074,6 @@ class MemCache
 
 end
 
-# TCPSocket facade class which implements timeouts.
-class TCPTimeoutSocket
-  
-  def initialize(host, port, timeout)
-    MemCacheTimer.timeout(MemCache::Server::CONNECT_TIMEOUT) do
-      @sock = TCPSocket.new(host, port)
-      @len = timeout
-    end
-  end
-  
-  def write(*args)
-    MemCacheTimer.timeout(@len) do
-      @sock.write(*args)
-    end
-  end
-  
-  def gets(*args)
-    MemCacheTimer.timeout(@len) do
-      @sock.gets(*args)
-    end
-  end
-  
-  def read(*args)
-    MemCacheTimer.timeout(@len) do
-      @sock.read(*args)
-    end
-  end
-  
-  def _socket
-    @sock
-  end
-  
-  def method_missing(meth, *args)
-    @sock.__send__(meth, *args)
-  end
-  
-  def closed?
-    @sock.closed?
-  end
-  
-  def close
-    @sock.close
-  end
-end
-
 module Continuum
   POINTS_PER_SERVER = 160 # this is the default in libmemcached
 
@@ -1142,3 +1112,4 @@ module Continuum
     end
   end
 end
+require 'continuum_native'

data/test/test_mem_cache.rb

@@ -1076,7 +1076,8 @@ class TestMemCache < Test::Unit::TestCase
   def test_crazy_multithreaded_access
     requirement(memcached_running?, 'A real memcached server must be running for performance testing') do
 
-      cache = MemCache.new(['localhost:11211', '127.0.0.1:11211'])
+      # Use a null logger to verify logging doesn't blow up at runtime
+      cache = MemCache.new(['localhost:11211', '127.0.0.1:11211'], :logger => Logger.new('/dev/null'))
       cache.flush_all
       workers = []
 
@@ -1111,9 +1112,9 @@ class TestMemCache < Test::Unit::TestCase
             assert cache.decr('c', 5) > 14
             assert_equal 11, cache.get('b')
             d = cache.get('d', true)
-            assert_match /\Aab+\Z/, d
+            assert_match /\Aab*\Z/, d
             e = cache.get('e', true)
-            assert_match /\Ay+x\Z/, e
+            assert_match /\Ay*x\Z/, e
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors: 
 - Eric Hodel
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-07 23:00:00 -06:00
+date: 2009-03-28 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -24,11 +24,13 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- FAQ.rdoc
 - README.rdoc
 - LICENSE.txt
 - History.rdoc
 - Rakefile
 - lib/memcache.rb
+- lib/continuum_native.rb
 has_rdoc: false
 homepage: http://github.com/mperham/memcache-client
 post_install_message: