mob-dalli 1.1.4

data/Rakefile

@@ -0,0 +1,39 @@
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+end
+
+Rake::TestTask.new(:bench) do |test|
+  test.libs << 'test'
+  test.pattern = 'test/benchmark_test.rb'
+end
+
+begin
+  require 'metric_fu'
+  MetricFu::Configuration.run do |config|
+    config.rcov[:rcov_opts] << "-Itest:lib"
+  end
+rescue LoadError
+end
+
+task :default => :test
+
+task :test_all do
+  system('rake test RAILS_VERSION="~> 3.0.0"')
+  system('rake test RAILS_VERSION=">= 3.0.0"')
+end
+
+# 'gem install rdoc' to upgrade RDoc if this is giving you errors
+begin
+  require 'rdoc/task'
+  RDoc::Task.new do |rd|
+    rd.rdoc_files.include("lib/**/*.rb")
+  end
+rescue LoadError
+  puts "Unable to load rdoc, run 'gem install rdoc' to fix this."
+end
+
+require 'rake/clean'
+CLEAN.include "**/*.rbc"
+CLEAN.include "**/.DS_Store"

data/Upgrade.md

@@ -0,0 +1,45 @@
+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/action_dispatch/middleware/session/dalli_store.rb

@@ -0,0 +1,76 @@
+require 'active_support/cache'
+require 'action_dispatch/middleware/session/abstract_store'
+require 'dalli'
+
+# Dalli-based session store for Rails 3.0.
+module ActionDispatch
+  module Session
+    class DalliStore < AbstractStore
+      def initialize(app, options = {})
+        # Support old :expires option
+        options[:expire_after] ||= options[:expires]
+
+        super
+
+        @default_options = { :namespace => 'rack:session' }.merge(@default_options)
+
+        @pool = options[:cache] || begin
+          Dalli::Client.new(
+              @default_options[:memcache_server], @default_options)
+        end
+        @namespace = @default_options[:namespace]
+
+        super
+      end
+
+      def reset
+        @pool.reset
+      end
+
+      private
+
+      def get_session(env, sid)
+        sid ||= generate_sid
+        begin
+          session = @pool.get(sid) || {}
+        rescue Dalli::DalliError => ex
+          # re-raise ArgumentError so Rails' session abstract_store.rb can autoload any missing models
+          raise ArgumentError, ex.message if ex.message =~ /unmarshal/
+          Rails.logger.warn("Session::DalliStore#get: #{ex.message}")
+          session = {}
+        end
+        [sid, session]
+      end
+
+      def set_session(env, sid, session_data, options = nil)
+        options ||= env[ENV_SESSION_OPTIONS_KEY]
+        expiry  = options[:expire_after]
+        @pool.set(sid, session_data, expiry)
+        sid
+      rescue Dalli::DalliError
+        Rails.logger.warn("Session::DalliStore#set: #{$!.message}")
+        false
+      end
+
+      def destroy_session(env, session_id, options)
+        begin
+          @pool.delete(session_id)
+        rescue Dalli::DalliError
+          Rails.logger.warn("Session::DalliStore#destroy_session: #{$!.message}")
+        end
+        return nil if options[:drop]
+        generate_sid
+      end
+
+      def destroy(env)
+        if sid = current_session_id(env)
+          @pool.delete(sid)
+        end
+      rescue Dalli::DalliError
+        Rails.logger.warn("Session::DalliStore#destroy: #{$!.message}")
+        false
+      end
+
+    end
+  end
+end

data/lib/active_support/cache/dalli_store.rb

@@ -0,0 +1,184 @@
+# encoding: ascii
+begin
+  require 'dalli'
+rescue LoadError => e
+  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require 'digest/md5'
+require 'active_support/cache'
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores data in Memcached:
+    # http://www.memcached.org
+    #
+    # DalliStore implements the Strategy::LocalCache strategy which implements
+    # an in memory cache inside of a block.
+    class DalliStore < Store
+
+      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/
+      RAW = { :raw => true }
+
+      # 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!
+        super(options)
+
+        addresses << 'localhost:11211' if addresses.empty?
+        options = options.dup
+        # Extend expiry by stale TTL or else memcached will never return stale data.
+        # See ActiveSupport::Cache#fetch.
+        options[:expires_in] += options[:race_condition_ttl] if options[:expires_in] && options[:race_condition_ttl]
+        @data = Dalli::Client.new(addresses, options)
+
+        extend Strategy::LocalCache
+        extend LocalCacheWithRaw
+      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 = names.extract_options!
+        options = merged_options(options)
+        keys_to_names = names.flatten.inject({}){|map, name| map[escape_key(namespaced_key(name, options))] = name; map}
+        raw_values = @data.get_multi(keys_to_names.keys, RAW)
+        values = {}
+        raw_values.each do |key, value|
+          entry = deserialize_entry(value)
+          values[keys_to_names[key]] = entry.value unless entry.expired?
+        end
+        values
+      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 fail.
+      # :initial defaults to the amount passed in, as if the counter was initially zero.
+      # memcached counters cannot hold negative values.
+      def increment(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        initial = options[:initial] || amount
+        expires_in = options[:expires_in].to_i
+        response = instrument(:increment, name, :amount => amount) do
+          @data.incr(escape_key(namespaced_key(name, options)), amount, expires_in, initial)
+        end
+      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 fail.
+      # :initial defaults to zero, as if the counter was initially zero.
+      # memcached counters cannot hold negative values.
+      def decrement(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        initial = options[:initial] || 0
+        expires_in = options[:expires_in].to_i
+        response = instrument(:decrement, name, :amount => amount) do
+          @data.decr(escape_key(namespaced_key(name, options)), amount, expires_in, initial)
+        end
+      rescue Dalli::DalliError => e
+        logger.error("DalliError: #{e.message}") if logger
+        nil
+      end
+
+      # Clear the entire cache on all memcached servers. This method should
+      # be used with care when using a shared cache.
+      def clear(options = nil)
+        @data.flush_all
+      end
+
+      # Get the statistics from the memcached servers.
+      def stats
+        @data.stats
+      end
+
+      def reset
+        @data.reset
+      end
+
+      protected
+
+        # This CacheStore impl controls value marshalling so we take special
+        # care to always pass :raw => true to the Dalli API so it does not
+        # double marshal.
+
+        # Read an entry from the cache.
+        def read_entry(key, options) # :nodoc:
+          deserialize_entry(@data.get(escape_key(key), RAW))
+        rescue Dalli::DalliError => e
+          logger.error("DalliError: #{e.message}") if logger
+          nil
+        end
+
+        # Write an entry to the cache.
+        def write_entry(key, entry, options) # :nodoc:
+          method = options[:unless_exist] ? :add : :set
+          value = options[:raw] ? entry.value.to_s : entry
+          expires_in = options[:expires_in].to_i
+          if expires_in > 0 && !options[:raw]
+            # Set the memcache expire a few minutes in the future to support race condition ttls on read
+            expires_in += 5.minutes
+          end
+          @data.send(method, escape_key(key), value, expires_in, options)
+        rescue Dalli::DalliError => e
+          logger.error("DalliError: #{e.message}") if logger
+          false
+        end
+
+        # Delete an entry from the cache.
+        def delete_entry(key, options) # :nodoc:
+          @data.delete(escape_key(key))
+        rescue Dalli::DalliError => e
+          logger.error("DalliError: #{e.message}") if logger
+          false
+        end
+
+      private
+        def escape_key(key)
+          key = key.to_s
+          key = key.force_encoding('ASCII-8BIT') if key.respond_to? :force_encoding
+          key = key.gsub(ESCAPE_KEY_CHARS){|match| "%#{match.getbyte(0).to_s(16).upcase}"}
+          key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
+          key
+        end
+
+        def deserialize_entry(raw_value)
+          if raw_value
+            # FIXME: This is a terrible implementation for performance reasons:
+            # throwing an exception is much slower than some if logic.
+            entry = Marshal.load(raw_value) rescue raw_value
+            entry.is_a?(Entry) ? entry : Entry.new(entry)
+          else
+            nil
+          end
+        end
+
+      # Provide support for raw values in the local cache strategy.
+      module LocalCacheWithRaw # :nodoc:
+        protected
+          def write_entry(key, entry, options) # :nodoc:
+            retval = super
+            if options[:raw] && local_cache && retval
+              raw_entry = Entry.new(entry.value.to_s)
+              raw_entry.expires_at = entry.expires_at
+              local_cache.write_entry(key, raw_entry, options)
+            end
+            retval
+          end
+      end
+    end
+  end
+end

data/lib/active_support/cache/dalli_store23.rb

@@ -0,0 +1,172 @@
+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