memcache-client 1.7.8 → 1.8.0

data/FAQ.rdoc

@@ -25,7 +25,8 @@ You can increase the timeout or disable them completely with the following confi
 
 == Isn't Evan Weaver's memcached gem faster?
 
-The latest version of memcached-client is anywhere from 33% to 100% slower than memcached in various benchmarks.  Keep in mind this means that 10,000 get requests take 1.8 sec instead of 1.2 seconds.
+The latest version of memcached-client is anywhere from 33% to 100% slower than memcached in various
+benchmarks.  Keep in mind this means that 10,000 get requests take 1.8 sec instead of 1.2 seconds.
 In practice, memcache-client is unlikely to be a bottleneck in your system but there is always going
 to be an overhead to pure Ruby.  memcache-client does have the advantage of built-in integration into
 Rails and should work on non-MRI platforms: JRuby, MacRuby, etc.

data/History.rdoc

@@ -1,3 +1,9 @@
+= 1.8.0 (2010-03-05)
+
+ * Add support for EventMachine-based connections.
+ * Add support for raw values in get_multi
+ * Add memcached_top binary for gathering server statistics
+
 = 1.7.8 (2010-02-03)
 
 * Fix issue where autofix_keys logic did not account for namespace length. (menno)

data/README.rdoc

@@ -36,6 +36,22 @@ Rails 2.1+ includes memcache-client 1.5.0 out of the box.  See ActiveSupport::Ca
 and the Rails.cache method for more details.  Rails 2.3+ will use the latest memcache-client
 gem installed.
 
+== Using memcache-client with EventMachine
+
+memcache-client 1.8.0 added support for native EventMachine connections using
+Ruby 1.9.  If you are using an EventMachine-based application (e.g. thin), you can
+activate the EventMachine support like so:
+
+  require 'memcache'
+  require 'memcache/event_machine'
+
+  EM.run do
+    Fiber.new do
+      m = MemCache.new('localhost:11211')
+      m.set 'abc', 'xyz'
+      m.get 'abc'
+    end.resume
+  end
 
 == Questions?
 

data/Rakefile

@@ -14,6 +14,7 @@ begin
     s.has_rdoc = true
     s.files = FileList["[A-Z]*", "{lib,test}/**/*", 'performance.txt']
     s.test_files = FileList["test/test_*.rb"]
+    s.executables = ['memcached_top']
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -29,6 +30,7 @@ end
 
 Rake::TestTask.new do |t|
   t.warning = true
+  t.libs = ['lib', 'test']
 end
 
 task :default => :test

data/VERSION.yml

@@ -1,4 +1,5 @@
----
-:patch: 8
+--- 
+:build: 
 :major: 1
-:minor: 7
+:minor: 8
+:patch: 0

data/bin/memcached_top

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ostruct'
+require 'socket'
+
+@options = OpenStruct.new
+@options.hostname = 'localhost'
+@options.port = 11211
+
+op = OptionParser.new do |opts|
+	opts.banner = "View memcached server statistics\nUsage: #{$0} [options]"
+	opts.separator "General Options:"
+	opts.on("-h HOSTNAME", "--hostname=HOSTNAME", "Hostname [default: localhost]") do |h|
+		@options.hostname = h
+	end
+	opts.on("-p PORT", "--port=PORT", Integer, "Port [default: 11211]") do |p|
+		@options.port = p
+	end
+	opts.on_tail("--help", "Show this message") do
+		puts opts
+		exit
+	end
+end
+op.parse!
+
+def stats_data
+  data = ''
+  sock = TCPSocket.new(@options.hostname, @options.port)
+  sock.print("stats\r\n")
+  sock.flush
+  # memcached does not close the socket once it is done writing
+  # the stats data.  We need to read line by line until we detect
+  # the END line and then stop/close on our side.
+  stats = sock.gets
+  while true
+    data += stats
+    break if stats.strip == 'END'
+    stats = sock.gets
+  end
+  sock.close
+  data
+end
+
+def parse(stats_data)
+  stats = []
+  stats_data.each_line do |line|
+    stats << "#{$1}: #{$2}" if line =~ /STAT (\w+) (\S+)/
+  end
+  stats.sort
+end
+
+stats = parse(stats_data)
+stats.each do |stat|
+  puts stat
+end

data/lib/memcache.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 $TESTING = defined?($TESTING) && $TESTING
 
 require 'socket'
@@ -295,11 +296,16 @@ class MemCache
   #   cache["b"] = 2
   #   cache.get_multi "a", "b" # => { "a" => 1, "b" => 2 }
   #
-  # Note that get_multi assumes the values are marshalled.
+  # Note that get_multi assumes the values are marshalled.  You can pass
+  # in :raw => true to bypass value marshalling.
+  #
+  #   cache.get_multi('a', 'b', ..., :raw => true)
 
   def get_multi(*keys)
     raise MemCacheError, 'No active servers' unless active?
 
+    opts = keys.last.is_a?(Hash) ? keys.pop : {}
+
     keys.flatten!
     key_count = keys.length
     cache_keys = {}
@@ -313,13 +319,13 @@ class MemCache
     end
 
     results = {}
-
+    raw = opts[:raw] || false
     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]] = Marshal.load value
+          results[cache_keys[key]] = raw ? value : Marshal.load(value)
         end
       rescue IndexError => e
         # Ignore this server and try the others

data/lib/memcache/event_machine.rb

@@ -0,0 +1,149 @@
+# Extensions for using memcache-client with EventMachine
+
+raise "memcache/event_machine requires Ruby 1.9" if RUBY_VERSION < '1.9'
+
+require 'fiber'
+
+class MemCache::Server
+  
+  alias :blocking_socket :socket
+    
+  def socket
+    # Support plain old TCP socket connections if the user
+    # has not setup EM.  Much easier to deal with in irb, 
+    # script/console, etc.
+    return blocking_socket if !EM.reactor_running?
+
+    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
+    
+    fiber = Fiber.current
+    @sock = EM::SocketConnection.connect(@host, @port, @timeout)
+    yielding = true
+    @sock.callback do
+      @status = 'CONNECTED'
+      @retry  = nil
+      yielding = false
+      fiber.resume if Fiber.current != fiber
+    end
+    @sock.errback do
+      yielding = false
+      fiber.resume if Fiber.current != fiber
+    end
+    Fiber.yield if yielding
+    @sock
+  end
+  
+end
+
+module EM
+  module SocketConnection
+    include EM::Deferrable
+
+    def self.connect(host, port, timeout)
+      EM.connect(host, port, self) do |conn|
+        conn.pending_connect_timeout = timeout
+      end
+    end
+
+    def initialize
+      @connected = false
+      @index = 0
+      @buf = ''
+    end
+
+    def closed?
+      !@connected
+    end
+
+    def close
+      @connected = false
+      close_connection(true)
+    end
+
+    def write(buf)
+      send_data(buf)
+    end
+
+    def read(size)
+      if can_read?(size)
+        yank(size)
+      else
+        fiber = Fiber.current
+        @size = size
+        @callback = proc { |data|
+          fiber.resume(data)
+        }
+        # TODO Can leak fiber if the connection dies while
+        # this fiber is yielded, waiting for data
+        Fiber.yield
+      end
+    end
+    
+    SEP = "\r\n"
+
+    def gets
+      while true
+        # Read to ensure we have some data in the buffer
+        line = read(2)
+        # Reset the buffer index to zero
+        @buf = @buf.slice(@index..-1)
+        @index = 0
+        if eol = @buf.index(SEP)
+          line << yank(eol + SEP.size)
+          break
+        else
+          # EOL not in the current buffer
+          line << yank(@buf.size)
+        end
+      end
+      line
+    end
+
+    def can_read?(size)
+      @buf.size >= @index + size
+    end
+
+    # EM callbacks
+
+    def receive_data(data)
+      @buf << data
+
+      if @callback and can_read?(@size)
+        callback = @callback
+        data = yank(@size)
+        @callback = @size = nil
+        callback.call(data)
+      end
+    end
+
+    def post_init
+      @connected = true
+      succeed
+    end
+
+    def unbind
+      @connected = false
+    end
+    
+    private
+    
+    BUFFER_SIZE = 4096
+
+    def yank(len)      
+      data = @buf.slice(@index, len)
+      @index += len
+      @index = @buf.size if @index > @buf.size
+      if @index >= BUFFER_SIZE
+        @buf = @buf.slice(@index..-1)
+        @index = 0
+      end
+      data
+    end
+    
+  end
+end

data/test/test_benchmark.rb

@@ -1,13 +1,8 @@
-HERE = File.dirname(__FILE__)
-$LOAD_PATH.unshift "#{HERE}/../lib"
-#$LOAD_PATH << "/Library/Ruby/Gems/1.8/gems/activesupport-2.2.2/lib/active_support/vendor/memcache-client-1.5.1"
-
 require 'benchmark'
-require 'rubygems'
 require 'test/unit'
 
 $TESTING = true
-require 'memcache' if not defined?(MemCache)
+require 'memcache'
 
 class TestBenchmark < Test::Unit::TestCase
 
@@ -34,12 +29,24 @@ class TestBenchmark < Test::Unit::TestCase
     @key5 = "Medium2"*8
     @key6 = "Long3"*40
   end
+  
+  def test_em
+    return if RUBY_VERSION < '1.9'
+    require 'eventmachine'
+    require 'memcache/event_machine'
+    puts "with EventMachine"
+    EM.run do
+      Fiber.new do
+        test_benchmark
+        EM.stop
+      end.resume
+    end
+  end
 
   def test_benchmark
     Benchmark.bm(31) do |x|
 
       n = 2500
-#      n = 1000
 
       @m = MemCache.new(*@opts)
       x.report("set:plain:memcache-client") do

data/test/test_event_machine.rb

@@ -0,0 +1,62 @@
+# encoding: ascii-8bit
+require 'test/unit'
+require 'memcache'
+
+class TestEventMachine < Test::Unit::TestCase
+
+  def test_live_server
+    return puts("Skipping EventMachine test, not Ruby 1.9") if RUBY_VERSION < '1.9'
+    return puts("Skipping EventMachine test, no live server") if !live_server?
+
+    require 'eventmachine'
+    require 'memcache/event_machine'
+    ex = nil
+    within_em do
+      begin
+        m = MemCache.new(['127.0.0.1:11211', 'localhost:11211'])
+        key1 = 'foo'
+        key2 = 'bar'*50
+        key3 = '£∞'*50
+        value1 = 'abc'
+        value2 = 'xyz'*1000
+        value3 = '∞§¶•ª'*1000
+    
+        1000.times do
+          assert_equal "STORED\r\n", m.set(key1, value1)
+          assert_equal "STORED\r\n", m.set(key2, value2)
+          assert_equal "STORED\r\n", m.set(key3, value3)
+          assert_equal value1, m.get(key1)
+          assert_equal value2, m.get(key2)
+          assert_equal value3, m.get(key3)
+          assert_equal "DELETED\r\n", m.delete(key1)
+          assert_equal "STORED\r\n", m.set(key1, value2)
+          assert_equal value2, m.get(key1)
+          assert_equal "STORED\r\n", m.set(key2, value3)
+          assert_equal value3, m.get(key2)
+          assert_equal "STORED\r\n", m.set(key3, value1)
+          assert_equal value1, m.get(key3)
+          assert_equal({ key1 => value2, key2 => value3, key3 => value1 }, 
+                       m.get_multi(key1, key2, key3))
+        end
+      rescue Exception => exp
+        puts exp.message
+        ex = exp
+      ensure
+        EM.stop
+      end
+    end
+    raise ex if ex
+  end
+  
+  private
+  
+  def within_em(&block)
+    EM.run do
+      Fiber.new(&block).resume
+    end
+  end
+  
+  def live_server?
+    TCPSocket.new('localhost', 11211) rescue nil
+  end
+end

data/test/test_mem_cache.rb

@@ -2,6 +2,9 @@
 require 'logger'
 require 'stringio'
 require 'test/unit'
+$TESTING = true
+require 'memcache'
+
 require 'rubygems'
 begin
   gem 'flexmock'
@@ -11,9 +14,6 @@ rescue LoadError => e
 end
 
 Thread.abort_on_exception = true
-$TESTING = true
-
-require File.dirname(__FILE__) + '/../lib/memcache' if not defined?(MemCache)
 
 class MemCache
 
@@ -598,6 +598,28 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal expected.sort, values.sort
   end
 
+  def test_get_multi_raw
+    server = FakeServer.new
+    server.socket.data.write "VALUE my_namespace:key 0 10\r\n"
+    server.socket.data.write "0123456789\r\n"
+    server.socket.data.write "VALUE my_namespace:keyb 0 10\r\n"
+    server.socket.data.write "9876543210\r\n"
+    server.socket.data.write "END\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    values = @cache.get_multi 'key', 'keyb', :raw => true
+
+    assert_equal "get my_namespace:key my_namespace:keyb\r\n",
+                 server.socket.written.string
+
+    expected = { 'key' => '0123456789', 'keyb' => '9876543210' }
+
+    assert_equal expected.sort, values.sort
+  end
+
   def test_get_raw
     server = FakeServer.new
     server.socket.data.write "VALUE my_namespace:key 0 10\r\n"

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.7.8
+  prerelease: false
+  segments: 
+  - 1
+  - 8
+  - 0
+  version: 1.8.0
 platform: ruby
 authors: 
 - Eric Hodel
@@ -11,14 +16,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-03 00:00:00 -06:00
-default_executable: 
+date: 2010-03-05 00:00:00 -06:00
+default_executable: memcached_top
 dependencies: []
 
 description: A Ruby library for accessing memcached.
 email: mperham@gmail.com
-executables: []
-
+executables: 
+- memcached_top
 extensions: []
 
 extra_rdoc_files: 
@@ -33,9 +38,11 @@ files:
 - VERSION.yml
 - lib/continuum_native.rb
 - lib/memcache.rb
+- lib/memcache/event_machine.rb
 - lib/memcache_util.rb
 - performance.txt
 - test/test_benchmark.rb
+- test/test_event_machine.rb
 - test/test_mem_cache.rb
 has_rdoc: true
 homepage: http://github.com/mperham/memcache-client
@@ -50,21 +57,24 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A Ruby library for accessing memcached.
 test_files: 
 - test/test_benchmark.rb
+- test/test_event_machine.rb
 - test/test_mem_cache.rb