memcached 0.10 → 0.11

data/test/profile/benchmark.rb

@@ -44,7 +44,7 @@ class Bench
       {
         :buffer_requests => false,
         :no_block => false,
-        :namespace => "benchmark_namespace"
+        :namespace => "namespace"
       }
     ]
     @key1 = "Short"

data/test/profile/profile.rb

@@ -8,7 +8,7 @@ require 'ruby-prof'
 
 @cache = Memcached.new(
   '127.0.0.1:43042', '127.0.0.1:43043'], 
-   :namespace => "benchmark_namespace"
+   :namespace => "namespace"
  )
 
 result = RubyProf.profile do  

data/test/profile/valgrind.rb

@@ -21,7 +21,7 @@ class Worker
       {
         :buffer_requests => false,
         :no_block => false,
-        :namespace => "benchmark_namespace"
+        :namespace => "namespace"
       }
     ]    
     system("ruby #{HERE}/../setup.rb")

data/test/unit/memcached_test.rb

@@ -4,18 +4,20 @@ require "#{File.dirname(__FILE__)}/../test_helper"
 class MemcachedTest < Test::Unit::TestCase
 
   def setup
-    @servers = ['127.0.0.1:43042', '127.0.0.1:43043']
-    @namespace = 'memcached_test_namespace'
+    @servers = ['localhost:43042', 'localhost:43043']
+
+    # Maximum allowed prefix key size
+    @prefix_key = 'prefix_key_' 
     
     @options = {      
-      :namespace => @namespace, 
+      :prefix_key => @prefix_key, 
       :hash => :default,
       :distribution => :modula
     }
     @cache = Memcached.new(@servers, @options)
     
     @nb_options = {
-      :namespace => @namespace, 
+      :prefix_key => @prefix_key, 
       :no_block => true, 
       :buffer_requests => true, 
       :hash => :default
@@ -25,24 +27,30 @@ class MemcachedTest < Test::Unit::TestCase
     @value = OpenStruct.new(:a => 1, :b => 2, :c => GenericClass)
     @marshalled_value = Marshal.dump(@value)
   end
-  
-  def teardown
-    ObjectSpace.each_object(Memcached) do |cache|
-      cache.destroy rescue Memcached::ClientError
-    end
-  end
-  
+    
   # Initialize
 
   def test_initialize
-    cache = Memcached.new @servers, :namespace => 'test'
-    assert_equal 'test', cache.options[:namespace]
+    cache = Memcached.new @servers, :prefix_key => 'test'
+    assert_equal 'test', cache.options[:prefix_key]
     assert_equal 2, 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
+  end
+  
+  def test_initialize_with_ip_addresses
+    cache = Memcached.new ['127.0.0.1:43042', '127.0.0.1:43043'], :prefix_key => 'test'  
     assert_equal '127.0.0.1', cache.send(:server_structs).first.hostname
     assert_equal '127.0.0.1', cache.send(:server_structs).last.hostname
-    assert_equal 43043, cache.send(:server_structs).last.port
   end
   
+  def test_initialize_without_port
+    cache = Memcached.new ['localhost'], :prefix_key => 'test'
+    assert_equal 'localhost', cache.send(:server_structs).first.hostname
+    assert_equal 11211, cache.send(:server_structs).first.port
+  end
+
   def test_options_are_set
     Memcached::DEFAULTS.merge(@nb_options).each do |key, expected|
       value = @nb_cache.options[key]
@@ -55,19 +63,29 @@ class MemcachedTest < Test::Unit::TestCase
       @cache.options[:no_block] = true
     end
   end
-  
-  def test_destroy
-    cache = Memcached.new @servers, :namespace => 'test'
-    cache.destroy
-    assert_raise(Memcached::ClientError) do
-      cache.get key
+    
+  def test_behaviors_are_set
+    Memcached::BEHAVIORS.keys.each do |key, value|
+      assert_not_nil @cache.send(:get_behavior, key)
     end
   end
-  
+
   def test_initialize_with_invalid_server_strings
-    assert_raise(ArgumentError) { Memcached.new "localhost:43042" }
-    assert_raise(ArgumentError) { Memcached.new "127.0.0.1:memcached" }
-    assert_raise(ArgumentError) { Memcached.new "127.0.0.1:43043:1" }
+    assert_raise(ArgumentError) { Memcached.new ":43042" }
+    assert_raise(ArgumentError) { Memcached.new "localhost:memcached" }
+    assert_raise(ArgumentError) { Memcached.new "local host:43043:1" }
+  end
+  
+  if ENV['USER'] == "eweaver"
+    def test_initialize_with_resolvable_hosts
+     `hostname` =~ /(chloe|mackenzie)/
+      host = "#{$1}.lan"
+      cache = Memcached.new ["#{host}:43042"]
+      assert_equal host, cache.send(:server_structs).first.hostname
+      
+      cache.set(key, @value)
+      assert_equal @value, cache.get(key)
+    end
   end
   
   def test_initialize_with_invalid_options
@@ -75,10 +93,16 @@ class MemcachedTest < Test::Unit::TestCase
       Memcached.new @servers, :sort_hosts => true, :distribution => :consistent
     end
   end
+
+  def test_initialize_with_invalid_prefix_key
+    assert_raise(ArgumentError) do 
+      Memcached.new @servers, :prefix_key => "prefix_key__"
+    end
+  end
   
-  def test_initialize_without_namespace
+  def test_initialize_without_prefix_key
     cache = Memcached.new @servers
-    assert_equal nil, cache.options[:namespace]
+    assert_equal nil, cache.options[:prefix_key]
     assert_equal 2, cache.send(:server_structs).size
   end
   
@@ -120,7 +144,6 @@ class MemcachedTest < Test::Unit::TestCase
     )
     assert_equal @servers.sort, 
       cache.servers
-    cache.destroy
 
     # Original with sort_hosts
     cache = Memcached.new(@servers.sort,
@@ -129,7 +152,6 @@ class MemcachedTest < Test::Unit::TestCase
     )
     assert_equal @servers.sort, 
       cache.servers
-    cache.destroy
     
     # Reversed 
     cache = Memcached.new(@servers.sort.reverse,
@@ -138,7 +160,6 @@ class MemcachedTest < Test::Unit::TestCase
     )
       assert_equal @servers.sort.reverse, 
     cache.servers
-    cache.destroy
       
     # Reversed with sort_hosts
     cache = Memcached.new(@servers.sort.reverse,
@@ -147,12 +168,11 @@ class MemcachedTest < Test::Unit::TestCase
     )
     assert_equal @servers.sort, 
       cache.servers
-    cache.destroy
   end
   
   def test_initialize_single_server
-    cache = Memcached.new '127.0.0.1:43042'
-    assert_equal nil, cache.options[:namespace]
+    cache = Memcached.new 'localhost:43042'
+    assert_equal nil, cache.options[:prefix_key]
     assert_equal 1, cache.send(:server_structs).size
   end
 
@@ -167,16 +187,6 @@ class MemcachedTest < Test::Unit::TestCase
     result = @cache.get key
     assert_equal @value, result
   end
-  
-  def test_get_with_namespace
-    @cache.set key, @value
-    result = @cache.get key, false
-    direct_result = Rlibmemcached.memcached_get(
-      @cache.instance_variable_get("@struct"), 
-      "#{@namespace}#{key}"
-    ).first  
-    assert_equal result, direct_result
-  end
 
   def test_get_nil
     @cache.set key, nil, 0
@@ -190,6 +200,29 @@ class MemcachedTest < Test::Unit::TestCase
       result = @cache.get key
     end
   end
+  
+  def test_get_with_prefix_key
+    # Prefix_key
+    cache = Memcached.new(
+      # We can only use one server because the key is hashed separately from the prefix key
+      @servers.first,
+      :prefix_key => @prefix_key, 
+      :hash => :default,
+      :distribution => :modula
+    )
+    cache.set key, @value
+    assert_equal @value, cache.get(key)
+    
+    # No prefix_key specified
+    cache = Memcached.new(
+      @servers.first,
+      :hash => :default,
+      :distribution => :modula
+    )
+    assert_nothing_raised do    
+      assert_equal @value, cache.get("#{@prefix_key}#{key}")
+    end
+  end
 
   def test_values_with_null_characters_are_not_truncated
     value = OpenStruct.new(:a => Object.new) # Marshals with a null \000
@@ -197,7 +230,7 @@ class MemcachedTest < Test::Unit::TestCase
     result = @cache.get key, false
     non_wrapped_result = Rlibmemcached.memcached_get(
       @cache.instance_variable_get("@struct"), 
-      "#{@namespace}#{key}"
+      key
     ).first
     assert result.size > non_wrapped_result.size      
   end  
@@ -268,7 +301,7 @@ class MemcachedTest < Test::Unit::TestCase
     assert_nothing_raised do
       @cache.get key
     end
-    sleep(1)
+    sleep(2)
     assert_raise(Memcached::NotFound) do
       @cache.get key
     end
@@ -434,7 +467,7 @@ class MemcachedTest < Test::Unit::TestCase
   def test_cas
     cache = Memcached.new(
       @servers, 
-      :namespace => @namespace, 
+      :prefix_key => @prefix_key, 
       :support_cas => true
     )        
     value2 = OpenStruct.new(:d => 3, :e => 4, :f => GenericClass)
@@ -468,81 +501,60 @@ class MemcachedTest < Test::Unit::TestCase
         current
       end
     end
-    
-    cache.destroy    
   end
-  
-  # Namespace and key validation
-  
-  def test_ns
-    assert_equal "#{@namespace}i_have_a_space", 
-      Rlibmemcached.ns(@namespace, "i have a space")     
-
-    # STR2CSTR doesn't handle strings with nulls very well, so this is what happens 
-    assert_equal "#{@namespace}with_____", 
-      Rlibmemcached.ns(@namespace, "with\000null")
-
-    assert_equal "#{@namespace}ch__teau", 
-      Rlibmemcached.ns(@namespace, "ch\303\242teau")
-
-    assert_equal "#{@namespace}#{'x'*251}"[0..249], 
-      Rlibmemcached.ns(@namespace, 'x'*251)
-  end  
-  
+    
   # Error states
   
   def test_key_with_spaces
-    value = "value"
     key = "i have a space"
-    assert_nothing_raised do
-      @cache.set key, value
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      @cache.set key, @value
     end
-    assert_nothing_raised do
-      assert_equal(value, @cache.get(key))
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      @cache.get(key)
     end
-    # Spaces were stripped
-    assert_not_equal(key,
-      @cache.get([key]).keys.first)
   end
   
   def test_key_with_null
-    value = "value"
     key = "with\000null"
-    assert_nothing_raised do
-      @cache.set key, value
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      @cache.set key, @value
     end
-    assert_nothing_raised do
-      assert_equal(value, @cache.get(key))
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      @cache.get(key)
+    end
+
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      response = @cache.get([key])
     end
-    # Multiget returns
-    response = @cache.get([key])
-    assert_equal 1, response.size
-    # Nulls were stripped    
-    assert_not_equal(key, response.keys.first)
   end  
   
-  def test_key_with_valid_control_characters
-    value = "value"
+  def test_key_with_invalid_control_characters
     key = "ch\303\242teau"
-    @cache.set key, value
-    assert_equal(value, 
-      @cache.get(key))
-    assert_not_equal(key,
-      @cache.get([key]).keys.first)
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      @cache.set key, @value
+    end
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      @cache.get(key)
+    end
+
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
+      response = @cache.get([key])
+    end
   end
   
   def test_key_too_long
     key = "x"*251
-    assert_nothing_raised do    
+    assert_raises(Memcached::ClientError) do
       @cache.set key, @value
     end
-    assert_nothing_raised do
-      assert_equal(@value, 
-        @cache.get(key))  
+    assert_raises(Memcached::ClientError) do
+      @cache.get(key)
+    end
+    
+    assert_raises(Memcached::ClientError) do
+      @cache.get([key])
     end
-    # Key was truncated
-    assert_not_equal(key,
-      @cache.get([key]).keys.first)
   end  
 
   def test_set_object_too_large
@@ -568,7 +580,9 @@ class MemcachedTest < Test::Unit::TestCase
     assert_not_equal cache, @cache
     
     # Definitely check that the structs are unlinked
-    cache.destroy
+    assert_not_equal @cache.instance_variable_get('@struct').object_id,
+      cache.instance_variable_get('@struct').object_id
+    
     assert_nothing_raised do
       @cache.set key, @value
     end
@@ -584,7 +598,7 @@ class MemcachedTest < Test::Unit::TestCase
     end
     ret = Rlibmemcached.memcached_set(
       cache.instance_variable_get("@struct"), 
-      "#{@namespace}#{key}", 
+      key, 
       @marshalled_value, 
       0, 
       Memcached::FLAGS
@@ -598,7 +612,7 @@ class MemcachedTest < Test::Unit::TestCase
     end
     ret = Rlibmemcached.memcached_set(
       @nb_cache.instance_variable_get("@struct"), 
-      "#{@namespace}#{key}", 
+      key, 
       @marshalled_value, 
       0, 
       Memcached::FLAGS
@@ -614,7 +628,7 @@ class MemcachedTest < Test::Unit::TestCase
   end  
 
   def test_no_block_set_invalid_key
-    assert_nothing_raised do
+    assert_raises(Memcached::ABadKeyWasProvidedOrCharactersOutOfRange) do
       @nb_cache.set "I'm so bad", @value
     end
   end   
@@ -636,40 +650,47 @@ class MemcachedTest < Test::Unit::TestCase
   # Server removal and consistent hashing
   
   def test_missing_server
-    # XXX Does this test actually do anything? :hash behaves oddly
     cache = Memcached.new(
-      [@servers.last, '127.0.0.1:43041'], # Use a server that isn't running
-      :namespace => @namespace,
+      [@servers.last, 'localhost:43041'], # Use a server that isn't running
+      :prefix_key => @prefix_key,
       :failover => true,
       :hash => :md5
     )
     
-    # Verify that the second server is the hash target
+    # Hit first server
     key = 'test_missing_server3'
-    assert_equal 1, cache.send(:hash, key)
-
+    cache.set(key, @value)
+    cache.get(key) == @value
+        
+    # Hit second server
+    key = 'test_missing_server'
     assert_raise(Memcached::SystemError) do
       cache.set(key, @value)
       cache.get(key)
     end    
 
-    # Verify that we are targeting the first server now
-    assert_equal 0, cache.send(:hash, key)
-
+    # Hit first server on retry
     assert_nothing_raised do
       cache.set(key, @value)
       cache.get(key)
     end    
   end
   
+  def test_sweep_servers_with_missing_server_first
+    cache = Memcached.new(['127.0.0.1:00000'] + @servers)
+    assert_nothing_raised do
+      cache.send(:sweep_servers)
+    end
+  end
+
   def test_consistent_hashing
 
     keys = %w(EN6qtgMW n6Oz2W4I ss4A8Brr QShqFLZt Y3hgP9bs CokDD4OD Nd3iTSE1 24vBV4AU H9XBUQs5 E5j8vUq1 AzSh8fva PYBlK2Pi Ke3TgZ4I AyAIYanO oxj8Xhyd eBFnE6Bt yZyTikWQ pwGoU7Pw 2UNDkKRN qMJzkgo2 keFXbQXq pBl2QnIg ApRl3mWY wmalTJW1 TLueug8M wPQL4Qfg uACwus23 nmOk9R6w lwgZJrzJ v1UJtKdG RK629Cra U2UXFRqr d9OQLNl8 KAm1K3m5 Z13gKZ1v tNVai1nT LhpVXuVx pRib1Itj I1oLUob7 Z1nUsd5Q ZOwHehUa aXpFX29U ZsnqxlGz ivQRjOdb mB3iBEAj)
     
     # Five servers
     cache = Memcached.new(
-      @servers + ['127.0.0.1:43044', '127.0.0.1:43045', '127.0.0.1:43046'], 
-      :namespace => @namespace
+      @servers + ['localhost:43044', 'localhost:43045', 'localhost:43046'], 
+      :prefix_key => @prefix_key
     )        
     
     cache.flush    
@@ -679,8 +700,8 @@ class MemcachedTest < Test::Unit::TestCase
 
     # Pull a server
     cache = Memcached.new(
-      @servers + ['127.0.0.1:43044', '127.0.0.1:43046'],
-      :namespace => @namespace
+      @servers + ['localhost:43044', 'localhost:43046'],
+      :prefix_key => @prefix_key
     )
     
     failed = 0
@@ -721,13 +742,7 @@ class MemcachedTest < Test::Unit::TestCase
     assert_not_equal original_struct, 
       @cache.instance_variable_get("@struct") 
   end
-  
-  # Private hash generation method
-  
-  def test_hash_generation
-    assert [0, 1].include?(@cache.send(:hash, key))
-  end
-  
+    
   private
   
   def key