memcached 1.2 → 1.2.1

data.tar.gz.sig

@@ -1 +1,2 @@
-���a'�������:X,de��}z�|1��4�|z�_F�A���ʐ��V������U#���/�I�W�� ?�RB�n�/
+�UU>�������/�s���!x塓�D��C��)�r�����e��I<��n�ߡMq�9��d�C�G�*d�@b[�]�.Y��^2,�ɉ�ZIKf�I���<�`���V�“3���9T�S�;�H�G����U%��o$ˣ.F�4J��|F�Ѻ2���J�
+�y���|��I�n�#~J�ƚ>�5�b��'Y��P���R#��f����d�
U����<��7<b%.�{ԥ�1��)(�)�
�:s,�S�k�

data/CHANGELOG

@@ -1,3 +1,5 @@
+v1.2.1. Fix large allocation on error bug.
+
 v1.2. Clean up duplicated set_prefix_key API. Pipeline deletes and remove dead replication code. Apply prefix_key to binary protocol properly (tarrall). Add Memcached::Rails#exist? (ssoroka).
 
 v1.1.3. Register new objects to fix leaks around memcached_server_st and other rich structs (tobi).

data/README

@@ -54,10 +54,10 @@ You can get multiple values at once:
   $cache.get ['test', 'test2', 'missing']
     #=> {"test" => "hello", "test2" => "hello"}
 
-You can set a counter and increment it:
+You can set a counter and increment it. Note that you must initialize it with an integer, encoded as an unmarshalled ASCII string:
 
   start = 1
-  $cache.set 'counter', start, 0, false
+  $cache.set 'counter', start.to_s, 0, false
   $cache.increment 'counter' #=> 2
   $cache.increment 'counter' #=> 3
   $cache.get('counter', false).to_i #=> 3
@@ -73,9 +73,16 @@ Note that the API is not the same as that of <b>Ruby-MemCache</b> or <b>memcache
   $cache.delete 'test'
   $cache.get 'test' #=> raises Memcached::NotFound
 
-== Legacy applications
+== Pipelining
 
-There is a compatibility wrapper for legacy applications called Memcached::Rails.
+Pipelining updates is extremely effective in <b>memcached</b>, leading to more than 25x write throughput than the default settings. Use the following options to enable it:
+
+  :no_block => true,
+  :buffer_requests => true,
+  :noreply => true,
+  :binary_protocol => false
+
+Currently #append, #prepend, #set, and #delete are pipelined. Note that when you perform a read, all pending writes are flushed to the servers.
 
 == Threading
 
@@ -91,6 +98,10 @@ There is a compatibility wrapper for legacy applications called Memcached::Rails
   # Join the thread so that exceptions don't get lost
   thread.join
 
+== Legacy applications
+
+There is a compatibility wrapper for legacy applications called Memcached::Rails.
+
 == Benchmarks
 
 <b>memcached</b>, correctly configured, is at least twice as fast as <b>memcache-client</b> and <b>dalli</b>. See BENCHMARKS[link:files/BENCHMARKS.html] for details.

data/ext/rlibmemcached.i

@@ -17,13 +17,15 @@
 
 // Register libmemcached's struct free function to prevent memory leaks
 %freefunc memcached_st "memcached_free";
+%freefunc memcached_stat_st "memcached_stat_free";
 %freefunc memcached_server_st "memcached_server_free";
 
 // Register which functions generate new objects
-%newobject memcached_server_by_key;
 %newobject memcached_create;
 %newobject memcached_clone;
 %newobject memcached_stat_get_value;
+// %newobject memcached_stat;
+%newobject memcached_server_by_key;
 
 // %trackobjects; // Doesn't fix any interesting leaks
 
@@ -155,7 +157,7 @@ VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length
 %{
 VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
   VALUE ret;
-  size_t value_length;
+  size_t value_length = 0;
   char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
   ret = rb_str_new(value, value_length);
   free(value);
@@ -167,7 +169,7 @@ VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_le
 %{
 VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
   VALUE ret;
-  size_t value_length;
+  size_t value_length = 0;
   char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
   ret = rb_str_new(value, value_length);
   free(value);
@@ -179,7 +181,7 @@ VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t
 %{
 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;
+  size_t value_length = 0;
   char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
   ret = rb_str_new(value, value_length);
   free(value);
@@ -191,9 +193,8 @@ VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t
 VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error);
 %{
 VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
-  size_t value_length;
+  size_t value_length = 0;
   VALUE result = rb_ary_new();
-
   char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
   VALUE ret = rb_str_new(value, value_length);
   rb_ary_push(result, ret);

data/ext/rlibmemcached_wrap.c

@@ -2254,7 +2254,7 @@ SWIG_From_unsigned_SS_int  (unsigned int value)
 
 VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
   VALUE ret;
-  size_t value_length;
+  size_t value_length = 0;
   char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
   ret = rb_str_new(value, value_length);
   free(value);
@@ -2264,7 +2264,7 @@ VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length
 
 VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
   VALUE ret;
-  size_t value_length;
+  size_t value_length = 0;
   char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
   ret = rb_str_new(value, value_length);
   free(value);
@@ -2274,7 +2274,7 @@ VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_le
 
 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;
+  size_t value_length = 0;
   char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
   ret = rb_str_new(value, value_length);
   free(value);
@@ -2283,9 +2283,8 @@ VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t
 
 
 VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
-  size_t value_length;
+  size_t value_length = 0;
   VALUE result = rb_ary_new();
-
   char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
   VALUE ret = rb_str_new(value, value_length);
   rb_ary_push(result, ret);
@@ -4324,11 +4323,6 @@ fail:
 }
 
 
-SWIGINTERN void
-free_memcached_stat_st(struct memcached_stat_st *arg1) {
-    free((char *) arg1);
-}
-
 swig_class SwigClassMemcachedSt;
 
 SWIGINTERN VALUE
@@ -13208,7 +13202,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_method(SwigClassMemcachedStatSt.klass, "version=", _wrap_MemcachedStatSt_version_set, -1);
   rb_define_method(SwigClassMemcachedStatSt.klass, "version", _wrap_MemcachedStatSt_version_get, -1);
   SwigClassMemcachedStatSt.mark = 0;
-  SwigClassMemcachedStatSt.destroy = (void (*)(void *)) free_memcached_stat_st;
+  SwigClassMemcachedStatSt.destroy = (void (*)(void *)) memcached_stat_free;
   SwigClassMemcachedStatSt.trackObjects = 0;
   
   SwigClassMemcachedSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedSt", rb_cObject);

data/lib/memcached/exceptions.rb

@@ -3,7 +3,7 @@ class Memcached
 
 =begin rdoc
 
-Superclass for all Memcached runtime exceptions. 
+Superclass for all Memcached runtime exceptions.
 
 Subclasses correspond one-to-one with server response strings or libmemcached errors. For example, raising <b>Memcached::NotFound</b> means that the server returned <tt>"NOT_FOUND\r\n"</tt>.
 
@@ -48,15 +48,15 @@ Subclasses correspond one-to-one with server response strings or libmemcached er
 =end
   class Error < RuntimeError
     attr_accessor :no_backtrace
-    
+
     def set_backtrace(*args)
       @no_backtrace ? [] : super
     end
-    
+
     def backtrace(*args)
       @no_backtrace ? [] : super
     end
-  end 
+  end
 
 #:stopdoc:
 
@@ -64,21 +64,21 @@ Subclasses correspond one-to-one with server response strings or libmemcached er
     private
     def camelize(string)
       string.downcase.gsub('/', ' or ').split(' ').map {|s| s.capitalize}.join
-    end           
+    end
   end
-  
+
   ERRNO_HASH = Hash[*Errno.constants.grep(/^E/).map{ |c| [Errno.const_get(c)::Errno, Errno.const_get(c).new.message] }.flatten]
-  
+
   EXCEPTIONS = []
-  EMPTY_STRUCT = Rlibmemcached::MemcachedSt.new
-  Rlibmemcached.memcached_create(EMPTY_STRUCT)
-  
+  empty_struct = Lib.memcached_create(nil)
+  Lib.memcached_create(empty_struct)
+
   # Generate exception classes
-  Rlibmemcached::MEMCACHED_MAXIMUM_RETURN.times do |index|
-    description = Rlibmemcached.memcached_strerror(EMPTY_STRUCT, index).gsub("!", "")
+  Lib::MEMCACHED_MAXIMUM_RETURN.times do |index|
+    description = Lib.memcached_strerror(empty_struct, index).gsub("!", "")
     exception_class = eval("class #{camelize(description)} < Error; self; end")
     EXCEPTIONS << exception_class
   end
-  
+
 #:startdoc:
 end

data/lib/memcached/memcached.rb

@@ -115,17 +115,16 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       end
     end
 
-    if options[:credentials] == nil && ENV.key?("MEMCACHE_USERNAME") && ENV.key?("MEMCACHE_PASSWORD")
+    if !options[:credentials] and ENV["MEMCACHE_USERNAME"] and ENV["MEMCACHE_PASSWORD"]
       options[:credentials] = [ENV["MEMCACHE_USERNAME"], ENV["MEMCACHE_PASSWORD"]]
     end
 
     instance_eval { send(:extend, Experimental) } if options[:experimental_features]
 
-    options[:binary_protocol] = true if options[:credentials] != nil
+    options[:binary_protocol] = true if options[:credentials]
 
     # Force :buffer_requests to use :no_block
-    # XXX Deleting the :no_block key should also work, but libmemcached doesn't seem to set it
-    # consistently
+    # FIXME This should all be wrapped up in a single :pipeline option.
     options[:no_block] = true if options[:buffer_requests]
 
     # Disallow weights without ketama
@@ -137,8 +136,8 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     end
 
     # Read timeouts
-    options[:rcv_timeout] ||= options[:timeout] || 0
-    options[:poll_timeout] ||= options[:timeout] || 0
+    options[:rcv_timeout] ||= options[:timeout]
+    options[:poll_timeout] ||= options[:timeout]
 
     # Set the prefix key. Support the legacy name.
     set_prefix_key(options[:prefix_key] || options[:namespace])
@@ -234,15 +233,16 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
   end
 
   # Reset the state of the libmemcached struct. This is useful for changing the server list at runtime.
-  def reset(current_servers = nil, with_prefix_key = true)
+  def reset(current_servers = nil)
     # Store state and teardown
     current_servers ||= servers
     prev_prefix_key = prefix_key
+    quit
 
     # Create
     # FIXME Duplicates logic with initialize()
     @struct = Lib.memcached_create(nil)
-    set_prefix_key(prev_prefix_key) if with_prefix_key
+    set_prefix_key(prev_prefix_key)
     set_behaviors
     set_credentials
     set_servers(current_servers)
@@ -289,7 +289,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
   #
   # Accepts an optional <tt>ttl</tt> value to specify the maximum lifetime of the key on the server, in seconds. <tt>ttl</tt> must be a <tt>FixNum</tt>. <tt>0</tt> means no ttl. Note that there is no guarantee that the key will persist as long as the <tt>ttl</tt>, but it will not persist longer.
   #
-  # Also accepts a <tt>marshal</tt> value, which defaults to <tt>true</tt>. Set <tt>marshal</tt> to <tt>false</tt> if you want the <tt>value</tt> to be set directly.
+  # Also accepts a <tt>marshal</tt> value, which defaults to <tt>true</tt>. Set <tt>marshal</tt> to <tt>false</tt>, and pass a String as the <tt>value</tt>, if you want to set a raw byte array.
   #
   def set(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
     value = marshal ? Marshal.dump(value) : value

data/memcached.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "1.2"
+  s.version = "1.2.1"
 
   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{2011-03-02}
+  s.date = %q{2011-03-07}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]

data/test/profile/exercise.rb

@@ -8,8 +8,6 @@ require 'ostruct'
 
 GC.copy_on_write_friendly = true if GC.respond_to?("copy_on_write_friendly=")
 
-Struct
-
 class Worker
   def initialize(method_name, iterations, with_memory = 'false')
     @method = method_name || 'mixed'
@@ -32,7 +30,7 @@ class Worker
       {
         :buffer_requests => true,
         :no_block => true,
-        :noreply => true,
+        :noreply => false,
         :namespace => "namespace"
       }
     ]
@@ -112,9 +110,11 @@ class Worker
           @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
@@ -151,6 +151,8 @@ class Worker
         raise "No such method"
     end
 
+    @cache = nil
+
     if @with_memory == "true"
       puts "*** Garbage collect. ***"
       10.times do

data/test/unit/memcached_test.rb

@@ -434,15 +434,19 @@ class MemcachedTest < Test::Unit::TestCase
 
   def test_random_distribution_is_statistically_random
     cache = Memcached.new(@servers, :distribution => :random)
-    cache.flush
-    20.times { |i| cache.set "#{key}#{i}", @value }
+    read_cache = Memcached.new(@servers.first)
+    hits = 4
 
-    cache, hits = Memcached.new(@servers.first), 4
     while hits == 4 do
+      cache.flush
+      20.times do |i|
+        cache.set "#{key}#{i}", @value
+      end
+
       hits = 0
       20.times do |i|
         begin
-          cache.get "#{key}#{i}"
+          read_cache.get "#{key}#{i}"
           hits += 1
         rescue Memcached::NotFound
         end
@@ -794,11 +798,23 @@ class MemcachedTest < Test::Unit::TestCase
 
   # Stats
 
-  def test_stats
+  def disable_test_stats
     stats = @cache.stats
     assert_equal 3, stats[:pid].size
     assert_instance_of Fixnum, stats[:pid].first
     assert_instance_of String, stats[:version].first
+
+    stats = @binary_protocol_cache.stats
+    assert_equal 3, stats[:pid].size
+    assert_instance_of Fixnum, stats[:pid].first
+    assert_instance_of String, stats[:version].first
+
+    assert_nothing_raised do
+      @noblock_cache.stats
+    end
+    assert_raises(TypeError) do
+      @udp_cache.stats
+    end
   end
 
   def test_missing_stats

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: memcached
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 29
   prerelease: 
   segments: 
   - 1
   - 2
-  version: "1.2"
+  - 1
+  version: 1.2.1
 platform: ruby
 authors: 
 - Evan Weaver
@@ -35,7 +36,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2011-03-02 00:00:00 -08:00
+date: 2011-03-07 00:00:00 -08:00
 default_executable: 
 dependencies: []