dalli 5.0.4 → 5.0.6

data/lib/dalli/protocol/meta.rb

@@ -24,48 +24,38 @@ module Dalli
 
       # Retrieval Commands
       def get(key, options = nil)
-        encoded_key, base64 = KeyRegularizer.encode(key)
         # Skip bitflags in raw mode - saves 2 bytes per request and skips parsing
         skip_flags = raw_mode? || (options && options[:raw])
-        req = RequestFormatter.meta_get(key: encoded_key, base64: base64, skip_flags: skip_flags)
-        write(req)
-        @connection_manager.flush
+        req = RequestFormatter.meta_get(key: key, skip_flags: skip_flags)
+        flushed_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)
         # Skip bitflags in raw mode - saves 2 bytes per request and skips parsing
-        RequestFormatter.meta_get(key: encoded_key, return_cas: true, base64: base64, quiet: true,
-                                  skip_flags: raw_mode?)
+        RequestFormatter.meta_get(key: key, return_cas: true, quiet: true, skip_flags: raw_mode?)
       end
 
       def gat(key, ttl, options = nil)
         ttl = TtlSanitizer.sanitize(ttl)
-        encoded_key, base64 = KeyRegularizer.encode(key)
         skip_flags = raw_mode? || (options && options[:raw])
-        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64, skip_flags: skip_flags)
-        write(req)
-        @connection_manager.flush
+        req = RequestFormatter.meta_get(key: key, ttl: ttl, skip_flags: skip_flags)
+        flushed_write(req)
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
         ttl = TtlSanitizer.sanitize(ttl)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, value: false, base64: base64)
-        write(req)
-        @connection_manager.flush
+        req = RequestFormatter.meta_get(key: key, ttl: ttl, value: false)
+        flushed_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)
-        @connection_manager.flush
+        req = RequestFormatter.meta_get(key: key, value: true, return_cas: true)
+        flushed_write(req)
         response_processor.meta_get_with_value_and_cas
       end
 
@@ -94,15 +84,13 @@ module Dalli
       #   - :hit_before - true/false if previously accessed (only if return_hit_status: true)
       #   - :last_access - seconds since last access (only if return_last_access: true)
       def meta_get(key, options = {})
-        encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(
-          key: encoded_key, value: true, return_cas: true, base64: base64,
+          key: key, value: true, return_cas: true,
           vivify_ttl: options[:vivify_ttl], recache_ttl: options[:recache_ttl],
           return_hit_status: options[:return_hit_status],
           return_last_access: options[:return_last_access], skip_lru_bump: options[:skip_lru_bump]
         )
-        write(req)
-        @connection_manager.flush
+        flushed_write(req)
         response_processor.meta_get_with_metadata(
           cache_nils: cache_nils?(options), return_hit_status: options[:return_hit_status],
           return_last_access: options[:return_last_access]
@@ -117,10 +105,8 @@ module Dalli
       # @param cas [Integer] optional CAS value for compare-and-swap
       # @return [Boolean] true if successful
       def delete_stale(key, cas = nil)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_delete(key: encoded_key, cas: cas, base64: base64, stale: true)
-        write(req)
-        @connection_manager.flush
+        req = RequestFormatter.meta_delete(key: key, cas: cas, stale: true)
+        flushed_write(req)
         response_processor.meta_delete
       end
 
@@ -146,17 +132,13 @@ module Dalli
         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 = {}, quiet: quiet?)
         (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,
+        req = RequestFormatter.meta_set(key: key, value: value,
                                         bitflags: bitflags, cas: cas,
-                                        ttl: ttl, mode: mode, quiet: quiet, base64: base64)
-        write(req)
-        write(value)
-        write(TERMINATOR)
+                                        ttl: ttl, mode: mode, quiet: quiet)
+        write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet
       end
       # rubocop:enable Metrics/ParameterLists
@@ -174,21 +156,16 @@ module Dalli
       # 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,
+        req = RequestFormatter.meta_set(key: key, value: value,
                                         cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
-        write(req)
-        write(value)
-        write(TERMINATOR)
+        write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet?
       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?)
+        req = RequestFormatter.meta_delete(key: key, cas: cas, quiet: quiet?)
         write(req)
         @connection_manager.flush unless quiet?
         response_processor.meta_delete unless quiet?
@@ -197,11 +174,15 @@ module Dalli
       # Pipelined delete - writes a quiet delete request without reading response.
       # Used by PipelinedDeleter for bulk operations.
       def pipelined_delete(key)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_delete(key: encoded_key, base64: base64, quiet: true)
+        req = RequestFormatter.meta_delete(key: key, quiet: true)
         write(req)
       end
 
+      def finish_pipelined_delete(sent)
+        write_noop
+        sent - response_processor.pipelined_delete_non_deletions
+      end
+
       # Arithmetic Commands
       def decr(key, count, ttl, initial)
         decr_incr false, key, count, ttl, initial
@@ -213,9 +194,8 @@ module Dalli
 
       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))
+        write(RequestFormatter.meta_arithmetic(key: key, delta: delta, initial: initial, incr: incr, ttl: ttl,
+                                               quiet: quiet?))
         @connection_manager.flush unless quiet?
         response_processor.decr_incr unless quiet?
       end
@@ -235,26 +215,22 @@ module Dalli
       end
 
       def stats(info = nil)
-        write(RequestFormatter.stats(info))
-        @connection_manager.flush
+        flushed_write(RequestFormatter.stats(info))
         response_processor.stats
       end
 
       def reset_stats
-        write(RequestFormatter.stats('reset'))
-        @connection_manager.flush
+        flushed_write(RequestFormatter.stats('reset'))
         response_processor.reset
       end
 
       def version
-        write(RequestFormatter.version)
-        @connection_manager.flush
+        flushed_write(RequestFormatter.version)
         response_processor.version
       end
 
       def write_noop
-        write(RequestFormatter.meta_noop)
-        @connection_manager.flush
+        flushed_write(RequestFormatter.meta_noop)
       end
 
       # Single-server fast path for get_multi. Inlines request formatting and
@@ -262,17 +238,9 @@ module Dalli
       # 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
-
+        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw)
+        flushed_write(buffer)
+        buffer.clear
         read_multi_get_responses(is_raw)
       end
 
@@ -295,7 +263,8 @@ module Dalli
         raw_key = tokens[key_index]
         return unless raw_key
 
-        key = KeyRegularizer.decode(raw_key[1..], tokens.include?('b'))
+        key = raw_key[1..]
+        key = KeyRegularizer.decode(key) if tokens.include?('b')
         bitflags = is_raw ? 0 : response_processor.bitflags_from_tokens(tokens)
         [key, @value_marshaller.retrieve(value, bitflags)]
       end
@@ -304,33 +273,23 @@ module Dalli
       # 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)
+        entries = pairs.map do |key, raw_value|
+          [key, @value_marshaller.store(key, raw_value, req_options)]
         end
-        write_noop
+
+        buffer = RequestFormatter.multi_meta_set(entries, ttl: ttl)
+        flushed_write(buffer)
+        buffer.clear
         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
+        buffer = RequestFormatter.multi_meta_delete(keys)
+        flushed_write(buffer)
+        buffer.clear
+        keys.size - response_processor.pipelined_delete_non_deletions
       end
 
       require_relative 'key_regularizer'

data/lib/dalli/protocol/request_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 
 module Dalli
   module Protocol
@@ -7,14 +7,13 @@ module Dalli
       # Class that encapsulates logic for formatting meta protocol requests
       # to memcached.
       ##
-      class RequestFormatter
+      module RequestFormatter
+        extend self
+
         # 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/ParameterLists
-        # rubocop:disable Metrics/PerceivedComplexity
         #
         # Meta get flags:
         #
@@ -35,16 +34,15 @@ module Dalli
         # - Z: Client lost the recache race (another client is already regenerating)
         # - h0/h1: Hit status (0 = first access, 1 = previously accessed)
         # - l<N>: Seconds since last access
-        def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false,
-                          vivify_ttl: nil, recache_ttl: nil,
-                          return_hit_status: false, return_last_access: false, skip_lru_bump: false,
-                          skip_flags: false)
-          cmd = "mg #{key}"
+        def meta_get(key:, value: true, return_cas: false, ttl: nil, quiet: false,
+                     vivify_ttl: nil, recache_ttl: nil,
+                     return_hit_status: false, return_last_access: false, skip_lru_bump: false,
+                     skip_flags: false)
+          cmd = "mg #{encoded_key(key)}"
           # In raw mode (skip_flags: true), we don't request bitflags since they're not used.
           # This saves 2 bytes per request and skips parsing on response.
           cmd << (skip_flags ? ' v' : ' 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 << " N#{vivify_ttl}" if vivify_ttl # Thundering herd: vivify on miss
@@ -52,12 +50,27 @@ module Dalli
           cmd << ' h' if return_hit_status # Return hit status (0 or 1)
           cmd << ' l' if return_last_access # Return seconds since last access
           cmd << ' u' if skip_lru_bump # Don't bump LRU or update access stats
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
 
-        def self.meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, base64: false, quiet: false)
+        def multi_meta_get(keys, skip_flags: false)
+          # 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 = skip_flags ? " v k q s\r\n" : " v f k q s\r\n"
+          buffer = ''.b
+          keys.each do |key|
+            buffer << 'mg ' << encoded_key(key) << post_get
+          end
+          buffer << 'mn' << TERMINATOR
+        end
+
+        def meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, quiet: false)
+          base64 = KeyRegularizer.required?(key)
+          key = KeyRegularizer.encode(key) if base64
           cmd = "ms #{key} #{value.bytesize}"
-          cmd << ' c' unless %i[append prepend].include?(mode)
+          # Skip the cas-return flag in quiet mode: the response is suppressed,
+          # so requesting it only adds bytes to the request.
+          cmd << ' c' if !quiet && !%i[append prepend].include?(mode)
           cmd << ' b' if base64
           cmd << " F#{bitflags}" if bitflags
           cmd << cas_string(cas)
@@ -67,22 +80,46 @@ module Dalli
           cmd << TERMINATOR
         end
 
+        def multi_meta_set(entries, ttl: nil)
+          buffer = ''.b
+          entries.each do |key, pair|
+            value, bitflags = pair
+
+            base64 = KeyRegularizer.required?(key)
+            key = KeyRegularizer.encode(key) if base64
+
+            # Inline format: "ms <key> <size> c [b] F<flags> T<ttl> MS q\r\n"
+            buffer << "ms #{key} #{value.bytesize} c"
+            buffer << ' b' if base64
+            buffer << " F#{bitflags}" if bitflags
+            buffer << " T#{ttl}" if ttl
+            buffer << ' MS q' << TERMINATOR << value << TERMINATOR
+          end
+          buffer << META_NOOP
+        end
+
         # Thundering herd protection flag:
         # - stale (I flag): Instead of deleting the item, mark it as stale. Other clients
         #   using N/R flags will see the X flag and know the item is being regenerated.
-        def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false, stale: false)
-          cmd = "md #{key}"
-          cmd << ' b' if base64
+        def meta_delete(key:, cas: nil, ttl: nil, quiet: false, stale: false)
+          cmd = "md #{encoded_key(key)}"
           cmd << cas_string(cas)
           cmd << " T#{ttl}" if ttl
           cmd << ' I' if stale # Mark stale instead of deleting
           cmd << ' q' if quiet
-          cmd + TERMINATOR
+          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
+        def multi_meta_delete(keys)
+          buffer = ''.b
+          keys.each do |key|
+            buffer << 'md ' << encoded_key(key) << ' q' << TERMINATOR
+          end
+          buffer << META_NOOP
+        end
+
+        def meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, quiet: false)
+          cmd = "ma #{encoded_key(key)} v"
           cmd << " D#{delta}" if delta
           cmd << " J#{initial}" if initial
           # Always set a TTL if an initial value is specified
@@ -90,38 +127,49 @@ module Dalli
           cmd << cas_string(cas)
           cmd << ' q' if quiet
           cmd << " M#{incr ? 'I' : 'D'}"
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/ParameterLists
         # rubocop:enable Metrics/PerceivedComplexity
 
-        def self.meta_noop
-          "mn#{TERMINATOR}"
+        META_NOOP = "mn#{TERMINATOR}".freeze
+        def meta_noop
+          META_NOOP
         end
 
-        def self.version
+        def version
           "version#{TERMINATOR}"
         end
 
-        def self.flush(delay: nil, quiet: false)
+        def flush(delay: nil, quiet: false)
           cmd = +'flush_all'
           cmd << " #{parse_to_64_bit_int(delay, 0)}" if delay
           cmd << ' noreply' if quiet
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
 
         ALLOWED_STATS_ARGS = [nil, '', 'items', 'slabs', 'settings', 'reset'].freeze
 
-        def self.stats(arg = nil)
+        def stats(arg = nil)
           raise ArgumentError, "Invalid stats argument: #{arg.inspect}" unless ALLOWED_STATS_ARGS.include?(arg)
 
           cmd = +'stats'
           cmd << " #{arg}" if arg && !arg.empty?
-          cmd + TERMINATOR
+          cmd << TERMINATOR
+        end
+
+        def encoded_key(key)
+          if KeyRegularizer.required?(key)
+            KeyRegularizer.encode(key) << ' b'
+          else
+            key
+          end
         end
 
-        def self.mode_to_token(mode)
+        private
+
+        def mode_to_token(mode)
           case mode
           when :add
             'E'
@@ -136,12 +184,12 @@ module Dalli
           end
         end
 
-        def self.cas_string(cas)
+        def cas_string(cas)
           cas = parse_to_64_bit_int(cas, nil)
           cas.nil? || cas.zero? ? '' : " C#{cas}"
         end
 
-        def self.parse_to_64_bit_int(val, default)
+        def parse_to_64_bit_int(val, default)
           val.nil? ? nil : Integer(val)
         rescue ArgumentError
           # Sanitize to default if it isn't parsable as an integer

data/lib/dalli/protocol/response_buffer.rb

@@ -5,16 +5,16 @@ require 'timeout'
 
 module Dalli
   module Protocol
+    # Compact the buffer when the consumed portion exceeds this
+    # threshold and represents more than half the buffer
+    COMPACT_THRESHOLD = 4096
+
     ##
     # 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
@@ -23,22 +23,32 @@ module Dalli
       end
 
       def read
-        @buffer << @io_source.read_nonblock
+        remaining_bytes = @buffer.bytesize - @offset
+        if remaining_bytes.zero?
+          @offset = 0
+          @buffer = @io_source.read_available(@buffer)
+        else
+          if @offset > COMPACT_THRESHOLD && @offset > (@buffer.bytesize / 2)
+            @buffer.bytesplice(0, @offset, '')
+            @offset = 0
+          end
+          @buffer << @io_source.read_available
+        end
       end
 
       # 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, @offset)
-        @offset += bytes
-        compact_if_needed
-        [status, cas, key, value]
+        response = @response_processor.getk_response_from_buffer(@buffer, @offset)
+        @offset += response.pop
+        response
       end
 
       # Resets the internal buffer to an empty state,
       # so that we're ready to read pipelined responses
       def reset
-        @buffer = ''.b
+        @buffer&.clear
+        @buffer ||= ''.b
         @offset = 0
       end
 
@@ -54,6 +64,7 @@ module Dalli
 
       # Clear the internal response buffer
       def clear
+        @buffer&.clear
         @buffer = nil
         @offset = 0
       end
@@ -61,18 +72,6 @@ module Dalli
       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