memcache-client 1.1.0 → 1.2.0

data/History.txt

@@ -1,3 +1,16 @@
+= 1.2.0
+
+NOTE: This version will store keys in different places than previous
+versions!  Be prepared for some thrashing while memcached sorts itself
+out!
+
+* Fixed multithreaded operations, bug 5994 and 5989.
+  Thanks to Blaine Cook, Erik Hetzner, Elliot Smith, Dave Myron (and
+  possibly others I have forgotten).
+* Made memcached interoperable with other memcached libraries, bug
+  4509.  Thanks to anonymous.
+* Added get_multi to match Perl/etc APIs
+
 = 1.1.0
 
 * Added some tests

data/LICENSE.txt

@@ -1,5 +1,5 @@
-All original code copyright 2005 Bob Cottrell, The Robot Co-op.  All rights
-reserved.
+All original code copyright 2005, 2006 Bob Cottrell, Eric Hodel, The
+Robot Co-op.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
@@ -14,7 +14,7 @@ are met:
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 4. Redistribution in Rails or any sub-projects of Rails is not allowed
-   until Rails runs without warnings with the ``-W2'' flag enabled.
+   until Rails runs without warnings with the ``-w'' flag enabled.
 
 THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

data/Manifest.txt

@@ -5,4 +5,4 @@ README.txt
 Rakefile
 lib/memcache.rb
 lib/memcache_util.rb
-test/test_memcache.rb
+test/test_mem_cache.rb

data/README.txt

@@ -10,35 +10,37 @@ memcache-client is a fast memcached client.
 
 == Installing memcache-client
 
-Just install the gem
+Just install the gem:
 
   $ sudo gem install memcache-client
 
 == Using memcache-client
 
-  CACHE = MemCache.new :c_threshold => 10_000,
-                       :compression => true,
-                       :debug => false,
-                       :namespace => 'my_namespace',
-                       :readonly => false,
-                       :urlencode => false
-  CACHE.servers = 'localhost:11211'
+With one server:
 
-You can specify multiple servers by sending an Array of servers to #servers=.
+  CACHE = MemCache.new 'localhost:11211', :namespace => 'my_namespace'
+
+Or with multiple servers:
+
+  CACHE = MemCache.new %w[one.example.com:11211 two.example.com:11211],
+                       :namespace => 'my_namespace'
+
+See MemCache.new for details.
 
 === Using memcache-client with Rails
 
-Rails will automatically load the memcache-client gem, but you may wish to
-uninstall Ruby-memcache, I don't know which one it will pick by default.
+Rails will automatically load the memcache-client gem, but you may
+need to uninstall Ruby-memcache, I don't know which one it will pick
+by default.
 
 Add your environment-specific caches to config/environment/*.  If you run both
 development and production on the same machine be sure to use different
-namespaces.  Be careful when running tests under memcache, you may get strange
-results, it will be less of a headache to simply use a readonly memcache when
+namespaces.  Be careful when running tests using memcache, you may get strange
+results.  It will be less of a headache to simply use a readonly memcache when
 testing.
 
 memcache-client also comes with a wrapper called Cache in memcache_util.rb for
 use with Rails.  To use it be sure to assign your memcache connection to
 CACHE.  Cache returns nil on all memcache errors so you don't have to rescue
-yourself.  It has #get, #put and #delete module functions.
+the errors yourself.  It has #get, #put and #delete module functions.
 

data/Rakefile

@@ -4,15 +4,20 @@ require 'hoe'
 
 DEV_DOC_PATH = "Libraries/memcache-client"
 
-SPEC = Hoe.new 'memcache-client', '1.1.0' do |p|
+hoe = Hoe.new 'memcache-client', '1.2.0' do |p|
   p.summary = 'A Ruby memcached client'
   p.description = 'memcache-client is a pure-ruby client to Danga\'s memcached.'
-  p.author = 'Robert Cottrell'
+  p.author = ['Eric Hodel', 'Robert Cottrell']
   p.email = 'eric@robotcoop.com'
   p.url = "http://dev.robotcoop.com/#{DEV_DOC_PATH}"
 
   p.rubyforge_name = 'rctools'
 end
 
-require '../tasks'
+SPEC = hoe.spec
+
+begin
+  require '../tasks'
+rescue LoadError
+end
 

data/lib/memcache.rb

@@ -5,6 +5,31 @@ require 'thread'
 require 'timeout'
 require 'rubygems'
 
+class String
+
+  ##
+  # Uses the ITU-T polynomial in the CRC32 algorithm.
+
+  def crc32_ITU_T
+    n = length
+    r = 0xFFFFFFFF
+
+    n.times do |i|
+      r ^= self[i]
+      8.times do
+        if (r & 1) != 0 then
+          r = (r>>1) ^ 0xEDB88320
+        else
+          r >>= 1
+        end
+      end
+    end
+
+    r ^ 0xFFFFFFFF
+  end
+
+end
+
 ##
 # A Ruby client library for memcached.
 #
@@ -169,11 +194,22 @@ class MemCache
     raise new_err
   end
 
+  ##
+  # Retrieves +keys+ and returns a Hash mapping keys to values.
+
+  def get_multi(*keys)
+    values = {}
+    keys.flatten.each { |key| values[key] = get key }
+    values
+  end
+
   ##
   # Add +key+ to the cache with value +value+ that expires in +expiry+
   # seconds.
 
   def set(key, value, expiry = 0)
+    @mutex.lock if @multithread
+
     raise MemCacheError, "No active servers" unless self.active?
     raise MemCacheError, "Update of readonly cache" if @readonly
     cache_key = make_cache_key(key)
@@ -186,20 +222,22 @@ class MemCache
     command = "set #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n#{marshaled_value}\r\n"
 
     begin
-      @mutex.synchronize do
-        sock.write command
-        sock.gets
-      end
+      sock.write command
+      sock.gets
     rescue SystemCallError, IOError => err
       server.close
       raise MemCacheError, err.message
     end
+  ensure
+    @mutex.unlock if @multithread
   end
 
   ##
   # Removes +key+ from the cache in +expiry+ seconds.
 
   def delete(key, expiry = 0)
+    @mutex.lock if @multithread
+
     raise MemCacheError, "No active servers" unless active?
     cache_key = make_cache_key key
     server = get_server_for_key cache_key
@@ -208,14 +246,14 @@ class MemCache
     raise MemCacheError, "No connection to server" if sock.nil?
 
     begin
-      @mutex.synchronize do
-        sock.write "delete #{cache_key} #{expiry}\r\n"
-        sock.gets
-      end
+      sock.write "delete #{cache_key} #{expiry}\r\n"
+      sock.gets
     rescue SystemCallError, IOError => err
       server.close
       raise MemCacheError, err.message
     end
+  ensure
+    @mutex.unlock if @multithread
   end
 
   ##
@@ -261,18 +299,25 @@ class MemCache
     raise MemCacheError, "No servers available" if @servers.empty?
     return @servers.first if @servers.length == 1
 
-    # Hash the value of the key to select the bucket.
-    hkey = key.hash
+    hkey = hash_for key
 
-    # Fetch a server for the given key, retrying if that server is offline.
     20.times do |try|
-      server = @buckets[(hkey + try) % @buckets.nitems]
+      server = @buckets[hkey % @buckets.nitems]
       return server if server.alive?
+      hkey += hash_for "#{try}#{key}"
     end
 
     raise MemCacheError, "No servers available"
   end
 
+  ##
+  # Returns an interoperable hash value for +key+.  (I think, docs are
+  # sketchy for down servers).
+
+  def hash_for(key)
+    (key.crc32_ITU_T >> 16) & 0x7fff
+  end
+
   ##
   # Fetches the raw data for +cache_key+ from +server+.  Returns nil on cache
   # miss.
@@ -354,6 +399,7 @@ class MemCache
       @weight = weight.to_i
 
       @multithread = @memcache.multithread
+      @mutex = Mutex.new
 
       @sock   = nil
       @retry  = nil
@@ -398,7 +444,7 @@ class MemCache
         end
         @retry  = nil
         @status = 'CONNECTED'
-      rescue SystemCallError, IOError, Timeout::Error => err
+      rescue SocketError, SystemCallError, IOError, Timeout::Error => err
         mark_dead err.message
       end
 

data/test/{test_memcache.rb → test_mem_cache.rb}

@@ -55,7 +55,7 @@ class TestMemCache < Test::Unit::TestCase
   end
 
   def test_cache_get
-    server = util_setup_server
+    server = util_setup_fake_server
 
     assert_equal "\004\b\"\0170123456789",
                  @cache.cache_get(server, 'my_namespace:key')
@@ -76,6 +76,11 @@ class TestMemCache < Test::Unit::TestCase
                  socket.written.string
   end
 
+  def test_crc32_ITU_T
+    assert_equal 0, ''.crc32_ITU_T
+    assert_equal 1260851911, 'my_namespace:key'.crc32_ITU_T
+  end
+
   def test_initialize
     cache = MemCache.new :namespace => 'my_namespace', :readonly => true
 
@@ -124,7 +129,7 @@ class TestMemCache < Test::Unit::TestCase
   end
 
   def test_get
-    util_setup_server
+    util_setup_fake_server
 
     value = @cache.get 'key'
 
@@ -182,12 +187,36 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal 'No active servers', e.message
   end
 
+  def test_get_multi
+    util_setup_fake_server
+
+    values = @cache.get_multi 'keya', 'keyb'
+
+    assert_equal "get my_namespace:keya\r\nget my_namespace:keyb\r\n",
+                 @cache.servers.first.socket.written.string
+
+    expected = { 'keya' => '0123456789', 'keyb' => nil }
+    assert_equal expected, values
+  end
+
   def test_get_server_for_key
     server = @cache.get_server_for_key 'key'
     assert_equal 'localhost', server.host
     assert_equal 1, server.port
   end
 
+  def test_get_server_for_key_multiple
+    s1 = util_setup_server @cache, 'one.example.com', ''
+    s2 = util_setup_server @cache, 'two.example.com', ''
+    @cache.instance_variable_set :@servers, [s1, s2]
+    @cache.instance_variable_set :@buckets, [s1, s2]
+
+    server = @cache.get_server_for_key 'keya'
+    assert_equal 'two.example.com', server.host
+    server = @cache.get_server_for_key 'keyb'
+    assert_equal 'one.example.com', server.host
+  end
+
   def test_get_server_for_key_no_servers
     @cache.servers = []
 
@@ -204,7 +233,31 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal 'key', @cache.make_cache_key('key')
   end
 
-  def util_setup_server
+  def test_basic_threaded_operations_should_work
+    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]
+
+    assert_nothing_raised do
+      cache.set "test", "test value"
+    end
+  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]
+
+    assert_nothing_raised do
+      cache.set "test", "test value"
+    end
+  end
+ 
+  def util_setup_fake_server
     server = FakeServer.new
     server.socket.data.write "VALUE my_namepsace:key 0 14\r\n"
     server.socket.data.write "\004\b\"\0170123456789\r\n"
@@ -217,5 +270,15 @@ class TestMemCache < Test::Unit::TestCase
     return server
   end
 
+  def util_setup_server(memcache, host, responses)
+    server = MemCache::Server.new memcache, host
+    server.instance_variable_set :@sock, StringIO.new(responses)
+
+    @cache.servers = []
+    @cache.servers << server
+
+    return server
+  end
+
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.99
 specification_version: 1
 name: memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
-date: 2006-09-29 00:00:00 -07:00
+  version: 1.2.0
+date: 2006-10-17 00:00:00 -07:00
 summary: A Ruby memcached client
 require_paths: 
 - lib
@@ -28,6 +28,7 @@ signing_key:
 cert_chain: 
 post_install_message: 
 authors: 
+- Eric Hodel
 - Robert Cottrell
 files: 
 - History.txt
@@ -37,7 +38,7 @@ files:
 - Rakefile
 - lib/memcache.rb
 - lib/memcache_util.rb
-- test/test_memcache.rb
+- test/test_mem_cache.rb
 test_files: []
 
 rdoc_options: []
@@ -56,7 +57,7 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: 1.1.0
     version: