fiveruns-memcache-client 1.5.0.3 → 1.5.0.4

data/History.txt

@@ -1,3 +1,11 @@
+= 1.5.0.4
+
+* Get test suite working again (packagethief)
+* Ruby 1.9 compatiblity fixes (packagethief, mperham)
+* Consistently return server responses and check for errors (packagethief)
+* Properly calculate CRC in Ruby 1.9 strings (mperham)
+* Drop rspec in favor of test/unit, for 1.9 compat (mperham)
+
 = 1.5.0.3 (FiveRuns fork)
 
 * Integrated ITU-T CRC32 operation in native C extension for speed.  Thanks to Justin Balthrop!

data/Rakefile

@@ -1,7 +1,7 @@
 # vim: syntax=Ruby
 require 'rubygems'
 require 'rake/rdoctask'
-require 'spec/rake/spectask'
+require 'rake/testtask'
 
 task :gem do
 	sh "gem build memcache-client.gemspec"
@@ -11,14 +11,12 @@ task :install => [:gem] do
 	sh "sudo gem install memcache-client-*.gem"
 end
 
-Spec::Rake::SpecTask.new do |t|
-	t.ruby_opts = ['-rtest/unit']
-	t.spec_files = FileList['test/test_*.rb']
-	t.fail_on_error = true
-end
-  
 Rake::RDocTask.new do |rd|
 	rd.main = "README.rdoc"
 	rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
 	rd.rdoc_dir = 'doc'
 end
+
+Rake::TestTask.new
+
+task :default => :test

data/ext/crc32/crc32.c

@@ -3,8 +3,18 @@
 
 static VALUE t_itu_t(VALUE self, VALUE string) {
   VALUE str = StringValue(string);
+#ifdef RSTRING_LEN
+  int   n = RSTRING_LEN(str);
+#else
   int   n = RSTRING(str)->len;
+#endif
+
+#ifdef RSTRING_PTR
+  char* p = RSTRING_PTR(str);
+#else
   char* p = RSTRING(str)->ptr;
+#endif
+
   unsigned long r = 0xFFFFFFFF;
   int i, j;
 

data/lib/memcache.rb

@@ -18,11 +18,10 @@ class String
     puts "Loading with slow CRC32 ITU-T implementation: #{e.message}"
     
     def crc32_ITU_T
-      n = length
       r = 0xFFFFFFFF
 
-      n.times do |i|
-        r ^= self[i]
+      each_byte do |i|
+        r ^= i
         8.times do
           if (r & 1) != 0 then
             r = (r>>1) ^ 0xEDB88320
@@ -100,7 +99,7 @@ class MemCache
   # Valid options for +opts+ are:
   #
   #   [:namespace]   Prepends this value to all keys added or retrieved.
-  #   [:readonly]    Raises an exeception on cache writes when true.
+  #   [:readonly]    Raises an exception on cache writes when true.
   #   [:multithread] Wraps cache access in a Mutex for thread safety.
   #
   # Other options are ignored.
@@ -163,7 +162,7 @@ class MemCache
 
   def servers=(servers)
     # Create the server objects.
-    @servers = servers.collect do |server|
+    @servers = Array(servers).collect do |server|
       case server
       when String
         host, port, weight = server.split ':', 3
@@ -198,7 +197,7 @@ class MemCache
       cache_decr server, cache_key, amount
     end
   rescue TypeError => err
-    handle_error server, err
+    handle_error nil, err
   end
 
   ##
@@ -213,7 +212,7 @@ class MemCache
       return value
     end
   rescue TypeError => err
-    handle_error server, err
+    handle_error nil, err
   end
 
   ##
@@ -249,17 +248,17 @@ class MemCache
 
     results = {}
 
-    server_keys.each do |server, keys|
-      keys = keys.join ' '
-      values = cache_get_multi server, keys
+    server_keys.each do |server, keys_for_server|
+      keys_for_server = keys_for_server.join ' '
+      values = cache_get_multi server, keys_for_server
       values.each do |key, value|
         results[cache_keys[key]] = Marshal.load value
       end
     end
 
     return results
-  rescue TypeError => err
-    handle_error server, err
+  rescue TypeError, IndexError => err
+    handle_error nil, err
   end
 
   ##
@@ -273,9 +272,9 @@ class MemCache
       cache_incr server, cache_key, amount
     end
   rescue TypeError => err
-    handle_error server, err
+    handle_error nil, err
   end
-  
+
   ##
   # Add +key+ to the cache with value +value+ that expires in +expiry+
   # seconds.  If +raw+ is true, +value+ will not be Marshalled.
@@ -293,15 +292,14 @@ class MemCache
       with_socket_management(server) do |socket|
         socket.write command
         result = socket.gets
-  			if result.nil?
+        raise_on_error_response! result
+
+        if result.nil?
           server.close
           raise MemCacheError, "lost connection to #{server.host}:#{server.port}"
         end
 
-  			if result =~ /^SERVER_ERROR (.*)/
-          server.close
-          raise MemCacheError, $1.strip
-  			end
+        result
       end
     end
   end
@@ -322,21 +320,25 @@ class MemCache
 
       with_socket_management(server) do |socket|
         socket.write command
-        socket.gets
+        result = socket.gets
+        raise_on_error_response! result
+        result
       end
     end
   end
-  
+
   ##
   # Removes +key+ from the cache in +expiry+ seconds.
 
   def delete(key, expiry = 0)
     raise MemCacheError, "Update of readonly cache" if @readonly
-    server, cache_key = request_setup key
-
-    with_socket_management(server) do |socket|
-      socket.write "delete #{cache_key} #{expiry}\r\n"
-      socket.gets
+    with_server(key) do |server, cache_key|
+      with_socket_management(server) do |socket|
+        socket.write "delete #{cache_key} #{expiry}\r\n"
+        result = socket.gets
+        raise_on_error_response! result
+        result
+      end
     end
   end
 
@@ -346,15 +348,19 @@ class MemCache
   def flush_all
     raise MemCacheError, 'No active servers' unless active?
     raise MemCacheError, "Update of readonly cache" if @readonly
+
     begin
       @mutex.lock if @multithread
       @servers.each do |server|
         with_socket_management(server) do |socket|
           socket.write "flush_all\r\n"
           result = socket.gets
-          raise MemCacheError, $2.strip if result =~ /^(SERVER_)?ERROR(.*)/
+          raise_on_error_response! result
+          result
         end
       end
+    rescue IndexError => err
+      handle_error nil, err
     ensure
       @mutex.unlock if @multithread
     end
@@ -407,13 +413,15 @@ class MemCache
 
     @servers.each do |server|
       next unless server.alive?
+
       with_socket_management(server) do |socket|
-        value = nil # TODO: why is this line here?
+        value = nil
         socket.write "stats\r\n"
         stats = {}
         while line = socket.gets do
+          raise_on_error_response! line
           break if line == "END\r\n"
-          if line =~ /^STAT ([\w]+) ([\w\.\:]+)/ then
+          if line =~ /\ASTAT ([\w]+) ([\w\.\:]+)/ then
             name, value = $1, $2
             stats[name] = case name
                           when 'version'
@@ -423,7 +431,7 @@ class MemCache
                             microseconds ||= 0
                             Float(seconds) + (Float(microseconds) / 1_000_000)
                           else
-                            if value =~ /^\d+$/ then
+                            if value =~ /\A\d+\Z/ then
                               value.to_i
                             else
                               value
@@ -435,6 +443,7 @@ class MemCache
       end
     end
 
+    raise MemCacheError, "No active servers" if server_stats.empty?
     server_stats
   end
 
@@ -478,7 +487,7 @@ class MemCache
     hkey = hash_for key
 
     20.times do |try|
-      server = @buckets[hkey % @buckets.nitems]
+      server = @buckets[hkey % @buckets.compact.size]
       return server if server.alive?
       hkey += hash_for "#{try}#{key}"
     end
@@ -502,6 +511,7 @@ class MemCache
     with_socket_management(server) do |socket|
       socket.write "decr #{cache_key} #{amount}\r\n"
       text = socket.gets
+      raise_on_error_response! text
       return nil if text == "NOT_FOUND\r\n"
       return text.to_i
     end
@@ -518,9 +528,10 @@ class MemCache
 
       if keyline.nil? then
         server.close
-        raise MemCacheError, "lost connection to #{server.host}:#{server.port}" # TODO: retry here too
+        raise MemCacheError, "lost connection to #{server.host}:#{server.port}"
       end
 
+      raise_on_error_response! keyline
       return nil if keyline == "END\r\n"
 
       unless keyline =~ /(\d+)\r/ then
@@ -544,8 +555,9 @@ class MemCache
 
       while keyline = socket.gets do
         return values if keyline == "END\r\n"
+        raise_on_error_response! keyline
 
-        unless keyline =~ /^VALUE (.+) (.+) (.+)/ then
+        unless keyline =~ /\AVALUE (.+) (.+) (.+)/ then
           server.close
           raise MemCacheError, "unexpected response #{keyline.inspect}"
         end
@@ -568,31 +580,36 @@ class MemCache
     with_socket_management(server) do |socket|
       socket.write "incr #{cache_key} #{amount}\r\n"
       text = socket.gets
+      raise_on_error_response! text
       return nil if text == "NOT_FOUND\r\n"
       return text.to_i
     end
   end
-  
+
   ##
   # Gets or creates a socket connected to the given server, and yields it
-  # to the block.  If a socket error (SocketError, SystemCallError, IOError) 
-  # or protocol error (MemCacheError) is raised by the block, closes the
-  # socket, attempts to connect again, and retries the block (once).  If
-  # an error is again raised, reraises it as MemCacheError.
+  # to the block, wrapped in a mutex synchronization if @multithread is true.
+  #
+  # If a socket error (SocketError, SystemCallError, IOError) or protocol error
+  # (MemCacheError) is raised by the block, closes the socket, attempts to
+  # connect again, and retries the block (once).  If an error is again raised,
+  # reraises it as MemCacheError.
+  #
   # If unable to connect to the server (or if in the reconnect wait period),
-  # raises MemCacheError - note that the socket connect code marks a server
+  # raises MemCacheError.  Note that the socket connect code marks a server
   # dead for a timeout period, so retrying does not apply to connection attempt
-  # failures (but does still apply to unexpectedly lost connections etc.).  
-  # Wraps the whole lot in mutex synchronization if @multithread is true.
+  # failures (but does still apply to unexpectedly lost connections etc.).
 
   def with_socket_management(server, &block)
     @mutex.lock if @multithread
     retried = false
     begin
       socket = server.socket
-      # Raise an IndexError to show this server is out of whack.
-      # We'll catch it in higher-level code and attempt to restart the operation.
+
+      # Raise an IndexError to show this server is out of whack. If were inside
+      # a with_server block, we'll catch it and attempt to restart the operation.
       raise IndexError, "No connection to server (#{server.status})" if socket.nil?
+
       block.call(socket)
     rescue MemCacheError, SocketError, SystemCallError, IOError => err
       handle_error(server, err) if retried || socket.nil?
@@ -610,7 +627,7 @@ class MemCache
       yield server, cache_key
     rescue IndexError => e
       if !retried && @servers.size > 1
-        puts "Connection to server #{server.inspect} DIED!  Retrying operation..."
+        puts "Connection to server #{server.inspect} DIED! Retrying operation..."
         retried = true
         retry
       end
@@ -640,6 +657,12 @@ class MemCache
     return server, cache_key
   end
 
+  def raise_on_error_response!(response)
+    if response =~ /\A(?:CLIENT_|SERVER_)?ERROR(.*)/
+      raise MemCacheError, $1.strip
+    end
+  end
+
   ##
   # This class represents a memcached server instance.
 

data/test/test_mem_cache.rb

@@ -1,11 +1,10 @@
+# encoding: utf-8
 require 'stringio'
 require 'test/unit'
-require 'rubygems'
-require 'test/zentest_assertions'
 
 $TESTING = true
 
-require 'memcache'
+require File.dirname(__FILE__) + '/../lib/memcache'
 
 class MemCache
 
@@ -86,7 +85,9 @@ class TestMemCache < Test::Unit::TestCase
 
   def test_cache_get_bad_state
     server = FakeServer.new
-    server.socket.data.write "bogus response\r\n"
+
+    # Write two messages to the socket to test failover
+    server.socket.data.write "bogus response\r\nbogus response\r\n"
     server.socket.data.rewind
 
     @cache.servers = []
@@ -96,12 +97,11 @@ class TestMemCache < Test::Unit::TestCase
       @cache.cache_get(server, 'my_namespace:key')
     end
 
-    assert_equal "unexpected response \"bogus response\\r\\n\"", e.message
+    assert_match /#{Regexp.quote 'unexpected response "bogus response\r\n"'}/, e.message
 
-    deny server.alive?
+    assert !server.alive?
 
-    assert_equal "get my_namespace:key\r\n",
-                 server.socket.written.string
+    assert_match /get my_namespace:key\r\n/, server.socket.written.string
   end
 
   def test_cache_get_miss
@@ -145,7 +145,9 @@ class TestMemCache < Test::Unit::TestCase
 
   def test_cache_get_multi_bad_state
     server = FakeServer.new
-    server.socket.data.write "bogus response\r\n"
+
+    # Write two messages to the socket to test failover
+    server.socket.data.write "bogus response\r\nbogus response\r\n"
     server.socket.data.rewind
 
     @cache.servers = []
@@ -155,17 +157,22 @@ class TestMemCache < Test::Unit::TestCase
       @cache.cache_get_multi server, 'my_namespace:key'
     end
 
-    assert_equal "unexpected response \"bogus response\\r\\n\"", e.message
+    assert_match /#{Regexp.quote 'unexpected response "bogus response\r\n"'}/, e.message
 
-    deny server.alive?
+    assert !server.alive?
 
-    assert_equal "get my_namespace:key\r\n",
-                 server.socket.written.string
+    assert_match /get my_namespace:key\r\n/, server.socket.written.string
   end
 
   def test_crc32_ITU_T
     assert_equal 0, ''.crc32_ITU_T
-    assert_equal 1260851911, 'my_namespace:key'.crc32_ITU_T
+    # First value is the fast C version, last value is the pure Ruby version
+    assert_in [-886631737, 1260851911], 'my_namespace:key'.crc32_ITU_T
+    assert_in [-224284233, 870540390], 'my_name√space:key'.crc32_ITU_T
+  end
+  
+  def assert_in(possible_values, value)
+    assert possible_values.include?(value), "#{possible_values.inspect} should contain #{value}"
   end
 
   def test_initialize
@@ -216,7 +223,7 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal 'my_namespace', cache.namespace
     assert_equal true, cache.readonly?
     assert_equal false, cache.servers.empty?
-    deny_empty cache.instance_variable_get(:@buckets)
+    assert !cache.instance_variable_get(:@buckets).empty?
   end
 
   def test_initialize_too_many_args
@@ -503,7 +510,9 @@ class TestMemCache < Test::Unit::TestCase
 
     @cache.set 'key', 'value'
 
-    expected = "set my_namespace:key 0 0 9\r\n\004\b\"\nvalue\r\n"
+    dumped = Marshal.dump('value')
+    expected = "set my_namespace:key 0 0 #{dumped.length}\r\n#{dumped}\r\n"
+#    expected = "set my_namespace:key 0 0 9\r\n\004\b\"\nvalue\r\n"
     assert_equal expected, server.socket.written.string
   end
 
@@ -516,7 +525,8 @@ class TestMemCache < Test::Unit::TestCase
 
     @cache.set 'key', 'value', 5
 
-    expected = "set my_namespace:key 0 5 9\r\n\004\b\"\nvalue\r\n"
+    dumped = Marshal.dump('value')
+    expected = "set my_namespace:key 0 5 #{dumped.length}\r\n#{dumped}\r\n"
     assert_equal expected, server.socket.written.string
   end
 
@@ -545,8 +555,11 @@ class TestMemCache < Test::Unit::TestCase
 
   def test_set_too_big
     server = FakeServer.new
-    server.socket.data.write "SERVER_ERROR object too large for cache\r\n"
+
+    # Write two messages to the socket to test failover
+    server.socket.data.write "SERVER_ERROR\r\nSERVER_ERROR object too large for cache\r\n"
     server.socket.data.rewind
+
     @cache.servers = []
     @cache.servers << server
 
@@ -554,7 +567,7 @@ class TestMemCache < Test::Unit::TestCase
       @cache.set 'key', 'v'
     end
 
-    assert_equal 'object too large for cache', e.message
+    assert_match /object too large for cache/, e.message
   end
 
   def test_add
@@ -565,8 +578,10 @@ class TestMemCache < Test::Unit::TestCase
     @cache.servers << server
 
     @cache.add 'key', 'value'
+    
+    dumped = Marshal.dump('value')
 
-    expected = "add my_namespace:key 0 0 9\r\n\004\b\"\nvalue\r\n"
+    expected = "add my_namespace:key 0 0 #{dumped.length}\r\n#{dumped}\r\n"
     assert_equal expected, server.socket.written.string
   end
 
@@ -579,7 +594,8 @@ class TestMemCache < Test::Unit::TestCase
 
     @cache.add 'key', 'value'
 
-    expected = "add my_namespace:key 0 0 9\r\n\004\b\"\nvalue\r\n"
+    dumped = Marshal.dump('value')
+    expected = "add my_namespace:key 0 0 #{dumped.length}\r\n#{dumped}\r\n"
     assert_equal expected, server.socket.written.string
   end
 
@@ -592,7 +608,8 @@ class TestMemCache < Test::Unit::TestCase
 
     @cache.add 'key', 'value', 5
 
-    expected = "add my_namespace:key 0 5 9\r\n\004\b\"\nvalue\r\n"
+    dumped = Marshal.dump('value')
+    expected = "add my_namespace:key 0 5 #{dumped.length}\r\n#{dumped}\r\n"
     assert_equal expected, server.socket.written.string
   end
 
@@ -655,11 +672,12 @@ class TestMemCache < Test::Unit::TestCase
 
   def test_flush_all_failure
     socket = FakeSocket.new
-    socket.data.write "ERROR\r\n"
+
+    # Write two messages to the socket to test failover
+    socket.data.write "ERROR\r\nERROR\r\n"
     socket.data.rewind
+
     server = FakeServer.new socket
-    def server.host() "localhost"; end
-    def server.port() 11211; end
 
     @cache.servers = []
     @cache.servers << server
@@ -668,7 +686,7 @@ class TestMemCache < Test::Unit::TestCase
       @cache.flush_all
     end
 
-    assert_equal "flush_all\r\n", socket.written.string
+    assert_match /flush_all\r\n/, socket.written.string
   end
 
   def test_stats
@@ -697,24 +715,44 @@ class TestMemCache < Test::Unit::TestCase
     cache = MemCache.new :multithread => true,
                          :namespace => 'my_namespace',
                          :readonly => false
-    server = util_setup_server cache, 'example.com', "OK\r\n"
-    cache.instance_variable_set :@servers, [server]
+
+    server = FakeServer.new
+    server.socket.data.write "STORED\r\n"
+    server.socket.data.rewind
+
+    cache.servers = []
+    cache.servers << server
+
+    assert cache.multithread
 
     assert_nothing_raised do
       cache.set "test", "test value"
     end
+
+    # TODO Fails in 1.9
+    assert_match /set my_namespace:test.*\r\n.*test value.*\r\n/, server.socket.written.string
   end
 
   def test_basic_unthreaded_operations_should_work
     cache = MemCache.new :multithread => false,
                          :namespace => 'my_namespace',
                          :readonly => false
-    server = util_setup_server cache, 'example.com', "OK\r\n"
-    cache.instance_variable_set :@servers, [server]
+
+    server = FakeServer.new
+    server.socket.data.write "STORED\r\n"
+    server.socket.data.rewind
+
+    cache.servers = []
+    cache.servers << server
+
+    assert !cache.multithread
 
     assert_nothing_raised do
       cache.set "test", "test value"
     end
+
+    # TODO Fails in 1.9
+    assert_match /set my_namespace:test.*\r\n.*test value\r\n/, server.socket.written.string
   end
 
   def util_setup_fake_server

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fiveruns-memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.5.0.3
+  version: 1.5.0.4
 platform: ruby
 authors: 
 - Eric Hodel
@@ -11,12 +11,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-06 00:00:00 -07:00
+date: 2008-10-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
 description: A Ruby-based memcached client library
-email: mike@fiveruns.com
+email: mperham@gmail.com
 executables: []
 
 extensions: