memcached 0.14 → 0.15

data/test/profile/profile.rb

@@ -1,18 +1,13 @@
 
-HERE = File.dirname(__FILE__)
-$LOAD_PATH << "#{HERE}/../../lib/"
+require "#{File.dirname(__FILE__)}/../setup"
 
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
 require 'rubygems'
 require 'memcached'
 require 'ruby-prof'
 
-@cache = Memcached.new(
-  '127.0.0.1:43042', '127.0.0.1:43043'], 
-   :namespace => "namespace"
- )
-
 result = RubyProf.profile do  
-  load "#{HERE}/valgrind.rb"
+  load "#{HERE}/profile/valgrind.rb"
 end
 
 printer = RubyProf::GraphPrinter.new(result)

data/test/profile/valgrind.rb

@@ -1,14 +1,14 @@
 
-HERE = File.dirname(__FILE__)
-$LOAD_PATH << "#{HERE}/../../lib/"
+require "#{File.dirname(__FILE__)}/../setup"
 
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
 require 'memcached'
 require 'rubygems'
 
 class Worker  
   def initialize(method_name, iterations)
     @method = method_name || 'mixed'
-    @i = (iterations || 1000).to_i
+    @i = (iterations || 10000).to_i
 
     @key1 = "key1-"*8  
     @key2 = "key2-"*8  
@@ -17,15 +17,13 @@ class Worker
     @marshalled = Marshal.dump(@value)
     
     @opts = [
-      ['127.0.0.1:43042', '127.0.0.1:43043'], 
+      ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"], 
       {
         :buffer_requests => false,
         :no_block => false,
         :namespace => "namespace"
       }
     ]    
-    system("ruby #{HERE}/../setup.rb")
-    sleep(1)  
     @cache = Memcached.new(*@opts)
 
     @cache.set @key1, @value
@@ -103,11 +101,6 @@ class Worker
       when "clone"
         @i.times do
           cache = @cache.clone
-          cache.destroy(false)
-        end
-      when "clone-nodestroy"
-        @i.times do
-          @cache.clone      
         end
       when "servers"
         @i.times do
@@ -117,7 +110,7 @@ class Worker
         raise "No such method"
     end
     
-    @cache.destroy    
+    GC.start
   end  
   
 end

data/test/setup.rb

@@ -1,17 +1,22 @@
-
-# Start memcached
-
-HERE = File.dirname(__FILE__)
-
-`ps awx`.split("\n").grep(/4304[2-6]/).map do |process| 
-  system("kill -9 #{process.to_i}")
+  
+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"
+  system ">#{log}"
+  
+  # Network memcached
+  (43042..43046).each do |port|
+    system "memcached #{verbosity} -U #{port} -p #{port} >> #{log} 2>&1 &"
+  end
+  # Domain socket memcached
+  (0..1).each do |i|
+    system "memcached -M -s #{UNIX_SOCKET_NAME}#{i} #{verbosity} >> #{log} 2>&1 &"
+  end
 end
-
-log = "/tmp/memcached.log"
-system ">#{log}"
-
-verbosity = (ENV['DEBUG'] ? "-vv" : "")
-
-(43042..43046).each do |port|
-  system "memcached #{verbosity} -p #{port} >> #{log} 2>&1 &"
-end

data/test/test_helper.rb

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

data/test/unit/memcached_test.rb

@@ -1,12 +1,13 @@
-
+ 
 require "#{File.dirname(__FILE__)}/../test_helper"
 require 'socket'
+require 'mocha'
 require 'benchmark'
 
 class MemcachedTest < Test::Unit::TestCase
 
   def setup
-    @servers = ['localhost:43042', 'localhost:43043']
+    @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_'
@@ -18,6 +19,14 @@ class MemcachedTest < Test::Unit::TestCase
     }
     @cache = Memcached.new(@servers, @options)
 
+    @udp_options = {
+      :prefix_key => @prefix_key,
+      :hash => :default,
+      :udp => true,
+      :distribution => :modula
+    }
+    @udp_cache = Memcached.new(@servers, @udp_options)
+
     @nb_options = {
       :prefix_key => @prefix_key,
       :no_block => true,
@@ -35,10 +44,9 @@ class MemcachedTest < Test::Unit::TestCase
   def test_initialize
     cache = Memcached.new @servers, :prefix_key => 'test'
     assert_equal 'test', cache.options[:prefix_key]
-    assert_equal 2, cache.send(:server_structs).size
+    assert_equal 3, cache.send(:server_structs).size
     assert_equal 'localhost', cache.send(:server_structs).first.hostname
-    assert_equal 'localhost', cache.send(:server_structs).last.hostname
-    assert_equal 43043, cache.send(:server_structs).last.port
+    assert_equal 43042, cache.send(:server_structs).first.port
   end
 
   def test_initialize_with_ip_addresses
@@ -69,6 +77,12 @@ class MemcachedTest < Test::Unit::TestCase
     end
   end
 
+  def test_initialize_with_ip_address_and_options
+    cache = Memcached.new '127.0.0.1:43042', :ketama_weighted => false
+    assert_equal '127.0.0.1', cache.send(:server_structs).first.hostname
+    assert_equal false, cache.options[:ketama_weighted]
+  end
+
   def test_options_are_set
     Memcached::DEFAULTS.merge(@nb_options).each do |key, expected|
       value = @nb_cache.options[key]
@@ -120,7 +134,7 @@ class MemcachedTest < Test::Unit::TestCase
   def test_initialize_without_prefix_key
     cache = Memcached.new @servers
     assert_equal nil, cache.options[:prefix_key]
-    assert_equal 2, cache.send(:server_structs).size
+    assert_equal 3, cache.send(:server_structs).size
   end
 
   def test_initialize_negative_behavior
@@ -204,6 +218,12 @@ class MemcachedTest < Test::Unit::TestCase
     result = @cache.get key
     assert_equal @value, result
   end
+  
+  def test_udp_get
+    @udp_cache.set key, @value
+    result = @udp_cache.get key
+    assert_equal @value, result
+  end  
 
   def test_get_nil
     @cache.set key, nil, 0
@@ -222,21 +242,21 @@ class MemcachedTest < Test::Unit::TestCase
     socket = stub_server 43047
     cache = Memcached.new("localhost:43047:1", :timeout => 0.5)
     assert 0.49 < (Benchmark.measure do
-      assert_raise(Memcached::UnknownReadFailure) do
+      assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
 
     cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.001, :rcv_timeout => 0.5)
     assert 0.49 < (Benchmark.measure do
-      assert_raise(Memcached::UnknownReadFailure) do
+      assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
 
     cache = Memcached.new("localhost:43047:1", :poll_timeout => 0.25, :rcv_timeout => 0.25)
-    assert 0.4 > (Benchmark.measure do
-      assert_raise(Memcached::UnknownReadFailure) do
+    assert 0.51 > (Benchmark.measure do
+      assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
@@ -246,14 +266,14 @@ class MemcachedTest < Test::Unit::TestCase
     socket = stub_server 43048
     cache = Memcached.new("localhost:43048:1", :no_block => true, :timeout => 0.25)
     assert 0.24 < (Benchmark.measure do
-      assert_raise(Memcached::UnknownReadFailure) do
+      assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
 
     cache = Memcached.new("localhost:43048:1", :no_block => true, :poll_timeout => 0.25, :rcv_timeout => 0.001)
     assert 0.24 < (Benchmark.measure do
-      assert_raise(Memcached::UnknownReadFailure) do
+      assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
@@ -263,7 +283,7 @@ class MemcachedTest < Test::Unit::TestCase
       :rcv_timeout => 0.25 # No affect in no-block mode
     )
     assert 0.24 > (Benchmark.measure do
-      assert_raise(Memcached::UnknownReadFailure) do
+      assert_raise(Memcached::ATimeoutOccurred) do
         result = cache.get key
       end
     end).real
@@ -379,6 +399,12 @@ class MemcachedTest < Test::Unit::TestCase
     end
   end
 
+  def test_udp_set
+    assert_nothing_raised do
+      @udp_cache.set(key, @value)
+    end
+  end
+
   def test_set_expiry
     @cache.set key, @value, 1
     assert_nothing_raised do
@@ -655,17 +681,25 @@ class MemcachedTest < Test::Unit::TestCase
     end
   end
 
-  def test_set_object_too_large
-    assert_raise(Memcached::ServerError) do
-      @cache.set key, "I'm big" * 1000000
-    end
+  def test_server_error_message
+    @cache.set key, "I'm big" * 1000000
+    assert false # Never reached
+  rescue Memcached::ServerError => e
+    assert_match /^"object too large for cache". Key/, e.message
+  end
+  
+  def test_errno_message
+    Rlibmemcached::MemcachedServerSt.any_instance.expects("cached_errno").returns(1)
+    @cache.send(:check_return_code, Rlibmemcached::MEMCACHED_ERRNO, key)    
+  rescue Memcached::SystemError => e
+    assert_match /^Errno 1: "Operation not permitted". Key/, e.message
   end
 
   # Stats
 
   def test_stats
     stats = @cache.stats
-    assert_equal 2, stats[:pid].size
+    assert_equal 3, stats[:pid].size
     assert_instance_of Fixnum, stats[:pid].first
     assert_instance_of String, stats[:version].first
   end
@@ -753,30 +787,64 @@ class MemcachedTest < Test::Unit::TestCase
 
   # Server removal and consistent hashing
 
-  def test_missing_server
+  def test_unresponsive_server
     socket = stub_server 43041  
     cache = Memcached.new(
       [@servers.last, 'localhost:43041'],
       :prefix_key => @prefix_key,
       :auto_eject_hosts => true,
-      :server_failure_limit => 1,
+      :server_failure_limit => 2,
       :retry_timeout => 1,
       :hash_with_prefix_key => false,
       :hash => :md5
     )
 
-    # Hit first server
-    key1 = 'test_missing_server6'
-    cache.set(key1, @value)
-    cache.get(key1) == @value
+    # Hit second server up to the server_failure_limit 
+    key2 = 'test_missing_server'
+    assert_raise(Memcached::ATimeoutOccurred) { cache.set(key2, @value) }
+    assert_raise(Memcached::ATimeoutOccurred) { cache.get(key2, @value) }
 
-    # Hit second server
+    # Hit second server and pass the limit
     key2 = 'test_missing_server'
-    assert_raise(Memcached::UnknownReadFailure) do
+    begin
+      cache.get(key2)
+    rescue => e
+      assert_equal Memcached::ServerIsMarkedDead, e.class
+      assert_match /localhost:43041/, e.message
+    end
+
+    # Hit first server on retry
+    assert_nothing_raised do
       cache.set(key2, @value)
+      assert_equal cache.get(key2), @value
     end
+    
+    sleep(2)
+    
+    # Hit second server again after restore, expect same failure
+    key2 = 'test_missing_server'
+    assert_raise(Memcached::ATimeoutOccurred) do
+      cache.set(key2, @value)
+    end        
+  end
 
-    # Hit second server again
+  def test_missing_server
+    cache = Memcached.new(
+      [@servers.last, 'localhost:43041'],
+      :prefix_key => @prefix_key,
+      :auto_eject_hosts => true,
+      :server_failure_limit => 2,
+      :retry_timeout => 1,
+      :hash_with_prefix_key => false,
+      :hash => :md5
+    )
+
+    # Hit second server up to the server_failure_limit 
+    key2 = 'test_missing_server'
+    assert_raise(Memcached::SystemError) { cache.set(key2, @value) }
+    assert_raise(Memcached::SystemError) { cache.get(key2, @value) }
+
+    # Hit second server and pass the limit
     key2 = 'test_missing_server'
     begin
       cache.get(key2)
@@ -788,14 +856,14 @@ class MemcachedTest < Test::Unit::TestCase
     # Hit first server on retry
     assert_nothing_raised do
       cache.set(key2, @value)
-      cache.get(key2)
+      assert_equal cache.get(key2), @value
     end
     
     sleep(2)
     
     # Hit second server again after restore, expect same failure
     key2 = 'test_missing_server'
-    assert_raise(Memcached::UnknownReadFailure) do
+    assert_raise(Memcached::SystemError) do
       cache.set(key2, @value)
     end        
   end
@@ -849,7 +917,7 @@ class MemcachedTest < Test::Unit::TestCase
     threads.each {|thread| thread.join}
   end
   
-  # Hash
+  # Hash  
   
   def test_hash
     assert_equal 3157003241, 

data/test/unit/rails_test.rb

@@ -4,7 +4,7 @@ require "#{File.dirname(__FILE__)}/../test_helper"
 class RailsTest < Test::Unit::TestCase
 
   def setup
-    @servers = ['127.0.0.1:43042', '127.0.0.1:43043']
+    @servers = ['127.0.0.1:43042', '127.0.0.1:43043', "#{UNIX_SOCKET_NAME}0"]
     @namespace = 'rails_test'
     @cache = Memcached::Rails.new(:servers => @servers, :namespace => @namespace)
     @value = OpenStruct.new(:a => 1, :b => 2, :c => GenericClass)
@@ -19,7 +19,7 @@ class RailsTest < Test::Unit::TestCase
   
   def test_get_multi
     @cache.set key, @value
-    result = @cache.get_multi key
+    result = @cache.get_multi([key])
     assert_equal(
       {key => @value}, 
       result
@@ -47,6 +47,36 @@ class RailsTest < Test::Unit::TestCase
     assert_equal @value, result
   end
   
+  def test_cas
+    cache = Memcached::Rails.new(:servers => @servers, :namespace => @namespace, :support_cas => true)
+    value2 = OpenStruct.new(:d => 3, :e => 4, :f => GenericClass)
+
+    # Existing set
+    cache.set key, @value
+    cache.cas(key) do |current|
+      assert_equal @value, current
+      value2
+    end
+    assert_equal value2, cache.get(key)
+
+    # Missing set
+    cache.delete key
+    assert_nothing_raised do
+      cache.cas(key) { @called = true }
+    end
+    assert_nil cache.get(key)
+    assert_nil @called
+
+    # Conflicting set
+    cache.set key, @value
+    assert_raises(Memcached::ConnectionDataExists) do
+      cache.cas(key) do |current|
+        cache.set key, value2
+        current
+      end
+    end
+  end  
+  
   def test_get_missing
     @cache.delete key rescue nil
     result = @cache.get key