dalli 2.6.0 → 2.6.1

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 
 gem 'rake'
 gem 'kgio', :platform => :mri
+gem 'RubyInline', :platform => :mri
 
 group :test do
   gem 'simplecov'

data/History.md

@@ -1,6 +1,19 @@
 Dalli Changelog
 =====================
 
+2.6.1
+=======
+
+- Add optional native C binary search for ring, add:
+
+gem 'RubyInline'
+
+  to your Gemfile to get a 10% speedup when using many servers.
+  You will see no improvement if you are only using one server.
+
+- More get_multi performance optimization [xaop, #315]
+- Add lambda support for cache namespaces [joshwlewis, #311]
+
 2.6.0
 =======
 

data/README.md

@@ -55,12 +55,14 @@ On Ubuntu you can install it by running:
 
 You can verify your installation using this piece of code:
 
-    gem install dalli
+```ruby
+gem install dalli
 
-    require 'dalli'
-    dc = Dalli::Client.new('localhost:11211')
-    dc.set('abc', 123)
-    value = dc.get('abc')
+require 'dalli'
+dc = Dalli::Client.new('localhost:11211')
+dc.set('abc', 123)
+value = dc.get('abc')
+```
 
 The test suite requires memcached 1.4.3+ with SASL enabled (brew install memcached --enable-sasl ; mv /usr/bin/memcached /usr/bin/memcached.old).  Currently only supports the PLAIN mechanism.
 
@@ -73,27 +75,37 @@ Usage with Rails 3.x
 
 In your Gemfile:
 
-    gem 'dalli'
+```ruby
+gem 'dalli'
+```
 
 In `config/environments/production.rb`:
 
-    config.cache_store = :dalli_store
+```ruby
+config.cache_store = :dalli_store
+```
 
 Here's a more comprehensive example that sets a reasonable default for maximum cache entry lifetime (one day), enables compression for large values and namespaces all entries for this rails app.  Remove the namespace if you have multiple apps which share cached values.
 
-    config.cache_store = :dalli_store, 'cache-1.example.com', 'cache-2.example.com',
-        { :namespace => NAME_OF_RAILS_APP, :expires_in => 1.day, :compress => true }
+```ruby
+config.cache_store = :dalli_store, 'cache-1.example.com', 'cache-2.example.com',
+  { :namespace => NAME_OF_RAILS_APP, :expires_in => 1.day, :compress => true }
+```
 
 To use Dalli for Rails session storage that times out after 20 minutes, in `config/initializers/session_store.rb`:
 
 For Rails >= 3.2.4:
 
-    Rails.application.config.session_store ActionDispatch::Session::CacheStore, :expire_after => 20.minutes
+```ruby
+Rails.application.config.session_store ActionDispatch::Session::CacheStore, :expire_after => 20.minutes
+```
 
 For Rails 3.x:
 
-    require 'action_dispatch/middleware/session/dalli_store'
-    Rails.application.config.session_store :dalli_store, :memcache_server => ['host1', 'host2'], :namespace => 'sessions', :key => '_foundation_session', :expire_after => 20.minutes
+```ruby
+require 'action_dispatch/middleware/session/dalli_store'
+Rails.application.config.session_store :dalli_store, :memcache_server => ['host1', 'host2'], :namespace => 'sessions', :key => '_foundation_session', :expire_after => 20.minutes
+```
 
 Dalli does not support Rails 2.x.
 
@@ -146,6 +158,7 @@ socket.
 
 Note that Dalli does not require ActiveSupport or Rails.  You can safely use it in your own Ruby projects.
 
+![View the API](http://www.ruby-doc.org/gems/docs/d/dalli-2.5.0/Dalli/Client.html)
 
 Helping Out
 -------------

data/lib/dalli/client.rb

@@ -340,19 +340,22 @@ module Dalli
       raise ArgumentError, "key cannot be blank" if !key || key.length == 0
       key = key_with_namespace(key)
       if key.length > 250
-        namespace_length = @options[:namespace] ? @options[:namespace].size : 0
-        max_length_before_namespace = 212 - namespace_length
+        max_length_before_namespace = 212 - (namespace || '').size
         key = "#{key[0, max_length_before_namespace]}:md5:#{Digest::MD5.hexdigest(key)}"
       end
       return key
     end
 
     def key_with_namespace(key)
-      @options[:namespace] ? "#{@options[:namespace]}:#{key}" : key
+      (ns = namespace) ? "#{ns}:#{key}" : key
     end
 
     def key_without_namespace(key)
-      @options[:namespace] ? key.sub(%r(\A#{@options[:namespace]}:), '') : key
+      (ns = namespace) ? key.sub(%r(\A#{ns}:), '') : key
+    end
+
+    def namespace
+      @options[:namespace].is_a?(Proc) ? @options[:namespace].call : @options[:namespace]
     end
 
     def normalize_options(opts)

data/lib/dalli/ring.rb

@@ -31,7 +31,7 @@ module Dalli
       if @continuum
         hkey = hash_for(key)
         20.times do |try|
-          entryidx = self.class.binary_search(@continuum, hkey)
+          entryidx = binary_search(@continuum, hkey)
           server = @continuum[entryidx].server
           return server if server.alive?
           break unless @failover
@@ -70,25 +70,60 @@ module Dalli
       ((total_servers * POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
     end
 
-    # Find the closest index in the Ring with value <= the given value
-    def self.binary_search(ary, value)
-      upper = ary.size - 1
-      lower = 0
-      idx = 0
-
-      while (lower <= upper) do
-        idx = (lower + upper) / 2
-        comp = ary[idx].value <=> value
-
-        if comp == 0
-          return idx
-        elsif comp > 0
-          upper = idx - 1
-        else
-          lower = idx + 1
+    # Native extension to perform the binary search within the continuum
+    # space.  Fallback to a pure Ruby version if the compilation doesn't work.
+    # optional for performance and only necessary if you are using multiple
+    # memcached servers.
+    begin
+      require 'inline'
+      inline do |builder|
+        builder.c <<-EOM
+        int binary_search(VALUE ary, unsigned int r) {
+            int upper = RARRAY_LEN(ary) - 1;
+            int lower = 0;
+            int idx = 0;
+            ID value = rb_intern("value");
+
+            while (lower <= upper) {
+                idx = (lower + upper) / 2;
+
+                VALUE continuumValue = rb_funcall(RARRAY_PTR(ary)[idx], value, 0);
+                unsigned int l = NUM2UINT(continuumValue);
+                if (l == r) {
+                    return idx;
+                }
+                else if (l > r) {
+                    upper = idx - 1;
+                }
+                else {
+                    lower = idx + 1;
+                }
+            }
+            return upper;
+        }
+        EOM
+      end
+    rescue
+      # Find the closest index in the Ring with value <= the given value
+      def binary_search(ary, value)
+        upper = ary.size - 1
+        lower = 0
+        idx = 0
+
+        while (lower <= upper) do
+          idx = (lower + upper) / 2
+          comp = ary[idx].value <=> value
+
+          if comp == 0
+            return idx
+          elsif comp > 0
+            upper = idx - 1
+          else
+            lower = idx + 1
+          end
         end
+        return upper
       end
-      return upper
     end
 
     class Entry

data/lib/dalli/server.rb

@@ -116,6 +116,7 @@ module Dalli
       verify_state
       write_noop
       @multi_buffer = ''
+      @position = 0
       @inprogress = true
     end
 
@@ -135,23 +136,26 @@ module Dalli
 
       @multi_buffer << @sock.read_available
       buf = @multi_buffer
+      pos = @position
       values = {}
 
-      while buf.bytesize >= 24
-        header = buf.slice(0, 24)
+      while buf.bytesize - pos >= 24
+        header = buf.slice(pos, 24)
         (key_length, _, body_length) = header.unpack(KV_HEADER)
 
         if key_length == 0
           # all done!
           @multi_buffer = nil
+          @position = nil
           @inprogress = false
           break
 
-        elsif buf.bytesize >= (24 + body_length)
-          buf.slice!(0, 24)
-          flags = buf.slice!(0, 4).unpack('N')[0]
-          key = buf.slice!(0, key_length)
-          value = buf.slice!(0, body_length - key_length - 4) if body_length - key_length - 4 > 0
+        elsif buf.bytesize - pos >= 24 + body_length
+          flags = buf.slice(pos + 24, 4).unpack('N')[0]
+          key = buf.slice(pos + 24 + 4, key_length)
+          value = buf.slice(pos + 24 + 4 + key_length, body_length - key_length - 4) if body_length - key_length - 4 > 0
+
+          pos = pos + 24 + body_length
 
           begin
             values[key] = deserialize(value, flags)
@@ -163,6 +167,7 @@ module Dalli
           break
         end
       end
+      @position = pos
 
       values
     rescue SystemCallError, Timeout::Error, EOFError
@@ -176,6 +181,7 @@ module Dalli
     # Returns nothing.
     def multi_response_abort
       @multi_buffer = nil
+      @position = nil
       @inprogress = false
       failure!
     rescue NetworkError

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '2.6.0'
+  VERSION = '2.6.1'
 end

data/test/test_active_support.rb

@@ -329,7 +329,7 @@ describe 'ActiveSupport' do
   end
 
   def connect
-    @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => 'x')
+    @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => lambda{33.to_s(36)})
     @dalli.clear
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-15 00:00:00.000000000 Z
+date: 2013-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_shoulda