mperham-memcache-client 1.6.0 → 1.6.1

data/History.txt

@@ -1,21 +1,37 @@
-= 1.6.0
+= 1.6.2 (upcoming)
 
-* First official release since 1.5.0.  Thanks to Eric Hodel for turning the project to me!
+* First official release since 1.5.0.  Thanks to Eric Hodel for turning over the project to me!
+  New project home page: http://github.com/mperham/memcache-client
 
-* Implement socket timeouts, should fix rare cases of very bad things happening
-  in production at 37signals and FiveRuns. (jseirles)
+= 1.6.1 (2009-01-28)
+
+* Add option to disable socket timeout support.  Socket timeout has a significant performance 
+  penalty (approx 3x slower than without in Ruby 1.8.6).  You can turn off the timeouts if you 
+  need absolute performance, but by default timeouts are enabled. The performance
+  penalty is much lower in Ruby 1.8.7, 1.9 and JRuby.  (mperham)
+
+* Add option to disable server failover.  Failover can lead to "split-brain" caches that 
+  return stale data. (mperham)
 
-* New project home page: http://github.com/mperham/memcache-client
+* Implement continuum binary search in native code for performance reasons.  Pure ruby
+  is available for platforms like JRuby or Rubinius which can't use C extensions. (mperham)
+  
+* Fix #add with raw=true (iamaleksey)
+
+= 1.6.0
 
 * Implement a consistent hashing algorithm, as described in libketama.
   This dramatically reduces the cost of adding or removing servers dynamically
   as keys are much more likely to map to the same server.
 
-  Take a scenario where we add a fourth server.  With a dumb modulo algorithm, about
+  Take a scenario where we add a fourth server.  With a naive modulo algorithm, about
   25% of the keys will map to the same server.  In other words, 75% of your memcached
   content suddenly becomes invalid.  With a consistent algorithm, 75% of the keys
   will map to the same server as before - only 25% will be invalidated. (mperham)
 
+* Implement socket timeouts, should fix rare cases of very bad things happening
+  in production at 37signals and FiveRuns.  (jseirles)
+
 = 1.5.0.5
 
 * Remove native C CRC32_ITU_T extension in favor of Zlib's crc32 method.

data/README.rdoc

@@ -0,0 +1,43 @@
+= memcache-client
+
+A pure ruby library for accessing memcached.
+
+Source:
+
+http://github.com/mperham/memcache-client
+
+== Installing memcache-client
+
+Just install the gem:
+
+  $ sudo gem install memcache-client
+
+== Using memcache-client
+
+With one server:
+
+  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.  Please note memcache-client is not thread-safe
+by default.  You should create a separate instance for each thread in your
+process.
+
+== Using memcache-client with Rails
+
+There's no need to use memcache-client in a Rails application.  Rails 2.1+ includes
+a basic caching library which can be used with memcached.  See ActiveSupport::Cache::Store
+for more details.
+
+== Questions?
+
+memcache-client is maintained by Mike Perham and was originally written by Bob Cottrell, 
+Eric Hodel and the seattle.rb crew.
+
+Email::        mailto:mperham@gmail.com
+Twitter::      mperham[http://twitter.com/mperham]
+WWW::          http://mikeperham.com

data/Rakefile

@@ -20,3 +20,7 @@ end
 Rake::TestTask.new
 
 task :default => :test
+
+task :rcov do
+  `rcov -Ilib test/*.rb`
+end

data/ext/memcache/binary_search.c

@@ -0,0 +1,54 @@
+#include "ruby.h"
+#include "stdio.h"
+
+/*
+def binary_search(ary, value)
+  upper = ary.size - 1
+  lower = 0
+  idx = 0
+
+  while(lower <= upper) do
+    idx = (lower + upper) / 2
+    comp = ary[idx].value <=> value
+
+    if comp == 0
+      return idx
+    elsif comp > 0
+      upper = idx - 1
+    else
+      lower = idx + 1
+    end
+  end
+  return upper
+end
+*/ 
+static VALUE binary_search(VALUE self, VALUE ary, VALUE number) {
+    int upper = RARRAY_LEN(ary) - 1;
+    int lower = 0;
+    int idx = 0;
+    unsigned int r = NUM2UINT(number);
+    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 INT2FIX(idx);
+        }
+        else if (l > r) {
+            upper = idx - 1;
+        }
+        else {
+            lower = idx + 1;
+        }
+    }
+    return INT2FIX(upper);
+}
+ 
+VALUE cContinuum;
+void Init_binary_search() {
+  cContinuum = rb_define_module("Continuum");
+  rb_define_module_function(cContinuum, "binary_search", binary_search, 2);
+}

data/ext/memcache/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+ 
+dir_config("binary_search")
+ 
+create_makefile("binary_search")

data/lib/continuum.rb

@@ -0,0 +1,46 @@
+module Continuum
+  POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+  begin
+    require 'binary_search' # try to load native extension
+  rescue LoadError => e
+    puts "Unable to load fast binary search, falling back to pure Ruby: #{e.message}"
+
+    # slow but pure ruby version
+    # Find the closest index in Continuum with value <= the given value
+    def self.binary_search(ary, value, &block)
+      upper = ary.size - 1
+      lower = 0
+      idx = 0
+
+      while(lower <= upper) do
+        idx = (lower + upper) / 2
+        comp = ary[idx].value <=> value
+ 
+        if comp == 0
+          return idx
+        elsif comp > 0
+          upper = idx - 1
+        else
+          lower = idx + 1
+        end
+      end
+      return upper
+    end
+  end
+
+
+  class Entry
+    attr_reader :value
+    attr_reader :server
+
+    def initialize(val, srv)
+      @value = val
+      @server = srv
+    end
+
+    def inspect
+      "<#{value}, #{server.host}:#{server.port}>"
+    end
+  end
+end

data/lib/memcache.rb

@@ -3,10 +3,11 @@ $TESTING = defined?($TESTING) && $TESTING
 require 'socket'
 require 'thread'
 require 'timeout'
-require 'rubygems'
 require 'zlib'
 require 'digest/sha1'
 
+require 'continuum'
+
 ##
 # A Ruby client library for memcached.
 #
@@ -19,7 +20,7 @@ class MemCache
   ##
   # The version of MemCache you are using.
 
-  VERSION = '1.6.0'
+  VERSION = '1.6.1'
 
   ##
   # Default options for the cache object.
@@ -28,6 +29,8 @@ class MemCache
     :namespace   => nil,
     :readonly    => false,
     :multithread => false,
+    :failover    => true,
+    :timeout     => 0.25,
   }
 
   ##
@@ -40,13 +43,6 @@ class MemCache
 
   DEFAULT_WEIGHT = 1
 
-  ##
-  # The amount of time to wait for a response from a memcached server.  If a
-  # response is not completed within this time, the connection to the server
-  # will be closed and an error will be raised.
-
-  attr_accessor :request_timeout
-
   ##
   # The namespace for this instance
 
@@ -62,6 +58,24 @@ class MemCache
 
   attr_reader :servers
 
+  ##
+  # Socket timeout limit with this client, defaults to 0.25 sec.
+  # Set to nil to disable timeouts.
+
+  attr_reader :timeout
+
+  ##
+  # Should the client try to failover to another server if the
+  # first server is down?  Defaults to true.
+
+  attr_reader :failover
+
+  ##
+  # Log errors to the following IO stream, defaults to STDOUT,
+  # set to nil to disable logging.
+
+  attr_accessor :logger
+
   ##
   # Accepts a list of +servers+ and a list of +opts+.  +servers+ may be
   # omitted.  See +servers=+ for acceptable server list arguments.
@@ -71,6 +85,10 @@ class MemCache
   #   [:namespace]   Prepends this value to all keys added or retrieved.
   #   [:readonly]    Raises an exception on cache writes when true.
   #   [:multithread] Wraps cache access in a Mutex for thread safety.
+  #   [:failover]    Should the client try to failover to another server if the
+  #                  first server is down?  Defaults to true.
+  #   [:timeout]     Time to use as the socket read timeout.  Defaults to 0.25 sec,
+  #                  set to nil to disable timeouts (this is a major performance penalty in Ruby 1.8).
   #
   # Other options are ignored.
 
@@ -98,7 +116,10 @@ class MemCache
     @namespace   = opts[:namespace]
     @readonly    = opts[:readonly]
     @multithread = opts[:multithread]
+    @timeout     = opts[:timeout]
+    @failover    = opts[:failover]
     @mutex       = Mutex.new if @multithread
+    @logger      = $stdout
     self.servers = servers
   end
 
@@ -138,13 +159,11 @@ class MemCache
         port ||= DEFAULT_PORT
         weight ||= DEFAULT_WEIGHT
         Server.new self, host, port, weight
-      when Server
+      else
         if server.multithread != @multithread then
           raise ArgumentError, "can't mix threaded and non-threaded servers"
         end
         server
-      else
-        raise TypeError, "cannot convert #{server.class} into MemCache::Server"
       end
     end
 
@@ -284,7 +303,7 @@ class MemCache
     raise MemCacheError, "Update of readonly cache" if @readonly
     with_server(key) do |server, cache_key|
       value = Marshal.dump value unless raw
-      command = "add #{cache_key} 0 #{expiry} #{value.size}\r\n#{value}\r\n"
+      command = "add #{cache_key} 0 #{expiry} #{value.to_s.size}\r\n#{value}\r\n"
 
       with_socket_management(server) do |socket|
         socket.write command
@@ -389,7 +408,7 @@ class MemCache
         while line = socket.gets do
           raise_on_error_response! line
           break if line == "END\r\n"
-          if line =~ /\ASTAT ([\w]+) ([\w\.\:]+)/ then
+          if line =~ /\ASTAT ([\S]+) ([\w\.\:]+)/ then
             name, value = $1, $2
             stats[name] = case name
                           when 'version'
@@ -463,8 +482,10 @@ class MemCache
     hkey = hash_for(key)
 
     20.times do |try|
-      server = binary_search(@continuum, hkey) { |e| e.value }.server
+      entryidx = Continuum.binary_search(@continuum, hkey)
+      server = @continuum[entryidx].server
       return server if server.alive?
+      break unless failover
       hkey = hash_for "#{try}#{key}"
     end
     
@@ -571,22 +592,22 @@ class MemCache
   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. 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 SocketError => err
       server.mark_dead(err.message)
       handle_error(server, err)
 
-    rescue MemCacheError, SocketError, SystemCallError, IOError => err
+    rescue MemCacheError, SystemCallError, IOError => err
       handle_error(server, err) if retried || socket.nil?
       retried = true
       retry
@@ -602,7 +623,7 @@ class MemCache
       yield server, cache_key
     rescue IndexError => e
       if !retried && @servers.size > 1
-        puts "Connection to server #{server.inspect} DIED! Retrying operation..."
+        logger.puts "Connection to server #{server.inspect} DIED! Retrying operation..." if logger
         retried = true
         retry
       end
@@ -646,7 +667,7 @@ class MemCache
       entry_count_for(server, servers.size, total_weight).times do |idx|
         hash = Digest::SHA1.hexdigest("#{server.host}:#{server.port}:#{idx}")
         value = Integer("0x#{hash[0..7]}")
-        continuum << ContinuumEntry.new(value, server)
+        continuum << Continuum::Entry.new(value, server)
       end
     end
 
@@ -654,23 +675,7 @@ class MemCache
   end
 
   def entry_count_for(server, total_servers, total_weight)
-    ((total_servers * ContinuumEntry::POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
-  end
-
-  class ContinuumEntry
-    POINTS_PER_SERVER = 160 # this is the default in libmemcached
-
-    attr_reader :value
-    attr_reader :server
-
-    def initialize(val, srv)
-      @value = val
-      @server = srv
-    end
-
-    def inspect
-      "<#{value}, #{server.host}:#{server.port}>"
-    end
+    ((total_servers * Continuum::POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
   end
 
   ##
@@ -685,13 +690,6 @@ class MemCache
 
     CONNECT_TIMEOUT = 0.25
 
-    ##
-    # The amount of time to wait for a response from a memcached server.
-    # If a response isn't received within this time limit,
-    # the server will be marked as down.
-
-    SOCKET_TIMEOUT = 0.25
-
     ##
     # The amount of time to wait before attempting to re-establish a
     # connection with a server that is marked dead.
@@ -743,6 +741,7 @@ class MemCache
       @sock   = nil
       @retry  = nil
       @status = 'NOT CONNECTED'
+      @timeout = memcache.timeout
     end
 
     ##
@@ -777,8 +776,7 @@ class MemCache
 
       # Attempt to connect if not already connected.
       begin
-
-        @sock = TCPTimeoutSocket.new @host, @port
+        @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
@@ -826,35 +824,15 @@ class MemCache
 
   class MemCacheError < RuntimeError; end
 
-
-  # Find the closest element in Array less than or equal to value. 
-  def binary_search(ary, value, &block)
-    upper = ary.size - 1
-    lower = 0
-    idx = 0
-
-    result = while(lower <= upper) do
-      idx = (lower + upper) / 2
-      comp = block.call(ary[idx]) <=> value
- 
-      if comp == 0
-        break idx
-      elsif comp > 0
-        upper = idx - 1
-      else
-        lower = idx + 1
-      end
-    end
-    result ? ary[result] : ary[upper]
-  end
 end
 
 # TCPSocket facade class which implements timeouts.
 class TCPTimeoutSocket
-  def initialize(*args)
+  
+  def initialize(host, port, timeout)
     Timeout::timeout(MemCache::Server::CONNECT_TIMEOUT, SocketError) do
-      @sock = TCPSocket.new(*args)
-      @len = MemCache::Server::SOCKET_TIMEOUT
+      @sock = TCPSocket.new(host, port)
+      @len = timeout
     end
   end
   
@@ -880,7 +858,11 @@ class TCPTimeoutSocket
     @sock
   end
   
-  def method_missing(meth, *args)
-    @sock.__send__(meth, *args)
+  def setsockopt(*args)
+    @sock.setsockopt(*args)
   end
-end
+  
+  def closed?
+    @sock.closed?
+  end
+end

data/test/test_mem_cache.rb

@@ -5,7 +5,7 @@ require 'rubygems'
 begin
   gem 'flexmock'
   require 'flexmock/test_unit'
-rescue => e
+rescue LoadError => e
   puts "Some tests require flexmock, please run `gem install flexmock`"
 end
 
@@ -42,22 +42,67 @@ class FakeSocket
 
 end
 
+class Test::Unit::TestCase
+  def requirement(bool, msg)
+    if bool
+      yield
+    else
+      puts msg
+      assert true
+    end
+  end
+  
+  def memcached_running?
+    TCPSocket.new('localhost', 11211) rescue false
+  end
+  
+  def xprofile(name, &block)
+    a = Time.now
+    block.call
+    Time.now - a
+  end
+
+  def profile(name, &block)
+    require 'ruby-prof'
+    a = Time.now
+    result = RubyProf.profile(&block)
+    time = Time.now - a
+    printer = RubyProf::GraphHtmlPrinter.new(result)
+    File.open("#{name}.html", 'w') do |f|
+      printer.print(f, :min_percent=>1)
+    end
+    time
+  end
+  
+end
+
 class FakeServer
 
-  attr_reader :host, :port, :socket
+  attr_reader :host, :port, :socket, :weight, :multithread, :status
 
   def initialize(socket = nil)
     @closed = false
     @host = 'example.com'
     @port = 11211
     @socket = socket || FakeSocket.new
+    @weight = 1
+    @multithread = false
+    @status = "CONNECTED"
   end
 
   def close
+    # begin
+    #   raise "Already closed"
+    # rescue => e
+    #   puts e.backtrace.join("\n")
+    # end
     @closed = true
+    @socket = nil
+    @status = "NOT CONNECTED"
   end
 
   def alive?
+    # puts "I'm #{@closed ? 'dead' : 'alive'}"
     !@closed
   end
 
@@ -69,28 +114,102 @@ class TestMemCache < Test::Unit::TestCase
     @cache = MemCache.new 'localhost:1', :namespace => 'my_namespace'
   end
 
+  def test_performance
+    requirement(memcached_running?, 'A real memcached server must be running for performance testing') do
+      host = Socket.gethostname
+
+      cache = MemCache.new(['localhost:11211',"#{host}:11211"])
+      cache.add('a', 1, 120)
+      with = xprofile 'get' do
+        1000.times do
+          cache.get('a')
+        end
+      end
+
+      cache = MemCache.new(['localhost:11211',"#{host}:11211"], :timeout => false)
+      cache.add('a', 1, 120)
+      without = xprofile 'get' do
+        1000.times do
+          cache.get('a')
+        end
+      end
+
+      assert without < with
+    end
+  end
+
   def test_consistent_hashing
-    flexmock(MemCache::Server).new_instances.should_receive(:alive?).and_return(true)
+    requirement(self.respond_to?(:flexmock), 'Flexmock is required to run this test') do
+
+      flexmock(MemCache::Server).new_instances.should_receive(:alive?).and_return(true)
 
-    # Setup a continuum of two servers
-    @cache.servers = ['mike1', 'mike2', 'mike3']
+      # Setup a continuum of two servers
+      @cache.servers = ['mike1', 'mike2', 'mike3']
 
-    keys = []
-    1000.times do |idx|
-      keys << idx.to_s
+      keys = []
+      1000.times do |idx|
+        keys << idx.to_s
+      end
+
+      before_continuum = keys.map {|key| @cache.get_server_for_key(key) }
+
+      @cache.servers = ['mike1', 'mike2', 'mike3', 'mike4']
+
+      after_continuum = keys.map {|key| @cache.get_server_for_key(key) }
+
+      same_count = before_continuum.zip(after_continuum).find_all {|a| a[0].host == a[1].host }.size
+
+      # With continuum, we should see about 75% of the keys map to the same server
+      # With modulo, we would see about 25%.
+      assert same_count > 700
     end
+  end
+  
+  def test_cache_get_with_failover
+    s1 = FakeServer.new
+    s2 = FakeServer.new
 
-    before_continuum = keys.map {|key| @cache.get_server_for_key(key) }
+    @cache.logger = nil
 
-    @cache.servers = ['mike1', 'mike2', 'mike3', 'mike4']
+    # Write two messages to the socket to test failover
+    s1.socket.data.write "VALUE foo 0 14\r\n\004\b\"\0170123456789\r\n"
+    s1.socket.data.rewind
+    s2.socket.data.write "bogus response\r\nbogus response\r\n"
+    s2.socket.data.rewind
+
+    @cache.instance_variable_set(:@failover, true)
+    @cache.servers = [s1, s2]
 
-    after_continuum = keys.map {|key| @cache.get_server_for_key(key) }
+    assert s1.alive?
+    assert s2.alive?
+    @cache.get('foo')
+    assert s1.alive?
+    assert !s2.alive?
+  end
+  
+  def test_cache_get_without_failover
+    s1 = FakeServer.new
+    s2 = FakeServer.new
+    
+    @cache.logger = nil
 
-    same_count = before_continuum.zip(after_continuum).find_all {|a| a[0].host == a[1].host }.size
+    s1.socket.data.write "VALUE foo 0 14\r\n\004\b\"\0170123456789\r\n"
+    s1.socket.data.rewind
+    s2.socket.data.write "bogus response\r\nbogus response\r\n"
+    s2.socket.data.rewind
 
-    # With continuum, we should see about 75% of the keys map to the same server
-    # With modulo, we would see about 25%.
-    assert same_count > 700
+    @cache.instance_variable_set(:@failover, false)
+    @cache.servers = [s1, s2]
+
+    assert s1.alive?
+    assert s2.alive?
+    e = assert_raise MemCache::MemCacheError do
+      @cache.get('foo')
+    end
+    assert s1.alive?
+    assert !s2.alive?
+
+    assert_equal "No servers available", e.message
   end
 
   def test_cache_get
@@ -107,11 +226,11 @@ class TestMemCache < Test::Unit::TestCase
     server = util_setup_fake_server
     server.socket.data.string = ''
 
-    e = assert_raise MemCache::MemCacheError do
+    e = assert_raise IndexError do
       @cache.cache_get server, 'my_namespace:key'
     end
 
-    assert_equal "lost connection to example.com:11211", e.message
+    assert_equal "No connection to server (NOT CONNECTED)", e.message
   end
 
   def test_cache_get_bad_state
@@ -124,15 +243,13 @@ class TestMemCache < Test::Unit::TestCase
     @cache.servers = []
     @cache.servers << server
 
-    e = assert_raise MemCache::MemCacheError do
+    e = assert_raise IndexError do
       @cache.cache_get(server, 'my_namespace:key')
     end
 
-    assert_match /#{Regexp.quote 'unexpected response "bogus response\r\n"'}/, e.message
+    assert_match /#{Regexp.quote 'No connection to server (NOT CONNECTED)'}/, e.message
 
     assert !server.alive?
-
-    assert_match /get my_namespace:key\r\n/, server.socket.written.string
   end
 
   def test_cache_get_miss
@@ -167,11 +284,11 @@ class TestMemCache < Test::Unit::TestCase
     server = util_setup_fake_server
     server.socket.data.string = ''
 
-    e = assert_raise MemCache::MemCacheError do
+    e = assert_raise IndexError do
       @cache.cache_get_multi server, 'my_namespace:key'
     end
 
-    assert_equal "lost connection to example.com:11211", e.message
+    assert_equal "No connection to server (NOT CONNECTED)", e.message
   end
 
   def test_cache_get_multi_bad_state
@@ -184,15 +301,13 @@ class TestMemCache < Test::Unit::TestCase
     @cache.servers = []
     @cache.servers << server
 
-    e = assert_raise MemCache::MemCacheError do
+    e = assert_raise IndexError do
       @cache.cache_get_multi server, 'my_namespace:key'
     end
 
-    assert_match /#{Regexp.quote 'unexpected response "bogus response\r\n"'}/, e.message
+    assert_match /#{Regexp.quote 'No connection to server (NOT CONNECTED)'}/, e.message
 
     assert !server.alive?
-
-    assert_match /get my_namespace:key\r\n/, server.socket.written.string
   end
 
   def test_initialize
@@ -516,14 +631,6 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal [server], @cache.servers
   end
 
-  def test_servers_equals_type_error
-    e = assert_raise TypeError do
-      @cache.servers = [Object.new]
-    end
-
-    assert_equal 'cannot convert Object into MemCache::Server', e.message
-  end
-
   def test_set
     server = FakeServer.new
     server.socket.data.write "STORED\r\n"
@@ -649,6 +756,19 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal expected, server.socket.written.string
   end
 
+  def test_add_raw_int
+    server = FakeServer.new
+    server.socket.data.write "STORED\r\n"
+    server.socket.data.rewind
+    @cache.servers = []
+    @cache.servers << server
+
+    @cache.add 'key', 12, 0, true
+
+    expected = "add my_namespace:key 0 0 2\r\n12\r\n"
+    assert_equal expected, server.socket.written.string
+  end
+
   def test_add_readonly
     cache = MemCache.new :readonly => true
 
@@ -753,7 +873,7 @@ class TestMemCache < Test::Unit::TestCase
     end
 
     # TODO Fails in 1.9
-    assert_match /set my_namespace:test.*\r\n.*test value.*\r\n/, server.socket.written.string
+    assert_match /set my_namespace:test.*?\r\n.*?test value.*?\r\n/, server.socket.written.string
   end
 
   def test_basic_unthreaded_operations_should_work
@@ -775,7 +895,7 @@ class TestMemCache < Test::Unit::TestCase
     end
 
     # TODO Fails in 1.9
-    assert_match /set my_namespace:test.*\r\n.*test value\r\n/, server.socket.written.string
+    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: mperham-memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.6.0
+  version: 1.6.1
 platform: ruby
 authors: 
 - Eric Hodel
@@ -19,17 +19,19 @@ description: A pure Ruby library for accessing memcached.
 email: mperham@gmail.com
 executables: []
 
-extensions: []
-
+extensions: 
+- ext/memcache/extconf.rb
 extra_rdoc_files: []
 
 files: 
-- README.txt
+- README.rdoc
 - LICENSE.txt
 - History.txt
 - Rakefile
+- lib/continuum.rb
 - lib/memcache.rb
 - lib/memcache_util.rb
+- ext/memcache/binary_search.c
 has_rdoc: false
 homepage: http://github.com/mperham/memcache-client
 post_install_message: