dalli_memcached 1.8.0

data/test/profile/c_profiler.rb

@@ -0,0 +1,14 @@
+require "#{File.dirname(__FILE__)}/../setup"
+
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
+require 'memcached'
+
+profile = "/tmp/memcached_#{Memcached::VERSION}_c"
+
+system("env CPUPROFILE_FREQUENCY=500 CPUPROFILE=#{profile}.out DYLD_INSERT_LIBRARIES=/opt/local/lib/libprofiler.dylib ruby -r#{File.dirname(__FILE__)}/exercise -e \"Worker.new('mixed', 200000).work\"")
+
+ruby = `which ruby`.chomp
+
+system("pprof --nodefraction=0.0000001 --text #{ruby} #{profile}.out")
+system("pprof --nodefraction=0.0000001 --pdf #{ruby} #{profile}.out > #{profile}.pdf")
+system("open #{profile}.pdf")

data/test/profile/exercise.rb

@@ -0,0 +1,185 @@
+
+require "#{File.dirname(__FILE__)}/../setup"
+
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
+require 'memcached'
+require 'rubygems'
+require 'ostruct'
+
+GC.copy_on_write_friendly = true if GC.respond_to?("copy_on_write_friendly=")
+
+class Worker
+  def initialize(method_name, iterations, with_memory = 'false')
+    @method = method_name || 'mixed'
+    @i = (iterations || 10000).to_i
+    @with_memory = with_memory
+
+    puts "*** Running #{@method.inspect} test for #{@i} loops. ***"
+
+    @key1 = "key1--------------------------------"
+    @key2 = "key2--------------------------------"
+    @key3 = "key3--------------------------------"
+
+    @value = OpenStruct.new(
+      :a => 1, :b => 2, "array" => [1, 2, 3], "hash" => {:badger => 1}
+    )
+    @marshalled = Marshal.dump(@value)
+
+    @opts = [
+      ['localhost:43042', 'localhost:43043', 'localhost:43044'],
+      {
+        :buffer_requests => true,
+        :no_block => true,
+        :noreply => false,
+        :namespace => "namespace"
+      }
+    ]
+    @cache = Memcached::Rails.new(*@opts)
+
+    @cache.set @key1, @value
+  end
+
+  def work
+    case @method
+      when "set"
+        @i.times do
+          @cache.set @key1, @value
+        end
+      when "get"
+        @i.times do
+          @cache.get @key1
+        end
+      when "delete"
+        @i.times do
+          @cache.set @key1, @value
+          @cache.delete @key1
+        end
+      when "delete-miss"
+        @i.times do
+          @cache.delete @key1
+        end
+      when "get-miss"
+        @i.times do
+          @cache.get @key2
+        end
+      when "get-increasing"
+        one_k = "x"*1024
+        @i.times do |i|
+          @cache.set @key1, one_k*(i+1), 0, false
+          @cache.get @key1, false
+        end
+      when "get-miss-increasing"
+        @i.times do |i|
+          @cache.delete @key2
+          @cache.get @key2
+        end
+      when "add"
+        @i.times do
+          @cache.delete @key1
+          @cache.add @key1, @value
+        end
+      when "add-present"
+        @cache.set @key1, @value
+        @i.times do
+          @cache.add @key1, @value
+        end
+      when "mixed"
+        @i.times do
+          @cache.set @key1, @value
+          @cache.set @key2, @value
+          @cache.get @key1
+          @cache.get @key3
+          @cache.get [@key1, @key2, @key3]
+          @cache.prepend @key1, @marshalled
+          @cache.prepend @key2, @marshalled
+          @cache.delete @key1
+          @cache.delete @key2
+        end
+      when "everything"
+        @i.times do
+          @cache.set @key1, @value
+          @cache.set @key2, @value
+          @cache.get @key1
+          @cache.get @key3
+          @cache.get [@key1, @key2, @key3]
+          @cache.prepend @key1, @marshalled
+          @cache.prepend @key2, @marshalled
+          @cache.delete @key1
+          @cache.delete @key2
+          @cache.prepend @key1, @marshalled
+          @cache.prepend @key2, @marshalled
+          @cache.get @key1
+          @cache.get @key3
+          cache = Memcached::Rails.new(*@opts)
+          cache = @cache.clone
+          servers = @cache.servers
+          server = @cache.server_by_key(@key1)
+          @cache.stats
+        end
+        @i.times do
+          @cache.reset
+        end
+        system("killall -9 memcached")
+        @i.times do
+          @cache.set @key1, @value rescue nil
+          @cache.get @key3 rescue nil
+          @cache.delete @key2 rescue nil
+        end
+      when "stats"
+        @cache.stats
+      when "multiget"
+        @i.times do
+          @cache.get([@key1, @key2, @key3])
+        end
+      when "clone"
+        @i.times do
+          cache = @cache.clone
+        end
+      when "reset"
+        @i.times do
+          @cache.reset
+        end
+      when "servers"
+        @i.times do
+          @cache.servers
+        end
+      when "server_by_key"
+        @i.times do
+          @cache.server_by_key(@key1)
+        end
+      when "server_error"
+        @i.times do
+          begin
+            @cache.set @key1, "I'm big" * 1000000
+          rescue
+          end
+        end
+      else
+        raise "No such method"
+    end
+
+    @cache = nil
+
+    if @with_memory == "true"
+      puts "*** Garbage collect. ***"
+      10.times do
+        GC.start
+        sleep 0.1
+      end
+
+      sts, server_sts, clients = 0, 0, 0
+      ObjectSpace.each_object(Memcached) { clients += 1 }
+      ObjectSpace.each_object(Rlibmemcached::MemcachedSt) { sts += 1 }
+      ObjectSpace.each_object(Rlibmemcached::MemcachedServerSt) { server_sts += 1 }
+      puts "*** memcached_st structs: #{sts} ***"
+      puts "*** memcached_server_st structs: #{server_sts} ***"
+      puts "*** Memcached instances: #{clients} ***"
+
+      begin;
+        require 'memory'
+        Process.memory.each { |key, value| puts "#{key}: #{value/1024.0}M" }
+      rescue LoadError
+      end
+    end
+  end
+end

data/test/profile/rb_profiler.rb

@@ -0,0 +1,21 @@
+
+require "#{File.dirname(__FILE__)}/../setup"
+
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
+
+ENV['CPUPROFILE_FREQUENCY'] = '500'
+require 'memcached'
+require 'rubygems'
+require 'perftools'
+require "#{HERE}/profile/exercise"
+
+profile = "/tmp/memcached_#{Memcached::VERSION}_rb"
+worker = Worker.new('mixed', 200000)
+
+PerfTools::CpuProfiler.start("#{profile}.out") do
+  worker.work
+end
+
+system("pprof.rb --nodefraction=0.0000001 --text #{profile}.out")
+system("pprof.rb --nodefraction=0.0000001 --edgefraction=0.0000001 --pdf #{profile}.out > #{profile}.pdf")
+system("open #{profile}.pdf")

data/test/profile/valgrind.rb

@@ -0,0 +1,10 @@
+require "#{File.dirname(__FILE__)}/../setup"
+
+COMMAND =  "--dsymutil=yes ruby -r#{File.dirname(__FILE__)}/exercise.rb -e \"Worker.new(ENV['TEST'] || 'everything', (ENV['LOOPS'] || 50).to_i, 'true').work\""
+
+case ENV["TOOL"]
+when nil, "memcheck":
+  exec("valgrind --tool=memcheck --error-limit=no --undef-value-errors=no --leak-check=full --show-reachable=no --num-callers=15 --track-fds=yes --workaround-gcc296-bugs=yes --leak-resolution=med --max-stackframe=7304328 #{COMMAND}")
+when "massif":
+  exec("valgrind --tool=massif --time-unit=B #{COMMAND}")
+end

data/test/setup.rb

@@ -0,0 +1,30 @@
+
+unless defined? UNIX_SOCKET_NAME
+  HERE = File.dirname(__FILE__)
+  UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached')
+
+  # Kill memcached
+  system("killall -9 memcached")
+
+  # Start memcached
+  verbosity = (ENV['DEBUG'] ? "-vv" : "")
+  log = "/tmp/memcached.log"
+  memcached = ENV['MEMCACHED_COMMAND'] || 'memcached'
+  system ">#{log}"
+
+  # TCP memcached
+  (43042..43046).each do |port|
+    cmd = "#{memcached} #{verbosity} -U 0 -p #{port} >> #{log} 2>&1 &"
+    raise "'#{cmd}' failed to start" unless system(cmd)
+  end
+  # UDP memcached
+  (43052..43053).each do |port|
+    cmd = "#{memcached} #{verbosity} -U #{port} -p 0 >> #{log} 2>&1 &"
+    raise "'#{cmd}' failed to start" unless system(cmd)
+  end
+  # Domain socket memcached
+  (0..1).each do |i|
+    cmd = "#{memcached} -M -s #{UNIX_SOCKET_NAME}#{i} #{verbosity} >> #{log} 2>&1 &"
+    raise "'#{cmd}' failed to start" unless system(cmd)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../lib"
+
+require 'socket'
+require 'benchmark'
+
+require 'rubygems'
+require 'ruby-debug' if ENV['DEBUG']
+require 'memcached'
+
+require 'test/unit'
+require 'test/unit/assertions'
+require 'mocha/test_unit'
+require 'ostruct'
+
+UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached') unless defined? UNIX_SOCKET_NAME
+
+class GenericClass
+end

data/test/unit/binding_test.rb

@@ -0,0 +1,8 @@
+
+require File.expand_path("#{File.dirname(__FILE__)}/../test_helper")
+
+class BindingTest < Test::Unit::TestCase
+  def test_libmemcached_loaded
+    assert_nothing_raised { Rlibmemcached }
+  end
+end

data/test/unit/memcached_experimental_test.rb

@@ -0,0 +1,272 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../test_helper")
+
+class MemcachedExperimentalTest < Test::Unit::TestCase
+
+  def setup
+    @servers = ['localhost:43042', 'localhost:43043', "#{UNIX_SOCKET_NAME}0"]
+
+    # Maximum allowed prefix key size for :hash_with_prefix_key_key => false
+    @prefix_key = 'prefix_key_'
+
+    @options = {
+      :prefix_key => @prefix_key,
+      :hash => :default,
+      :distribution => :modula}
+    @cache = Memcached.new(@servers, @options)
+
+    @experimental_options = {
+      :prefix_key => @prefix_key,
+      :hash => :default,
+      :distribution => :modula,
+      :experimental_features => true}
+    @experimental_cache = Memcached.new(@servers, @experimental_options)
+
+    @experimental_cas_options = {
+      :prefix_key => @prefix_key,
+      :support_cas => true,
+      :experimental_features => true}
+    @experimental_cas_cache = Memcached.new(@servers, @experimental_cas_options)
+
+    @experimental_binary_protocol_options = {
+      :prefix_key => @prefix_key,
+      :hash => :default,
+      :distribution => :modula,
+      :experimental_features => true,
+      # binary_protocol does not work -- test_get, test_get, test_append, and test_missing_append will fail when it is set to true.
+      :binary_protocol => true}
+    @experimental_binary_protocol_cache = Memcached.new(@servers, @experimental_binary_protocol_options)
+
+    @value = OpenStruct.new(:a => 1, :b => 2, :c => GenericClass)
+  end
+
+  def server_get_len_capable
+    begin
+      value = "foobar"
+      @experimental_cache.set key, value, 0, false
+      @experimental_cache.get_len 1, key
+      yield
+    rescue Memcached::ProtocolError
+      # Skip tests when the server does not support the experimental get_len command.
+    end
+  end
+
+  def server_touch_capable
+    @experimental_binary_protocol_cache.set(key, 'touchval')
+    @experimental_binary_protocol_cache.touch(key)
+    yield
+  rescue Memcached::ProtocolError
+    # Skip tests when the server does not support the experimental touch command
+  end
+
+  def test_get_len
+    server_get_len_capable do
+      value = "foobar"
+      @experimental_cache.set key, value, 0, false
+      result = @experimental_cache.get_len 1, key
+      assert_equal result.size, 1
+      assert_equal result, value[0..0]
+
+      result = @experimental_cache.get_len 2, key
+      assert_equal result.size, 2
+      assert_equal result, value[0..1]
+
+      result = @experimental_cache.get_len 5, key
+      assert_equal result.size, 5
+      assert_equal result, value[0..4]
+
+      result = @experimental_cache.get_len 6, key
+      assert_equal result.size, 6
+      assert_equal result, value
+
+      result = @experimental_cache.get_len 32, key
+      assert_equal result.size, 6
+      assert_equal result, value
+    end
+  end
+
+  def test_get_len_0_failure
+    server_get_len_capable do
+      value = "Test that we cannot get 0 bytes with a get_len call."
+      @experimental_cache.set key, value, 0, false
+      assert_raises(Memcached::Failure) do
+        result = @experimental_cache.get_len 0, key
+      end
+    end
+  end
+
+  def test_get_len_large
+    server_get_len_capable do
+      value = "Test that we can get the first 20 bytes of a string"
+      @experimental_cache.set key, value, 0, false
+      result = @experimental_cache.get_len 20, key
+      assert_equal result.size, 20
+      assert_equal result, value[0..19]
+    end
+  end
+
+  def test_get_len_packed
+    server_get_len_capable do
+      value = [1, 2, 3, 4].pack("Q*")
+      @experimental_cache.set key, value, 0, false
+      result = @experimental_cache.get_len 8, key
+      assert_equal [1], result.unpack("Q*")
+    end
+  end
+
+  # get_len is not supported when using the binary protocol.
+  # Make sure the single get variant fails appropriately.
+  def test_get_len_binary
+    server_get_len_capable do
+      @experimental_binary_protocol_cache.set key, @value
+      assert_raises(Memcached::ActionNotSupported) do
+        result = @experimental_binary_protocol_cache.get_len 2, key
+      end
+    end
+  end
+
+  # Retrieve the first 64 bits of the values for multiple keys.
+  def test_get_len_multi_packed
+    server_get_len_capable do
+      key_1 = "get_len_1"
+      value_1 = [1, 2, 3].pack("Q*")
+      key_2 = "get_len_missing"
+      key_3 = "get_len_2"
+      value_3 = [5, 6, 4].pack("Q*")
+      keys = [key_1, key_2, key_3]
+      @experimental_cache.set key_1, value_1, 0, false
+      @experimental_cache.set key_3, value_3, 0, false
+      assert_equal(
+        {key_1=>value_1[0..7], key_3=>value_3[0..7]},
+        @experimental_cache.get_len(8, keys)
+      )
+    end
+  end
+
+  # Test that the entire value is passed back when the length specified
+  # is larger than any of the values (e.g., 32 in the case below).
+  def test_get_len_multi_packed_full
+    server_get_len_capable do
+      key_1 = "get_len_1"
+      value_1 = [1, 2, 3].pack("Q*")
+      key_2 = "get_len_missing"
+      key_3 = "get_len_2"
+      value_3 = [5, 6, 4].pack("Q*")
+      keys = [key_1, key_2, key_3]
+      @experimental_cache.set key_1, value_1, 0, false
+      @experimental_cache.set key_3, value_3, 0, false
+      assert_equal(
+        {key_1=>value_1, key_3=>value_3},
+        @experimental_cache.get_len(32, keys)
+      )
+    end
+  end
+
+  # get_len is not supported when using the binary protocol.
+  # Test that the multi get variant fails appropriately.
+  def test_get_len_multi_packed_binary
+    server_get_len_capable do
+      key_1 = "get_len_1"
+      value_1 = [1, 2, 3].pack("Q*")
+      key_2 = "get_len_2"
+      value_2 = [5, 6, 4].pack("Q*")
+      keys = [key_1, key_2]
+      @experimental_binary_protocol_cache.set key_1, value_1, 0, false
+      @experimental_binary_protocol_cache.set key_2, value_2, 0, false
+      assert_raises(Memcached::ActionNotSupported) do
+        result = @experimental_binary_protocol_cache.get_len 2, keys
+      end
+    end
+  end
+
+  def test_get_len_multi_completely_missing
+    server_get_len_capable do
+      @experimental_cache.delete "#{key}_1" rescue nil
+      @experimental_cache.delete "#{key}_2" rescue nil
+      assert_equal(
+        {},
+        @experimental_cache.get_len(1, ["#{key}_1", "#{key}_2"])
+       )
+    end
+  end
+
+  def test_get_len_failure
+    server_get_len_capable do
+      value = "Test that we cannot use get_len without setting the :experimental_features config."
+      assert_raises(NoMethodError) do
+        result = @cache.get_len 10, key
+      end
+    end
+  end
+
+  def test_cas
+    server_get_len_capable do
+      # Get the first three chars of the value back.
+      @experimental_cas_cache.set(key, "foo_bar", 0, false)
+      assert_equal "foo", @experimental_cas_cache.get_len(3, key)
+      assert_equal "foo_bar", @experimental_cas_cache.get_len(7, key)
+    end
+  end
+
+  # Touch command
+
+  def test_touch_capability
+    server_touch_capable do
+      @experimental_binary_protocol_cache.set(key, "value", 10)
+      assert_nothing_raised do
+        @experimental_binary_protocol_cache.touch(key, 20)
+      end
+      assert_raises(Memcached::ActionNotSupported) do
+        @experimental_cache.touch(key, 10)
+      end
+    end
+  end
+
+  def test_touch_missing_key
+    server_touch_capable do
+      @experimental_binary_protocol_cache.delete key rescue nil
+      assert_raises(Memcached::NotFound) do
+        @experimental_binary_protocol_cache.touch(key, 10)
+      end
+    end
+  end
+
+  def test_touch
+    server_touch_capable do
+      @experimental_binary_protocol_cache.set key, @value, 2
+      assert_equal @value, @experimental_binary_protocol_cache.get(key)
+      sleep(1)
+      assert_equal @value, @experimental_binary_protocol_cache.get(key)
+      @experimental_binary_protocol_cache.touch(key, 3)
+      sleep(2)
+      assert_equal @value, @experimental_binary_protocol_cache.get(key)
+      sleep(2)
+      assert_raises(Memcached::NotFound) do
+        @experimental_binary_protocol_cache.get(key)
+      end
+    end
+  end
+
+  # Memory cleanup
+
+  def test_reset
+    original_struct = @cache.instance_variable_get("@struct")
+    assert_nothing_raised do
+      @cache.reset
+    end
+    assert_not_equal original_struct,
+      @cache.instance_variable_get("@struct")
+  end
+
+  private
+
+  def key
+    caller.first[/.*[` ](.*)'/, 1] # '
+  end
+
+  def stub_server(port)
+    socket = TCPServer.new('127.0.0.1', port)
+    Thread.new { socket.accept }
+    socket
+  end
+
+end