dalli 2.6.2 → 2.6.3

data/Gemfile

@@ -1,10 +1,10 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec
 
 gem 'rake'
 gem 'kgio', :platform => :mri
-gem 'RubyInline', :platform => :mri
+gem 'appraisal'
 
 group :test do
   gem 'simplecov'

data/History.md

@@ -1,6 +1,14 @@
 Dalli Changelog
 =====================
 
+2.6.3
+=======
+
+- Support specific stats by passing `:items` or `:slabs` to `stats` method [bukhamseen]
+- Fix 'can't modify frozen String' errors in `ActiveSupport::Cache::DalliStore` [dblock]
+- Protect against objects with custom equality checking [theron17]
+- Warn if value for key is too large to store [locriani]
+
 2.6.2
 =======
 

data/README.md

@@ -114,7 +114,7 @@ Configuration
 ------------------------
 Dalli::Client accepts the following options. All times are in seconds.
 
-**expires_in**: Global default for key TTL.  No default.
+**expires_in**: Global default for key TTL.  Default is 0, which means no expiry.
 
 **failover**: Boolean, if true Dalli will failover to another server if the main server for a key is down.
 
@@ -141,7 +141,7 @@ Default is Marshal.
 
 **password**: The password to use for authenticating this client instance against a SASL-enabled memcached server.  Heroku users should not need to use this normally.
 
-**keepalive**: Boolean, if true Dalli will enable keep-alives on the socket so inactivity
+**keepalive**: Boolean. If true, Dalli will enable keep-alive for socket connections.  Default is false.
 
 **compressor**: The compressor to use for objects being stored.
 Default is zlib, implemented under `Dalli::Compressor`.
@@ -158,7 +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)
+[View the API](http://www.ruby-doc.org/gems/docs/d/dalli-2.6.2/Dalli/Client.html)
 
 Helping Out
 -------------

data/Rakefile

@@ -1,3 +1,4 @@
+require 'appraisal'
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'

data/lib/active_support/cache/dalli_store.rb

@@ -63,8 +63,12 @@ module ActiveSupport
         if block_given?
           unless options[:force]
             entry = instrument(:read, name, options) do |payload|
-              payload[:super_operation] = :fetch if payload
-              read_entry(name, options)
+              read_entry(name, options).tap do |result|
+                if payload
+                  payload[:super_operation] = :fetch
+                  payload[:hit] = !!result
+                end
+              end
             end
           end
 
@@ -124,7 +128,6 @@ module ActiveSupport
       # servers for all keys. Keys must be Strings.
       def read_multi(*names)
         names.extract_options!
-        names = names.flatten
         mapping = names.inject({}) { |memo, name| memo[expanded_key(name)] = name; memo }
         instrument(:read_multi, names) do
           results = {}
@@ -267,7 +270,10 @@ module ActiveSupport
         end
 
         key = key.to_param
-        key.force_encoding('binary') if key.respond_to? :force_encoding
+        if key.respond_to? :force_encoding
+          key = key.dup
+          key.force_encoding('binary')
+        end
         key
       end
 

data/lib/dalli/client.rb

@@ -21,17 +21,27 @@ module Dalli
     # - :failover - if a server is down, look for and store values on another server in the ring.  Default: true.
     # - :threadsafe - ensure that only one thread is actively using a socket at a time. Default: true.
     # - :expires_in - default TTL in seconds if you do not pass TTL as a parameter to an individual operation, defaults to 0 or forever
-    # - :compress - defaults to false, if true Dalli will compress values larger than 1024 bytes before
+    # - :compress - defaults to false, if true Dalli will compress values larger than 1024 bytes before sending them to memcached.
     # - :serializer - defaults to Marshal
-    #   sending them to memcached.
     # - :compressor - defaults to zlib
     #
     def initialize(servers=nil, options={})
-      @servers = servers || env_servers || '127.0.0.1:11211'
+      @servers = normalize_servers(servers || ENV["MEMCACHE_SERVERS"] || '127.0.0.1:11211')
       @options = normalize_options(options)
       @ring = nil
     end
 
+    ##
+    # Normalizes the argument into an array of servers. If the argument is a string, it's expected to be of
+    # the format "memcache1.example.com:11211[,memcache2.example.com:11211[,memcache3.example.com:11211[...]]]
+    def normalize_servers(servers)
+      if servers.is_a? String
+        return servers.split(",")
+      else
+        return servers
+      end
+    end
+
     #
     # The standard memcached instruction set
     #
@@ -50,7 +60,7 @@ module Dalli
 
     def get(key, options=nil)
       resp = perform(:get, key)
-      resp.nil? || resp == 'Not found' ? nil : resp
+      resp.nil? || 'Not found' == resp ? nil : resp
     end
 
     ##
@@ -263,11 +273,13 @@ module Dalli
 
     ##
     # Collect the stats for each server.
+    # You can optionally pass a type including :items or :slabs to get specific stats
     # Returns a hash like { 'hostname:port' => { 'stat1' => 'value1', ... }, 'hostname2:port' => { ... } }
-    def stats
+    def stats(type=nil)
+      type = nil if ![nil, :items,:slabs].include? type
       values = {}
       ring.servers.each do |server|
-        values["#{server.hostname}:#{server.port}"] = server.alive? ? server.request(:stats) : nil
+        values["#{server.hostname}:#{server.port}"] = server.alive? ? server.request(:stats,type.to_s) : nil
       end
       values
     end
@@ -295,7 +307,7 @@ module Dalli
 
     def ring
       @ring ||= Dalli::Ring.new(
-        Array(@servers).map do |s|
+        @servers.map do |s|
          server_options = {}
           if s =~ %r{\Amemcached://}
             uri = URI.parse(s)
@@ -308,10 +320,6 @@ module Dalli
       )
     end
 
-    def env_servers
-      ENV['MEMCACHE_SERVERS'] ? ENV['MEMCACHE_SERVERS'].split(',') : nil
-    end
-
     # Chokepoint method for instrumentation
     def perform(op, key, *args)
       key = key.to_s

data/lib/dalli/ring.rb

@@ -79,16 +79,18 @@ module Dalli
       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;
+            long upper = RARRAY_LEN(ary) - 1;
+            long lower = 0;
+            long idx = 0;
             ID value = rb_intern("value");
+            VALUE continuumValue;
+            unsigned int l;
 
             while (lower <= upper) {
                 idx = (lower + upper) / 2;
 
-                VALUE continuumValue = rb_funcall(RARRAY_PTR(ary)[idx], value, 0);
-                unsigned int l = NUM2UINT(continuumValue);
+                continuumValue = rb_funcall(RARRAY_PTR(ary)[idx], value, 0);
+                l = NUM2UINT(continuumValue);
                 if (l == r) {
                     return idx;
                 }

data/lib/dalli/server.rb

@@ -43,6 +43,7 @@ module Dalli
       @options = DEFAULTS.merge(options)
       @sock = nil
       @msg = nil
+      @error = nil
       @pid = nil
       @inprogress = nil
     end
@@ -259,7 +260,7 @@ module Dalli
     def set(key, value, ttl, cas, options)
       (value, flags) = serialize(key, value, options)
 
-      if under_max_value_size?(value)
+      if under_max_value_size?(key, value)
         req = [REQUEST, OPCODES[multi? ? :setq : :set], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, flags, ttl, key, value].pack(FORMAT[:set])
         write(req)
         generic_response unless multi?
@@ -271,7 +272,7 @@ module Dalli
     def add(key, value, ttl, options)
       (value, flags) = serialize(key, value, options)
 
-      if under_max_value_size?(value)
+      if under_max_value_size?(key, value)
         req = [REQUEST, OPCODES[multi? ? :addq : :add], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, flags, ttl, key, value].pack(FORMAT[:add])
         write(req)
         generic_response unless multi?
@@ -283,7 +284,7 @@ module Dalli
     def replace(key, value, ttl, options)
       (value, flags) = serialize(key, value, options)
 
-      if under_max_value_size?(value)
+      if under_max_value_size?(key, value)
         req = [REQUEST, OPCODES[multi? ? :replaceq : :replace], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, flags, ttl, key, value].pack(FORMAT[:replace])
         write(req)
         generic_response unless multi?
@@ -450,8 +451,13 @@ module Dalli
     NORMAL_HEADER = '@4CCnN'
     KV_HEADER = '@2n@6nN'
 
-    def under_max_value_size?(value)
-      value.bytesize <= @options[:value_max_bytes]
+    def under_max_value_size?(key, value)
+      if value.bytesize <= @options[:value_max_bytes]
+        true
+      else
+        Dalli.logger.warn "Value for #{key} over max size"
+        false
+      end
     end
 
     def generic_response(unpack=false)

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '2.6.2'
+  VERSION = '2.6.3'
 end

data/test/memcached_mock.rb

@@ -63,7 +63,6 @@ module MemcachedMock
       end
 
       raise Errno::ENOENT, "Unable to find memcached 1.4+ locally"
-      nil
     end
 
     def memcached(port=19122, args='', options={})

data/test/test_active_support.rb

@@ -98,7 +98,9 @@ describe 'ActiveSupport' do
           assert_equal({}, @dalli.read_multi([x, y]))
           @dalli.write(x, '123')
           @dalli.write(y, 123)
-          assert_equal({ x => '123', y => 123 }, @dalli.read_multi([x, y]))
+          assert_equal({}, @dalli.read_multi([x, y]))
+          @dalli.write([x, y], '123')
+          assert_equal({ [x, y] => '123' }, @dalli.read_multi([x, y]))
         end
       end
     end
@@ -328,6 +330,30 @@ describe 'ActiveSupport' do
     end
   end
 
+  should 'allow keys to be frozen' do
+    with_activesupport do
+      memcached do
+        connect
+        key = "foo"
+        key.freeze
+        assert_equal true, @dalli.write(key, "value")
+      end
+    end
+  end
+
+  should 'allow keys from a hash' do
+    with_activesupport do
+      memcached do
+        connect
+        map = { "one" => "one", "two" => "two" }
+        map.each_pair do |k, v|
+          assert_equal true, @dalli.write(k, v)
+        end
+        assert_equal map, @dalli.read_multi(*(map.keys))
+      end
+    end
+  end
+
   def connect
     @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => lambda{33.to_s(36)})
     @dalli.clear

data/test/test_compressor.rb

@@ -16,20 +16,24 @@ end
 describe 'Compressor' do
 
   should 'default to Dalli::Compressor' do
-    memcache = Dalli::Client.new('127.0.0.1:11211')
-    memcache.set 1,2
-    assert_equal Dalli::Compressor, memcache.instance_variable_get('@ring').servers.first.compressor
+    memcached_kill(29199) do |dc|
+      memcache = Dalli::Client.new('127.0.0.1:29199')
+      memcache.set 1,2
+      assert_equal Dalli::Compressor, memcache.instance_variable_get('@ring').servers.first.compressor
+    end
   end
 
   should 'support a custom compressor' do
-    memcache = Dalli::Client.new('127.0.0.1:11211', :compressor => NoopCompressor)
-    memcache.set 1,2
-    begin
-      assert_equal NoopCompressor, memcache.instance_variable_get('@ring').servers.first.compressor
-
-      memcached(19127) do |dc|
-        assert dc.set("string-test", "a test string")
-        assert_equal("a test string", dc.get("string-test"))
+    memcached_kill(29199) do |dc|
+      memcache = Dalli::Client.new('127.0.0.1:29199', :compressor => NoopCompressor)
+      memcache.set 1,2
+      begin
+        assert_equal NoopCompressor, memcache.instance_variable_get('@ring').servers.first.compressor
+
+        memcached(19127) do |dc|
+          assert dc.set("string-test", "a test string")
+          assert_equal("a test string", dc.get("string-test"))
+        end
       end
     end
   end

data/test/test_dalli.rb

@@ -67,6 +67,24 @@ describe 'Dalli' do
     assert_equal s2, s3
   end
 
+  should "accept comma separated string" do
+    dc = Dalli::Client.new("server1.example.com:11211,server2.example.com:11211")
+    ring = dc.send(:ring)
+    assert_equal 2, ring.servers.size
+    s1,s2 = ring.servers.map(&:hostname)
+    assert_equal "server1.example.com", s1
+    assert_equal "server2.example.com", s2
+  end
+
+  should "accept array of servers" do
+    dc = Dalli::Client.new(["server1.example.com:11211","server2.example.com:11211"])
+    ring = dc.send(:ring)
+    assert_equal 2, ring.servers.size
+    s1,s2 = ring.servers.map(&:hostname)
+    assert_equal "server1.example.com", s1
+    assert_equal "server2.example.com", s2
+  end
+
   context 'using a live server' do
 
     should "support get/set" do
@@ -95,7 +113,23 @@ describe 'Dalli' do
         servers = stats.keys
         assert(servers.any? do |s|
           stats[s]["get_hits"].to_i != 0
-        end)
+        end, "general stats failed")
+
+        stats_items = dc.stats(:items)
+        servers = stats_items.keys
+        assert(servers.all? do |s|
+          stats_items[s].keys.any? do |key|
+            key =~ /items:[0-9]+:number/
+          end
+        end, "stats items failed")
+
+        stats_slabs = dc.stats(:slabs)
+        servers = stats_slabs.keys
+        assert(servers.all? do |s|
+          stats_slabs[s].keys.any? do |key|
+            key == "active_slabs"
+          end
+        end, "stats slabs failed")
 
         # reset_stats test
         results = dc.reset_stats

data/test/test_serializer.rb

@@ -6,20 +6,24 @@ require 'memcached_mock'
 describe 'Serializer' do
 
   should 'default to Marshal' do
-    memcache = Dalli::Client.new('127.0.0.1:11211')
-    memcache.set 1,2
-    assert_equal Marshal, memcache.instance_variable_get('@ring').servers.first.serializer
+    memcached_kill(29198) do |dc|
+      memcache = Dalli::Client.new('127.0.0.1:29198')
+      memcache.set 1,2
+      assert_equal Marshal, memcache.instance_variable_get('@ring').servers.first.serializer
+    end
   end
 
   should 'support a custom serializer' do
-    memcache = Dalli::Client.new('127.0.0.1:11211', :serializer => JSON)
-    memcache.set 1,2
-    begin
-      assert_equal JSON, memcache.instance_variable_get('@ring').servers.first.serializer
+    memcached_kill(29198) do |dc|
+      memcache = Dalli::Client.new('127.0.0.1:29198', :serializer => JSON)
+      memcache.set 1,2
+      begin
+        assert_equal JSON, memcache.instance_variable_get('@ring').servers.first.serializer
 
-      memcached(19128) do |dc|
-        assert dc.set("json_test", {"foo" => "bar"})
-        assert_equal({"foo" => "bar"}, dc.get("json_test"))
+        memcached(19128) do |dc|
+          assert dc.set("json_test", {"foo" => "bar"})
+          assert_equal({"foo" => "bar"}, dc.get("json_test"))
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.6.2
+  version: 2.6.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
+date: 2013-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_shoulda
@@ -119,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: High performance memcached client for Ruby