dalli 2.0.1 → 3.2.8

data/lib/dalli/key_manager.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+module Dalli
+  ##
+  # This class manages and validates keys sent to Memcached, ensuring
+  # that they meet Memcached key length requirements, and supporting
+  # the implementation of optional namespaces on a per-Dalli client
+  # basis.
+  ##
+  class KeyManager
+    MAX_KEY_LENGTH = 250
+
+    NAMESPACE_SEPARATOR = ':'
+
+    # This is a hard coded md5 for historical reasons
+    TRUNCATED_KEY_SEPARATOR = ':md5:'
+
+    # This is 249 for historical reasons
+    TRUNCATED_KEY_TARGET_SIZE = 249
+
+    DEFAULTS = {
+      digest_class: ::Digest::MD5
+    }.freeze
+
+    OPTIONS = %i[digest_class namespace].freeze
+
+    attr_reader :namespace
+
+    def initialize(client_options)
+      @key_options =
+        DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+      validate_digest_class_option(@key_options)
+
+      @namespace = namespace_from_options
+    end
+
+    ##
+    # Validates the key, and transforms as needed.
+    #
+    # If the key is nil or empty, raises ArgumentError.  Whitespace
+    # characters are allowed for historical reasons, but likely shouldn't
+    # be used.
+    # If the key (with namespace) is shorter than the memcached maximum
+    # allowed key length, just returns the argument key
+    # Otherwise computes a "truncated" key that uses a truncated prefix
+    # combined with a 32-byte hex digest of the whole key.
+    ##
+    def validate_key(key)
+      raise ArgumentError, 'key cannot be blank' unless key&.length&.positive?
+
+      key = key_with_namespace(key)
+      key.length > MAX_KEY_LENGTH ? truncated_key(key) : key
+    end
+
+    ##
+    # Returns the key with the namespace prefixed, if a namespace is
+    # defined.  Otherwise just returns the key
+    ##
+    def key_with_namespace(key)
+      return key if namespace.nil?
+
+      "#{evaluate_namespace}#{NAMESPACE_SEPARATOR}#{key}"
+    end
+
+    def key_without_namespace(key)
+      return key if namespace.nil?
+
+      key.sub(namespace_regexp, '')
+    end
+
+    def digest_class
+      @digest_class ||= @key_options[:digest_class]
+    end
+
+    def namespace_regexp
+      return /\A#{Regexp.escape(evaluate_namespace)}:/ if namespace.is_a?(Proc)
+
+      @namespace_regexp ||= /\A#{Regexp.escape(namespace)}:/.freeze unless namespace.nil?
+    end
+
+    def validate_digest_class_option(opts)
+      return if opts[:digest_class].respond_to?(:hexdigest)
+
+      raise ArgumentError, 'The digest_class object must respond to the hexdigest method'
+    end
+
+    def namespace_from_options
+      raw_namespace = @key_options[:namespace]
+      return nil unless raw_namespace
+      return raw_namespace.to_s unless raw_namespace.is_a?(Proc)
+
+      raw_namespace
+    end
+
+    def evaluate_namespace
+      return namespace.call.to_s if namespace.is_a?(Proc)
+
+      namespace
+    end
+
+    ##
+    # Produces a truncated key, if the raw key is longer than the maximum allowed
+    # length.  The truncated key is produced by generating a hex digest
+    # of the key, and appending that to a truncated section of the key.
+    ##
+    def truncated_key(key)
+      digest = digest_class.hexdigest(key)
+      "#{key[0, prefix_length(digest)]}#{TRUNCATED_KEY_SEPARATOR}#{digest}"
+    end
+
+    def prefix_length(digest)
+      return TRUNCATED_KEY_TARGET_SIZE - (TRUNCATED_KEY_SEPARATOR.length + digest.length) if namespace.nil?
+
+      # For historical reasons, truncated keys with namespaces had a length of 250 rather
+      # than 249
+      TRUNCATED_KEY_TARGET_SIZE + 1 - (TRUNCATED_KEY_SEPARATOR.length + digest.length)
+    end
+  end
+end

data/lib/dalli/options.rb

@@ -1,19 +1,19 @@
-require 'thread'
+# frozen_string_literal: true
+
 require 'monitor'
 
 module Dalli
-
   # Make Dalli threadsafe by using a lock around all
   # public server methods.
   #
-  # Dalli::Server.extend(Dalli::Threadsafe)
+  # Dalli::Protocol::Binary.extend(Dalli::Threadsafe)
   #
   module Threadsafe
     def self.extended(obj)
       obj.init_threadsafe
     end
 
-    def request(op, *args)
+    def request(opcode, *args)
       @lock.synchronize do
         super
       end
@@ -31,6 +31,24 @@ module Dalli
       end
     end
 
+    def pipeline_response_setup
+      @lock.synchronize do
+        super
+      end
+    end
+
+    def pipeline_next_responses
+      @lock.synchronize do
+        super
+      end
+    end
+
+    def pipeline_abort
+      @lock.synchronize do
+        super
+      end
+    end
+
     def lock!
       @lock.mon_enter
     end

data/lib/dalli/pid_cache.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Dalli::PIDCache is a wrapper class for PID checking to avoid system calls when checking the PID.
+  ##
+  module PIDCache
+    if !Process.respond_to?(:fork) # JRuby or TruffleRuby
+      @pid = Process.pid
+      singleton_class.attr_reader(:pid)
+    elsif Process.respond_to?(:_fork) # Ruby 3.1+
+      class << self
+        attr_reader :pid
+
+        def update!
+          @pid = Process.pid
+        end
+      end
+      update!
+
+      ##
+      # Dalli::PIDCache::CoreExt hooks into Process to be able to reset the PID cache after fork
+      ##
+      module CoreExt
+        def _fork
+          child_pid = super
+          PIDCache.update! if child_pid.zero?
+          child_pid
+        end
+      end
+      Process.singleton_class.prepend(CoreExt)
+    else # Ruby 3.0 or older
+      class << self
+        def pid
+          Process.pid
+        end
+      end
+    end
+  end
+end

data/lib/dalli/pipelined_getter.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Contains logic for the pipelined gets implemented by the client.
+  ##
+  class PipelinedGetter
+    def initialize(ring, key_manager)
+      @ring = ring
+      @key_manager = key_manager
+    end
+
+    ##
+    # Yields, one at a time, keys and their values+attributes.
+    #
+    def process(keys, &block)
+      return {} if keys.empty?
+
+      @ring.lock do
+        servers = setup_requests(keys)
+        start_time = Time.now
+        servers = fetch_responses(servers, start_time, @ring.socket_timeout, &block) until servers.empty?
+      end
+    rescue NetworkError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying pipelined gets because of timeout' }
+      retry
+    end
+
+    def setup_requests(keys)
+      groups = groups_for_keys(keys)
+      make_getkq_requests(groups)
+
+      # TODO: How does this exit on a NetworkError
+      finish_queries(groups.keys)
+    end
+
+    ##
+    # Loop through the server-grouped sets of keys, writing
+    # the corresponding getkq requests to the appropriate servers
+    #
+    # It's worth noting that we could potentially reduce bytes
+    # on the wire by switching from getkq to getq, and using
+    # the opaque value to match requests to responses.
+    ##
+    def make_getkq_requests(groups)
+      groups.each do |server, keys_for_server|
+        server.request(:pipelined_get, keys_for_server)
+      rescue DalliError, NetworkError => e
+        Dalli.logger.debug { e.inspect }
+        Dalli.logger.debug { "unable to get keys for server #{server.name}" }
+      end
+    end
+
+    ##
+    # This loops through the servers that have keys in
+    # our set, sending the noop to terminate the set of queries.
+    ##
+    def finish_queries(servers)
+      deleted = []
+
+      servers.each do |server|
+        next unless server.connected?
+
+        begin
+          finish_query_for_server(server)
+        rescue Dalli::NetworkError
+          raise
+        rescue Dalli::DalliError
+          deleted.append(server)
+        end
+      end
+
+      servers.delete_if { |server| deleted.include?(server) }
+    rescue Dalli::NetworkError
+      abort_without_timeout(servers)
+      raise
+    end
+
+    def finish_query_for_server(server)
+      server.pipeline_response_setup
+    rescue Dalli::NetworkError
+      raise
+    rescue Dalli::DalliError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { "Results from server: #{server.name} will be missing from the results" }
+      raise
+    end
+
+    # Swallows Dalli::NetworkError
+    def abort_without_timeout(servers)
+      servers.each(&:pipeline_abort)
+    end
+
+    def fetch_responses(servers, start_time, timeout, &block)
+      # Remove any servers which are not connected
+      servers.delete_if { |s| !s.connected? }
+      return [] if servers.empty?
+
+      time_left = remaining_time(start_time, timeout)
+      readable_servers = servers_with_response(servers, time_left)
+      if readable_servers.empty?
+        abort_with_timeout(servers)
+        return []
+      end
+
+      # Loop through the servers with responses, and
+      # delete any from our list that are finished
+      readable_servers.each do |server|
+        servers.delete(server) if process_server(server, &block)
+      end
+      servers
+    rescue NetworkError
+      # Abort and raise if we encountered a network error.  This triggers
+      # a retry at the top level.
+      abort_without_timeout(servers)
+      raise
+    end
+
+    def remaining_time(start, timeout)
+      elapsed = Time.now - start
+      return 0 if elapsed > timeout
+
+      timeout - elapsed
+    end
+
+    # Swallows Dalli::NetworkError
+    def abort_with_timeout(servers)
+      abort_without_timeout(servers)
+      servers.each do |server|
+        Dalli.logger.debug { "memcached at #{server.name} did not response within timeout" }
+      end
+
+      true # Required to simplify caller
+    end
+
+    # Processes responses from a server.  Returns true if there are no
+    # additional responses from this server.
+    def process_server(server)
+      server.pipeline_next_responses.each_pair do |key, value_list|
+        yield @key_manager.key_without_namespace(key), value_list
+      end
+
+      server.pipeline_complete?
+    end
+
+    def servers_with_response(servers, timeout)
+      return [] if servers.empty?
+
+      # TODO: - This is a bit challenging.  Essentially the PipelinedGetter
+      # is a reactor, but without the benefit of a Fiber or separate thread.
+      # My suspicion is that we may want to try and push this down into the
+      # individual servers, but I'm not sure.  For now, we keep the
+      # mapping between the alerted object (the socket) and the
+      # corrresponding server here.
+      server_map = servers.each_with_object({}) { |s, h| h[s.sock] = s }
+
+      readable, = IO.select(server_map.keys, nil, nil, timeout)
+      return [] if readable.nil?
+
+      readable.map { |sock| server_map[sock] }
+    end
+
+    def groups_for_keys(*keys)
+      keys.flatten!
+      keys.map! { |a| @key_manager.validate_key(a.to_s) }
+      groups = @ring.keys_grouped_by_server(keys)
+      if (unfound_keys = groups.delete(nil))
+        Dalli.logger.debug do
+          "unable to get keys for #{unfound_keys.length} keys " \
+            'because no matching server was found'
+        end
+      end
+      groups
+    end
+  end
+end

data/lib/dalli/protocol/base.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'socket'
+require 'timeout'
+
+module Dalli
+  module Protocol
+    ##
+    # Base class for a single Memcached server, containing logic common to all
+    # protocols.  Contains logic for managing connection state to the server and value
+    # handling.
+    ##
+    class Base
+      extend Forwardable
+
+      attr_accessor :weight, :options
+
+      def_delegators :@value_marshaller, :serializer, :compressor, :compression_min_size, :compress_by_default?
+      def_delegators :@connection_manager, :name, :sock, :hostname, :port, :close, :connected?, :socket_timeout,
+                     :socket_type, :up!, :down!, :write, :reconnect_down_server?, :raise_down_error
+
+      def initialize(attribs, client_options = {})
+        hostname, port, socket_type, @weight, user_creds = ServerConfigParser.parse(attribs)
+        @options = client_options.merge(user_creds)
+        @value_marshaller = ValueMarshaller.new(@options)
+        @connection_manager = ConnectionManager.new(hostname, port, socket_type, @options)
+      end
+
+      # Chokepoint method for error handling and ensuring liveness
+      def request(opkey, *args)
+        verify_state(opkey)
+
+        begin
+          @connection_manager.start_request!
+          response = send(opkey, *args)
+
+          # pipelined_get emit query but doesn't read the response(s)
+          @connection_manager.finish_request! unless opkey == :pipelined_get
+
+          response
+        rescue Dalli::MarshalError => e
+          log_marshal_err(args.first, e)
+          raise
+        rescue Dalli::DalliError
+          raise
+        rescue StandardError => e
+          log_unexpected_err(e)
+          close
+          raise
+        end
+      end
+
+      ##
+      # Boolean method used by clients of this class to determine if this
+      # particular memcached instance is available for use.
+      def alive?
+        ensure_connected!
+      rescue Dalli::NetworkError
+        # ensure_connected! raises a NetworkError if connection fails.  We
+        # want to capture that error and convert it to a boolean value here.
+        false
+      end
+
+      def lock!; end
+
+      def unlock!; 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 pipeline_response_setup
+        verify_pipelined_state(:getkq)
+        write_noop
+        response_buffer.reset
+      end
+
+      # Attempt to receive and parse as many key/value pairs as possible
+      # from this server. After #pipeline_response_setup, this should be invoked
+      # repeatedly whenever this server's socket is readable until
+      # #pipeline_complete?.
+      #
+      # Returns a Hash of kv pairs received.
+      def pipeline_next_responses
+        reconnect_on_pipeline_complete!
+        values = {}
+
+        response_buffer.read
+
+        status, cas, key, value = response_buffer.process_single_getk_response
+        # status is not nil only if we have a full response to parse
+        # in the buffer
+        until status.nil?
+          # If the status is ok and key is nil, then this is the response
+          # to the noop at the end of the pipeline
+          finish_pipeline && break if status && key.nil?
+
+          # If the status is ok and the key is not nil, then this is a
+          # getkq response with a value that we want to set in the response hash
+          values[key] = [value, cas] unless key.nil?
+
+          # Get the next response from the buffer
+          status, cas, key, value = response_buffer.process_single_getk_response
+        end
+
+        values
+      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
+        @connection_manager.error_on_request!(e)
+      end
+
+      # Abort current pipelined get. Generally used to signal an external
+      # timeout during pipelined get.  The underlying socket is
+      # disconnected, and the exception is swallowed.
+      #
+      # Returns nothing.
+      def pipeline_abort
+        response_buffer.clear
+        @connection_manager.abort_request!
+        return true unless connected?
+
+        # Closes the connection, which ensures that our connection
+        # is in a clean state for future requests
+        @connection_manager.error_on_request!('External timeout')
+      rescue NetworkError
+        true
+      end
+
+      # Did the last call to #pipeline_response_setup complete successfully?
+      def pipeline_complete?
+        !response_buffer.in_progress?
+      end
+
+      def username
+        @options[:username] || ENV.fetch('MEMCACHE_USERNAME', nil)
+      end
+
+      def password
+        @options[:password] || ENV.fetch('MEMCACHE_PASSWORD', nil)
+      end
+
+      def require_auth?
+        !username.nil?
+      end
+
+      def quiet?
+        Thread.current[::Dalli::QUIET]
+      end
+      alias multi? quiet?
+
+      # NOTE: Additional public methods should be overridden in Dalli::Threadsafe
+
+      private
+
+      ALLOWED_QUIET_OPS = %i[add replace set delete incr decr append prepend flush noop].freeze
+      def verify_allowed_quiet!(opkey)
+        return if ALLOWED_QUIET_OPS.include?(opkey)
+
+        raise Dalli::NotPermittedMultiOpError, "The operation #{opkey} is not allowed in a quiet block."
+      end
+
+      ##
+      # Checks to see if we can execute the specified operation.  Checks
+      # whether the connection is in use, and whether the command is allowed
+      ##
+      def verify_state(opkey)
+        @connection_manager.confirm_ready!
+        verify_allowed_quiet!(opkey) if quiet?
+
+        # The ensure_connected call has the side effect of connecting the
+        # underlying socket if it is not connected, or there's been a disconnect
+        # because of timeout or other error.  Method raises an error
+        # if it can't connect
+        raise_down_error unless ensure_connected!
+      end
+
+      def verify_pipelined_state(_opkey)
+        @connection_manager.confirm_in_progress!
+        raise_down_error unless connected?
+      end
+
+      # The socket connection to the underlying server is initialized as a side
+      # effect of this call.  In fact, this is the ONLY place where that
+      # socket connection is initialized.
+      #
+      # Both this method and connect need to be in this class so we can do auth
+      # as required
+      #
+      # Since this is invoked exclusively in verify_state!, we don't need to worry about
+      # thread safety.  Using it elsewhere may require revisiting that assumption.
+      def ensure_connected!
+        return true if connected?
+        return false unless reconnect_down_server?
+
+        connect # This call needs to be in this class so we can do auth
+        connected?
+      end
+
+      def cache_nils?(opts)
+        return false unless opts.is_a?(Hash)
+
+        opts[:cache_nils] ? true : false
+      end
+
+      def connect
+        @connection_manager.establish_connection
+        authenticate_connection if require_auth?
+        @version = version # Connect socket if not authed
+        up!
+      end
+
+      def pipelined_get(keys)
+        req = +''
+        keys.each do |key|
+          req << quiet_get_request(key)
+        end
+        # Could send noop here instead of in pipeline_response_setup
+        write(req)
+      end
+
+      def response_buffer
+        @response_buffer ||= ResponseBuffer.new(@connection_manager, response_processor)
+      end
+
+      # Called after the noop response is received at the end of a set
+      # of pipelined gets
+      def finish_pipeline
+        response_buffer.clear
+        @connection_manager.finish_request!
+
+        true # to simplify response
+      end
+
+      def reconnect_on_pipeline_complete!
+        @connection_manager.reconnect! 'pipelined get has completed' if pipeline_complete?
+      end
+
+      def log_marshal_err(key, err)
+        Dalli.logger.error "Marshalling error for key '#{key}': #{err.message}"
+        Dalli.logger.error 'You are trying to cache a Ruby object which cannot be serialized to memcached.'
+      end
+
+      def log_unexpected_err(err)
+        Dalli.logger.error "Unexpected exception during Dalli request: #{err.class.name}: #{err.message}"
+        Dalli.logger.error err.backtrace.join("\n\t")
+      end
+    end
+  end
+end