dalli 3.0.1 → 3.0.5

data/lib/dalli/protocol/server_config_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    ##
+    # Dalli::Protocol::ServerConfigParser parses a server string passed to
+    # a Dalli::Protocol::Binary instance into the hostname, port, weight, and
+    # socket_type.
+    ##
+    class ServerConfigParser
+      MEMCACHED_URI_PROTOCOL = 'memcached://'
+
+      # TODO: Revisit this, especially the IP/domain part.  Likely
+      # can limit character set to LDH + '.'.  Hex digit section
+      # is there to support IPv6 addresses, which need to be specified with
+      # a bounding []
+      SERVER_CONFIG_REGEXP = /\A(\[([\h:]+)\]|[^:]+)(?::(\d+))?(?::(\d+))?\z/.freeze
+
+      DEFAULT_PORT = 11_211
+      DEFAULT_WEIGHT = 1
+
+      def self.parse(str, client_options)
+        return parse_non_uri(str, client_options) unless str.start_with?(MEMCACHED_URI_PROTOCOL)
+
+        parse_uri(str, client_options)
+      end
+
+      def self.parse_uri(str, client_options)
+        uri = URI.parse(str)
+        auth_details = {
+          username: uri.user,
+          password: uri.password
+        }
+        [uri.host, normalize_port(uri.port), DEFAULT_WEIGHT, :tcp, client_options.merge(auth_details)]
+      end
+
+      def self.parse_non_uri(str, client_options)
+        res = deconstruct_string(str)
+
+        hostname = normalize_host_from_match(str, res)
+        if hostname.start_with?('/')
+          socket_type = :unix
+          port, weight = attributes_for_unix_socket(res)
+        else
+          socket_type = :tcp
+          port, weight = attributes_for_tcp_socket(res)
+        end
+        [hostname, port, weight, socket_type, client_options]
+      end
+
+      def self.deconstruct_string(str)
+        mtch = str.match(SERVER_CONFIG_REGEXP)
+        raise Dalli::DalliError, "Could not parse hostname #{str}" if mtch.nil? || mtch[1] == '[]'
+
+        mtch
+      end
+
+      def self.attributes_for_unix_socket(res)
+        # in case of unix socket, allow only setting of weight, not port
+        raise Dalli::DalliError, "Could not parse hostname #{res[0]}" if res[4]
+
+        [nil, normalize_weight(res[3])]
+      end
+
+      def self.attributes_for_tcp_socket(res)
+        [normalize_port(res[3]), normalize_weight(res[4])]
+      end
+
+      def self.normalize_host_from_match(str, res)
+        raise Dalli::DalliError, "Could not parse hostname #{str}" if res.nil? || res[1] == '[]'
+
+        res[2] || res[1]
+      end
+
+      def self.normalize_port(port)
+        Integer(port || DEFAULT_PORT)
+      end
+
+      def self.normalize_weight(weight)
+        Integer(weight || DEFAULT_WEIGHT)
+      end
+    end
+  end
+end

data/lib/dalli/protocol/ttl_sanitizer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    ##
+    # Utility class for sanitizing TTL arguments based on Memcached rules.
+    # TTLs are either expirations times in seconds (with a maximum value of
+    # 30 days) or expiration timestamps.  This class sanitizes TTLs to ensure
+    # they meet those restrictions.
+    ##
+    class TtlSanitizer
+      # https://github.com/memcached/memcached/blob/master/doc/protocol.txt#L79
+      # > An expiration time, in seconds. Can be up to 30 days. After 30 days, is
+      #   treated as a unix timestamp of an exact date.
+      MAX_ACCEPTABLE_EXPIRATION_INTERVAL = 30 * 24 * 60 * 60 # 30 days
+
+      # Ensures the TTL passed to Memcached is a valid TTL in the expected format.
+      def self.sanitize(ttl)
+        ttl_as_i = ttl.to_i
+        return ttl_as_i if less_than_max_expiration_interval?(ttl_as_i)
+
+        as_timestamp(ttl_as_i)
+      end
+
+      def self.less_than_max_expiration_interval?(ttl_as_i)
+        ttl_as_i <= MAX_ACCEPTABLE_EXPIRATION_INTERVAL
+      end
+
+      def self.as_timestamp(ttl_as_i)
+        now = current_timestamp
+        return ttl_as_i if ttl_as_i > now # Already a timestamp
+
+        Dalli.logger.debug "Expiration interval (#{ttl_as_i}) too long for Memcached " \
+                           'and too short to be a future timestamp,' \
+                           'converting to an expiration timestamp'
+        now + ttl_as_i
+      end
+
+      # Pulled out into a method so it's easy to stub time
+      def self.current_timestamp
+        Time.now.to_i
+      end
+    end
+  end
+end

data/lib/dalli/protocol/value_compressor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module Dalli
+  module Protocol
+    ##
+    # Dalli::Protocol::ValueCompressor compartmentalizes the logic for managing
+    # compression and decompression of stored values.  It manages interpreting
+    # relevant options from both client and request, determining whether to
+    # compress/decompress on store/retrieve, and processes bitflags as necessary.
+    ##
+    class ValueCompressor
+      DEFAULTS = {
+        compress: true,
+        compressor: ::Dalli::Compressor,
+        # min byte size to attempt compression
+        compression_min_size: 4 * 1024 # 4K
+      }.freeze
+
+      OPTIONS = DEFAULTS.keys.freeze
+
+      # https://www.hjp.at/zettel/m/memcached_flags.rxml
+      # Looks like most clients use bit 1 to indicate gzip compression.
+      FLAG_COMPRESSED = 0x2
+
+      def initialize(client_options)
+        # Support the deprecated compression option, but don't allow it to override
+        # an explicit compress
+        # Remove this with 4.0
+        if client_options.key?(:compression) && !client_options.key?(:compress)
+          Dalli.logger.warn "DEPRECATED: Dalli's :compression option is now just 'compress: true'.  " \
+                            'Please update your configuration.'
+          client_options[:compress] = client_options.delete(:compression)
+        end
+
+        @compression_options =
+          DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+      end
+
+      def store(value, req_options, bitflags)
+        do_compress = compress_value?(value, req_options)
+        store_value = do_compress ? compressor.compress(value) : value
+        bitflags |= FLAG_COMPRESSED if do_compress
+
+        [store_value, bitflags]
+      end
+
+      def retrieve(value, bitflags)
+        compressed = (bitflags & FLAG_COMPRESSED) != 0
+        compressed ? compressor.decompress(value) : value
+
+      # TODO: We likely want to move this rescue into the Dalli::Compressor / Dalli::GzipCompressor
+      # itself, since not all compressors necessarily use Zlib.  For now keep it here, so the behavior
+      # of custom compressors doesn't change.
+      rescue Zlib::Error
+        raise UnmarshalError, "Unable to uncompress value: #{$ERROR_INFO.message}"
+      end
+
+      def compress_by_default?
+        @compression_options[:compress]
+      end
+
+      def compressor
+        @compression_options[:compressor]
+      end
+
+      def compression_min_size
+        @compression_options[:compression_min_size]
+      end
+
+      # Checks whether we should apply compression when serializing a value
+      # based on the specified options.  Returns false unless the value
+      # is greater than the minimum compression size.  Otherwise returns
+      # based on a method-level option if specified, falling back to the
+      # server default.
+      def compress_value?(value, req_options)
+        return false unless value.bytesize >= compression_min_size
+        return compress_by_default? unless req_options && !req_options[:compress].nil?
+
+        req_options[:compress]
+      end
+    end
+  end
+end

data/lib/dalli/protocol/value_marshaller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Dalli
+  module Protocol
+    ##
+    # Dalli::Protocol::ValueMarshaller compartmentalizes the logic for marshalling
+    # and unmarshalling unstructured data (values) to Memcached.  It also enforces
+    # limits on the maximum size of marshalled data.
+    ##
+    class ValueMarshaller
+      extend Forwardable
+
+      DEFAULTS = {
+        # max size of value in bytes (default is 1 MB, can be overriden with "memcached -I <size>")
+        value_max_bytes: 1024 * 1024
+      }.freeze
+
+      OPTIONS = DEFAULTS.keys.freeze
+
+      def_delegators :@value_serializer, :serializer
+      def_delegators :@value_compressor, :compressor, :compression_min_size, :compress_by_default?
+
+      def initialize(client_options)
+        @value_serializer = ValueSerializer.new(client_options)
+        @value_compressor = ValueCompressor.new(client_options)
+
+        @marshal_options =
+          DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+      end
+
+      def store(key, value, options = nil)
+        bitflags = 0
+        value, bitflags = @value_serializer.store(value, options, bitflags)
+        value, bitflags = @value_compressor.store(value, options, bitflags)
+
+        error_if_over_max_value_bytes(key, value)
+        [value, bitflags]
+      end
+
+      def retrieve(value, flags)
+        value = @value_compressor.retrieve(value, flags)
+        @value_serializer.retrieve(value, flags)
+      end
+
+      def value_max_bytes
+        @marshal_options[:value_max_bytes]
+      end
+
+      def error_if_over_max_value_bytes(key, value)
+        return if value.bytesize <= value_max_bytes
+
+        message = "Value for #{key} over max size: #{value_max_bytes} <= #{value.bytesize}"
+        raise Dalli::ValueOverMaxSize, message
+      end
+    end
+  end
+end

data/lib/dalli/protocol/value_serializer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    ##
+    # Dalli::Protocol::ValueSerializer compartmentalizes the logic for managing
+    # serialization and deserialization of stored values.  It manages interpreting
+    # relevant options from both client and request, determining whether to
+    # serialize/deserialize on store/retrieve, and processes bitflags as necessary.
+    ##
+    class ValueSerializer
+      DEFAULTS = {
+        serializer: Marshal
+      }.freeze
+
+      OPTIONS = DEFAULTS.keys.freeze
+
+      # https://www.hjp.at/zettel/m/memcached_flags.rxml
+      # Looks like most clients use bit 0 to indicate native language serialization
+      FLAG_SERIALIZED = 0x1
+
+      attr_accessor :serialization_options
+
+      def initialize(protocol_options)
+        @serialization_options =
+          DEFAULTS.merge(protocol_options.select { |k, _| OPTIONS.include?(k) })
+      end
+
+      def store(value, req_options, bitflags)
+        do_serialize = !(req_options && req_options[:raw])
+        store_value = do_serialize ? serialize_value(value) : value.to_s
+        bitflags |= FLAG_SERIALIZED if do_serialize
+        [store_value, bitflags]
+      end
+
+      # TODO: Some of these error messages need to be validated.  It's not obvious
+      # that all of them are actually generated by the invoked code
+      # in current systems
+      # rubocop:disable Layout/LineLength
+      TYPE_ERR_REGEXP = %r{needs to have method `_load'|exception class/object expected|instance of IO needed|incompatible marshal file format}.freeze
+      ARGUMENT_ERR_REGEXP = /undefined class|marshal data too short/.freeze
+      NAME_ERR_STR = 'uninitialized constant'
+      # rubocop:enable Layout/LineLength
+
+      def retrieve(value, bitflags)
+        serialized = (bitflags & FLAG_SERIALIZED) != 0
+        serialized ? serializer.load(value) : value
+      rescue TypeError => e
+        filter_type_error(e)
+      rescue ArgumentError => e
+        filter_argument_error(e)
+      rescue NameError => e
+        filter_name_error(e)
+      end
+
+      def filter_type_error(err)
+        raise err unless TYPE_ERR_REGEXP.match?(err.message)
+
+        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
+      end
+
+      def filter_argument_error(err)
+        raise err unless ARGUMENT_ERR_REGEXP.match?(err.message)
+
+        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
+      end
+
+      def filter_name_error(err)
+        raise err unless err.message.include?(NAME_ERR_STR)
+
+        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
+      end
+
+      def serializer
+        @serialization_options[:serializer]
+      end
+
+      def serialize_value(value)
+        serializer.dump(value)
+      rescue Timeout::Error => e
+        raise e
+      rescue StandardError => e
+        # Serializing can throw several different types of generic Ruby exceptions.
+        # Convert to a specific exception so we can special case it higher up the stack.
+        exc = Dalli::MarshalError.new(e.message)
+        exc.set_backtrace e.backtrace
+        raise exc
+      end
+    end
+  end
+end

data/lib/dalli/protocol.rb

@@ -2,8 +2,7 @@
 
 module Dalli
   module Protocol
-    # Implements the NullObject pattern to store an application-defined value for 'Key not found' responses.
-    class NilObject; end
-    NOT_FOUND = NilObject.new
+    # Preserved for backwards compatibility.  Should be removed in 4.0
+    NOT_FOUND = ::Dalli::NOT_FOUND
   end
 end

data/lib/dalli/ring.rb

@@ -1,10 +1,24 @@
 # frozen_string_literal: true
 
-require "digest/sha1"
-require "zlib"
+require 'digest/sha1'
+require 'zlib'
 
 module Dalli
+  ##
+  # An implementation of a consistent hash ring, designed to minimize
+  # the cache miss impact of adding or removing servers from the ring.
+  # That is, adding or removing a server from the ring should impact
+  # the key -> server mapping of ~ 1/N of the stored keys where N is the
+  # number of servers in the ring.  This is done by creating a large
+  # number of "points" per server, distributed over the space
+  # 0x00000000 - 0xFFFFFFFF. For a given key, we calculate the CRC32
+  # hash, and find the nearest "point" that is less than or equal to the
+  # the key's hash.  In this implemetation, each "point" is represented
+  # by a Dalli::Ring::Entry.
+  ##
   class Ring
+    # The number of entries on the continuum created per server
+    # in an equally weighted scenario.
     POINTS_PER_SERVER = 160 # this is the default in libmemcached
 
     attr_accessor :servers, :continuum
@@ -12,45 +26,48 @@ module Dalli
     def initialize(servers, options)
       @servers = servers
       @continuum = nil
-      if servers.size > 1
-        total_weight = servers.inject(0) { |memo, srv| memo + srv.weight }
-        continuum = []
-        servers.each do |server|
-          entry_count_for(server, servers.size, total_weight).times do |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_by(&:value)
-      end
+      @continuum = build_continuum(servers) if servers.size > 1
 
       threadsafe! unless options[:threadsafe] == false
       @failover = options[:failover] != false
     end
 
     def server_for_key(key)
-      if @continuum
-        hkey = hash_for(key)
-        20.times do |try|
-          # Find the closest index in the Ring with value <= the given value
-          entryidx = @continuum.bsearch_index { |entry| entry.value > hkey }
-          if entryidx.nil?
-            entryidx = @continuum.size - 1
-          else
-            entryidx -= 1
-          end
-          server = @continuum[entryidx].server
-          return server if server.alive?
-          break unless @failover
-          hkey = hash_for("#{try}#{key}")
-        end
-      else
-        server = @servers.first
-        return server if server&.alive?
+      server = if @continuum
+                 server_from_continuum(key)
+               else
+                 @servers.first
+               end
+
+      # Note that the call to alive? has the side effect of initializing
+      # the socket
+      return server if server&.alive?
+
+      raise Dalli::RingError, 'No server available'
+    end
+
+    def server_from_continuum(key)
+      hkey = hash_for(key)
+      20.times do |try|
+        server = server_for_hash_key(hkey)
+
+        # Note that the call to alive? has the side effect of initializing
+        # the socket
+        return server if server.alive?
+        break unless @failover
+
+        hkey = hash_for("#{try}#{key}")
       end
+      nil
+    end
 
-      raise Dalli::RingError, "No server available"
+    def keys_grouped_by_server(key_arr)
+      key_arr.group_by do |key|
+        server_for_key(key)
+      rescue Dalli::RingError
+        Dalli.logger.debug { "unable to get key #{key}" }
+        nil
+      end
     end
 
     def lock
@@ -62,6 +79,19 @@ module Dalli
       end
     end
 
+    def flush_multi_responses
+      @servers.each do |s|
+        s.request(:noop)
+      rescue Dalli::NetworkError
+        # Ignore this error, as it indicates the socket is unavailable
+        # and there's no need to flush
+      end
+    end
+
+    def socket_timeout
+      @servers.first.socket_timeout
+    end
+
     private
 
     def threadsafe!
@@ -78,9 +108,35 @@ module Dalli
       ((total_servers * POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
     end
 
+    def server_for_hash_key(hash_key)
+      # Find the closest index in the Ring with value <= the given value
+      entryidx = @continuum.bsearch_index { |entry| entry.value > hash_key }
+      if entryidx.nil?
+        entryidx = @continuum.size - 1
+      else
+        entryidx -= 1
+      end
+      @continuum[entryidx].server
+    end
+
+    def build_continuum(servers)
+      continuum = []
+      total_weight = servers.inject(0) { |memo, srv| memo + srv.weight }
+      servers.each do |server|
+        entry_count_for(server, servers.size, total_weight).times do |idx|
+          hash = Digest::SHA1.hexdigest("#{server.name}:#{idx}")
+          value = Integer("0x#{hash[0..7]}")
+          continuum << Dalli::Ring::Entry.new(value, server)
+        end
+      end
+      continuum.sort_by(&:value)
+    end
+
+    ##
+    # Represents a point in the consistent hash ring implementation.
+    ##
     class Entry
-      attr_reader :value
-      attr_reader :server
+      attr_reader :value, :server
 
       def initialize(val, srv)
         @value = val

data/lib/dalli/server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Dalli
-  warn "Dalli::Server is deprecated, use Dalli::Protocol::Binary instead"
+module Dalli # rubocop:disable Style/Documentation
+  warn 'Dalli::Server is deprecated, use Dalli::Protocol::Binary instead'
   Server = Protocol::Binary
 end

data/lib/dalli/servers_arg_normalizer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # This module contains methods for validating and normalizing the servers
+  # argument passed to the client.  This argument can be nil, a string, or
+  # an array of strings.  Each string value in the argument can represent
+  # a single server or a comma separated list of servers.
+  #
+  # If nil, it falls back to the values of ENV['MEMCACHE_SERVERS'] if the latter is
+  # defined.  If that environment value is not defined, a default of '127.0.0.1:11211'
+  # is used.
+  #
+  # A server config string can take one of three forms:
+  #   * A colon separated string of (host, port, weight) where both port and
+  #     weight are optional (e.g. 'localhost', 'abc.com:12345', 'example.org:22222:3')
+  #   * A colon separated string of (UNIX socket, weight) where the weight is optional
+  #     (e.g. '/var/run/memcached/socket', '/tmp/xyz:3') (not supported on Windows)
+  #   * A URI with a 'memcached' protocol, which will typically include a username/password
+  #
+  # The methods in this module do not validate the format of individual server strings, but
+  # rather normalize the argument into a compact array, wherein each array entry corresponds
+  # to a single server config string.  If that normalization is not possible, then an
+  # ArgumentError is thrown.
+  ##
+  module ServersArgNormalizer
+    ENV_VAR_NAME = 'MEMCACHE_SERVERS'
+    DEFAULT_SERVERS = ['127.0.0.1:11211'].freeze
+
+    ##
+    # 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 self.normalize_servers(arg)
+      arg = apply_defaults(arg)
+      validate_type(arg)
+      Array(arg).flat_map { |s| s.split(',') }.reject(&:empty?)
+    end
+
+    def self.apply_defaults(arg)
+      return arg unless arg.nil?
+
+      ENV[ENV_VAR_NAME] || DEFAULT_SERVERS
+    end
+
+    def self.validate_type(arg)
+      return if arg.is_a?(String)
+      return if arg.is_a?(Array) && arg.all?(String)
+
+      raise ArgumentError,
+            'An explicit servers argument must be a comma separated string or an array containing strings.'
+    end
+  end
+end