dalli 4.3.2 → 5.0.2

data/lib/dalli/protocol/meta.rb

@@ -257,13 +257,85 @@ module Dalli
         @connection_manager.flush
       end
 
-      def authenticate_connection
-        raise Dalli::DalliError, 'Authentication not supported for the meta protocol.'
+      # Single-server fast path for get_multi. Inlines request formatting and
+      # response parsing to minimize per-key overhead. Avoids the PipelinedGetter
+      # machinery (IO.select, response buffering, server grouping).
+      def read_multi_req(keys)
+        is_raw = raw_mode?
+        # Inline request formatting — avoids RequestFormatter.meta_get overhead per key.
+        # In raw mode: "mg <key> v k q s\r\n" (no f flag, key at index 2)
+        # Normal mode: "mg <key> v f k q s\r\n" (key at index 3)
+        post_get = is_raw ? " v k q s\r\n" : " v f k q s\r\n"
+        keys.each do |key|
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          write(base64 ? "mg #{encoded_key} b#{post_get}" : "mg #{encoded_key}#{post_get}")
+        end
+        write("mn\r\n")
+        @connection_manager.flush
+
+        read_multi_get_responses(is_raw)
+      end
+
+      def read_multi_get_responses(is_raw)
+        hash = {}
+        key_index = is_raw ? 2 : 3
+        while (line = @connection_manager.read_line)
+          break if line.start_with?('MN')
+          next unless line.start_with?('VA ')
+
+          key, value = parse_multi_get_value(line, key_index, is_raw)
+          hash[key] = value if key
+        end
+        hash
+      end
+
+      def parse_multi_get_value(line, key_index, is_raw)
+        tokens = line.chomp!(TERMINATOR).split
+        value = @connection_manager.read(tokens[1].to_i + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+        raw_key = tokens[key_index]
+        return unless raw_key
+
+        key = KeyRegularizer.decode(raw_key[1..], tokens.include?('b'))
+        bitflags = is_raw ? 0 : response_processor.bitflags_from_tokens(tokens)
+        [key, @value_marshaller.retrieve(value, bitflags)]
+      end
+
+      # Single-server fast path for set_multi. Inlines request formatting to
+      # minimize per-key overhead. Avoids PipelinedSetter server grouping.
+      def write_multi_req(pairs, ttl, req_options)
+        ttl = TtlSanitizer.sanitize(ttl) if ttl
+        pairs.each do |key, raw_value|
+          (value, bitflags) = @value_marshaller.store(key, raw_value, req_options)
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          # Inline format: "ms <key> <size> c [b] F<flags> T<ttl> MS q\r\n"
+          cmd = "ms #{encoded_key} #{value.bytesize} c"
+          cmd << ' b' if base64
+          cmd << " F#{bitflags}" if bitflags
+          cmd << " T#{ttl}" if ttl
+          cmd << " MS q\r\n"
+          write(cmd)
+          write(value)
+          write(TERMINATOR)
+        end
+        write_noop
+        response_processor.consume_all_responses_until_mn
+      end
+
+      # Single-server fast path for delete_multi. Writes all quiet delete requests
+      # terminated by a noop, then consumes all responses.
+      def delete_multi_req(keys)
+        keys.each do |key|
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          # Inline format: "md <key> [b] q\r\n"
+          write(base64 ? "md #{encoded_key} b q\r\n" : "md #{encoded_key} q\r\n")
+        end
+        write_noop
+        response_processor.consume_all_responses_until_mn
       end
 
-      require_relative 'meta/key_regularizer'
-      require_relative 'meta/request_formatter'
-      require_relative 'meta/response_processor'
+      require_relative 'key_regularizer'
+      require_relative 'request_formatter'
+      require_relative 'response_processor'
     end
   end
 end

data/lib/dalli/protocol/response_buffer.rb

@@ -7,38 +7,39 @@ module Dalli
   module Protocol
     ##
     # Manages the buffer for responses from memcached.
+    # Uses an offset-based approach to avoid string allocations
+    # when advancing through parsed responses.
     ##
     class ResponseBuffer
+      # Compact the buffer when the consumed portion exceeds this
+      # threshold and represents more than half the buffer
+      COMPACT_THRESHOLD = 4096
+
       def initialize(io_source, response_processor)
         @io_source = io_source
         @response_processor = response_processor
         @buffer = nil
+        @offset = 0
       end
 
       def read
         @buffer << @io_source.read_nonblock
       end
 
-      # Attempts to process a single response from the buffer.  Starts
-      # by advancing the buffer to the specified start position
+      # Attempts to process a single response from the buffer,
+      # advancing the offset past the consumed bytes.
       def process_single_getk_response
-        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer)
-        advance(bytes)
+        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer, @offset)
+        @offset += bytes
+        compact_if_needed
         [status, cas, key, value]
       end
 
-      # Advances the internal response buffer by bytes_to_advance
-      # bytes.  The
-      def advance(bytes_to_advance)
-        return unless bytes_to_advance.positive?
-
-        @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 = ''.b
+        @offset = 0
       end
 
       # Ensures the buffer is initialized for reading without discarding
@@ -48,16 +49,30 @@ module Dalli
         return if in_progress?
 
         @buffer = ''.b
+        @offset = 0
       end
 
       # Clear the internal response buffer
       def clear
         @buffer = nil
+        @offset = 0
       end
 
       def in_progress?
         !@buffer.nil?
       end
+
+      private
+
+      # Only compact when we've consumed a significant portion of the buffer.
+      # This avoids per-response string allocation while preventing unbounded
+      # memory growth for large pipelines.
+      def compact_if_needed
+        return unless @offset > COMPACT_THRESHOLD && @offset > @buffer.bytesize / 2
+
+        @buffer = @buffer.byteslice(@offset..)
+        @offset = 0
+      end
     end
   end
 end

data/lib/dalli/protocol/{meta/response_processor.rb → response_processor.rb}

@@ -147,14 +147,6 @@ module Dalli
           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]
@@ -170,11 +162,15 @@ module Dalli
         # 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)
+        def getk_response_from_buffer(buf, offset = 0)
+          # Find the header terminator starting from offset
+          term_idx = buf.index(TERMINATOR, offset)
+          return [0, nil, nil, nil, nil] unless term_idx
 
-          tokens, header_len, body_len = tokens_from_header_buffer(buf)
+          header = buf.byteslice(offset, term_idx - offset)
+          tokens = header.split
+          header_len = header.bytesize + TERMINATOR.length
+          body_len = body_len_from_tokens(tokens)
 
           # We have a complete response that has no body.
           # This is either the response to the terminating
@@ -185,22 +181,14 @@ module Dalli
           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
+          return [0, nil, nil, nil, nil] unless buf.bytesize >= offset + resp_size
 
           # The full response is in our buffer, so parse it and return
           # the values
-          body = buf.slice(header_len, body_len)
+          body = buf.byteslice(offset + 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
 

data/lib/dalli/protocol/server_config_parser.rb

@@ -6,7 +6,7 @@ module Dalli
   module Protocol
     ##
     # Dalli::Protocol::ServerConfigParser parses a server string passed to
-    # a Dalli::Protocol::Binary instance into the hostname, port, weight, and
+    # a Dalli::Protocol::Meta instance into the hostname, port, weight, and
     # socket_type.
     ##
     class ServerConfigParser

data/lib/dalli/ring.rb

@@ -23,9 +23,9 @@ module Dalli
 
     attr_accessor :servers, :continuum
 
-    def initialize(servers_arg, protocol_implementation, options)
+    def initialize(servers_arg, options)
       @servers = servers_arg.map do |s|
-        protocol_implementation.new(s, options)
+        Dalli::Protocol::Meta.new(s, options)
       end
       @continuum = nil
       @continuum = build_continuum(servers) if servers.size > 1

data/lib/dalli/servers_arg_normalizer.rb

@@ -16,7 +16,7 @@ module Dalli
   #     weight are optional (e.g. 'localhost', 'abc.com:12345', 'example.org:22222:3')
   #   * A colon separated string of (UNIX socket, weight) where the weight is optional
   #     (e.g. '/var/run/memcached/socket', '/tmp/xyz:3') (not supported on Windows)
-  #   * A URI with a 'memcached' protocol, which will typically include a username/password
+  #   * A URI with a 'memcached' protocol (e.g. 'memcached://localhost:11211')
   #
   # The methods in this module do not validate the format of individual server strings, but
   # rather normalize the argument into a compact array, wherein each array entry corresponds

data/lib/dalli/socket.rb

@@ -108,12 +108,14 @@ module Dalli
       # Detect and cache whether TCPSocket supports the connect_timeout: keyword argument.
       # Returns false if TCPSocket#initialize has been monkey-patched by gems like
       # socksify or resolv-replace, which don't support keyword arguments.
+      # rubocop:disable ThreadSafety/ClassInstanceVariable
       def self.supports_connect_timeout?
         return @supports_connect_timeout if defined?(@supports_connect_timeout)
 
         @supports_connect_timeout = RUBY_VERSION >= '3.0' &&
                                     ::TCPSocket.instance_method(:initialize).parameters == TCPSOCKET_NATIVE_PARAMETERS
       end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
 
       def self.create_socket_with_timeout(host, port, options)
         if supports_connect_timeout?
@@ -170,12 +172,14 @@ module Dalli
 
       # Detect and cache the correct pack format for struct timeval on this platform.
       # Different architectures have different sizes for time_t and suseconds_t.
+      # rubocop:disable ThreadSafety/ClassInstanceVariable
       def self.timeval_pack_format(sock)
         @timeval_pack_format ||= begin
           expected_size = sock.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO).data.bytesize
           TIMEVAL_PACK_FORMATS.find { |fmt| TIMEVAL_TEST_VALUES.pack(fmt).bytesize == expected_size } || 'll'
         end
       end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
 
       def self.pack_timeval(sock, seconds, microseconds)
         [seconds, microseconds].pack(timeval_pack_format(sock))

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '4.3.2'
+  VERSION = '5.0.2'
 
-  MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
+  MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
 end

data/lib/dalli.rb

@@ -38,7 +38,7 @@ module Dalli
   QUIET = :dalli_multi
 
   def self.logger
-    @logger ||= rails_logger || default_logger
+    @logger ||= rails_logger || default_logger # rubocop:disable ThreadSafety/ClassInstanceVariable
   end
 
   def self.rails_logger
@@ -54,7 +54,7 @@ module Dalli
   end
 
   def self.logger=(logger)
-    @logger = logger
+    @logger = logger # rubocop:disable ThreadSafety/ClassInstanceVariable
   end
 end
 
@@ -62,7 +62,6 @@ require_relative 'dalli/version'
 require_relative 'dalli/instrumentation'
 
 require_relative 'dalli/compressor'
-require_relative 'dalli/protocol_deprecations'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'
@@ -71,7 +70,6 @@ require_relative 'dalli/pipelined_deleter'
 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/meta'
 require_relative 'dalli/protocol/response_buffer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 4.3.2
+  version: 5.0.2
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -49,24 +49,18 @@ files:
 - lib/dalli/pipelined_setter.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
-- lib/dalli/protocol/binary/response_processor.rb
-- lib/dalli/protocol/binary/sasl_authentication.rb
 - lib/dalli/protocol/connection_manager.rb
+- lib/dalli/protocol/key_regularizer.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/request_formatter.rb
 - lib/dalli/protocol/response_buffer.rb
+- lib/dalli/protocol/response_processor.rb
 - lib/dalli/protocol/server_config_parser.rb
 - lib/dalli/protocol/string_marshaller.rb
 - lib/dalli/protocol/ttl_sanitizer.rb
 - lib/dalli/protocol/value_compressor.rb
 - lib/dalli/protocol/value_marshaller.rb
 - lib/dalli/protocol/value_serializer.rb
-- lib/dalli/protocol_deprecations.rb
 - lib/dalli/ring.rb
 - lib/dalli/servers_arg_normalizer.rb
 - lib/dalli/socket.rb
@@ -86,7 +80,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli
-  module Protocol
-    class Binary
-      ##
-      # Class that encapsulates logic for formatting binary protocol requests
-      # to memcached.
-      ##
-      class RequestFormatter
-        REQUEST = 0x80
-
-        OPCODES = {
-          get: 0x00,
-          set: 0x01,
-          add: 0x02,
-          replace: 0x03,
-          delete: 0x04,
-          incr: 0x05,
-          decr: 0x06,
-          flush: 0x08,
-          noop: 0x0A,
-          version: 0x0B,
-          getkq: 0x0D,
-          append: 0x0E,
-          prepend: 0x0F,
-          stat: 0x10,
-          setq: 0x11,
-          addq: 0x12,
-          replaceq: 0x13,
-          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
-        }.freeze
-
-        REQ_HEADER_FORMAT = 'CCnCCnNNQ'
-
-        KEY_ONLY = 'a*'
-        TTL_AND_KEY = 'Na*'
-        KEY_AND_VALUE = 'a*a*'
-        INCR_DECR = 'NNNNNa*'
-        TTL_ONLY = 'N'
-        NO_BODY = ''
-
-        BODY_FORMATS = {
-          get: KEY_ONLY,
-          getkq: KEY_ONLY,
-          delete: KEY_ONLY,
-          deleteq: KEY_ONLY,
-          stat: KEY_ONLY,
-
-          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,
-
-          set: 'NNa*a*',
-          setq: 'NNa*a*',
-          add: 'NNa*a*',
-          addq: 'NNa*a*',
-          replace: 'NNa*a*',
-          replaceq: 'NNa*a*',
-
-          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,
-          version: NO_BODY,
-
-          touch: TTL_AND_KEY,
-          gat: TTL_AND_KEY
-        }.freeze
-        FORMAT = BODY_FORMATS.transform_values { |v| REQ_HEADER_FORMAT + v }
-
-        # rubocop:disable Metrics/ParameterLists
-        def self.standard_request(opkey:, key: nil, value: nil, opaque: 0, cas: 0, bitflags: nil, ttl: nil)
-          extra_len = (bitflags.nil? ? 0 : 4) + (ttl.nil? ? 0 : 4)
-          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].compact
-          (header + body).pack(FORMAT[opkey])
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        def self.decr_incr_request(opkey:, key: nil, count: nil, initial: nil, expiry: nil)
-          extra_len = 20
-          (h, l) = as_8byte_uint(count)
-          (dh, dl) = as_8byte_uint(initial)
-          header = [REQUEST, OPCODES[opkey], key.bytesize, extra_len, 0, 0, key.bytesize + extra_len, 0, 0]
-          body = [h, l, dh, dl, expiry, key]
-          (header + body).pack(FORMAT[opkey])
-        end
-
-        def self.as_8byte_uint(val)
-          [val >> 32, val & 0xFFFFFFFF]
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# 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