dalli 3.0.5 → 3.1.2

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.alive?
+
+        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/binary/request_formatter.rb

@@ -31,11 +31,14 @@ module Dalli
           deleteq: 0x14,
           incrq: 0x15,
           decrq: 0x16,
+          flushq: 0x18,
+          appendq: 0x19,
+          prependq: 0x1A,
+          touch: 0x1C,
+          gat: 0x1D,
           auth_negotiation: 0x20,
           auth_request: 0x21,
-          auth_continue: 0x22,
-          touch: 0x1C,
-          gat: 0x1D
+          auth_continue: 0x22
         }.freeze
 
         REQ_HEADER_FORMAT = 'CCnCCnNNQ'
@@ -56,6 +59,8 @@ module Dalli
 
           append: KEY_AND_VALUE,
           prepend: KEY_AND_VALUE,
+          appendq: KEY_AND_VALUE,
+          prependq: KEY_AND_VALUE,
           auth_request: KEY_AND_VALUE,
           auth_continue: KEY_AND_VALUE,
 
@@ -68,8 +73,11 @@ module Dalli
 
           incr: INCR_DECR,
           decr: INCR_DECR,
+          incrq: INCR_DECR,
+          decrq: INCR_DECR,
 
           flush: TTL_ONLY,
+          flushq: TTL_ONLY,
 
           noop: NO_BODY,
           auth_negotiation: NO_BODY,

data/lib/dalli/protocol/binary/response_header.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    class Binary
+      ##
+      # Class that encapsulates data parsed from a memcached response header.
+      ##
+      class ResponseHeader
+        SIZE = 24
+        FMT = '@2nCCnNNQ'
+
+        attr_reader :key_len, :extra_len, :data_type, :status, :body_len, :opaque, :cas
+
+        def initialize(buf)
+          raise ArgumentError, "Response buffer must be at least #{SIZE} bytes" unless buf.bytesize >= SIZE
+
+          @key_len, @extra_len, @data_type, @status, @body_len, @opaque, @cas = buf.unpack(FMT)
+        end
+
+        def ok?
+          status.zero?
+        end
+
+        def not_found?
+          status == 1
+        end
+
+        NOT_STORED_STATUSES = [2, 5].freeze
+        def not_stored?
+          NOT_STORED_STATUSES.include?(status)
+        end
+      end
+    end
+  end
+end

data/lib/dalli/protocol/binary/response_processor.rb

@@ -9,9 +9,6 @@ module Dalli
       # and parsing into local values.  Handles errors on unexpected values.
       ##
       class ResponseProcessor
-        RESP_HEADER = '@2nCCnNNQ'
-        RESP_HEADER_SIZE = 24
-
         # Response codes taken from:
         # https://github.com/memcached/memcached/wiki/BinaryProtocolRevamped#response-status
         RESPONSE_CODES = {
@@ -44,14 +41,9 @@ module Dalli
         end
 
         def read_response
-          status, extra_len, key_len, body_len, cas = unpack_header(read_header)
-          body = read(body_len) if body_len.positive?
-          [status, extra_len, body, cas, key_len]
-        end
-
-        def unpack_header(header)
-          (key_len, extra_len, _, status, body_len, _, cas) = header.unpack(RESP_HEADER)
-          [status, extra_len, key_len, body_len, cas]
+          resp_header = ResponseHeader.new(read_header)
+          body = read(resp_header.body_len) if resp_header.body_len.positive?
+          [resp_header, body]
         end
 
         def unpack_response_body(extra_len, key_len, body, unpack)
@@ -63,45 +55,57 @@ module Dalli
         end
 
         def read_header
-          read(RESP_HEADER_SIZE) || raise(Dalli::NetworkError, 'No response')
+          read(ResponseHeader::SIZE) || raise(Dalli::NetworkError, 'No response')
         end
 
-        def not_found?(status)
-          status == 1
-        end
+        def raise_on_not_ok!(resp_header)
+          return if resp_header.ok?
 
-        NOT_STORED_STATUSES = [2, 5].freeze
-        def not_stored?(status)
-          NOT_STORED_STATUSES.include?(status)
+          raise Dalli::DalliError, "Response error #{resp_header.status}: #{RESPONSE_CODES[resp_header.status]}"
         end
 
-        def raise_on_not_ok_status!(status)
-          return if status.zero?
+        def generic_response(unpack: false, cache_nils: false)
+          resp_header, body = read_response
+
+          return false if resp_header.not_stored? # Not stored, normal status for add operation
+          return cache_nils ? ::Dalli::NOT_FOUND : nil if resp_header.not_found?
 
-          raise Dalli::DalliError, "Response error #{status}: #{RESPONSE_CODES[status]}"
+          raise_on_not_ok!(resp_header)
+          return true unless body
+
+          unpack_response_body(resp_header.extra_len, resp_header.key_len, body, unpack).last
         end
 
-        def generic_response(unpack: false, cache_nils: false)
-          status, extra_len, body, _, key_len = read_response
+        ##
+        # Response for a storage operation.  Returns the cas on success.  False
+        # if the value wasn't stored.  And raises an error on all other error
+        # codes from memcached.
+        ##
+        def storage_response
+          resp_header, = read_response
+          return false if resp_header.not_stored? # Not stored, normal status for add operation
 
-          return cache_nils ? ::Dalli::NOT_FOUND : nil if not_found?(status)
-          return false if not_stored?(status) # Not stored, normal status for add operation
+          raise_on_not_ok!(resp_header)
+          resp_header.cas
+        end
 
-          raise_on_not_ok_status!(status)
-          return true unless body
+        def no_body_response
+          resp_header, = read_response
+          return false if resp_header.not_stored? # Not stored, possible status for append/prepend
 
-          unpack_response_body(extra_len, key_len, body, unpack).last
+          raise_on_not_ok!(resp_header)
+          true
         end
 
-        def data_cas_response
-          status, extra_len, body, cas, key_len = read_response
-          return [nil, cas] if not_found?(status)
-          return [nil, false] if not_stored?(status)
+        def data_cas_response(unpack: true)
+          resp_header, body = read_response
+          return [nil, resp_header.cas] if resp_header.not_found?
+          return [nil, false] if resp_header.not_stored?
 
-          raise_on_not_ok_status!(status)
-          return [nil, cas] unless body
+          raise_on_not_ok!(resp_header)
+          return [nil, resp_header.cas] unless body
 
-          [unpack_response_body(extra_len, key_len, body, true).last, cas]
+          [unpack_response_body(resp_header.extra_len, resp_header.key_len, body, unpack).last, resp_header.cas]
         end
 
         def cas_response
@@ -111,17 +115,17 @@ module Dalli
         def multi_with_keys_response
           hash = {}
           loop do
-            status, extra_len, body, _, key_len = read_response
+            resp_header, body = read_response
             # This is the response to the terminating noop / end of stat
-            return hash if status.zero? && key_len.zero?
+            return hash if resp_header.ok? && resp_header.key_len.zero?
 
             # Ignore any responses with non-zero status codes,
             # such as errors from set operations.  That allows
             # this code to be used at the end of a multi
             # block to clear any error responses from inside the multi.
-            next unless status.zero?
+            next unless resp_header.ok?
 
-            key, value = unpack_response_body(extra_len, key_len, body, true)
+            key, value = unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true)
             hash[key] = value
           end
         end
@@ -132,16 +136,63 @@ module Dalli
         end
 
         def validate_auth_format(extra_len, count)
-          return if extra_len.zero? && count.positive?
+          return if extra_len.zero?
 
           raise Dalli::NetworkError, "Unexpected message format: #{extra_len} #{count}"
         end
 
-        def auth_response
-          (extra_len, _type, status, count) = read_header.unpack(RESP_HEADER)
-          validate_auth_format(extra_len, count)
-          content = read(count)
-          [status, content]
+        def auth_response(buf = read_header)
+          resp_header = ResponseHeader.new(buf)
+          body_len = resp_header.body_len
+          validate_auth_format(resp_header.extra_len, body_len)
+          content = read(body_len) if body_len.positive?
+          [resp_header.status, content]
+        end
+
+        def contains_header?(buf)
+          return false unless buf
+
+          buf.bytesize >= ResponseHeader::SIZE
+        end
+
+        def response_header_from_buffer(buf)
+          header = buf.slice(0, ResponseHeader::SIZE)
+          ResponseHeader.new(header)
+        end
+
+        ##
+        # This method returns an array of values used in a pipelined
+        # getk process.  The first value is the number of bytes by
+        # which to advance the pointer in the buffer.  If the
+        # complete response is found in the buffer, this will
+        # be the response size.  Otherwise it is zero.
+        #
+        # The remaining three values in the array are the ResponseHeader,
+        # key, and value.
+        ##
+        def getk_response_from_buffer(buf)
+          # There's no header in the buffer, so don't advance
+          return [0, nil, nil, nil] unless contains_header?(buf)
+
+          resp_header = response_header_from_buffer(buf)
+          body_len = resp_header.body_len
+
+          # We have a complete response that has no body.
+          # This is either the response to the terminating
+          # noop or, if the status is not zero, an intermediate
+          # error response that needs to be discarded.
+          return [ResponseHeader::SIZE, resp_header, nil, nil] if body_len.zero?
+
+          resp_size = ResponseHeader::SIZE + body_len
+          # The header is in the buffer, but the body is not.  As we don't have
+          # a complete response, don't advance the buffer
+          return [0, nil, nil, nil] unless buf.bytesize >= resp_size
+
+          # The full response is in our buffer, so parse it and return
+          # the values
+          body = buf.slice(ResponseHeader::SIZE, body_len)
+          key, value = unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true)
+          [resp_size, resp_header, key, value]
         end
       end
     end

data/lib/dalli/protocol/binary/sasl_authentication.rb

@@ -11,9 +11,12 @@ module Dalli
           write(RequestFormatter.standard_request(opkey: :auth_negotiation))
 
           status, content = @response_processor.auth_response
-          # TODO: Determine if this substitution is needed
-          content.tr("\u0000", ' ')
-          mechanisms = content.split
+          return [status, []] if content.nil?
+
+          # Substitute spaces for the \x00 returned by
+          # memcached as a separator for easier
+          content&.tr("\u0000", ' ')
+          mechanisms = content&.split
           [status, mechanisms]
         end
 
@@ -45,7 +48,7 @@ module Dalli
 
           return Dalli.logger.info("Dalli/SASL: #{content}") if status.zero?
 
-          raise Dalli::DalliError, "Error authenticating: #{status}" unless status == 0x21
+          raise Dalli::DalliError, "Error authenticating: 0x#{status.to_s(16)}" unless status == 0x21
 
           raise NotImplementedError, 'No two-step authentication mechanisms supported'
           # (step, msg) = sasl.receive('challenge', content)