dalli 2.7.0 → 2.7.11

data/lib/dalli/client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'digest/md5'
 require 'set'
 
@@ -9,12 +10,15 @@ module Dalli
     # Dalli::Client is the main class which developers will use to interact with
     # the memcached server.  Usage:
     #
-    #   Dalli::Client.new(['localhost:11211:10', 'cache-2.example.com:11211:5', '192.168.0.1:22122:5'],
+    #   Dalli::Client.new(['localhost:11211:10', 'cache-2.example.com:11211:5', '192.168.0.1:22122:5', '/var/run/memcached/socket'],
     #                   :threadsafe => true, :failover => true, :expires_in => 300)
     #
     # servers is an Array of "host:port:weight" where weight allows you to distribute cache unevenly.
     # Both weight and port are optional.  If you pass in nil, Dalli will use the <tt>MEMCACHE_SERVERS</tt>
-    # environment variable or default to 'localhost:11211' if it is not present.
+    # environment variable or default to 'localhost:11211' if it is not present.  Dalli also supports
+    # the ability to connect to Memcached on localhost through a UNIX socket.  To use this functionality,
+    # use a full pathname (beginning with a slash character '/') in place of the "host:port" pair in
+    # the server configuration.
     #
     # Options:
     # - :namespace - prepend each key with this value to provide simple namespacing.
@@ -24,6 +28,8 @@ module Dalli
     # - :compress - defaults to false, if true Dalli will compress values larger than 1024 bytes before sending them to memcached.
     # - :serializer - defaults to Marshal
     # - :compressor - defaults to zlib
+    # - :cache_nils - defaults to false, if true Dalli will not treat cached nil values as 'not found' for #fetch operations.
+    # - :digest_class - defaults to Digest::MD5, allows you to pass in an object that responds to the hexdigest method, useful for injecting a FIPS compliant hash object.
     #
     def initialize(servers=nil, options={})
       @servers = normalize_servers(servers || ENV["MEMCACHE_SERVERS"] || '127.0.0.1:11211')
@@ -49,8 +55,9 @@ module Dalli
 
     ##
     # Get the value associated with the key.
+    # If a value is not found, then +nil+ is returned.
     def get(key, options=nil)
-      perform(:get, key)
+      perform(:get, key, options)
     end
 
     ##
@@ -58,21 +65,38 @@ module Dalli
     # If a block is given, yields key/value pairs one at a time.
     # Otherwise returns a hash of { 'key' => 'value', 'key2' => 'value1' }
     def get_multi(*keys)
+      check_keys = keys.flatten
+      check_keys.compact!
+
+      return {} if check_keys.empty?
       if block_given?
         get_multi_yielder(keys) {|k, data| yield k, data.first}
       else
-         Hash.new.tap do |hash|
+        Hash.new.tap do |hash|
           get_multi_yielder(keys) {|k, data| hash[k] = data.first}
         end
       end
     end
 
+    CACHE_NILS = {cache_nils: true}.freeze
+
+    # Fetch the value associated with the key.
+    # If a value is found, then it is returned.
+    #
+    # If a value is not found and no block is given, then nil is returned.
+    #
+    # If a value is not found (or if the found value is nil and :cache_nils is false)
+    # and a block is given, the block will be invoked and its return value
+    # written to the cache and returned.
     def fetch(key, ttl=nil, options=nil)
-      ttl ||= @options[:expires_in].to_i
+      options = options.nil? ? CACHE_NILS : options.merge(CACHE_NILS) if @options[:cache_nils]
       val = get(key, options)
-      if val.nil? && block_given?
+      not_found = @options[:cache_nils] ?
+        val == Dalli::Server::NOT_FOUND :
+        val.nil?
+      if not_found && block_given?
         val = yield
-        add(key, val, ttl, options)
+        add(key, val, ttl_or_default(ttl), options)
       end
       val
     end
@@ -89,34 +113,36 @@ module Dalli
     # - false if the value was changed by someone else.
     # - true if the value was successfully updated.
     def cas(key, ttl=nil, options=nil, &block)
-      ttl ||= @options[:expires_in].to_i
-      (value, cas) = perform(:cas, key)
-      value = (!value || value == 'Not found') ? nil : value
-      if value
-        newvalue = block.call(value)
-        perform(:set, key, newvalue, ttl, cas, options)
-      end
+      cas_core(key, false, ttl, options, &block)
+    end
+
+    ##
+    # like #cas, but will yield to the block whether or not the value
+    # already exists.
+    #
+    # Returns:
+    # - false if the value was changed by someone else.
+    # - true if the value was successfully updated.
+    def cas!(key, ttl=nil, options=nil, &block)
+      cas_core(key, true, ttl, options, &block)
     end
 
     def set(key, value, ttl=nil, options=nil)
-      ttl ||= @options[:expires_in].to_i
-      perform(:set, key, value, ttl, 0, options)
+      perform(:set, key, value, ttl_or_default(ttl), 0, options)
     end
 
     ##
     # Conditionally add a key/value pair, if the key does not already exist
-    # on the server.  Returns true if the operation succeeded.
+    # on the server.  Returns truthy if the operation succeeded.
     def add(key, value, ttl=nil, options=nil)
-      ttl ||= @options[:expires_in].to_i
-      perform(:add, key, value, ttl, options)
+      perform(:add, key, value, ttl_or_default(ttl), options)
     end
 
     ##
     # Conditionally add a key/value pair, only if the key already exists
-    # on the server.  Returns true if the operation succeeded.
+    # on the server.  Returns truthy if the operation succeeded.
     def replace(key, value, ttl=nil, options=nil)
-      ttl ||= @options[:expires_in].to_i
-      perform(:replace, key, value, ttl, 0, options)
+      perform(:replace, key, value, ttl_or_default(ttl), 0, options)
     end
 
     def delete(key)
@@ -157,8 +183,7 @@ module Dalli
     # #cas.
     def incr(key, amt=1, ttl=nil, default=nil)
       raise ArgumentError, "Positive values only: #{amt}" if amt < 0
-      ttl ||= @options[:expires_in].to_i
-      perform(:incr, key, amt.to_i, ttl, default)
+      perform(:incr, key, amt.to_i, ttl_or_default(ttl), default)
     end
 
     ##
@@ -177,8 +202,7 @@ module Dalli
     # #cas.
     def decr(key, amt=1, ttl=nil, default=nil)
       raise ArgumentError, "Positive values only: #{amt}" if amt < 0
-      ttl ||= @options[:expires_in].to_i
-      perform(:decr, key, amt.to_i, ttl, default)
+      perform(:decr, key, amt.to_i, ttl_or_default(ttl), default)
     end
 
     ##
@@ -186,20 +210,19 @@ module Dalli
     #
     # Returns true if key exists, otherwise nil.
     def touch(key, ttl=nil)
-      ttl ||= @options[:expires_in].to_i
-      resp = perform(:touch, key, ttl)
+      resp = perform(:touch, key, ttl_or_default(ttl))
       resp.nil? ? nil : true
     end
 
     ##
     # Collect the stats for each server.
-    # You can optionally pass a type including :items or :slabs to get specific stats
+    # You can optionally pass a type including :items, :slabs or :settings to get specific stats
     # Returns a hash like { 'hostname:port' => { 'stat1' => 'value1', ... }, 'hostname2:port' => { ... } }
     def stats(type=nil)
-      type = nil if ![nil, :items,:slabs].include? type
+      type = nil if ![nil, :items,:slabs,:settings].include? type
       values = {}
       ring.servers.each do |server|
-        values["#{server.hostname}:#{server.port}"] = server.alive? ? server.request(:stats,type.to_s) : nil
+        values["#{server.name}"] = server.alive? ? server.request(:stats,type.to_s) : nil
       end
       values
     end
@@ -212,12 +235,18 @@ module Dalli
       end
     end
 
+    ##
+    ## Make sure memcache servers are alive, or raise an Dalli::RingError
+    def alive!
+      ring.server_for_key("")
+    end
+
     ##
     ## Version of the memcache servers.
     def version
       values = {}
       ring.servers.each do |server|
-        values["#{server.hostname}:#{server.port}"] = server.alive? ? server.request(:version) : nil
+        values["#{server.name}"] = server.alive? ? server.request(:version) : nil
       end
       values
     end
@@ -240,6 +269,20 @@ module Dalli
 
     private
 
+    def cas_core(key, always_set, ttl=nil, options=nil)
+      (value, cas) = perform(:cas, key)
+      value = (!value || value == 'Not found') ? nil : value
+      return if value.nil? && !always_set
+      newvalue = yield(value)
+      perform(:set, key, newvalue, ttl_or_default(ttl), cas, options)
+    end
+
+    def ttl_or_default(ttl)
+      (ttl || @options[:expires_in]).to_i
+    rescue NoMethodError
+      raise ArgumentError, "Cannot convert ttl (#{ttl}) to an integer"
+    end
+
     def groups_for_keys(*keys)
       groups = mapped_keys(keys).flatten.group_by do |key|
         begin
@@ -253,7 +296,9 @@ module Dalli
     end
 
     def mapped_keys(keys)
-      keys.flatten.map {|a| validate_key(a.to_s)}
+      keys_array = keys.flatten
+      keys_array.map! { |a| validate_key(a.to_s) }
+      keys_array
     end
 
     def make_multi_get_requests(groups)
@@ -266,7 +311,7 @@ module Dalli
           server.request(:send_multiget, keys_for_server)
         rescue DalliError, NetworkError => e
           Dalli.logger.debug { e.inspect }
-          Dalli.logger.debug { "unable to get keys for server #{server.hostname}:#{server.port}" }
+          Dalli.logger.debug { "unable to get keys for server #{server.name}" }
         end
       end
     end
@@ -286,13 +331,16 @@ module Dalli
     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[...]]]
+    # Normalizes the argument into an array of servers.
+    # If the argument is a string, or an array containing strings, it's expected that the URIs are comma separated e.g.
+    # "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
+      Array(servers).flat_map do |server|
+        if server.is_a? String
+          server.split(",")
+        else
+          server
+        end
       end
     end
 
@@ -312,8 +360,8 @@ module Dalli
     end
 
     # Chokepoint method for instrumentation
-    def perform(*all_args, &blk)
-      return blk.call if blk
+    def perform(*all_args)
+      return yield if block_given?
       op, key, *args = *all_args
 
       key = key.to_s
@@ -333,8 +381,9 @@ module Dalli
       raise ArgumentError, "key cannot be blank" if !key || key.length == 0
       key = key_with_namespace(key)
       if key.length > 250
+        digest_class = @options[:digest_class] || ::Digest::MD5
         max_length_before_namespace = 212 - (namespace || '').size
-        key = "#{key[0, max_length_before_namespace]}:md5:#{Digest::MD5.hexdigest(key)}"
+        key = "#{key[0, max_length_before_namespace]}:md5:#{digest_class.hexdigest(key)}"
       end
       return key
     end
@@ -344,11 +393,12 @@ module Dalli
     end
 
     def key_without_namespace(key)
-      (ns = namespace) ? key.sub(%r(\A#{ns}:), '') : key
+      (ns = namespace) ? key.sub(%r(\A#{Regexp.escape ns}:), '') : key
     end
 
     def namespace
-      @options[:namespace].is_a?(Proc) ? @options[:namespace].call : @options[:namespace]
+      return nil unless @options[:namespace]
+      @options[:namespace].is_a?(Proc) ? @options[:namespace].call.to_s : @options[:namespace].to_s
     end
 
     def normalize_options(opts)
@@ -361,6 +411,9 @@ module Dalli
       rescue NoMethodError
         raise ArgumentError, "cannot convert :expires_in => #{opts[:expires_in].inspect} to an integer"
       end
+      if opts[:digest_class] && !opts[:digest_class].respond_to?(:hexdigest)
+        raise ArgumentError, "The digest_class object must respond to the hexdigest method"
+      end
       opts
     end
 
@@ -382,7 +435,7 @@ module Dalli
             servers = perform_multi_response_start(servers)
 
             start = Time.now
-            loop do
+            while true
               # remove any dead servers
               servers.delete_if { |s| s.sock.nil? }
               break if servers.empty?
@@ -390,12 +443,10 @@ module Dalli
               # 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
+              time_left = (elapsed > timeout) ? 0 : timeout - elapsed
+
+              sockets = servers.map(&:sock)
+              readable, _ = IO.select(sockets, nil, nil, time_left)
 
               if readable.nil?
                 # no response within timeout; abort pending connections

data/lib/dalli/compressor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'zlib'
 require 'stringio'
 
@@ -14,7 +15,7 @@ module Dalli
 
   class GzipCompressor
     def self.compress(data)
-      io = StringIO.new("w")
+      io = StringIO.new(String.new(""), "w")
       gz = Zlib::GzipWriter.new(io)
       gz.write(data)
       gz.close

data/lib/dalli/options.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'thread'
 require 'monitor'
 

data/lib/dalli/railtie.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dalli
   class Railtie < ::Rails::Railtie
     config.before_configuration do

data/lib/dalli/ring.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'digest/sha1'
 require 'zlib'
 
@@ -15,12 +16,12 @@ module Dalli
         continuum = []
         servers.each do |server|
           entry_count_for(server, servers.size, total_weight).times do |idx|
-            hash = Digest::SHA1.hexdigest("#{server.hostname}:#{server.port}:#{idx}")
+            hash = Digest::SHA1.hexdigest("#{server.name}:#{idx}")
             value = Integer("0x#{hash[0..7]}")
             continuum << Dalli::Ring::Entry.new(value, server)
           end
         end
-        @continuum = continuum.sort { |a, b| a.value <=> b.value }
+        @continuum = continuum.sort_by(&:value)
       end
 
       threadsafe! unless options[:threadsafe] == false
@@ -46,11 +47,11 @@ module Dalli
     end
 
     def lock
-      @servers.each { |s| s.lock! }
+      @servers.each(&:lock!)
       begin
         return yield
       ensure
-        @servers.each { |s| s.unlock! }
+        @servers.each(&:unlock!)
       end
     end
 
@@ -110,7 +111,6 @@ module Dalli
       def binary_search(ary, value)
         upper = ary.size - 1
         lower = 0
-        idx = 0
 
         while (lower <= upper) do
           idx = (lower + upper) / 2
@@ -124,7 +124,7 @@ module Dalli
             lower = idx + 1
           end
         end
-        return upper
+        upper
       end
     end