memcached 0.19.5 → 0.19.6

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.19.6. Add get_from_last.
+
 v0.19.5. Fix autoconf datestamps.
 
 v0.19.3. Add exception_retry_limit and exceptions_to_retry.

data/Manifest

@@ -7,6 +7,7 @@ Rakefile
 TODO
 ext/extconf.rb
 ext/libmemcached-0.32.tar.gz
+ext/libmemcached-2.patch
 ext/libmemcached.patch
 ext/rlibmemcached.i
 ext/rlibmemcached_wrap.c

data/Rakefile

@@ -23,7 +23,7 @@ task :exceptions do
 end
 
 task :valgrind do
-  exec("valgrind  --tool=memcheck --leak-check=yes --show-reachable=no --num-callers=15 --track-fds=yes ruby #{File.dirname(__FILE__)}/test/profile/valgrind.rb")
+  exec("valgrind  --tool=memcheck --leak-check=full --show-reachable=no --num-callers=15 --track-fds=yes --workaround-gcc296-bugs=yes --max-stackframe=7304328 --dsymutil=yes --track-origins=yes ruby #{File.dirname(__FILE__)}/test/profile/valgrind.rb")
 end
 
 task :profile do

data/ext/extconf.rb

@@ -5,7 +5,11 @@ HERE = File.expand_path(File.dirname(__FILE__))
 BUNDLE = Dir.glob("libmemcached-*.tar.gz").first
 BUNDLE_PATH = BUNDLE.sub(".tar.gz", "")
 
+SOLARIS_32 = RbConfig::CONFIG['target'] == "i386-pc-solaris2.10"
+
 $CFLAGS = "#{RbConfig::CONFIG['CFLAGS']} #{$CFLAGS}".gsub("$(cflags)", "").gsub("-fno-common", "")
+$CFLAGS << " -std=gnu99" if SOLARIS_32
+$EXTRA_CONF = " --disable-64bit" if SOLARIS_32
 $LDFLAGS = "#{RbConfig::CONFIG['LDFLAGS']} #{$LDFLAGS}".gsub("$(ldflags)", "").gsub("-fno-common", "")
 $CXXFLAGS = " -std=gnu++98 #{$CFLAGS}"
 $CPPFLAGS = $ARCH_FLAG = $DLDFLAGS = ""
@@ -25,12 +29,14 @@ def check_libmemcached
   $CFLAGS = "#{$includes} #{$libraries} #{$CFLAGS}"
   $LDFLAGS = "#{$libraries} #{$LDFLAGS}"
   $LIBPATH = ["#{HERE}/lib"]
-  $DEFLIBPATH = []
+  $DEFLIBPATH = [] unless SOLARIS_32
 
   Dir.chdir(HERE) do
     if File.exist?("lib")
       puts "Libmemcached already built; run 'rake clean' first if you need to rebuild."
     else
+      tar = SOLARIS_32 ? 'gtar' : 'tar'
+      patch = SOLARIS_32 ? 'gpatch' : 'patch'
 
       # have_sasl check may fail on OSX, skip it
       # unless RUBY_PLATFORM =~ /darwin/ or have_library('sasl2')
@@ -38,15 +44,19 @@ def check_libmemcached
       # end
 
       puts "Building libmemcached."
-      puts(cmd = "tar xzf #{BUNDLE} 2>&1")
+      puts(cmd = "#{tar} xzf #{BUNDLE} 2>&1")
       raise "'#{cmd}' failed" unless system(cmd)
 
       puts "Patching libmemcached source."
-      puts(cmd = "patch -p1 -Z < libmemcached.patch")
+      puts(cmd = "#{patch} -p1 -Z < libmemcached.patch")
       raise "'#{cmd}' failed" unless system(cmd)
 
       puts "Patching libmemcached with SASL support."
-      puts(cmd = "patch -p1 -Z < sasl.patch")
+      puts(cmd = "#{patch} -p1 -Z < sasl.patch")
+      raise "'#{cmd}' failed" unless system(cmd)
+
+      puts "Patching libmemcached for get_from_last support."
+      puts(cmd = "#{patch} -p1 -Z < libmemcached-2.patch")
       raise "'#{cmd}' failed" unless system(cmd)
 
       puts "Touching aclocal.m4  in libmemcached."

data/ext/libmemcached-2.patch

@@ -0,0 +1,116 @@
+diff --git a/libmemcached-0.32/libmemcached/memcached.h libmemcached/libmemcached/memcached.h
+--- a/libmemcached-0.32/libmemcached/memcached.h
++++ b/libmemcached/libmemcached/memcached.h
+@@ -119,6 +119,7 @@
+ #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+   const sasl_callback_t *sasl_callbacks;
+ #endif
++  int last_server_key;
+ };
+ 
+ LIBMEMCACHED_API
+diff --git a/libmemcached-0.32/libmemcached/memcached_get.c libmemcached/libmemcached/memcached_get.c
+--- a/libmemcached-0.32/libmemcached/memcached_get.c
++++ b/libmemcached/libmemcached/memcached_get.c
+@@ -235,6 +235,8 @@
+       rc= MEMCACHED_SOME_ERRORS;
+       continue;
+     }
++    
++    ptr->last_server_key = server_key;
+   }
+ 
+   /*
+@@ -256,6 +258,74 @@
+   return rc;
+ }
+ 
++
++char *memcached_get_from_last(memcached_st *ptr,
++                              const char *key,
++                              size_t key_length,
++                              size_t *value_length, 
++                              uint32_t *flags,
++                              memcached_return *error)
++{
++  memcached_return rc = MEMCACHED_NOTFOUND;
++  char *value = NULL;
++
++  if (memcached_server_response_count(&ptr->hosts[ptr->last_server_key]) == 0) {
++    *error = memcached_connect(&ptr->hosts[ptr->last_server_key]);
++
++    if (*error != MEMCACHED_SUCCESS) {
++      return value;
++    }
++
++    if ((memcached_io_write(&ptr->hosts[ptr->last_server_key], "get ", 4, 0)) == -1) {
++      *error = MEMCACHED_SOME_ERRORS;
++      return value;
++    }
++    WATCHPOINT_ASSERT(ptr->hosts[ptr->last_server_key].cursor_active == 0);
++    memcached_server_response_increment(&ptr->hosts[ptr->last_server_key]);
++    WATCHPOINT_ASSERT(ptr->hosts[ptr->last_server_key].cursor_active == 1);
++  }
++
++  /* Only called when we have a prefix key */
++  if (ptr->prefix_key[0] != 0) {
++    if ((memcached_io_write(&ptr->hosts[ptr->last_server_key], ptr->prefix_key, ptr->prefix_key_length, 0)) == -1) {
++      memcached_server_response_reset(&ptr->hosts[ptr->last_server_key]);
++      *error = MEMCACHED_SOME_ERRORS;
++      return value;
++    }
++  }
++
++  if ((memcached_io_write(&ptr->hosts[ptr->last_server_key], key, key_length, 0)) == -1) {
++    memcached_server_response_reset(&ptr->hosts[ptr->last_server_key]);
++    *error = MEMCACHED_SOME_ERRORS;
++    return value;
++  }
++
++  if ((memcached_io_write(&ptr->hosts[ptr->last_server_key], "\r\n", 2, 1)) == -1) {
++    memcached_server_response_reset(&ptr->hosts[ptr->last_server_key]);
++    *error = MEMCACHED_SOME_ERRORS;
++    return value;
++  }
++
++  value = memcached_fetch(ptr, NULL, NULL, value_length, flags, error);
++
++  /* This is for historical reasons */
++  if (*error == MEMCACHED_END)
++    *error = MEMCACHED_NOTFOUND;
++
++  if (value != NULL) {
++    size_t dummy_length;
++    uint32_t dummy_flags;
++    memcached_return dummy_error;
++
++    (void)memcached_fetch(ptr, NULL, NULL, 
++                          &dummy_length, &dummy_flags, 
++                          &dummy_error);
++    WATCHPOINT_ASSERT(dummy_length == 0);
++  }
++
++  return value;
++}
++
+ static memcached_return simple_binary_mget(memcached_st *ptr,
+                                            unsigned int master_server_key,
+                                            bool is_master_key_set,
+diff --git a/libmemcached-0.32/libmemcached/memcached_get.h libmemcached/libmemcached/memcached_get.h
+--- a/libmemcached-0.32/libmemcached/memcached_get.h
++++ b/libmemcached/libmemcached/memcached_get.h
+@@ -53,7 +53,13 @@
+                                             memcached_result_st *result,
+                                             memcached_return *error);
+ 
+-
++LIBMEMCACHED_API
++char *memcached_get_from_last(memcached_st *ptr,
++                              const char *key,
++                              size_t key_length,
++                              size_t *value_length, 
++                              uint32_t *flags,
++                              memcached_return *error);
+ 
+ #ifdef __cplusplus
+ }

data/ext/rlibmemcached.i

@@ -163,6 +163,18 @@ VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length
 };
 %}
 
+VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
+  VALUE ret;  
+  size_t value_length;
+  char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
+  ret = rb_str_new(value, value_length);
+  free(value);
+  return ret;
+};
+%}
+
 // Multi get
 VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error);
 %{

data/ext/rlibmemcached_wrap.c

@@ -2228,6 +2228,15 @@ VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length
   return ret;
 };
 
+VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
+  VALUE ret;  
+  size_t value_length;
+  char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
+  ret = rb_str_new(value, value_length);
+  free(value);
+  return ret;
+};
+
 
 VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
   size_t value_length;
@@ -12211,6 +12220,55 @@ fail:
   return Qnil;
 }
 
+SWIGINTERN VALUE
+_wrap_memcached_get_from_last_rvalue(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  char *arg2 = (char *) 0 ;
+  size_t arg3 ;
+  uint32_t *arg4 = (uint32_t *) 0 ;
+  memcached_return *arg5 = (memcached_return *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  uint32_t temp4 ;
+  int res4 = SWIG_TMPOBJ ;
+  memcached_return temp5 ;
+  int res5 = SWIG_TMPOBJ ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  arg4 = &temp4;
+  arg5 = &temp5;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_from_last_rvalue", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  {
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = (size_t) RSTRING_LEN(argv[1]);
+  }
+  result = (VALUE)memcached_get_from_last_rvalue(arg1,(char const *)arg2,arg3,arg4,arg5);
+  vresult = result;
+  if (SWIG_IsTmpObj(res4)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg4)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_uint32_t, new_flags));
+  }
+  if (SWIG_IsTmpObj(res5)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg5)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_memcached_return, new_flags));
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
 
 SWIGINTERN VALUE
 _wrap_memcached_fetch_rvalue(int argc, VALUE *argv, VALUE self) {
@@ -13276,6 +13334,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_module_function(mRlibmemcached, "memcached_get_sasl_callbacks", _wrap_memcached_get_sasl_callbacks, -1);
   rb_define_module_function(mRlibmemcached, "memcached_sasl_authenticate_connection", _wrap_memcached_sasl_authenticate_connection, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_rvalue", _wrap_memcached_get_rvalue, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_get_from_last_rvalue", _wrap_memcached_get_from_last_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_fetch_rvalue", _wrap_memcached_fetch_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_stat_get_rvalue", _wrap_memcached_stat_get_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_select_server_at", _wrap_memcached_select_server_at, -1);

data/lib/memcached/memcached.rb

@@ -502,9 +502,11 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       keys.each do
         value, key, flags, ret = Lib.memcached_fetch_rvalue(@struct)
         break if ret == Lib::MEMCACHED_END
-        check_return_code(ret, key)
-        # Assign the value
-        hash[key] = (marshal ? Marshal.load(value) : value)
+        if ret != Lib::MEMCACHED_NOTFOUND
+          check_return_code(ret, key)
+          # Assign the value
+          hash[key] = (marshal ? Marshal.load(value) : value)
+        end
       end
       hash
     else
@@ -520,6 +522,14 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     retry 
   end
 
+  # Gets a key's value from the previous server. Only useful with random distribution.
+  def get_from_last(key, marshal=true)
+    raise ArgumentError, "get_from_last() is not useful unless :random distribution is enabled." unless options[:distribution] == :random
+    value, flags, ret = Lib.memcached_get_from_last_rvalue(@struct, key)
+    check_return_code(ret, key)
+    marshal ? Marshal.load(value) : value
+  end
+
   ### Information methods
 
   # Return the server used by a particular key.
@@ -586,12 +596,14 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       message = "Key #{inspect_keys(key, (detect_failure if ret == Lib::MEMCACHED_SERVER_MARKED_DEAD)).inspect}"
       if key.is_a?(String)
         if ret == Lib::MEMCACHED_ERRNO
-          server = Lib.memcached_server_by_key(@struct, key)
-          errno = server.first.cached_errno
-          message = "Errno #{errno}: #{ERRNO_HASH[errno].inspect}. #{message}"
+          if (server = Lib.memcached_server_by_key(@struct, key)).is_a?(Array)
+            errno = server.first.cached_errno
+            message = "Errno #{errno}: #{ERRNO_HASH[errno].inspect}. #{message}"
+          end
         elsif ret == Lib::MEMCACHED_SERVER_ERROR
-          server = Lib.memcached_server_by_key(@struct, key)
-          message = "\"#{server.first.cached_server_error}\". #{message}."
+          if (server = Lib.memcached_server_by_key(@struct, key)).is_a?(Array)
+            message = "\"#{server.first.cached_server_error}\". #{message}."
+          end
         end
       end
       raise EXCEPTIONS[ret], message

data/lib/memcached/rails.rb

@@ -7,7 +7,10 @@ class Memcached
   # A legacy compatibility wrapper for the Memcached class. It has basic compatibility with the <b>memcache-client</b> API.
   class Rails < ::Memcached
 
-    DEFAULTS[:logger] = nil
+    DEFAULTS = {
+      :logger => nil,
+      :string_return_types => false
+    }
 
     attr_reader :logger
 
@@ -46,7 +49,9 @@ class Memcached
     # Wraps Memcached#cas so that it doesn't raise. Doesn't set anything if no value is present.
     def cas(key, ttl=@default_ttl, raw=false, &block)
       super(key, ttl, !raw, &block)
+      true
     rescue NotFound
+      false
     end
 
     alias :compare_and_swap :cas
@@ -59,21 +64,24 @@ class Memcached
     # Wraps Memcached#set.
     def set(key, value, ttl=@default_ttl, raw=false)
       super(key, value, ttl, !raw)
+      true
+    rescue NotStored
+      false
     end
 
     # Alternative to #set. Accepts a key, value, and an optional options hash supporting the 
     # options :raw and :ttl.
     def write(key, value, options = {})
       set(key, value, options[:ttl] || @default_ttl, options[:raw])
-      true
     end
 
     # Wraps Memcached#add so that it doesn't raise.
     def add(key, value, ttl=@default_ttl, raw=false)
       super(key, value, ttl, !raw)
-      true
+      # This causes me physical pain.
+      opts[:string_return_types] ? "STORED\r\n" : true
     rescue NotStored
-      false
+      opts[:string_return_types] ? "NOT STORED\r\n" : false
     end
 
     # Wraps Memcached#delete so that it doesn't raise.

data/memcached.gemspec

@@ -2,17 +2,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "0.19.5"
+  s.version = "0.19.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]
   s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
-  s.date = %q{2010-05-20}
+  s.date = %q{2010-06-13}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = ["BENCHMARKS", "CHANGELOG", "LICENSE", "README", "TODO", "lib/memcached.rb", "lib/memcached/behaviors.rb", "lib/memcached/exceptions.rb", "lib/memcached/memcached.rb", "lib/memcached/rails.rb"]
-  s.files = ["BENCHMARKS", "CHANGELOG", "LICENSE", "Manifest", "README", "Rakefile", "TODO", "ext/extconf.rb", "ext/libmemcached-0.32.tar.gz", "ext/libmemcached.patch", "ext/rlibmemcached.i", "ext/rlibmemcached_wrap.c", "ext/sasl.patch", "lib/memcached.rb", "lib/memcached/auth.rb", "lib/memcached/behaviors.rb", "lib/memcached/exceptions.rb", "lib/memcached/integer.rb", "lib/memcached/memcached.rb", "lib/memcached/rails.rb", "test/profile/benchmark.rb", "test/profile/profile.rb", "test/profile/valgrind.rb", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/binding_test.rb", "test/unit/memcached_test.rb", "test/unit/rails_test.rb", "memcached.gemspec"]
+  s.files = ["BENCHMARKS", "CHANGELOG", "LICENSE", "Manifest", "README", "Rakefile", "TODO", "ext/extconf.rb", "ext/libmemcached-0.32.tar.gz", "ext/libmemcached-2.patch", "ext/libmemcached.patch", "ext/rlibmemcached.i", "ext/rlibmemcached_wrap.c", "ext/sasl.patch", "lib/memcached.rb", "lib/memcached/auth.rb", "lib/memcached/behaviors.rb", "lib/memcached/exceptions.rb", "lib/memcached/integer.rb", "lib/memcached/memcached.rb", "lib/memcached/rails.rb", "test/profile/benchmark.rb", "test/profile/profile.rb", "test/profile/valgrind.rb", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/binding_test.rb", "test/unit/memcached_test.rb", "test/unit/rails_test.rb", "memcached.gemspec"]
   s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/memcached/}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Memcached", "--main", "README"]
   s.require_paths = ["lib", "ext"]

data/test/profile/valgrind.rb

@@ -5,6 +5,8 @@ $LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
 require 'memcached'
 require 'rubygems'
 
+GC.copy_on_write_friendly = true if GC.respond_to?("copy_on_write_friendly=")
+
 class Worker  
   def initialize(method_name, iterations)
     @method = method_name || 'mixed'

data/test/unit/memcached_test.rb

@@ -255,6 +255,16 @@ class MemcachedTest < Test::Unit::TestCase
     assert_equal nil, result
   end
 
+  def test_get_from_last
+    cache = Memcached.new(@servers, :distribution => :random)
+    10.times do |n|
+      cache.set key, n
+    end
+    10.times do
+      assert_equal cache.get(key), cache.get_from_last(key)
+    end
+  end
+
   def test_get_missing
     @cache.delete key rescue nil
     assert_raise(Memcached::NotFound) do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 19
-  - 5
-  version: 0.19.5
+  - 6
+  version: 0.19.6
 platform: ruby
 authors: 
 - Evan Weaver
@@ -35,7 +35,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2010-05-20 00:00:00 -07:00
+date: 2010-06-13 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -66,6 +66,7 @@ files:
 - TODO
 - ext/extconf.rb
 - ext/libmemcached-0.32.tar.gz
+- ext/libmemcached-2.patch
 - ext/libmemcached.patch
 - ext/rlibmemcached.i
 - ext/rlibmemcached_wrap.c