yury-memcache-client 1.7.1.3

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

@@ -0,0 +1,207 @@
+= 1.7.1 (2009-03-28)
+
+* 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:
+  - cas
+  - append
+  - prepend
+  - replace
+  
+  Append and prepend only work with raw data since it makes no sense to concatenate two Marshalled
+  values together.  The cas functionality should be considered a prototype.  Since I don't have an
+  application which uses +cas+, I'm not sure what semantic sugar the API should provide.  Should it
+  retry if the value was changed?  Should it massage the returned string into true/false?  Feedback
+  would be appreciated.
+
+* Add fetch method which provides a method very similar to ActiveSupport::Cache::Store#fetch,
+  basically a wrapper around get and add. (djanowski)
+
+* Implement the flush_all delay parameter, to allow a large memcached farm to be flushed gradually.
+
+* Implement the noreply flag, which tells memcached not to reply in operations which don't
+  need a reply, i.e. set/add/delete/flush_all.
+
+* The only known functionality not implemented anymore is the <flags> parameter to the storage
+  commands.  This would require modification of the API method signatures.  If someone can come
+  up with a clean way to implement it, I would be happy to consider including it.
+
+= 1.6.5 (2009-02-27)
+
+* Change memcache-client to multithreaded by default.  The mutex does not add significant
+  overhead and it is far too easy, now that Sinatra, Rails and Merb are all thread-safe, to
+  use memcache-client in a thread-unsafe manner.  Remove some unnecessary mutexing and add
+  a test to verify heavily multithreaded usage does not act unexpectedly.
+
+* Add optional support for the SystemTimer gem when running on Ruby 1.8.x.  This gem is
+  highly recommended - it ensures timeouts actually work and halves the overhead of using
+  timeouts.  Using this gem, Ruby 1.8.x is actually faster in my performance tests
+  than Ruby 1.9.x.  Just "gem install SystemTimer" and it should be picked up automatically.
+
+= 1.6.4 (2009-02-19)
+
+* Remove native code altogether.  The speedup was only 10% on Ruby 1.8.6 and did not work
+  on Ruby 1.9.1.
+
+* Removed memcache_util.rb from the distribution.  If you are using it, please copy the code
+  into your own project.  The file will live in the github repository for a few more months
+  for this purposes. http://github.com/mperham/memcache-client/raw/7a276089aa3c914e47e3960f9740ac7377204970/lib/memcache_util.rb
+
+* Roll continuum.rb into memcache.rb.  The project is again a single Ruby file, with no dependencies.
+
+= 1.6.3 (2009-02-14)
+
+* Remove gem native extension in preference to RubyInline.  This allows the gem to install
+and work on JRuby and Ruby 1.8.5 when the native code fails to compile.
+
+= 1.6.2 (2009-02-04)
+
+* Validate that values are less than one megabyte in size.
+
+* Refactor error handling in get_multi to handle server failures and return what values
+  we could successfully retrieve.
+
+* Add optional logging parameter for debugging and tracing.
+
+* 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
+
+= 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)
+
+* 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 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.
+  memcache-client is now pure Ruby again and will work with JRuby and Rubinius.
+
+= 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!
+
+= 1.5.0.2 (FiveRuns fork)
+
+* Add support for seamless failover between servers.  If one server connection dies,
+the client will retry the operation on another server before giving up.
+
+* Merge Will Bryant's socket retry patch.
+http://willbryant.net/software/2007/12/21/ruby-memcache-client-reconnect-and-retry
+
+= 1.5.0.1 (FiveRuns fork)
+
+* Fix set not handling client disconnects.
+http://dev.twitter.com/2008/02/solving-case-of-missing-updates.html
+
+= 1.5.0
+
+* Add MemCache#flush_all command.  Patch #13019 and bug #10503.  Patches
+  submitted by Sebastian Delmont and Rick Olson.
+* Type-cast data returned by MemCache#stats.  Patch #10505 submitted by
+  Sebastian Delmont.
+
+= 1.4.0
+
+* Fix bug #10371, #set does not check response for server errors.
+  Submitted by Ben VandenBos.
+* Fix bug #12450, set TCP_NODELAY socket option.  Patch by Chris
+  McGrath.
+* Fix bug #10704, missing #add method.  Patch by Jamie Macey.
+* Fix bug #10371, handle socket EOF in cache_get.  Submitted by Ben
+  VandenBos.
+
+= 1.3.0
+
+* Apply patch #6507, add stats command.  Submitted by Tyler Kovacs.
+* Apply patch #6509, parallel implementation of #get_multi.  Submitted
+  by Tyler Kovacs.
+* Validate keys.  Disallow spaces in keys or keys that are too long.
+* Perform more validation of server responses.  MemCache now reports
+  errors if the socket was not in an expected state.  (Please file
+  bugs if you find some.)
+* Add #incr and #decr.
+* Add raw argument to #set and #get to retrieve #incr and #decr
+  values.
+* Also put on MemCacheError when using Cache::get with block.
+* memcache.rb no longer sets $TESTING to a true value if it was
+  previously defined.  Bug #8213 by Matijs van Zuijlen.
+
+= 1.2.1
+
+* Fix bug #7048, MemCache#servers= referenced changed local variable.
+  Submitted by Justin Dossey.
+* Fix bug #7049, MemCache#initialize resets @buckets.  Submitted by
+  Justin Dossey.
+* Fix bug #6232, Make Cache::Get work with a block only when nil is
+  returned.  Submitted by Jon Evans.
+* Moved to the seattlerb project.
+
+= 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
+* Sped up non-multithreaded and multithreaded operation
+* More Ruby-memcache compatibility
+* More RDoc
+* Switched to Hoe
+
+= 1.0.0
+
+Birthday!
+

data/LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright 2005-2009 Bob Cottrell, Eric Hodel, Mike Perham.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the names of the authors nor the names of their contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.rdoc

@@ -0,0 +1,50 @@
+= memcache-client
+
+A 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'
+
+Or with multiple servers:
+
+  CACHE = MemCache.new %w[one.example.com:11211 two.example.com:11211]
+
+
+== 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.  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
+
+Rails 2.1+ includes memcache-client out of the box.  See ActiveSupport::Cache::MemCacheStore
+and the Rails.cache method 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
+
+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/Rakefile

@@ -0,0 +1,35 @@
+# vim: syntax=Ruby
+require 'rubygems'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+task :gem do
+	sh "gem build memcache-client.gemspec"
+end
+
+task :install => [:gem] do
+	sh "sudo gem install memcache-client-*.gem"
+end
+
+task :clean do
+	sh "rm -f memcache-client-*.gem"
+end
+
+task :publish => [:clean, :gem, :install] do
+	require 'lib/memcache'
+	sh "rubyforge add_release seattlerb memcache-client #{MemCache::VERSION} memcache-client-#{MemCache::VERSION}.gem"
+end
+
+Rake::RDocTask.new do |rd|
+	rd.main = "README.rdoc"
+	rd.rdoc_files.include("README.rdoc", "FAQ.rdoc", "History.rdoc", "lib/memcache.rb")
+	rd.rdoc_dir = 'doc'
+end
+
+Rake::TestTask.new
+
+task :default => :test
+
+task :rcov do
+  `rcov -Ilib test/*.rb`
+end

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

@@ -0,0 +1,1120 @@
+$TESTING = defined?($TESTING) && $TESTING
+
+require 'socket'
+require 'thread'
+require 'zlib'
+require 'digest/sha1'
+
+begin
+  # Try to use the SystemTimer gem instead of Ruby's timeout library
+  # when running on something that looks like Ruby 1.8.x.  See:
+  #   http://ph7spot.com/articles/system_timer
+  # We don't want to bother trying to load SystemTimer on jruby and
+  # ruby 1.9+.
+  if !defined?(RUBY_ENGINE)
+    require 'system_timer'
+    MemCacheTimer = SystemTimer
+  else
+    require 'timeout'
+    MemCacheTimer = Timeout
+  end
+rescue LoadError => e
+  puts "[memcache-client] Could not load SystemTimer gem, falling back to Ruby's slower/unsafe timeout library: #{e.message}"
+  require 'timeout'
+  MemCacheTimer = Timeout
+end
+
+##
+# A Ruby client library for memcached.
+#
+
+class MemCache
+
+  ##
+  # The version of MemCache you are using.
+
+  VERSION = '1.7.1.2'
+
+  ##
+  # Default options for the cache object.
+
+  DEFAULT_OPTIONS = {
+    :namespace          => nil,
+    :readonly           => false,
+    :multithread        => true,
+    :failover           => true,
+    :timeout            => 0.5,
+    :logger             => nil,
+    :raw                => false,
+    :persistent_hashing => true,
+    :no_reply    	=> false,
+  }
+
+  ##
+  # Default memcached port.
+
+  DEFAULT_PORT = 11211
+
+  ##
+  # Default memcached server weight.
+
+  DEFAULT_WEIGHT = 1
+
+  ##
+  # The namespace for this instance
+
+  attr_reader :namespace
+
+  ##
+  # The multithread setting for this instance
+
+  attr_reader :multithread
+
+  ##
+  # The servers this client talks to.  Play at your own peril.
+
+  attr_reader :servers
+
+  ##
+  # Socket timeout limit with this client, defaults to 0.5 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 debug/info/warn/error to the given Logger, defaults to nil.
+
+  attr_reader :logger
+
+  ##
+  # Don't send or look for a reply from the memcached server for write operations.
+  # Please note this feature only works in memcached 1.2.5 and later.  Earlier
+  # versions will reply with "ERROR".
+  attr_reader :no_reply
+
+  ##
+  # Accepts a list of +servers+ and a list of +opts+.  +servers+ may be
+  # omitted.  See +servers=+ for acceptable server list arguments.
+  #
+  # Valid options for +opts+ are:
+  #
+  #   [: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. Defaults to true.
+  #   [: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.5 sec,
+  #                  set to nil to disable timeouts (this is a major performance penalty in Ruby 1.8,
+  #                  "gem install SystemTimer' to remove most of the penalty).
+  #   [:logger]      Logger to use for info/debug output, defaults to nil
+  #   [:raw]         If true, the value(s) will be returned unaltered.
+  #   [:persistent_hashing] 
+  #                  If true do persisting hashing otherwise do modulo hashing, defaults to true.
+  #   [:no_reply]    Don't bother looking for a reply for write operations (i.e. they
+  #                  become 'fire and forget'), memcached 1.2.5 and later only, speeds up
+  #                  set/add/delete/incr/decr significantly.
+  #
+  # Other options are ignored.
+
+  def initialize(*args)
+    servers = []
+    opts = {}
+
+    case args.length
+    when 0 then # NOP
+    when 1 then
+      arg = args.shift
+      case arg
+      when Hash   then opts = arg
+      when Array  then servers = arg
+      when String then servers = [arg]
+      else raise ArgumentError, 'first argument must be Array, Hash or String'
+      end
+    when 2 then
+      servers, opts = args
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 2)"
+    end
+
+    opts = DEFAULT_OPTIONS.merge opts
+    @namespace          = opts[:namespace]
+    @readonly           = opts[:readonly]
+    @multithread        = opts[:multithread]
+    @timeout            = opts[:timeout]
+    @failover           = opts[:failover]
+    @logger             = opts[:logger]
+    @raw                = opts[:raw]
+    @persistent_hashing = opts[:persistent_hashing]
+    @no_reply    = opts[:no_reply]
+    @mutex              = Mutex.new if @multithread
+
+    logger.info { "memcache-client #{VERSION} #{Array(servers).inspect}" } if logger
+
+    self.servers = servers
+  end
+
+  ##
+  # Returns a string representation of the cache object.
+
+  def inspect
+    "<MemCache: %d servers, ns: %p, ro: %p, raw: %p>" %
+      [@servers.length, @namespace, @readonly, @raw]
+  end
+
+  ##
+  # Returns whether there is at least one active server for the object.
+
+  def active?
+    not @servers.empty?
+  end
+
+  ##
+  # Returns whether or not the cache object was created read only.
+
+  def readonly?
+    @readonly
+  end
+
+  ##
+  # Set the servers that the requests will be distributed between.  Entries
+  # can be either strings of the form "hostname:port" or
+  # "hostname:port:weight" or MemCache::Server objects.
+  #
+  def servers=(servers)
+    # Create the server objects.
+    @servers = Array(servers).collect do |server|
+      case server
+      when String
+        host, port, weight = server.split ':', 3
+        port ||= DEFAULT_PORT
+        weight ||= DEFAULT_WEIGHT
+        Server.new self, host, port, weight
+      else
+        server
+      end
+    end
+
+    logger.debug { "Servers now: #{@servers.inspect}" } if logger
+
+    # There's no point in doing this if there's only one server
+    if @servers.size > 1
+      if @persistent_hashing
+        @continuum = create_continuum_for(@servers)
+      else
+        @buckets = []
+        @servers.each do |server|
+          server.weight.times { @buckets.push(server) }
+        end
+      end
+    end
+
+    @servers
+  end
+
+  ##
+  # Decrements the value for +key+ by +amount+ and returns the new value.
+  # +key+ must already exist.  If +key+ is not an integer, it is assumed to be
+  # 0.  +key+ can not be decremented below 0.
+
+  def decr(key, amount = 1)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    with_server(key) do |server, cache_key|
+      cache_decr server, cache_key, amount
+    end
+  rescue TypeError => err
+    handle_error nil, err
+  end
+
+  ##
+  # Retrieves +key+ from memcache.  If +raw+ is false, the value will be
+  # unmarshalled.
+
+  def get(key, raw = nil)
+    with_server(key) do |server, cache_key|
+      value = cache_get server, cache_key
+      logger.debug { "get #{key} from #{server.inspect}: #{value ? value.to_s.size : 'nil'}" } if logger
+      return nil if value.nil?
+      value = Marshal.load value unless (raw == nil && @raw) || raw
+      return value
+    end
+  rescue TypeError => err
+    handle_error nil, err
+  end
+
+  ##
+  # Performs a +get+ with the given +key+.  If 
+  # the value does not exist and a block was given,
+  # the block will be called and the result saved via +add+.
+  #
+  # If you do not provide a block, using this
+  # method is the same as using +get+.
+  #
+  def fetch(key, expiry = 0, raw = false)
+    value = get(key, raw)
+
+    if value.nil? && block_given?
+      value = yield
+      add(key, value, expiry, raw)
+    end
+
+    value
+  end
+
+  ##
+  # Retrieves multiple values from memcached in parallel, if possible.
+  #
+  # The memcached protocol supports the ability to retrieve multiple
+  # keys in a single request.  Pass in an array of keys to this method
+  # and it will:
+  #
+  # 1. map the key to the appropriate memcached server
+  # 2. send a single request to each server that has one or more key values
+  #
+  # Returns a hash of values.
+  #
+  #   cache["a"] = 1
+  #   cache["b"] = 2
+  #   cache.get_multi "a", "b" # => { "a" => 1, "b" => 2 }
+  #
+  # Note that get_multi assumes the values are marshalled.
+
+  def get_multi(*keys)
+    raise MemCacheError, 'No active servers' unless active?
+
+    keys.flatten!
+    key_count = keys.length
+    cache_keys = {}
+    server_keys = Hash.new { |h,k| h[k] = [] }
+
+    # map keys to servers
+    keys.each do |key|
+      server, cache_key = request_setup key
+      cache_keys[cache_key] = key
+      server_keys[server] << cache_key
+    end
+
+    results = {}
+
+    server_keys.each do |server, keys_for_server|
+      keys_for_server_str = keys_for_server.join ' '
+      begin
+        values = cache_get_multi server, keys_for_server_str
+        values.each do |key, value|
+          results[cache_keys[key]] = if @raw then value else Marshal.load value end
+        end
+      rescue IndexError => e
+        # Ignore this server and try the others
+        logger.warn { "Unable to retrieve #{keys_for_server.size} elements from #{server.inspect}: #{e.message}"} if logger
+      end
+    end
+
+    return results
+  rescue TypeError => err
+    handle_error nil, err
+  end
+
+  ##
+  # Increments the value for +key+ by +amount+ and returns the new value.
+  # +key+ must already exist.  If +key+ is not an integer, it is assumed to be
+  # 0.
+
+  def incr(key, amount = 1)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    with_server(key) do |server, cache_key|
+      cache_incr server, cache_key, amount
+    end
+  rescue TypeError => 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.
+  #
+  # Warning: Readers should not call this method in the event of a cache miss;
+  # see MemCache#add.
+
+  ONE_MB = 1024 * 1024
+
+  def set(key, value, expiry = 0, raw = nil)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    with_server(key) do |server, cache_key|
+
+      value = Marshal.dump value unless  (raw == nil && @raw) || raw
+      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 value.to_s.size > ONE_MB
+
+      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
+        break nil if @no_reply
+        result = socket.gets
+        raise_on_error_response! result
+
+        if result.nil?
+          server.close
+          raise MemCacheError, "lost connection to #{server.host}:#{server.port}"
+        end
+
+        result
+      end
+    end
+  end
+
+  ##
+  # "cas" is a check and set operation which means "store this data but
+  # only if no one else has updated since I last fetched it."  This can
+  # be used as a form of optimistic locking.
+  #
+  # Works in block form like so:
+  #   cache.cas('some-key') do |value|
+  #     value + 1
+  #   end
+  #
+  # Returns:
+  # +nil+ if the value was not found on the memcached server.
+  # +STORED+ if the value was updated successfully
+  # +EXISTS+ if the value was updated by someone else since last fetch
+
+  def cas(key, expiry=0, raw=nil)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    raise MemCacheError, "A block is required" unless block_given?
+
+    (value, token) = gets(key, raw)
+    return nil unless value
+    value = yield value
+
+    with_server(key) do |server, cache_key|
+      value = Marshal.dump value unless (raw == nil && @raw) || raw
+      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
+        break nil if @no_reply
+        result = socket.gets
+        raise_on_error_response! result
+
+        if result.nil?
+          server.close
+          raise MemCacheError, "lost connection to #{server.host}:#{server.port}"
+        end
+
+        result
+      end
+    end
+  end
+
+  ##
+  # Add +key+ to the cache with value +value+ that expires in +expiry+
+  # seconds, but only if +key+ does not already exist in the cache.
+  # If +raw+ is true, +value+ will not be Marshalled.
+  #
+  # Readers should call this method in the event of a cache miss, not
+  # MemCache#set.
+
+  def add(key, value, expiry = 0, raw = nil)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    with_server(key) do |server, cache_key|
+      value = Marshal.dump value unless (raw == nil && @raw) || raw
+      logger.debug { "add #{key} to #{server}: #{value ? value.to_s.size : 'nil'}" } if logger
+      command = "add #{cache_key} 0 #{expiry} #{value.to_s.size}#{noreply}\r\n#{value}\r\n"
+
+      with_socket_management(server) do |socket|
+        socket.write command
+        break nil if @no_reply
+        result = socket.gets
+        raise_on_error_response! result
+        result
+      end
+    end
+  end
+  
+  ##
+  # Add +key+ to the cache with value +value+ that expires in +expiry+
+  # seconds, but only if +key+ already exists in the cache.
+  # If +raw+ is true, +value+ will not be Marshalled.
+  def replace(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    with_server(key) do |server, cache_key|
+      value = Marshal.dump value unless raw
+      logger.debug { "replace #{key} to #{server}: #{value ? value.to_s.size : 'nil'}" } if logger
+      command = "replace #{cache_key} 0 #{expiry} #{value.to_s.size}#{noreply}\r\n#{value}\r\n"
+
+      with_socket_management(server) do |socket|
+        socket.write command
+        break nil if @no_reply
+        result = socket.gets
+        raise_on_error_response! result
+        result
+      end
+    end
+  end
+
+  ##
+  # Append - 'add this data to an existing key after existing data'
+  # Please note the value is always passed to memcached as raw since it
+  # doesn't make a lot of sense to concatenate marshalled data together.
+  def append(key, value)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    with_server(key) do |server, cache_key|
+      logger.debug { "append #{key} to #{server}: #{value ? value.to_s.size : 'nil'}" } if logger
+      command = "append #{cache_key} 0 0 #{value.to_s.size}#{noreply}\r\n#{value}\r\n"
+
+      with_socket_management(server) do |socket|
+        socket.write command
+        break nil if @no_reply
+        result = socket.gets
+        raise_on_error_response! result
+        result
+      end
+    end
+  end
+
+  ##
+  # Prepend - 'add this data to an existing key before existing data'
+  # Please note the value is always passed to memcached as raw since it
+  # doesn't make a lot of sense to concatenate marshalled data together.
+  def prepend(key, value)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    with_server(key) do |server, cache_key|
+      logger.debug { "prepend #{key} to #{server}: #{value ? value.to_s.size : 'nil'}" } if logger
+      command = "prepend #{cache_key} 0 0 #{value.to_s.size}#{noreply}\r\n#{value}\r\n"
+
+      with_socket_management(server) do |socket|
+        socket.write command
+        break nil if @no_reply
+        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
+    with_server(key) do |server, cache_key|
+      with_socket_management(server) do |socket|
+        logger.debug { "delete #{cache_key} on #{server}" } if logger
+        socket.write "delete #{cache_key} #{expiry}#{noreply}\r\n"
+        break nil if @no_reply
+        result = socket.gets
+        raise_on_error_response! result
+        result
+      end
+    end
+  end
+
+  ##
+  # Flush the cache from all memcache servers.
+  # A non-zero value for +delay+ will ensure that the flush
+  # is propogated slowly through your memcached server farm.
+  # The Nth server will be flushed N*delay seconds from now,
+  # asynchronously so this method returns quickly.
+  # This prevents a huge database spike due to a total
+  # flush all at once.
+
+  def flush_all(delay=0)
+    raise MemCacheError, 'No active servers' unless active?
+    raise MemCacheError, "Update of readonly cache" if @readonly
+
+    begin
+      delay_time = 0
+      @servers.each do |server|
+        with_socket_management(server) do |socket|
+          logger.debug { "flush_all #{delay_time} on #{server}" } if logger
+          socket.write "flush_all #{delay_time}#{noreply}\r\n"
+          break nil if @no_reply
+          result = socket.gets
+          raise_on_error_response! result
+          result
+        end
+        delay_time += delay
+      end
+    rescue IndexError => err
+      handle_error nil, err
+    end
+  end
+
+  ##
+  # Reset the connection to all memcache servers.  This should be called if
+  # there is a problem with a cache lookup that might have left the connection
+  # in a corrupted state.
+
+  def reset
+    @servers.each { |server| server.close }
+  end
+
+  ##
+  # Returns statistics for each memcached server.  An explanation of the
+  # statistics can be found in the memcached docs:
+  #
+  # http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt
+  #
+  # Example:
+  #
+  #   >> pp CACHE.stats
+  #   {"localhost:11211"=>
+  #     {"bytes"=>4718,
+  #      "pid"=>20188,
+  #      "connection_structures"=>4,
+  #      "time"=>1162278121,
+  #      "pointer_size"=>32,
+  #      "limit_maxbytes"=>67108864,
+  #      "cmd_get"=>14532,
+  #      "version"=>"1.2.0",
+  #      "bytes_written"=>432583,
+  #      "cmd_set"=>32,
+  #      "get_misses"=>0,
+  #      "total_connections"=>19,
+  #      "curr_connections"=>3,
+  #      "curr_items"=>4,
+  #      "uptime"=>1557,
+  #      "get_hits"=>14532,
+  #      "total_items"=>32,
+  #      "rusage_system"=>0.313952,
+  #      "rusage_user"=>0.119981,
+  #      "bytes_read"=>190619}}
+  #   => nil
+
+  def stats
+    raise MemCacheError, "No active servers" unless active?
+    server_stats = {}
+
+    @servers.each do |server|
+      next unless server.alive?
+
+      with_socket_management(server) do |socket|
+        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 =~ /\ASTAT ([\S]+) ([\w\.\:]+)/ then
+            name, value = $1, $2
+            stats[name] = case name
+                          when 'version'
+                            value
+                          when 'rusage_user', 'rusage_system' then
+                            seconds, microseconds = value.split(/:/, 2)
+                            microseconds ||= 0
+                            Float(seconds) + (Float(microseconds) / 1_000_000)
+                          else
+                            if value =~ /\A\d+\Z/ then
+                              value.to_i
+                            else
+                              value
+                            end
+                          end
+          end
+        end
+        server_stats["#{server.host}:#{server.port}"] = stats
+      end
+    end
+
+    raise MemCacheError, "No active servers" if server_stats.empty?
+    server_stats
+  end
+
+  ##
+  # Shortcut to get a value from the cache.
+
+  alias [] get
+
+  ##
+  # Shortcut to save a value in the cache.  This method does not set an
+  # expiration on the entry.  Use set to specify an explicit expiry.
+
+  def []=(key, value)
+    set key, value
+  end
+
+  protected unless $TESTING
+
+  ##
+  # Create a key for the cache, incorporating the namespace qualifier if
+  # requested.
+
+  def make_cache_key(key)
+    if namespace.nil? then
+      key
+    else
+      "#{@namespace}:#{key}"
+    end
+  end
+
+  ##
+  # Pick a server to handle the request based on a hash of the key.
+
+  def get_server_for_key(key, options = {})
+    raise ArgumentError, "illegal character in key #{key.inspect}" if
+      key =~ /\s/
+    raise ArgumentError, "key too long #{key.inspect}" if key.length > 250
+    raise MemCacheError, "No servers available" if @servers.empty?
+    return @servers.first if @servers.length == 1
+
+    # for unknown reason hashing is different between memcache-client.rb and original Cache::Memcached.pm
+
+    if @persistent_hashing
+      hkey = Zlib.crc32 key
+
+      20.times do |try|
+        entryidx = Continuum.binary_search(@continuum, hkey)
+        server = @continuum[entryidx].server
+        return server if server.alive?
+        break unless failover
+        hkey = Zlib.crc32 "#{try}#{key}"
+      end
+    else
+      hkey = (Zlib.crc32(key) >> 16) & 0x7fff
+
+      20.times do |try|
+        server = @buckets[hkey % @buckets.length]
+        return server if server.alive?
+        hkey += (Zlib.crc32("#{try}#{key}") >> 16) & 0x7fff 
+      end
+    end
+
+    raise MemCacheError, "No servers available"
+  end
+
+  ##
+  # Performs a raw decr for +cache_key+ from +server+.  Returns nil if not
+  # found.
+
+  def cache_decr(server, cache_key, amount)
+    with_socket_management(server) do |socket|
+      socket.write "decr #{cache_key} #{amount}#{noreply}\r\n"
+      break nil if @no_reply
+      text = socket.gets
+      raise_on_error_response! text
+      return nil if text == "NOT_FOUND\r\n"
+      return text.to_i
+    end
+  end
+
+  ##
+  # Fetches the raw data for +cache_key+ from +server+.  Returns nil on cache
+  # miss.
+
+  def cache_get(server, cache_key)
+    with_socket_management(server) do |socket|
+      socket.write "get #{cache_key}\r\n"
+      keyline = socket.gets # "VALUE <key> <flags> <bytes>\r\n"
+
+      if keyline.nil? then
+        server.close
+        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
+        server.close
+        raise MemCacheError, "unexpected response #{keyline.inspect}"
+      end
+      value = socket.read $1.to_i
+      socket.read 2 # "\r\n"
+      socket.gets   # "END\r\n"
+      return value
+    end
+  end
+
+  def gets(key, raw = nil)
+    with_server(key) do |server, cache_key|
+      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"
+
+        if keyline.nil? then
+          server.close
+          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+) (\w+)\r/ then
+          server.close
+          raise MemCacheError, "unexpected response #{keyline.inspect}"
+        end
+        value = socket.read $1.to_i
+        socket.read 2 # "\r\n"
+        socket.gets   # "END\r\n"
+        logger.debug { "gets #{key} from #{server.inspect}: #{value ? value.to_s.size : 'nil'}" } if logger
+        [value, $2]
+      end
+      result[0] = Marshal.load result[0] unless (raw == nil && @raw) || raw
+      result
+    end
+  rescue TypeError => err
+    handle_error nil, err
+  end
+
+
+  ##
+  # Fetches +cache_keys+ from +server+ using a multi-get.
+
+  def cache_get_multi(server, cache_keys)
+    with_socket_management(server) do |socket|
+      values = {}
+      socket.write "get #{cache_keys}\r\n"
+
+      while keyline = socket.gets do
+        return values if keyline == "END\r\n"
+        raise_on_error_response! keyline
+
+        unless keyline =~ /\AVALUE (.+) (.+) (.+)/ then
+          server.close
+          raise MemCacheError, "unexpected response #{keyline.inspect}"
+        end
+
+        key, data_length = $1, $3
+        values[$1] = socket.read data_length.to_i
+        socket.read(2) # "\r\n"
+      end
+
+      server.close
+      raise MemCacheError, "lost connection to #{server.host}:#{server.port}" # TODO: retry here too
+    end
+  end
+
+  ##
+  # Performs a raw incr for +cache_key+ from +server+.  Returns nil if not
+  # found.
+
+  def cache_incr(server, cache_key, amount)
+    with_socket_management(server) do |socket|
+      socket.write "incr #{cache_key} #{amount}#{noreply}\r\n"
+      break nil if @no_reply
+      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, 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
+  # dead for a timeout period, so retrying does not apply to connection attempt
+  # 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. 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, Errno::EAGAIN, Timeout::Error => err
+      logger.warn { "Socket failure: #{err.message}" } if logger
+      server.mark_dead(err)
+      handle_error(server, err)
+
+    rescue MemCacheError, SystemCallError, IOError => err
+      logger.warn { "Generic failure: #{err.class.name}: #{err.message}" } if logger
+      handle_error(server, err) if retried || socket.nil?
+      retried = true
+      retry
+    end
+  ensure
+    @mutex.unlock if @multithread
+  end
+
+  def with_server(key)
+    retried = false
+    begin
+      server, cache_key = request_setup(key)
+      yield server, cache_key
+    rescue IndexError => e
+      logger.warn { "Server failed: #{e.class.name}: #{e.message}" } if logger
+      if !retried && @servers.size > 1
+        logger.info { "Connection to server #{server.inspect} DIED! Retrying operation..." } if logger
+        retried = true
+        retry
+      end
+      handle_error(nil, e)
+    end
+  end
+
+  ##
+  # Handles +error+ from +server+.
+
+  def handle_error(server, error)
+    raise error if error.is_a?(MemCacheError)
+    server.close if server
+    new_error = MemCacheError.new error.message
+    new_error.set_backtrace error.backtrace
+    raise new_error
+  end
+
+  def noreply
+    @no_reply ? ' noreply' : ''
+  end
+
+  ##
+  # Performs setup for making a request with +key+ from memcached.  Returns
+  # the server to fetch the key from and the complete key to use.
+
+  def request_setup(key)
+    raise MemCacheError, 'No active servers' unless active?
+    cache_key = make_cache_key key
+    server = get_server_for_key cache_key
+    return server, cache_key
+  end
+
+  def raise_on_error_response!(response)
+    if response =~ /\A(?:CLIENT_|SERVER_)?ERROR(.*)/
+      raise MemCacheError, $1.strip
+    end
+  end
+
+  def create_continuum_for(servers)
+    total_weight = servers.inject(0) { |memo, srv| memo + srv.weight }
+    continuum = []
+
+    servers.each do |server|
+      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 << Continuum::Entry.new(value, server)
+      end
+    end
+
+    continuum.sort { |a, b| a.value <=> b.value }
+  end
+
+  def entry_count_for(server, total_servers, total_weight)
+    ((total_servers * Continuum::POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
+  end
+
+  ##
+  # This class represents a memcached server instance.
+
+  class Server
+
+    ##
+    # The amount of time to wait before attempting to re-establish a
+    # connection with a server that is marked dead.
+
+    RETRY_DELAY = 30.0
+
+    ##
+    # The host the memcached server is running on.
+
+    attr_reader :host
+
+    ##
+    # The port the memcached server is listening on.
+
+    attr_reader :port
+
+    ##
+    # The weight given to the server.
+
+    attr_reader :weight
+
+    ##
+    # The time of next retry if the connection is dead.
+
+    attr_reader :retry
+
+    ##
+    # A text status string describing the state of the server.
+
+    attr_reader :status
+
+    attr_reader :logger
+
+    ##
+    # Create a new MemCache::Server object for the memcached instance
+    # listening on the given host and port, weighted by the given weight.
+
+    def initialize(memcache, host, port = DEFAULT_PORT, weight = DEFAULT_WEIGHT)
+      raise ArgumentError, "No host specified" if host.nil? or host.empty?
+      raise ArgumentError, "No port specified" if port.nil? or port.to_i.zero?
+
+      @host   = host
+      @port   = port.to_i
+      @weight = weight.to_i
+
+      @sock   = nil
+      @retry  = nil
+      @status = 'NOT CONNECTED'
+      @timeout = memcache.timeout
+      @logger = memcache.logger
+    end
+
+    ##
+    # Return a string representation of the server object.
+
+    def inspect
+      "<MemCache::Server: %s:%d [%d] (%s)>" % [@host, @port, @weight, @status]
+    end
+
+    ##
+    # Check whether the server connection is alive.  This will cause the
+    # socket to attempt to connect if it isn't already connected and or if
+    # the server was previously marked as down and the retry time has
+    # been exceeded.
+
+    def alive?
+      !!socket
+    end
+
+    ##
+    # Try to connect to the memcached server targeted by this object.
+    # Returns the connected socket object on success or nil on failure.
+
+    def socket
+      return @sock if @sock and not @sock.closed?
+
+      @sock = nil
+
+      # If the host was dead, don't retry for a while.
+      return if @retry and @retry > Time.now
+
+      # Attempt to connect if not already connected.
+      begin
+        @sock = connect_to(@host, @port, @timeout)
+        @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+        @retry  = nil
+        @status = 'CONNECTED'
+      rescue SocketError, SystemCallError, IOError => err
+        logger.warn { "Unable to open socket: #{err.class.name}, #{err.message}" } if logger
+        mark_dead err
+      end
+
+      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.
+
+    def close
+      @sock.close if @sock && !@sock.closed?
+      @sock   = nil
+      @retry  = nil
+      @status = "NOT CONNECTED"
+    end
+
+    ##
+    # Mark the server as dead and close its socket.
+
+    def mark_dead(error)
+      @sock.close if @sock && !@sock.closed?
+      @sock   = nil
+      @retry  = Time.now + RETRY_DELAY
+
+      reason = "#{error.class.name}: #{error.message}"
+      @status = sprintf "%s:%s DEAD (%s), will retry at %s", @host, @port, reason, @retry
+      @logger.info { @status } if @logger
+    end
+
+  end
+
+  ##
+  # Base MemCache exception class.
+
+  class MemCacheError < RuntimeError; end
+
+end
+
+module Continuum
+  POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+  # 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
+
+  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
+require 'continuum_native'