dalli 2.5.0 → 2.6.0

data/History.md

@@ -1,6 +1,15 @@
 Dalli Changelog
 =====================
 
+2.6.0
+=======
+
+- read_multi optimization, now checks local_cache [chendo, #306]
+- Re-implement get_multi to be non-blocking [tmm1, #295]
+- Add `dalli` accessor to dalli_store to access the underlying
+Dalli::Client, for things like `get_multi`.
+- Add `Dalli::GzipCompressor`, primarily for compatibility with nginx's HttpMemcachedModule using `memcached_gzip_flag`
+
 2.5.0
 =======
 
@@ -9,12 +18,14 @@ Dalli Changelog
 - Removed lots of old session_store test code, tests now all run without a default memcached server [#275]
 - Changed Dalli ActiveSupport adapter to always attempt instrumentation [brianmario, #284]
 - Change write operations (add/set/replace) to return false when value is too large to store [brianmario, #283]
+- Allowing different compressors per client [naseem]
 
 2.4.0
 =======
 - Added the ability to swap out the compressed used to [de]compress cache data [brianmario, #276]
 - Fix get\_multi performance issues with lots of memcached servers [tmm1]
 - Throw more specific exceptions [tmm1]
+- Allowing different types of serialization per client [naseem]
 
 2.3.0
 =======

data/README.md

@@ -112,6 +112,9 @@ Dalli::Client accepts the following options. All times are in seconds.
 
 **compression_max_size**: Maximum value byte size for which to attempt compression. Default is unlimited.
 
+**serializer**: The serializer to use for objects being stored (ex. JSON).
+Default is Marshal.
+
 **socket_timeout**: Timeout for all socket operations (connect, read, write). Default is 0.5.
 
 **socket_max_failures**: When a socket operation fails after socket_timeout, the same operation is retried. This is to not immediately mark a server down when there's a very slight network problem. Default is 2.
@@ -128,6 +131,10 @@ Dalli::Client accepts the following options. All times are in seconds.
 
 **keepalive**: Boolean, if true Dalli will enable keep-alives on the socket so inactivity
 
+**compressor**: The compressor to use for objects being stored.
+Default is zlib, implemented under `Dalli::Compressor`.
+If serving compressed data using nginx's HttpMemcachedModule, set `memcached_gzip_flag 2` and use `Dalli::GzipCompressor`
+
 Features and Changes
 ------------------------
 

data/dalli.gemspec

@@ -3,6 +3,7 @@ require './lib/dalli/version'
 Gem::Specification.new do |s|
   s.name = %q{dalli}
   s.version = Dalli::VERSION
+  s.license = "MIT"
 
   s.authors = ["Mike Perham"]
   s.description = %q{High performance memcached client for Ruby}

data/lib/active_support/cache/dalli_store.rb

@@ -49,6 +49,13 @@ module ActiveSupport
         extend Strategy::LocalCache
       end
 
+      ##
+      # Access the underlying Dalli::Client instance for
+      # access to get_multi, etc.
+      def dalli
+        @data
+      end
+
       def fetch(name, options=nil)
         options ||= {}
         name = expanded_key name
@@ -118,13 +125,24 @@ module ActiveSupport
       def read_multi(*names)
         names.extract_options!
         names = names.flatten
-        mapping = names.inject({}) { |memo, name| memo[escape(expanded_key(name))] = name; memo }
+        mapping = names.inject({}) { |memo, name| memo[expanded_key(name)] = name; memo }
         instrument(:read_multi, names) do
-          results = @data.get_multi(mapping.keys)
+          results = {}
+          if local_cache
+            mapping.keys.each do |key|
+              if value = local_cache.read_entry(key, options)
+                results[key] = value
+              end
+            end
+          end
+
+          results.merge!(@data.get_multi(mapping.keys - results.keys))
           results.inject({}) do |memo, (inner, _)|
             entry = results[inner]
             # NB Backwards data compatibility, to be removed at some point
-            memo[mapping[inner]] = (entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry)
+            value = (entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry)
+            memo[mapping[inner]] = value
+            local_cache.write_entry(inner, value, options) if local_cache
             memo
           end
         end
@@ -201,7 +219,7 @@ module ActiveSupport
 
       # Read an entry from the cache.
       def read_entry(key, options) # :nodoc:
-        entry = @data.get(escape(key), options)
+        entry = @data.get(key, options)
         # NB Backwards data compatibility, to be removed at some point
         entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry
       rescue Dalli::DalliError => e
@@ -214,7 +232,7 @@ module ActiveSupport
       def write_entry(key, value, options) # :nodoc:
         method = options[:unless_exist] ? :add : :set
         expires_in = options[:expires_in]
-        @data.send(method, escape(key), value, expires_in, options)
+        @data.send(method, key, value, expires_in, options)
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
         raise if @raise_errors
@@ -223,7 +241,7 @@ module ActiveSupport
 
       # Delete an entry from the cache.
       def delete_entry(key, options) # :nodoc:
-        @data.delete(escape(key))
+        @data.delete(key)
       rescue Dalli::DalliError => e
         logger.error("DalliError: #{e.message}") if logger
         raise if @raise_errors
@@ -248,12 +266,8 @@ module ActiveSupport
           key = key.sort_by { |k,_| k.to_s }.collect{|k,v| "#{k}=#{v}"}
         end
 
-        key.to_param
-      end
-
-      def escape(key)
-        key = key.to_s.dup
-        key = key.force_encoding("BINARY") if key.respond_to?(:encode)
+        key = key.to_param
+        key.force_encoding('binary') if key.respond_to? :force_encoding
         key
       end
 

data/lib/dalli.rb

@@ -1,10 +1,10 @@
+require 'dalli/compressor'
 require 'dalli/client'
 require 'dalli/ring'
 require 'dalli/server'
 require 'dalli/socket'
 require 'dalli/version'
 require 'dalli/options'
-require 'dalli/compressor'
 require 'dalli/railtie' if defined?(::Rails::Railtie)
 
 module Dalli
@@ -39,27 +39,6 @@ module Dalli
     @logger = logger
   end
 
-  # Default serialization to Marshal
-  @serializer = Marshal
-
-  def self.serializer
-    @serializer
-  end
-
-  def self.serializer=(serializer)
-    @serializer = serializer
-  end
-
-  # Default serialization to Dalli::Compressor
-  @compressor = Compressor
-
-  def self.compressor
-    @compressor
-  end
-
-  def self.compressor=(compressor)
-    @compressor = compressor
-  end
 end
 
 if defined?(RAILS_VERSION) && RAILS_VERSION < '3'

data/lib/dalli/client.rb

@@ -22,13 +22,14 @@ module Dalli
     # - :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
+    # - :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'
       @options = normalize_options(options)
       @ring = nil
-      @servers_in_use = nil
     end
 
     #
@@ -60,33 +61,80 @@ module Dalli
       options = nil
       options = keys.pop if keys.last.is_a?(Hash) || keys.last.nil?
       ring.lock do
-        self.servers_in_use = Set.new
-
-        keys.flatten.each do |key|
-          begin
-            perform(:getkq, key)
-          rescue DalliError, NetworkError => e
-            Dalli.logger.debug { e.inspect }
-            Dalli.logger.debug { "unable to get key #{key}" }
+        begin
+          servers = self.servers_in_use = Set.new
+
+          keys.flatten.each do |key|
+            begin
+              perform(:getkq, key)
+            rescue DalliError, NetworkError => e
+              Dalli.logger.debug { e.inspect }
+              Dalli.logger.debug { "unable to get key #{key}" }
+            end
           end
-        end
 
-        values = {}
-        servers_in_use.each do |server|
-          next unless server.alive?
-          begin
-            server.request(:noop).each_pair do |key, value|
-              values[key_without_namespace(key)] = value
+          values = {}
+          return values if servers.empty?
+
+          servers.each do |server|
+            next unless server.alive?
+            begin
+              server.multi_response_start
+            rescue DalliError, NetworkError => e
+              Dalli.logger.debug { e.inspect }
+              Dalli.logger.debug { "results from this server will be missing" }
+              servers.delete(server)
             end
-          rescue DalliError, NetworkError => e
-            Dalli.logger.debug { e.inspect }
-            Dalli.logger.debug { "results from this server will be missing" }
           end
+
+          start = Time.now
+          loop do
+            # remove any dead servers
+            servers.delete_if { |s| s.sock.nil? }
+            break if servers.empty?
+
+            # calculate remaining timeout
+            elapsed = Time.now - start
+            timeout = servers.first.options[:socket_timeout]
+            if elapsed > timeout
+              readable = nil
+            else
+              sockets = servers.map(&:sock)
+              readable, _ = IO.select(sockets, nil, nil, timeout - elapsed)
+            end
+
+            if readable.nil?
+              # no response within timeout; abort pending connections
+              servers.each do |server|
+                puts "Abort!"
+                server.multi_response_abort
+              end
+              break
+
+            else
+              readable.each do |sock|
+                server = sock.server
+
+                begin
+                  server.multi_response_nonblock.each do |key, value|
+                    values[key_without_namespace(key)] = value
+                  end
+
+                  if server.multi_response_completed?
+                    servers.delete(server)
+                  end
+                rescue NetworkError
+                  servers.delete(server)
+                end
+              end
+            end
+          end
+
+          values
+        ensure
+          self.servers_in_use = nil
         end
-        values
       end
-    ensure
-      self.servers_in_use = nil
     end
 
     def fetch(key, ttl=nil, options=nil)

data/lib/dalli/compressor.rb

@@ -1,4 +1,5 @@
 require 'zlib'
+require 'stringio'
 
 module Dalli
   class Compressor
@@ -10,4 +11,19 @@ module Dalli
       Zlib::Inflate.inflate(data)
     end
   end
+
+  class GzipCompressor
+    def self.compress(data)
+      io = StringIO.new("w")
+      gz = Zlib::GzipWriter.new(io)
+      gz.write(data)
+      gz.close
+      io.string
+    end
+
+    def self.decompress(data)
+      io = StringIO.new(data, "rb")
+      Zlib::GzipReader.new(io).read
+    end
+  end
 end

data/lib/dalli/options.rb

@@ -31,6 +31,24 @@ module Dalli
       end
     end
 
+    def multi_response_start
+      @lock.synchronize do
+        super
+      end
+    end
+
+    def multi_response_nonblock
+      @lock.synchronize do
+        super
+      end
+    end
+
+    def multi_response_abort
+      @lock.synchronize do
+        super
+      end
+    end
+
     def lock!
       @lock.mon_enter
     end

data/lib/dalli/server.rb

@@ -7,6 +7,7 @@ module Dalli
     attr_accessor :port
     attr_accessor :weight
     attr_accessor :options
+    attr_reader :sock
 
     DEFAULTS = {
       # seconds between trying to contact a remote server
@@ -19,10 +20,12 @@ module Dalli
       :socket_failure_delay => 0.01,
       # max size of value in bytes (default is 1 MB, can be overriden with "memcached -I <size>")
       :value_max_bytes => 1024 * 1024,
+      :compressor => Compressor,
       # min byte size to attempt compression
       :compression_min_size => 1024,
       # max byte size for compression
       :compression_max_size => false,
+      :serializer => Marshal,
       :username => nil,
       :password => nil,
       :keepalive => true
@@ -96,6 +99,89 @@ module Dalli
     def unlock!
     end
 
+    def serializer
+      @options[:serializer]
+    end
+
+    def compressor
+      @options[:compressor]
+    end
+
+    # Start reading key/value pairs from this connection. This is usually called
+    # after a series of GETKQ commands. A NOOP is sent, and the server begins
+    # flushing responses for kv pairs that were found.
+    #
+    # Returns nothing.
+    def multi_response_start
+      verify_state
+      write_noop
+      @multi_buffer = ''
+      @inprogress = true
+    end
+
+    # Did the last call to #multi_response_start complete successfully?
+    def multi_response_completed?
+      @multi_buffer.nil?
+    end
+
+    # Attempt to receive and parse as many key/value pairs as possible
+    # from this server. After #multi_response_start, this should be invoked
+    # repeatedly whenever this server's socket is readable until
+    # #multi_response_completed?.
+    #
+    # Returns a Hash of kv pairs received.
+    def multi_response_nonblock
+      raise 'multi_response has completed' if @multi_buffer.nil?
+
+      @multi_buffer << @sock.read_available
+      buf = @multi_buffer
+      values = {}
+
+      while buf.bytesize >= 24
+        header = buf.slice(0, 24)
+        (key_length, _, body_length) = header.unpack(KV_HEADER)
+
+        if key_length == 0
+          # all done!
+          @multi_buffer = 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
+
+          begin
+            values[key] = deserialize(value, flags)
+          rescue DalliError
+          end
+
+        else
+          # not enough data yet, wait for more
+          break
+        end
+      end
+
+      values
+    rescue SystemCallError, Timeout::Error, EOFError
+      failure!
+    end
+
+    # Abort an earlier #multi_response_start. Used to signal an external
+    # timeout. The underlying socket is disconnected, and the exception is
+    # swallowed.
+    #
+    # Returns nothing.
+    def multi_response_abort
+      @multi_buffer = nil
+      @inprogress = false
+      failure!
+    rescue NetworkError
+      true
+    end
+
     # NOTE: Additional public methods should be overridden in Dalli::Threadsafe
 
     private
@@ -234,11 +320,15 @@ module Dalli
       body ? longlong(*body.unpack('NN')) : body
     end
 
+    def write_noop
+      req = [REQUEST, OPCODES[:noop], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
+      write(req)
+    end
+
     # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands.
     # We need to read all the responses at once.
     def noop
-      req = [REQUEST, OPCODES[:noop], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
-      write(req)
+      write_noop
       multi_response
     end
 
@@ -295,7 +385,7 @@ module Dalli
       value = unless options && options[:raw]
         marshalled = true
         begin
-          Dalli.serializer.dump(value)
+          self.serializer.dump(value)
         rescue => ex
           # Marshalling can throw several different types of generic Ruby exceptions.
           # Convert to a specific exception so we can special case it higher up the stack.
@@ -309,7 +399,7 @@ module Dalli
       compressed = false
       if @options[:compress] && value.bytesize >= @options[:compression_min_size] &&
         (!@options[:compression_max_size] || value.bytesize <= @options[:compression_max_size])
-        value = Dalli.compressor.compress(value)
+        value = self.compressor.compress(value)
         compressed = true
       end
 
@@ -320,8 +410,8 @@ module Dalli
     end
 
     def deserialize(value, flags)
-      value = Dalli.compressor.decompress(value) if (flags & FLAG_COMPRESSED) != 0
-      value = Dalli.serializer.load(value) if (flags & FLAG_SERIALIZED) != 0
+      value = self.compressor.decompress(value) if (flags & FLAG_COMPRESSED) != 0
+      value = self.serializer.load(value) if (flags & FLAG_SERIALIZED) != 0
       value
     rescue TypeError
       raise if $!.message !~ /needs to have method `_load'|exception class\/object expected|instance of IO needed|incompatible marshal file format/
@@ -432,7 +522,7 @@ module Dalli
 
       begin
         @pid = Process.pid
-        @sock = KSocket.open(hostname, port, options)
+        @sock = KSocket.open(hostname, port, self, options)
         @version = version # trigger actual connect
         sasl_authentication if need_auth?
         up!

data/lib/dalli/socket.rb

@@ -3,7 +3,7 @@ begin
   puts "Using kgio socket IO" if defined?($TESTING) && $TESTING
 
   class Dalli::Server::KSocket < Kgio::Socket
-    attr_accessor :options
+    attr_accessor :options, :server
 
     def kgio_wait_readable
       IO.select([self], nil, nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
@@ -13,12 +13,13 @@ begin
       IO.select(nil, [self], nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
     end
 
-    def self.open(host, port, options = {})
+    def self.open(host, port, server, options = {})
       addr = Socket.pack_sockaddr_in(port, host)
       sock = start(addr)
       sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
       sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
       sock.options = options
+      sock.server = server
       sock.kgio_wait_writable
       sock
     end
@@ -34,6 +35,22 @@ begin
       value
     end
 
+    def read_available
+      value = ''
+      loop do
+        ret = kgio_tryread(8196)
+        case ret
+        when nil
+          raise EOFError, 'end of stream'
+        when :wait_readable
+          break
+        else
+          value << ret
+        end
+      end
+      value
+    end
+
   end
 
   if ::Kgio.respond_to?(:wait_readable=)
@@ -45,14 +62,15 @@ rescue LoadError
 
   puts "Using standard socket IO (#{RUBY_DESCRIPTION})" if defined?($TESTING) && $TESTING
   class Dalli::Server::KSocket < TCPSocket
-    attr_accessor :options
+    attr_accessor :options, :server
 
-    def self.open(host, port, options = {})
+    def self.open(host, port, server, options = {})
       Timeout.timeout(options[:socket_timeout]) do
         sock = new(host, port)
         sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
         sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
         sock.options = { :host => host, :port => port }.merge(options)
+        sock.server = server
         sock
       end
     end
@@ -74,5 +92,17 @@ rescue LoadError
       value
     end
 
+    def read_available
+      value = ''
+      loop do
+        begin
+          value << read_nonblock(8196)
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          break
+        end
+      end
+      value
+    end
+
   end
 end

data/lib/dalli/version.rb

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

data/test/benchmark_test.rb

@@ -24,7 +24,7 @@ describe 'performance' do
   should 'run benchmarks' do
     memcached do
 
-      Benchmark.bm(31) do |x|
+      Benchmark.bm(37) do |x|
 
         n = 2500
 
@@ -44,6 +44,61 @@ describe 'performance' do
           end
         end
 
+        x.report("mixed:rails-localcache:dalli") do
+          n.times do
+            @ds.with_local_cache do
+              @ds.read @key1
+              @ds.write @key2, @value
+              @ds.fetch(@key3) { @value }
+              @ds.fetch(@key2) { @value }
+              @ds.fetch(@key1) { @value }
+              @ds.write @key2, @value, :unless_exists => true
+              @ds.delete @key2
+              @ds.increment @counter, 1, :initial => 100
+              @ds.increment @counter, 1, :expires_in => 12
+              @ds.decrement @counter, 1
+            end
+          end
+        end
+
+        @ds.clear
+        sizeable_data = "<marquee>some view partial data</marquee>" * 50
+        [@key1, @key2, @key3, @key4, @key5, @key6].each do |key|
+          @ds.write(key, sizeable_data)
+        end
+
+        x.report("read_multi_big:rails:dalli") do
+          n.times do
+            @ds.read_multi @key1, @key2, @key3, @key4
+            @ds.read @key1
+            @ds.read @key2
+            @ds.read @key3
+            @ds.read @key4
+            @ds.read @key1
+            @ds.read @key2
+            @ds.read @key3
+            @ds.read_multi @key1, @key2, @key3
+          end
+        end
+
+        x.report("read_multi_big:rails-localcache:dalli") do
+          n.times do
+            @ds.with_local_cache do
+              @ds.read_multi @key1, @key2, @key3, @key4
+              @ds.read @key1
+              @ds.read @key2
+              @ds.read @key3
+              @ds.read @key4
+            end
+            @ds.with_local_cache do
+              @ds.read @key1
+              @ds.read @key2
+              @ds.read @key3
+              @ds.read_multi @key1, @key2, @key3
+            end
+          end
+        end
+
         @m = Dalli::Client.new(@servers)
         x.report("set:plain:dalli") do
           n.times do

data/test/test_active_support.rb

@@ -114,6 +114,37 @@ describe 'ActiveSupport' do
       end
     end
 
+    should 'support read_multi with LocalCache' do
+      with_activesupport do
+        memcached do
+          connect
+          x = rand_key
+          y = rand_key
+          assert_equal({}, @dalli.read_multi(x, y))
+          @dalli.write(x, '123')
+          @dalli.write(y, 456)
+
+          @dalli.with_local_cache do
+            assert_equal({ x => '123', y => 456 }, @dalli.read_multi(x, y))
+            Dalli::Client.any_instance.expects(:get).with(any_parameters).never
+
+            dres = @dalli.read(x)
+            assert_equal dres, '123'
+          end
+
+          Dalli::Client.any_instance.unstub(:get)
+
+          # Fresh LocalStore
+          @dalli.with_local_cache do
+            @dalli.read(x)
+            Dalli::Client.any_instance.expects(:get_multi).with([y.to_s]).returns(y.to_s => 456)
+
+            assert_equal({ x => '123', y => 456}, @dalli.read_multi(x, y))
+          end
+        end
+      end
+    end
+
     should 'support read, write and delete' do
       with_activesupport do
         memcached do
@@ -147,6 +178,34 @@ describe 'ActiveSupport' do
       end
     end
 
+    should 'support read, write and delete with LocalCache' do
+      with_activesupport do
+        memcached do
+          connect
+          y = rand_key.to_s
+          @dalli.with_local_cache do
+            Dalli::Client.any_instance.expects(:get).with(y, {}).once.returns(123)
+            dres = @dalli.read(y)
+            assert_equal 123, dres
+
+            Dalli::Client.any_instance.expects(:get).with(y, {}).never
+
+            dres = @dalli.read(y)
+            assert_equal 123, dres
+
+            @dalli.write(y, 456)
+            dres = @dalli.read(y)
+            assert_equal 456, dres
+
+            @dalli.delete(y)
+            Dalli::Client.any_instance.expects(:get).with(y, {}).once.returns(nil)
+            dres = @dalli.read(y)
+            assert_equal nil, dres
+          end
+        end
+      end
+    end
+
     should 'support increment/decrement commands' do
       with_activesupport do
         memcached do

data/test/test_compressor.rb

@@ -16,21 +16,34 @@ end
 describe 'Compressor' do
 
   should 'default to Dalli::Compressor' do
-    assert_equal Dalli::Compressor, Dalli.compressor
+    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
   end
 
   should 'support a custom compressor' do
-    original_compressor = Dalli.compressor
+    memcache = Dalli::Client.new('127.0.0.1:11211', :compressor => NoopCompressor)
+    memcache.set 1,2
     begin
-      Dalli.compressor = NoopCompressor
-      assert_equal NoopCompressor, Dalli.compressor
+      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
-    ensure
-      Dalli.compressor = original_compressor
     end
   end
 end
+
+describe 'GzipCompressor' do
+
+  should 'compress and uncompress data using Zlib::GzipWriter/Reader' do
+    memcached(19127,nil,{:compress=>true,:compressor=>Dalli::GzipCompressor}) do |dc|
+      data = (0...1025).map{65.+(rand(26)).chr}.join
+      assert dc.set("test", data)
+      assert_equal Dalli::GzipCompressor, dc.instance_variable_get('@ring').servers.first.compressor
+      assert_equal(data, dc.get("test"))
+    end
+  end
+
+end

data/test/test_dalli.rb

@@ -184,18 +184,18 @@ describe 'Dalli' do
         resp = dc.get_multi(%w(a b c d e f))
         assert_equal({ 'a' => 'foo', 'b' => 123, 'c' => %w(a b c) }, resp)
 
-        # Perform a huge multi-get with 10,000 elements.
+        # Perform a big multi-get with 1000 elements.
         arr = []
         dc.multi do
-          10_000.times do |idx|
+          1000.times do |idx|
             dc.set idx, idx
             arr << idx
           end
         end
 
         result = dc.get_multi(arr)
-        assert_equal(10_000, result.size)
-        assert_equal(1000, result['1000'])
+        assert_equal(1000, result.size)
+        assert_equal(50, result['50'])
       end
     end
 
@@ -410,6 +410,9 @@ describe 'Dalli' do
               assert_equal 0, inc % 5
               cache.decr('cat', 5)
               assert_equal 11, cache.get('b')
+
+              assert_equal %w(a b), cache.get_multi('a', 'b', 'c').keys.sort
+
             end
           end
         end

data/test/test_serializer.rb

@@ -6,21 +6,21 @@ require 'memcached_mock'
 describe 'Serializer' do
 
   should 'default to Marshal' do
-    assert_equal Marshal, Dalli.serializer
+    memcache = Dalli::Client.new('127.0.0.1:11211')
+    memcache.set 1,2
+    assert_equal Marshal, memcache.instance_variable_get('@ring').servers.first.serializer
   end
 
   should 'support a custom serializer' do
-    original_serializer = Dalli.serializer
+    memcache = Dalli::Client.new('127.0.0.1:11211', :serializer => JSON)
+    memcache.set 1,2
     begin
-      Dalli.serializer = JSON
-      assert_equal JSON, Dalli.serializer
+      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"))
       end
-    ensure
-      Dalli.serializer = original_serializer
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-13 00:00:00.000000000 Z
+date: 2012-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_shoulda
@@ -98,7 +98,8 @@ files:
 - test/test_sasl.rb
 - test/test_serializer.rb
 homepage: http://github.com/mperham/dalli
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options:
 - --charset=UTF-8