dalli 3.1.2 → 3.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74310302432b6cdf905f2e581145a10a3dc1c08f97b47e3a8e1b91a113920d4d
-  data.tar.gz: b62f80ba194b9feba95ac7db0fac632381bdf5b2d0ecd24ec3b7a748c79e9d26
+  metadata.gz: 5a922a58b5cbaaf248ee0d3078b4bb6acd5827e7b2bf123aeabcda3a9f6ae4ba
+  data.tar.gz: a1ce97c6d6f4421deb4b46b0a3221f99c7939cec036ccaba07972be39aa7cf4c
 SHA512:
-  metadata.gz: ccf0a1722111940e132879abc0e4bb1899f6e337b8ef0ded051bd50eac76bbd9f79a50b22584b8893ed97ff99df0687edb5734ab958b56ed437adbed15176389
-  data.tar.gz: ba43861323882292b98e8dc12ea96cd42ca76ee146df523726e23dc1bca27fbc8e659d1a67bfbfcf529597626562d1731e7c5ee2dd56497e905cc594f6ed9569
+  metadata.gz: 5f7d9bb0dc9a911fe698a86f99a0a0c2786a68b35fc685a1aeb5a769ba53990681a77b1b99c95280a3250a8d226e8c62f79889e101cddd9c94d1c08464eadd0d
+  data.tar.gz: 9d078a4628973989cc53254e2a4398c8697d07d36682c90f3abce88b26f0c579fb6d46da58553c95cd59e190b663dad26cb65f6cad358681bb37653912e5b61f

data/History.md

@@ -4,6 +4,31 @@ Dalli Changelog
 Unreleased
 ==========
 
+3.1.6
+==========
+
+- Fix bug with cas/cas! with "Not found" value (petergoldstein)
+- Add Ruby 3.1 to CI (petergoldstein)
+- Replace reject(&:nil?) with compact (petergoldstein)
+
+3.1.5
+==========
+
+- Fix bug with get_cas key with "Not found" value (petergoldstein)
+- Replace should return nil, not raise error, on miss (petergoldstein)
+
+3.1.4
+==========
+
+- Improve response parsing performance (casperisfine)
+- Reorganize binary protocol parsing a bit (petergoldstein)
+- Fix handling of non-ASCII keys in get_multi (petergoldstein)
+
+3.1.3
+==========
+
+- Restore falsey behavior on delete/delete_cas for nonexistent key (petergoldstein)
+
 3.1.2
 ==========
 

data/lib/dalli/client.rb

@@ -86,8 +86,6 @@ module Dalli
     # value and CAS will be passed to the block.
     def get_cas(key)
       (value, cas) = perform(:cas, key)
-      #  TODO: This is odd.  Confirm this is working as expected.
-      value = nil if !value || value == 'Not found'
       return [value, cas] unless block_given?
 
       yield value, cas
@@ -377,7 +375,6 @@ module Dalli
 
     def cas_core(key, always_set, ttl = nil, req_options = nil)
       (value, cas) = perform(:cas, key)
-      value = nil if !value || value == 'Not found'
       return if value.nil? && !always_set
 
       newvalue = yield(value)

data/lib/dalli/protocol/base.rb

@@ -0,0 +1,234 @@
+# 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
+          send(opkey, *args)
+        rescue Dalli::MarshalError => e
+          log_marshal_err(args.first, e)
+          raise
+        rescue Dalli::DalliError
+          raise
+        rescue StandardError => e
+          log_unexpected_err(e)
+          down!
+        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_state(:getkq)
+        write_noop
+        response_buffer.reset
+        @connection_manager.start_request!
+      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::Error, 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['MEMCACHE_USERNAME']
+      end
+
+      def password
+        @options[:password] || ENV['MEMCACHE_PASSWORD']
+      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
+
+      ##
+      # 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
+
+      # 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!
+      rescue Dalli::DalliError
+        raise
+      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

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

@@ -94,7 +94,7 @@ module Dalli
           key_len = key.nil? ? 0 : key.bytesize
           value_len = value.nil? ? 0 : value.bytesize
           header = [REQUEST, OPCODES[opkey], key_len, extra_len, 0, 0, extra_len + key_len + value_len, opaque, cas]
-          body = [bitflags, ttl, key, value].reject(&:nil?)
+          body = [bitflags, ttl, key, value].compact
           (header + body).pack(FORMAT[opkey])
         end
         # rubocop:enable Metrics/ParameterLists

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

@@ -46,11 +46,13 @@ module Dalli
           [resp_header, body]
         end
 
-        def unpack_response_body(extra_len, key_len, body, unpack)
-          bitflags = extra_len.positive? ? body.byteslice(0, extra_len).unpack1('N') : 0x0
-          key = body.byteslice(extra_len, key_len) if key_len.positive?
-          value = body.byteslice(extra_len + key_len, body.bytesize - (extra_len + key_len))
-          value = unpack ? @value_marshaller.retrieve(value, bitflags) : value
+        def unpack_response_body(resp_header, body, parse_as_stored_value)
+          extra_len = resp_header.extra_len
+          key_len = resp_header.key_len
+          bitflags = extra_len.positive? ? body.unpack1('N') : 0x0
+          key = body.byteslice(extra_len, key_len).force_encoding('UTF-8') if key_len.positive?
+          value = body.byteslice((extra_len + key_len)..-1)
+          value = parse_as_stored_value ? @value_marshaller.retrieve(value, bitflags) : value
           [key, value]
         end
 
@@ -64,7 +66,7 @@ module Dalli
           raise Dalli::DalliError, "Response error #{resp_header.status}: #{RESPONSE_CODES[resp_header.status]}"
         end
 
-        def generic_response(unpack: false, cache_nils: false)
+        def get(cache_nils: false)
           resp_header, body = read_response
 
           return false if resp_header.not_stored? # Not stored, normal status for add operation
@@ -73,7 +75,7 @@ module Dalli
           raise_on_not_ok!(resp_header)
           return true unless body
 
-          unpack_response_body(resp_header.extra_len, resp_header.key_len, body, unpack).last
+          unpack_response_body(resp_header, body, true).last
         end
 
         ##
@@ -83,21 +85,22 @@ module Dalli
         ##
         def storage_response
           resp_header, = read_response
+          return nil if resp_header.not_found?
           return false if resp_header.not_stored? # Not stored, normal status for add operation
 
           raise_on_not_ok!(resp_header)
           resp_header.cas
         end
 
-        def no_body_response
+        def delete
           resp_header, = read_response
-          return false if resp_header.not_stored? # Not stored, possible status for append/prepend
+          return false if resp_header.not_found? || resp_header.not_stored?
 
           raise_on_not_ok!(resp_header)
           true
         end
 
-        def data_cas_response(unpack: true)
+        def data_cas_response
           resp_header, body = read_response
           return [nil, resp_header.cas] if resp_header.not_found?
           return [nil, false] if resp_header.not_stored?
@@ -105,14 +108,16 @@ module Dalli
           raise_on_not_ok!(resp_header)
           return [nil, resp_header.cas] unless body
 
-          [unpack_response_body(resp_header.extra_len, resp_header.key_len, body, unpack).last, resp_header.cas]
+          [unpack_response_body(resp_header, body, true).last, resp_header.cas]
         end
 
-        def cas_response
-          data_cas_response.last
+        # Returns the new value for the key, if found and updated
+        def decr_incr
+          body = generic_response
+          body ? body.unpack1('Q>') : body
         end
 
-        def multi_with_keys_response
+        def stats
           hash = {}
           loop do
             resp_header, body = read_response
@@ -125,14 +130,49 @@ module Dalli
             # block to clear any error responses from inside the multi.
             next unless resp_header.ok?
 
-            key, value = unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true)
+            key, value = unpack_response_body(resp_header, body, true)
             hash[key] = value
           end
         end
 
-        def decr_incr_response
-          body = generic_response
-          body ? body.unpack1('Q>') : body
+        def flush
+          no_body_response
+        end
+
+        def reset
+          generic_response
+        end
+
+        def version
+          generic_response
+        end
+
+        def consume_all_responses_until_noop
+          loop do
+            resp_header, = read_response
+            # This is the response to the terminating noop / end of stat
+            return true if resp_header.ok? && resp_header.key_len.zero?
+          end
+        end
+
+        def generic_response
+          resp_header, body = read_response
+
+          return false if resp_header.not_stored? # Not stored, normal status for add operation
+          return nil if resp_header.not_found?
+
+          raise_on_not_ok!(resp_header)
+          return true unless body
+
+          unpack_response_body(resp_header, body, false).last
+        end
+
+        def no_body_response
+          resp_header, = read_response
+          return false if resp_header.not_stored? # Not stored, possible status for append/prepend/delete
+
+          raise_on_not_ok!(resp_header)
+          true
         end
 
         def validate_auth_format(extra_len, count)
@@ -156,8 +196,7 @@ module Dalli
         end
 
         def response_header_from_buffer(buf)
-          header = buf.slice(0, ResponseHeader::SIZE)
-          ResponseHeader.new(header)
+          ResponseHeader.new(buf)
         end
 
         ##
@@ -172,7 +211,7 @@ module Dalli
         ##
         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)
+          return [0, nil, nil, nil, nil] unless contains_header?(buf)
 
           resp_header = response_header_from_buffer(buf)
           body_len = resp_header.body_len
@@ -181,18 +220,18 @@ module Dalli
           # 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?
+          return [ResponseHeader::SIZE, resp_header.ok?, resp_header.cas, 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
+          return [0, nil, 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]
+          body = buf.byteslice(ResponseHeader::SIZE, body_len)
+          key, value = unpack_response_body(resp_header, body, true)
+          [resp_size, resp_header.ok?, resp_header.cas, key, value]
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Dalli
         def perform_auth_negotiation
           write(RequestFormatter.standard_request(opkey: :auth_negotiation))
 
-          status, content = @response_processor.auth_response
+          status, content = response_processor.auth_response
           return [status, []] if content.nil?
 
           # Substitute spaces for the \x00 returned by

data/lib/dalli/protocol/binary.rb

@@ -4,11 +4,6 @@ require 'forwardable'
 require 'socket'
 require 'timeout'
 
-require_relative 'binary/request_formatter'
-require_relative 'binary/response_header'
-require_relative 'binary/response_processor'
-require_relative 'binary/sasl_authentication'
-
 module Dalli
   module Protocol
     ##
@@ -16,175 +11,13 @@ module Dalli
     # protocol.  Contains logic for managing connection state to the server (retries, etc),
     # formatting requests to the server, and unpacking responses.
     ##
-    class Binary
-      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)
-        @response_processor = ResponseProcessor.new(@connection_manager, @value_marshaller)
-      end
-
-      # Chokepoint method for error handling and ensuring liveness
-      def request(opkey, *args)
-        verify_state(opkey)
-
-        begin
-          send(opkey, *args)
-        rescue Dalli::MarshalError => e
-          log_marshal_err(args.first, e)
-          raise
-        rescue Dalli::DalliError
-          raise
-        rescue StandardError => e
-          log_unexpected_err(e)
-          down!
-        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_state(:getkq)
-        write_noop
-        response_buffer.reset
-        @connection_manager.start_request!
-      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
-
-        resp_header, key, value = pipeline_response
-        # resp_header is not nil only if we have a full response to parse
-        # in the buffer
-        while resp_header
-          # 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 resp_header.ok? && 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, resp_header.cas] unless key.nil?
-
-          # Get the next response from the buffer
-          resp_header, key, value = pipeline_response
-        end
-
-        values
-      rescue SystemCallError, Timeout::Error, 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['MEMCACHE_USERNAME']
-      end
-
-      def password
-        @options[:password] || ENV['MEMCACHE_PASSWORD']
-      end
-
-      def require_auth?
-        !username.nil?
+    class Binary < Base
+      def response_processor
+        @response_processor ||= ResponseProcessor.new(@connection_manager, @value_marshaller)
       end
 
-      def quiet?
-        Thread.current[::Dalli::QUIET]
-      end
-      alias multi? quiet?
-
-      # NOTE: Additional public methods should be overridden in Dalli::Threadsafe
-
       private
 
-      ##
-      # 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
-
-      # 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
-
       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)
@@ -192,30 +25,28 @@ module Dalli
         raise Dalli::NotPermittedMultiOpError, "The operation #{opkey} is not allowed in a quiet block."
       end
 
-      def cache_nils?(opts)
-        return false unless opts.is_a?(Hash)
-
-        opts[:cache_nils] ? true : false
-      end
-
       # Retrieval Commands
       def get(key, options = nil)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
-        @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
+        response_processor.get(cache_nils: cache_nils?(options))
+      end
+
+      def quiet_get_request(key)
+        RequestFormatter.standard_request(opkey: :getkq, key: key)
       end
 
       def gat(key, ttl, options = nil)
         ttl = TtlSanitizer.sanitize(ttl)
         req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
         write(req)
-        @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
+        response_processor.get(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
         ttl = TtlSanitizer.sanitize(ttl)
         write(RequestFormatter.standard_request(opkey: :touch, key: key, ttl: ttl))
-        @response_processor.generic_response
+        response_processor.generic_response
       end
 
       # TODO: This is confusing, as there's a cas command in memcached
@@ -223,7 +54,7 @@ module Dalli
       def cas(key)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
-        @response_processor.data_cas_response
+        response_processor.data_cas_response
       end
 
       # Storage Commands
@@ -251,7 +82,7 @@ module Dalli
                                                 value: value, bitflags: bitflags,
                                                 ttl: ttl, cas: cas)
         write(req)
-        @response_processor.storage_response unless quiet?
+        response_processor.storage_response unless quiet?
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -267,7 +98,7 @@ module Dalli
 
       def write_append_prepend(opkey, key, value)
         write(RequestFormatter.standard_request(opkey: opkey, key: key, value: value))
-        @response_processor.no_body_response unless quiet?
+        response_processor.no_body_response unless quiet?
       end
 
       # Delete Commands
@@ -275,7 +106,7 @@ module Dalli
         opkey = quiet? ? :deleteq : :delete
         req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
         write(req)
-        @response_processor.no_body_response unless quiet?
+        response_processor.delete unless quiet?
       end
 
       # Arithmetic Commands
@@ -301,37 +132,37 @@ module Dalli
         initial ||= 0
         write(RequestFormatter.decr_incr_request(opkey: opkey, key: key,
                                                  count: count, initial: initial, expiry: expiry))
-        @response_processor.decr_incr_response unless quiet?
+        response_processor.decr_incr unless quiet?
       end
 
       # Other Commands
       def flush(ttl = 0)
         opkey = quiet? ? :flushq : :flush
         write(RequestFormatter.standard_request(opkey: opkey, ttl: ttl))
-        @response_processor.no_body_response unless quiet?
+        response_processor.no_body_response unless quiet?
       end
 
       # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands.
       # We need to read all the responses at once.
       def noop
         write_noop
-        @response_processor.multi_with_keys_response
+        response_processor.consume_all_responses_until_noop
       end
 
       def stats(info = '')
         req = RequestFormatter.standard_request(opkey: :stat, key: info)
         write(req)
-        @response_processor.multi_with_keys_response
+        response_processor.stats
       end
 
       def reset_stats
         write(RequestFormatter.standard_request(opkey: :stat, key: 'reset'))
-        @response_processor.generic_response
+        response_processor.reset
       end
 
       def version
         write(RequestFormatter.standard_request(opkey: :version))
-        @response_processor.generic_response
+        response_processor.version
       end
 
       def write_noop
@@ -339,55 +170,10 @@ module Dalli
         write(req)
       end
 
-      def connect
-        @connection_manager.establish_connection
-        authenticate_connection if require_auth?
-        @version = version # Connect socket if not authed
-        up!
-      rescue Dalli::DalliError
-        raise
-      end
-
-      def pipelined_get(keys)
-        req = +''
-        keys.each do |key|
-          req << RequestFormatter.standard_request(opkey: :getkq, key: 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
-
-      def pipeline_response
-        response_buffer.process_single_getk_response
-      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
-
+      require_relative 'binary/request_formatter'
+      require_relative 'binary/response_header'
+      require_relative 'binary/response_processor'
+      require_relative 'binary/sasl_authentication'
       include SaslAuthentication
     end
   end

data/lib/dalli/protocol/response_buffer.rb

@@ -21,9 +21,9 @@ module Dalli
       # Attempts to process a single response from the buffer.  Starts
       # by advancing the buffer to the specified start position
       def process_single_getk_response
-        bytes, resp_header, key, value = @response_processor.getk_response_from_buffer(@buffer)
+        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer)
         advance(bytes)
-        [resp_header, key, value]
+        [status, cas, key, value]
       end
 
       # Advances the internal response buffer by bytes_to_advance
@@ -31,13 +31,13 @@ module Dalli
       def advance(bytes_to_advance)
         return unless bytes_to_advance.positive?
 
-        @buffer = @buffer[bytes_to_advance..-1]
+        @buffer = @buffer.byteslice(bytes_to_advance..-1)
       end
 
       # Resets the internal buffer to an empty state,
       # so that we're ready to read pipelined responses
       def reset
-        @buffer = +''
+        @buffer = ''.b
       end
 
       # Clear the internal response buffer

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '3.1.2'
+  VERSION = '3.1.6'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -62,6 +62,7 @@ require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'
 require_relative 'dalli/ring'
 require_relative 'dalli/protocol'
+require_relative 'dalli/protocol/base'
 require_relative 'dalli/protocol/binary'
 require_relative 'dalli/protocol/connection_manager'
 require_relative 'dalli/protocol/response_buffer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.1.6
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2022-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -121,6 +121,7 @@ files:
 - lib/dalli/options.rb
 - lib/dalli/pipelined_getter.rb
 - lib/dalli/protocol.rb
+- lib/dalli/protocol/base.rb
 - lib/dalli/protocol/binary.rb
 - lib/dalli/protocol/binary/request_formatter.rb
 - lib/dalli/protocol/binary/response_header.rb
@@ -159,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.31
+rubygems_version: 3.3.4
 signing_key:
 specification_version: 4
 summary: High performance memcached client for Ruby