dalli 3.1.3 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0905b56adf194401de7755ab22ebef6b57f6e673e8332f7cb99b3ef9ed1dde63'
-  data.tar.gz: dac2014c748ef0c55fe171af0cec8dec807ae2468f758338c8968135acd47b92
+  metadata.gz: 56babb2362639cca3fd24225eea2a76a0d9a075a3b113b7f8ea09814a79bf59a
+  data.tar.gz: 309f6be3fce52b38608c4b22e5dce439e68944796fbe1f2240b2ed40760e8700
 SHA512:
-  metadata.gz: 85d8382dfd13c2353a61c74525e17bd81e000308e8d476851ed25fdb6ef81e9aff4276eb0b1484e30c83001301a3500140cb46a595081e1b21f0801ea32d7e28
-  data.tar.gz: 7f0adfc09e31d435bbb3f6cff2f65392a58f81697e7025ca71d9423f9a536d9c984ed7ba0742d0c0f5de0e865a7ebd2dc5548a0406c86d7f1fe0c8135c7af363
+  metadata.gz: 16847c7b39ff624deeb5fecd324d3f0bddafdcd6096c5f65cfa7a79e8b2369930b7078e8fc019bd49015c3415b43f33ea07cf85380b28d3c46199339bc9aeb2a
+  data.tar.gz: 890f87a779947ec269fb9889334eaa7b4424a654995b9b12b723dee7452f82de066b538465800c20bf9ed9bb2c5a81fbca3ae5ff382340f241f0525ad158df0c

data/History.md

@@ -4,6 +4,32 @@ Dalli Changelog
 Unreleased
 ==========
 
+3.2.0
+==========
+
+- BREAKING CHANGE: Remove protocol_implementation client option (petergoldstein)
+- Add protocol option with meta implementation (petergoldstein)
+
+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
 ==========
 

data/lib/dalli/client.rb

@@ -43,8 +43,8 @@ module Dalli
     #                 #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.
-    # - :protocol_implementation - defaults to Dalli::Protocol::Binary which uses the binary protocol. Allows you to
-    #                              pass an alternative implementation using another protocol.
+    # - :protocol - one of either :binary or :meta, defaulting to :binary.  This sets the protocol that Dalli uses
+    #               to communicate with memcached.
     #
     def initialize(servers = nil, options = {})
       @servers = ::Dalli::ServersArgNormalizer.normalize_servers(servers)
@@ -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)
@@ -405,7 +402,12 @@ module Dalli
     end
 
     def protocol_implementation
-      @protocol_implementation ||= @options.fetch(:protocol_implementation, Dalli::Protocol::Binary)
+      @protocol_implementation ||= case @options[:protocol]&.to_s
+                                   when 'meta'
+                                     Dalli::Protocol::Meta
+                                   else
+                                     Dalli::Protocol::Binary
+                                   end
     end
 
     ##

data/lib/dalli/protocol/base.rb

@@ -83,20 +83,20 @@ module Dalli
 
         response_buffer.read
 
-        resp_header, key, value = pipeline_response
-        # resp_header is not nil only if we have a full response to parse
+        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
-        while resp_header
+        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 resp_header.ok? && key.nil?
+          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, resp_header.cas] unless key.nil?
+          values[key] = [value, cas] unless key.nil?
 
           # Get the next response from the buffer
-          resp_header, key, value = pipeline_response
+          status, cas, key, value = response_buffer.process_single_getk_response
         end
 
         values
@@ -147,6 +147,13 @@ module Dalli
 
       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
@@ -207,10 +214,6 @@ module Dalli
         @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

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,13 +85,14 @@ 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 delete_response
+        def delete
           resp_header, = read_response
           return false if resp_header.not_found? || resp_header.not_stored?
 
@@ -97,15 +100,7 @@ module Dalli
           true
         end
 
-        def no_body_response
-          resp_header, = read_response
-          return false if resp_header.not_stored? # Not stored, possible status for append/prepend
-
-          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?
@@ -113,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
@@ -133,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)
@@ -164,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
 
         ##
@@ -180,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
@@ -189,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.rb

@@ -18,18 +18,11 @@ module Dalli
 
       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
-
       # 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)
@@ -40,7 +33,7 @@ module Dalli
         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)
@@ -106,7 +99,7 @@ module Dalli
         opkey = quiet? ? :deleteq : :delete
         req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
         write(req)
-        response_processor.delete_response unless quiet?
+        response_processor.delete unless quiet?
       end
 
       # Arithmetic Commands
@@ -132,7 +125,7 @@ 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
@@ -146,23 +139,23 @@ module Dalli
       # 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

data/lib/dalli/protocol/connection_manager.rb

@@ -133,6 +133,16 @@ module Dalli
         @request_in_progress = false
       end
 
+      def read_line
+        start_request!
+        data = @sock.gets("\r\n")
+        error_on_request!('EOF in read_line') if data.nil?
+        finish_request!
+        data
+      rescue SystemCallError, Timeout::Error, EOFError => e
+        error_on_request!(e)
+      end
+
       def read(count)
         start_request!
         data = @sock.readfull(count)

data/lib/dalli/protocol/meta/key_regularizer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Dalli
+  module Protocol
+    class Meta
+      ##
+      # The meta protocol requires that keys be ASCII only, so Unicode keys are
+      # not supported.  In addition, the use of whitespace in the key is not
+      # allowed.
+      # memcached supports the use of base64 hashes for keys containing
+      # whitespace or non-ASCII characters, provided the 'b' flag is included in the request.
+      class KeyRegularizer
+        WHITESPACE = /\s/.freeze
+
+        def self.encode(key)
+          return [key, false] if key.ascii_only? && !WHITESPACE.match(key)
+
+          [Base64.strict_encode64(key), true]
+        end
+
+        def self.decode(encoded_key, base64_encoded)
+          return encoded_key unless base64_encoded
+
+          Base64.strict_decode64(encoded_key).force_encoding('UTF-8')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: false
+
+module Dalli
+  module Protocol
+    class Meta
+      ##
+      # Class that encapsulates logic for formatting meta protocol requests
+      # to memcached.
+      ##
+      class RequestFormatter
+        # Since these are string construction methods, we're going to disable these
+        # Rubocop directives.  We really can't make this construction much simpler,
+        # and introducing an intermediate object seems like overkill.
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable Metrics/PerceivedComplexity
+        def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false)
+          cmd = "mg #{key}"
+          cmd << ' v f' if value
+          cmd << ' c' if return_cas
+          cmd << ' b' if base64
+          cmd << " T#{ttl}" if ttl
+          cmd << ' k q s' if quiet # Return the key in the response if quiet
+          cmd + TERMINATOR
+        end
+
+        def self.meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, base64: false, quiet: false)
+          cmd = "ms #{key} #{value.bytesize}"
+          cmd << ' c' unless %i[append prepend].include?(mode)
+          cmd << ' b' if base64
+          cmd << " F#{bitflags}" if bitflags
+          cmd << " C#{cas}" if cas && !cas.zero?
+          cmd << " T#{ttl}" if ttl
+          cmd << " M#{mode_to_token(mode)}"
+          cmd << ' q' if quiet
+          cmd << TERMINATOR
+          cmd << value
+          cmd + TERMINATOR
+        end
+
+        def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false)
+          cmd = "md #{key}"
+          cmd << ' b' if base64
+          cmd << " C#{cas}" if cas && !cas.zero?
+          cmd << " T#{ttl}" if ttl
+          cmd << ' q' if quiet
+          cmd + TERMINATOR
+        end
+
+        def self.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false)
+          cmd = "ma #{key} v"
+          cmd << ' b' if base64
+          cmd << " D#{delta}" if delta
+          cmd << " J#{initial}" if initial
+          cmd << " C#{cas}" if cas && !cas.zero?
+          cmd << " N#{ttl}" if ttl
+          cmd << ' q' if quiet
+          cmd << " M#{incr ? 'I' : 'D'}"
+          cmd + TERMINATOR
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/ParameterLists
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        def self.meta_noop
+          "mn#{TERMINATOR}"
+        end
+
+        def self.version
+          "version#{TERMINATOR}"
+        end
+
+        def self.flush(delay: nil, quiet: false)
+          cmd = +'flush_all'
+          cmd << " #{delay}" if delay
+          cmd << ' noreply' if quiet
+          cmd + TERMINATOR
+        end
+
+        def self.stats(arg = nil)
+          cmd = +'stats'
+          cmd << " #{arg}" if arg
+          cmd + TERMINATOR
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def self.mode_to_token(mode)
+          case mode
+          when :add
+            'E'
+          when :replace
+            'R'
+          when :append
+            'A'
+          when :prepend
+            'P'
+          else
+            'S'
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    class Meta
+      ##
+      # Class that encapsulates logic for processing meta protocol responses
+      # from memcached.  Includes logic for pulling data from an IO source
+      # and parsing into local values.  Handles errors on unexpected values.
+      ##
+      class ResponseProcessor
+        EN = 'EN'
+        END_TOKEN = 'END'
+        EX = 'EX'
+        HD = 'HD'
+        MN = 'MN'
+        NF = 'NF'
+        NS = 'NS'
+        OK = 'OK'
+        RESET = 'RESET'
+        STAT = 'STAT'
+        VA = 'VA'
+        VERSION = 'VERSION'
+
+        def initialize(io_source, value_marshaller)
+          @io_source = io_source
+          @value_marshaller = value_marshaller
+        end
+
+        def meta_get_with_value(cache_nils: false)
+          tokens = error_on_unexpected!([VA, EN, HD])
+          return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
+          return true unless tokens.first == VA
+
+          @value_marshaller.retrieve(read_line, bitflags_from_tokens(tokens))
+        end
+
+        def meta_get_with_value_and_cas
+          tokens = error_on_unexpected!([VA, EN, HD])
+          return [nil, 0] if tokens.first == EN
+
+          cas = cas_from_tokens(tokens)
+          return [nil, cas] unless tokens.first == VA
+
+          [@value_marshaller.retrieve(read_line, bitflags_from_tokens(tokens)), cas]
+        end
+
+        def meta_get_without_value
+          tokens = error_on_unexpected!([EN, HD])
+          tokens.first == EN ? nil : true
+        end
+
+        def meta_set_with_cas
+          tokens = error_on_unexpected!([HD, NS, NF, EX])
+          return false unless tokens.first == HD
+
+          cas_from_tokens(tokens)
+        end
+
+        def meta_set_append_prepend
+          tokens = error_on_unexpected!([HD, NS, NF, EX])
+          return false unless tokens.first == HD
+
+          true
+        end
+
+        def meta_delete
+          tokens = error_on_unexpected!([HD, NF, EX])
+          tokens.first == HD
+        end
+
+        def decr_incr
+          tokens = error_on_unexpected!([VA, NF, NS, EX])
+          return false if [NS, EX].include?(tokens.first)
+          return nil if tokens.first == NF
+
+          read_line.to_i
+        end
+
+        def stats
+          tokens = error_on_unexpected!([END_TOKEN, STAT])
+          values = {}
+          while tokens.first != END_TOKEN
+            values[tokens[1]] = tokens[2]
+            tokens = next_line_to_tokens
+          end
+          values
+        end
+
+        def flush
+          error_on_unexpected!([OK])
+
+          true
+        end
+
+        def reset
+          error_on_unexpected!([RESET])
+
+          true
+        end
+
+        def version
+          tokens = error_on_unexpected!([VERSION])
+          tokens.last
+        end
+
+        def consume_all_responses_until_mn
+          tokens = next_line_to_tokens
+
+          tokens = next_line_to_tokens while tokens.first != MN
+          true
+        end
+
+        def tokens_from_header_buffer(buf)
+          header = header_from_buffer(buf)
+          tokens = header.split
+          header_len = header.bytesize + TERMINATOR.length
+          body_len = body_len_from_tokens(tokens)
+          [tokens, header_len, body_len]
+        end
+
+        def full_response_from_buffer(tokens, body, resp_size)
+          value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
+          [resp_size, tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value]
+        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, nil] unless contains_header?(buf)
+
+          tokens, header_len, body_len = tokens_from_header_buffer(buf)
+
+          # We have a complete response that has no body.
+          # This is either the response to the terminating
+          # noop or, if the status is not MN, an intermediate
+          # error response that needs to be discarded.
+          return [header_len, true, nil, nil, nil] if body_len.zero?
+
+          resp_size = header_len + body_len + TERMINATOR.length
+          # 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, nil] unless buf.bytesize >= resp_size
+
+          # The full response is in our buffer, so parse it and return
+          # the values
+          body = buf.slice(header_len, body_len)
+          full_response_from_buffer(tokens, body, resp_size)
+        end
+
+        def contains_header?(buf)
+          buf.include?(TERMINATOR)
+        end
+
+        def header_from_buffer(buf)
+          buf.split(TERMINATOR, 2).first
+        end
+
+        def error_on_unexpected!(expected_codes)
+          tokens = next_line_to_tokens
+          raise Dalli::DalliError, "Response error: #{tokens.first}" unless expected_codes.include?(tokens.first)
+
+          tokens
+        end
+
+        def bitflags_from_tokens(tokens)
+          value_from_tokens(tokens, 'f')&.to_i
+        end
+
+        def cas_from_tokens(tokens)
+          value_from_tokens(tokens, 'c')&.to_i
+        end
+
+        def key_from_tokens(tokens)
+          encoded_key = value_from_tokens(tokens, 'k')
+          base64_encoded = tokens.any?('b')
+          KeyRegularizer.decode(encoded_key, base64_encoded)
+        end
+
+        def body_len_from_tokens(tokens)
+          value_from_tokens(tokens, 's')&.to_i
+        end
+
+        def value_from_tokens(tokens, flag)
+          bitflags_token = tokens.find { |t| t.start_with?(flag) }
+          return 0 unless bitflags_token
+
+          bitflags_token[1..-1]
+        end
+
+        def read_line
+          @io_source.read_line&.chomp!(TERMINATOR)
+        end
+
+        def next_line_to_tokens
+          line = read_line
+          line&.split || []
+        end
+      end
+    end
+  end
+end

data/lib/dalli/protocol/meta.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'socket'
+require 'timeout'
+
+module Dalli
+  module Protocol
+    ##
+    # Access point for a single Memcached server, accessed via Memcached's meta
+    # protocol.  Contains logic for managing connection state to the server (retries, etc),
+    # formatting requests to the server, and unpacking responses.
+    ##
+    class Meta < Base
+      TERMINATOR = "\r\n"
+
+      def response_processor
+        @response_processor ||= ResponseProcessor.new(@connection_manager, @value_marshaller)
+      end
+
+      # NOTE: Additional public methods should be overridden in Dalli::Threadsafe
+
+      private
+
+      # Retrieval Commands
+      def get(key, options = nil)
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_get(key: encoded_key, base64: base64)
+        write(req)
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
+      end
+
+      def quiet_get_request(key)
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        RequestFormatter.meta_get(key: encoded_key, return_cas: true, base64: base64, quiet: true)
+      end
+
+      def gat(key, ttl, options = nil)
+        ttl = TtlSanitizer.sanitize(ttl)
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64)
+        write(req)
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
+      end
+
+      def touch(key, ttl)
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, value: false, base64: base64)
+        write(req)
+        response_processor.meta_get_without_value
+      end
+
+      # TODO: This is confusing, as there's a cas command in memcached
+      # and this isn't it.  Maybe rename?  Maybe eliminate?
+      def cas(key)
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
+        write(req)
+        response_processor.meta_get_with_value_and_cas
+      end
+
+      # Storage Commands
+      def set(key, value, ttl, cas, options)
+        write_storage_req(:set, key, value, ttl, cas, options)
+        response_processor.meta_set_with_cas unless quiet?
+      end
+
+      def add(key, value, ttl, options)
+        write_storage_req(:add, key, value, ttl, nil, options)
+        response_processor.meta_set_with_cas unless quiet?
+      end
+
+      def replace(key, value, ttl, cas, options)
+        write_storage_req(:replace, key, value, ttl, cas, options)
+        response_processor.meta_set_with_cas unless quiet?
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def write_storage_req(mode, key, raw_value, ttl = nil, cas = nil, options = {})
+        (value, bitflags) = @value_marshaller.store(key, raw_value, options)
+        ttl = TtlSanitizer.sanitize(ttl) if ttl
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_set(key: encoded_key, value: value,
+                                        bitflags: bitflags, cas: cas,
+                                        ttl: ttl, mode: mode, quiet: quiet?, base64: base64)
+        write(req)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def append(key, value)
+        write_append_prepend_req(:append, key, value)
+        response_processor.meta_set_append_prepend unless quiet?
+      end
+
+      def prepend(key, value)
+        write_append_prepend_req(:prepend, key, value)
+        response_processor.meta_set_append_prepend unless quiet?
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, _options = {})
+        ttl = TtlSanitizer.sanitize(ttl) if ttl
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_set(key: encoded_key, value: value, base64: base64,
+                                        cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
+        write(req)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Delete Commands
+      def delete(key, cas)
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_delete(key: encoded_key, cas: cas,
+                                           base64: base64, quiet: quiet?)
+        write(req)
+        response_processor.meta_delete unless quiet?
+      end
+
+      # Arithmetic Commands
+      def decr(key, count, ttl, initial)
+        decr_incr false, key, count, ttl, initial
+      end
+
+      def incr(key, count, ttl, initial)
+        decr_incr true, key, count, ttl, initial
+      end
+
+      def decr_incr(incr, key, delta, ttl, initial)
+        ttl = initial ? TtlSanitizer.sanitize(ttl) : nil # Only set a TTL if we want to set a value on miss
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        write(RequestFormatter.meta_arithmetic(key: encoded_key, delta: delta, initial: initial, incr: incr, ttl: ttl,
+                                               quiet: quiet?, base64: base64))
+        response_processor.decr_incr unless quiet?
+      end
+
+      # Other Commands
+      def flush(delay = 0)
+        write(RequestFormatter.flush(delay: delay))
+        response_processor.flush 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.consume_all_responses_until_mn
+      end
+
+      def stats(info = nil)
+        write(RequestFormatter.stats(info))
+        response_processor.stats
+      end
+
+      def reset_stats
+        write(RequestFormatter.stats('reset'))
+        response_processor.reset
+      end
+
+      def version
+        write(RequestFormatter.version)
+        response_processor.version
+      end
+
+      def write_noop
+        write(RequestFormatter.meta_noop)
+      end
+
+      def authenticate_connection
+        raise Dalli::DalliError, 'Authentication not supported for the meta protocol.'
+      end
+
+      require_relative 'meta/key_regularizer'
+      require_relative 'meta/request_formatter'
+      require_relative 'meta/response_processor'
+    end
+  end
+end

data/lib/dalli/protocol/response_buffer.rb

@@ -12,6 +12,7 @@ module Dalli
       def initialize(io_source, response_processor)
         @io_source = io_source
         @response_processor = response_processor
+        @buffer = nil
       end
 
       def read
@@ -21,9 +22,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 +32,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.3'
+  VERSION = '3.2.0'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -65,6 +65,7 @@ require_relative 'dalli/protocol'
 require_relative 'dalli/protocol/base'
 require_relative 'dalli/protocol/binary'
 require_relative 'dalli/protocol/connection_manager'
+require_relative 'dalli/protocol/meta'
 require_relative 'dalli/protocol/response_buffer'
 require_relative 'dalli/protocol/server_config_parser'
 require_relative 'dalli/protocol/ttl_sanitizer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.1.3
+  version: 3.2.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-14 00:00:00.000000000 Z
+date: 2022-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -128,6 +128,10 @@ files:
 - lib/dalli/protocol/binary/response_processor.rb
 - lib/dalli/protocol/binary/sasl_authentication.rb
 - lib/dalli/protocol/connection_manager.rb
+- lib/dalli/protocol/meta.rb
+- lib/dalli/protocol/meta/key_regularizer.rb
+- lib/dalli/protocol/meta/request_formatter.rb
+- lib/dalli/protocol/meta/response_processor.rb
 - lib/dalli/protocol/response_buffer.rb
 - lib/dalli/protocol/server_config_parser.rb
 - lib/dalli/protocol/ttl_sanitizer.rb
@@ -160,7 +164,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