dalli 1.1.5 → 2.0.0

data/test/test_dalli.rb

@@ -2,6 +2,33 @@ require 'helper'
 require 'memcached_mock'
 
 describe 'Dalli' do
+  describe 'options parsing' do
+    should 'handle deprecated options' do
+      dc = Dalli::Client.new('foo', :compression => true)
+      assert dc.instance_variable_get(:@options)[:compress]
+    end
+  end
+
+  describe 'key validation' do
+    should 'not allow whitespace' do
+      dc = Dalli::Client.new
+      assert_raises ArgumentError do
+        dc.set '   ', 1
+      end
+      assert_raises ArgumentError do
+        dc.set "\t", 1
+      end
+      assert_raises ArgumentError do
+        dc.set "\n", 1
+      end
+      assert_raises ArgumentError do
+        dc.set "", 1
+      end
+      assert_raises ArgumentError do
+        dc.set nil, 1
+      end
+    end
+  end
 
   should "default to localhost:11211" do
     dc = Dalli::Client.new
@@ -26,60 +53,6 @@ describe 'Dalli' do
     assert_equal s2, s3
   end
 
-  context 'using unix sockets' do
-    should 'pass smoke test' do
-      memcached(nil,'',{:unix => true}) do |dc|
-        # get/set
-        dc.flush
-        assert_nil dc.get(:a)
-        assert dc.set(:a,1)
-        assert_equal 1, dc.get(:a)
-
-        # replace
-        dc.set(:a,1)
-        dc.replace(:a,2)
-        assert_equal 2, dc.get(:a)
-
-        # delete
-        dc.delete(:a)
-        assert_nil dc.get(:a)
-
-        # fetch
-        executed, expected = false, 1
-
-        value = dc.fetch(:fetched) do
-          executed = true
-          expected
-        end
-
-        assert executed
-        assert_equal expected, value
-
-        executed = false
-        value = dc.fetch(:fetched) do
-          executed = true
-          expected
-        end
-
-        assert !executed
-        assert_equal expected, value
-
-        # cas
-        dc.set(:a,1)
-        3.times { dc.cas(:a){|a| a+=1} }
-        assert_equal 4, dc.get(:a)
-
-        # get_multi
-        resp = dc.get_multi(%w(b c d))
-        assert_equal({}, resp)
-        dc.set("b",1)
-        dc.set("c",11)
-        resp = dc.get_multi(%w(b c d))
-        assert_equal({"b" => 1, "c" => 11}, resp)
-      end
-    end
-  end
-
   context 'using a live server' do
 
     should "support get/set" do
@@ -103,6 +76,30 @@ describe 'Dalli' do
       end
     end
 
+    should "support stats" do
+      memcached do |dc|
+        # make sure that get_hits would not equal 0
+        dc.get(:a)
+
+        stats = dc.stats
+        servers = stats.keys
+        assert(servers.any? do |s|
+          stats[s]["get_hits"].to_i != 0
+        end)
+
+        # reset_stats test
+        results = dc.reset_stats
+        assert(results.all? { |x| x })
+        stats = dc.stats
+        servers = stats.keys
+
+        # check if reset was performed
+        servers.each do |s|
+          assert_equal 0, dc.stats[s]["get_hits"].to_i
+        end
+      end
+    end
+
     should "support the fetch operation" do
       memcached do |dc|
         dc.flush
@@ -270,6 +267,20 @@ describe 'Dalli' do
       end
     end
 
+    should 'allow TCP connections to be configured for keepalive' do
+      memcached(19122, '', :keepalive => true) do |dc|
+        dc.set(:a, 1)
+        ring = dc.send(:ring)
+        server = ring.servers.first
+        socket = server.instance_variable_get('@sock')
+
+        optval = socket.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE)
+        optval = optval.unpack 'i'
+
+        assert_equal true, (optval[0] != 0)
+      end
+    end
+
     should "pass a simple smoke test" do
       memcached do |dc|
         resp = dc.flush
@@ -396,7 +407,7 @@ describe 'Dalli' do
     context 'with compression' do
       should 'allow large values' do
         memcached do |dc|
-          dalli = Dalli::Client.new(dc.instance_variable_get(:@servers), :compression => true)
+          dalli = Dalli::Client.new(dc.instance_variable_get(:@servers), :compress => true)
 
           value = "0"*1024*1024
           assert_raises Dalli::DalliError, /too large/ do
@@ -428,7 +439,7 @@ describe 'Dalli' do
 
       should 'fit more values with compression' do
         memcached(19126, '-m 1 -M') do |dc|
-          dalli = Dalli::Client.new('localhost:19126', :compression => true)
+          dalli = Dalli::Client.new('localhost:19126', :compress => true)
           failed = false
           value = "1234567890"*1000
           10_000.times do |idx|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-25 00:00:00.000000000 Z
+date: 2012-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_shoulda
-  requirement: &70232123468080 !ruby/object:Gem::Requirement
+  requirement: &70227367207220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70232123468080
+  version_requirements: *70227367207220
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70232123467180 !ruby/object:Gem::Requirement
+  requirement: &70227367204000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,29 +32,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70232123467180
+  version_requirements: *70227367204000
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70232123465920 !ruby/object:Gem::Requirement
+  requirement: &70227367199700 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: *70232123465920
-- !ruby/object:Gem::Dependency
-  name: memcache-client
-  requirement: &70232123465100 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.8.5
+        version: '3'
   type: :development
   prerelease: false
-  version_requirements: *70232123465100
+  version_requirements: *70227367199700
 description: High performance memcached client for Ruby
 email: mperham@gmail.com
 executables: []
@@ -63,10 +52,7 @@ extra_rdoc_files: []
 files:
 - lib/action_dispatch/middleware/session/dalli_store.rb
 - lib/active_support/cache/dalli_store.rb
-- lib/active_support/cache/dalli_store23.rb
 - lib/dalli/client.rb
-- lib/dalli/compatibility.rb
-- lib/dalli/memcache-client.rb
 - lib/dalli/options.rb
 - lib/dalli/ring.rb
 - lib/dalli/server.rb
@@ -81,13 +67,11 @@ files:
 - Gemfile
 - dalli.gemspec
 - Performance.md
-- Upgrade.md
 - test/abstract_unit.rb
 - test/benchmark_test.rb
 - test/helper.rb
 - test/memcached_mock.rb
 - test/test_active_support.rb
-- test/test_compatibility.rb
 - test/test_dalli.rb
 - test/test_encoding.rb
 - test/test_failover.rb
@@ -95,7 +79,6 @@ files:
 - test/test_ring.rb
 - test/test_sasl.rb
 - test/test_session_store.rb
-- test/test_synchrony.rb
 homepage: http://github.com/mperham/dalli
 licenses: []
 post_install_message: 
@@ -127,7 +110,6 @@ test_files:
 - test/helper.rb
 - test/memcached_mock.rb
 - test/test_active_support.rb
-- test/test_compatibility.rb
 - test/test_dalli.rb
 - test/test_encoding.rb
 - test/test_failover.rb
@@ -135,4 +117,3 @@ test_files:
 - test/test_ring.rb
 - test/test_sasl.rb
 - test/test_session_store.rb
-- test/test_synchrony.rb

data/Upgrade.md

@@ -1,45 +0,0 @@
-Upgrading from memcache-client
-========
-
-Dalli is not meant to be 100% compatible with memcache-client, there are a few minor differences in the API.
-
-
-Compatibility Layer
-----------------------
-
-Enable memcache-client compatibility in your application when upgrading by requiring this when
-initalizing your app:
-
-    require 'dalli/memcache-client'
-
-This will print out warnings if your code is using the old memcache-client API style, explained below.
-
-
-Marshalling
----------------
-
-Dalli has changed the raw parameter to a :raw option.  The memcache-client API allowed you to control marshalling on a per-method basis using a boolean 'raw' parameter to several of the API methods:
-
-    cache = MemCache.new
-    cache.set('abc', 123, 0, true)
-    cache.get('abc', true) => '123'
-
-    cache.set('abc', 123, 0)
-    cache.get('abc') => 123
-
-Note that the last parameter is set to true in the first two API calls and so `get` returns a string, not an integer.  In the second example, we don't provide the raw parameter.  Since it defaults to false, it works exactly like Dalli.
-
-If the code specifies raw as false, you can simply remove that parameter.  If the code is using raw = true, you will need to use the :raw option:
-
-    cache.set('abc', 123, 0, :raw => true)
-
-
-Return Values
-----------------
-
-In memcache-client, `set(key, value)` normally returns "STORED\r\n".  This is an artifact of the text protocol used in earlier versions of memcached.  Code that checks the return value will need to be updated.  Dalli raises errors for exceptional cases but otherwise returns true or false depending on whether the operation succeeded or not.  These methods are affected:
-
-    set
-    add
-    replace
-    delete

data/lib/active_support/cache/dalli_store23.rb

@@ -1,172 +0,0 @@
-begin
-  require 'dalli'
-rescue LoadError => e
-  $stderr.puts "You don't have dalli installed in your application: #{e.message}"
-  raise e
-end
-require 'digest/md5'
-
-module ActiveSupport
-  module Cache
-    # A cache store implementation which stores data in Memcached:
-    # http://www.danga.com/memcached/
-    #
-    # DalliStore implements the Strategy::LocalCache strategy which implements
-    # an in memory cache inside of a block.
-    class DalliStore < Store
-
-      def self.build_mem_cache(*addresses)
-        addresses = addresses.flatten
-        options = addresses.extract_options!
-        addresses = ["localhost"] if addresses.empty?
-        Dalli::Client.new(addresses, options)
-      end
-
-      # Creates a new DalliStore object, with the given memcached server
-      # addresses. Each address is either a host name, or a host-with-port string
-      # in the form of "host_name:port". For example:
-      #
-      #   ActiveSupport::Cache::DalliStore.new("localhost", "server-downstairs.localnetwork:8229")
-      #
-      # If no addresses are specified, then DalliStore will connect to
-      # localhost port 11211 (the default memcached port).
-      #
-      def initialize(*addresses)
-        addresses = addresses.flatten
-        options = addresses.extract_options!
-
-        mem_cache_options = options.dup
-        @namespace = mem_cache_options.delete(:namespace)
-        @expires_in = mem_cache_options[:expires_in]
-        @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
-
-        extend Strategy::LocalCache
-      end
-
-      # Reads multiple keys from the cache using a single call to the
-      # servers for all keys. Options can be passed in the last argument.
-      def read_multi(*names)
-        options = nil
-        options = names.pop if names.last.is_a?(Hash)
-        keys_to_names = names.inject({}){|map, name| map[escape_key(name)] = name; map}
-        cache_keys = {}
-        # map keys to servers
-        names.each do |key|
-          cache_key = escape_key key
-          cache_keys[cache_key] = key
-        end
-
-        values = @data.get_multi(keys_to_names.keys, options)
-        results = {}
-        values.each do |key, value|
-          results[cache_keys[key]] = value
-        end
-        results
-      end
-
-      def reset
-        @data.reset
-      end
-
-      # Read an entry from the cache.
-      def read(key, options = nil) # :nodoc:
-        super
-        @data.get(escape_key(key), options)
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}")
-        nil
-      end
-
-      # Writes a value to the cache.
-      #
-      # Possible options:
-      # - +:unless_exist+ - set to true if you don't want to update the cache
-      #   if the key is already set.
-      # - +:expires_in+ - the number of seconds that this value may stay in
-      #   the cache. See ActiveSupport::Cache::Store#write for an example.
-      def write(key, value, options = nil)
-        super
-        value = value.to_s if options && options[:raw]
-        method = options && options[:unless_exist] ? :add : :set
-        @data.send(method, escape_key(key), value, expires_in(options), options)
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}")
-        false
-      end
-
-      def delete(key, options = nil) # :nodoc:
-        super
-        @data.delete(escape_key(key))
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}")
-        false
-      end
-
-      def exist?(key, options = nil) # :nodoc:
-        # Doesn't call super, cause exist? in memcache is in fact a read
-        # But who cares? Reading is very fast anyway
-        # Local cache is checked first, if it doesn't know then memcache itself is read from
-        !read(key, options).nil?
-      end
-
-      # Increment a cached value. This method uses the memcached incr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
-      def increment(key, amount = 1) # :nodoc:
-        log("incrementing", key, amount)
-        @data.incr(escape_key(key), amount)
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
-        nil
-      end
-
-      # Decrement a cached value. This method uses the memcached decr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
-      def decrement(key, amount = 1) # :nodoc:
-        log("decrement", key, amount)
-        @data.decr(escape_key(key), amount)
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
-        nil
-      end
-
-      def delete_matched(matcher, options = nil) # :nodoc:
-        # don't do any local caching at present, just pass
-        # through and let the error happen
-        super
-        raise "Not supported by Memcache"
-      end
-
-      # Clear the entire cache on all memcached servers. This method should
-      # be used with care when using a shared cache.
-      def clear
-        @data.flush_all
-      end
-
-      # Get the statistics from the memcached servers.
-      def stats
-        @data.stats
-      end
-
-      private
-
-      # Exists in 2.3.8 but not in 2.3.2 so roll our own version
-      def expires_in(options)
-        expires_in = (options && options[:expires_in]) || @expires_in
-
-        raise ":expires_in must be a number" if expires_in && !expires_in.is_a?(Numeric)
-
-        expires_in || 0
-      end
-
-      def escape_key(key)
-        prefix = @namespace.is_a?(Proc) ? @namespace.call : @namespace
-        key = "#{prefix}:#{key}" if prefix
-        key
-      end
-    end
-  end
-end