dalli 5.0.10 → 5.1.0

data/lib/dalli/protocol/connection_manager.rb

@@ -35,10 +35,7 @@ module Dalli
         @request_in_progress = false
         @sock = nil
         @pid = nil
-        @write_buffer = []
-        @write_buffer_bytes = 0
 
-        @fail_count = 0
         reset_down_info
       end
 
@@ -54,8 +51,7 @@ module Dalli
         Dalli.logger.debug { "Dalli::Server#connect #{name}" }
 
         @sock = memcached_socket
-        # Writes are buffered in @write_buffer instead; see WRITE_BUFFER_FLUSH_BYTES
-        @sock.sync = true
+        @sock.sync = false # Enable buffered I/O for better performance
         @pid = Process.pid
         @request_in_progress = false
       rescue SystemCallError, *TIMEOUT_ERRORS, EOFError, SocketError => e
@@ -87,8 +83,6 @@ module Dalli
       def down!
         close
         log_down_detected
-        # Once down_retry_delay passes, the server gets a full set of attempts
-        @fail_count = 0
 
         @error = $ERROR_INFO&.class&.name
         @msg ||= $ERROR_INFO&.message
@@ -118,7 +112,7 @@ module Dalli
         return unless @sock
 
         begin
-          close_socket
+          @sock.close
         rescue StandardError
           nil
         ensure
@@ -129,18 +123,10 @@ module Dalli
           # @request_in_progress == true.
           @sock = nil
           @pid = nil
-          discard_write_buffer
           abort_request!
         end
       end
 
-      # A forked child shares the parent's connection, so it closes only its
-      # own file descriptor. Closing the TLS socket itself would send
-      # close_notify and end the parent's TLS session.
-      def close_socket
-        fork_detected? ? @sock.to_io.close : @sock.close
-      end
-
       def connected?
         !@sock.nil?
       end
@@ -159,11 +145,6 @@ module Dalli
         raise '[Dalli] No request in progress. This may be a bug in Dalli.' unless @request_in_progress
 
         @request_in_progress = false
-        # A completed request is what proves the server healthy again, so the
-        # failure count resets here rather than on reconnect: a server that
-        # accepts connections but never answers would otherwise reset it on
-        # every retry and never reach socket_max_failures.
-        @fail_count = 0
       end
 
       def abort_request!
@@ -171,7 +152,6 @@ module Dalli
       end
 
       def read_line
-        flush_write_buffer
         data = @sock.gets("\r\n")
         error_on_request!('EOF in read_line') if data.nil?
         data
@@ -181,29 +161,14 @@ module Dalli
 
       # JRuby doesn't support IO#timeout=, so use custom readfull implementation
       # CRuby 3.3+ has IO#timeout= which makes IO#read work with timeouts
-      # memcached can't store an item larger than 1 GiB (its -I maximum), so a
-      # reply claiming more (or a negative size) is malformed or hostile.
-      # IO#read allocates the full count up front, so check before reading.
-      MAX_READ_BYTES = (1024 * 1024 * 1024) + 2 # plus the value's trailing "\r\n"
-
-      def check_read_size!(count)
-        return if count.between?(0, MAX_READ_BYTES)
-
-        raise Dalli::DalliError, "Reply size #{count} from #{name} is out of range"
-      end
-
       if RUBY_ENGINE == 'jruby'
         def read(count)
-          check_read_size!(count)
-          flush_write_buffer
           @sock.readfull(count)
         rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
           error_on_request!(e)
         end
       else
         def read(count)
-          check_read_size!(count)
-          flush_write_buffer
           read_bytes(count)
         rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
           error_on_request!(e)
@@ -214,34 +179,22 @@ module Dalli
       # at the call site.
       alias read_exact read
 
-      # Requests are buffered here rather than in the socket's own IO buffer
-      # (the socket is sync). Ruby flushes an IO's write buffer when any process
-      # holding it closes or finalizes the IO, so after a fork a child could
-      # send bytes the parent had buffered but not sent yet: a quiet write would
-      # run twice, or the parent's replies would shift onto the wrong requests.
-      # A forked child discards this buffer instead. Like IO's own buffer, it
-      # is sent once it grows past this size, or when a reply is read.
-      WRITE_BUFFER_FLUSH_BYTES = 64 * 1024
-
       def write(bytes)
-        @write_buffer << bytes
-        @write_buffer_bytes += bytes.bytesize
-        flush_write_buffer if @write_buffer_bytes >= WRITE_BUFFER_FLUSH_BYTES
-        bytes.bytesize
+        @sock.write(bytes)
       rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, IOError => e
         error_on_request!(e)
       end
 
       def flush
-        flush_write_buffer
+        @sock.flush
       rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, IOError => e
         error_on_request!(e)
       end
 
       def flushed_write(bytes)
-        @write_buffer << bytes
-        flush_write_buffer
-        bytes.bytesize
+        written = @sock.write(bytes)
+        @sock.flush
+        written
       rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, IOError => e
         error_on_request!(e)
       end
@@ -249,7 +202,6 @@ module Dalli
       # Non-blocking read.  Here to support the operation
       # of the get_multi operation
       def read_available(...)
-        flush_write_buffer
         @sock.read_available(...)
       end
 
@@ -276,9 +228,8 @@ module Dalli
         raise Dalli::RetryableNetworkError, message
       end
 
-      # Called on connect. Deliberately leaves @fail_count alone; see
-      # finish_request!.
       def reset_down_info
+        @fail_count = 0
         @down_at = nil
         @last_down_at = nil
         @msg = nil
@@ -303,8 +254,7 @@ module Dalli
       def reconnect_on_fork
         message = 'Fork detected, re-connecting child process...'
         Dalli.logger.info { message }
-        # Drops anything the parent had buffered, closes the inherited socket
-        # without touching the parent's connection, and reconnects immediately
+        # Close socket on a fork and reconnect immediately
         close
         establish_connection
       end
@@ -334,37 +284,6 @@ module Dalli
 
       private
 
-      # One write per flush. A TLS socket sends each argument of
-      # write(*parts) as its own record and system call, so the parts are
-      # joined first.
-      def flush_write_buffer
-        return if @write_buffer.empty?
-
-        @sock.write(@write_buffer.size == 1 ? @write_buffer.first : joined_write_buffer)
-        discard_write_buffer
-      end
-
-      # Joined as bytes: requests can mix UTF-8 and binary strings, which
-      # String#<< refuses to combine when both hold non-ASCII bytes
-      if String.method_defined?(:append_as_bytes)
-        def joined_write_buffer
-          out = String.new(capacity: @write_buffer_bytes, encoding: Encoding::BINARY)
-          @write_buffer.each { |part| out.append_as_bytes(part) }
-          out
-        end
-      else
-        def joined_write_buffer
-          out = String.new(capacity: @write_buffer_bytes, encoding: Encoding::BINARY)
-          @write_buffer.each { |part| out << part.b }
-          out
-        end
-      end
-
-      def discard_write_buffer
-        @write_buffer.clear
-        @write_buffer_bytes = 0
-      end
-
       # Reads exactly `count` bytes. IO#read(count) on a blocking socket blocks
       # until it has `count` bytes, accumulating across TCP chunks internally,
       # and only hands back a shorter (or nil) buffer when the stream hits EOF.

data/lib/dalli/protocol/key_regularizer.rb

@@ -12,8 +12,25 @@ module Dalli
       module KeyRegularizer
         module_function
 
+        # protocol.txt requires that a key "must not include control
+        # characters or whitespace" -- \p{Cntrl} is C0 (0x00-0x1F) plus DEL
+        # (0x7F). \s alone misses NUL and the rest of that range: a key
+        # containing one of those bytes but no whitespace is ASCII-only, so
+        # it would otherwise be written to the wire unencoded. Not a
+        # protocol-injection risk (the text protocol splits on CRLF, not
+        # other control bytes), but a downstream consumer that treats the key
+        # specially at one of those bytes (a C string terminating at NUL, a
+        # terminal or log line interpreting an escape byte) could silently
+        # act on a different key than Dalli believes it sent.
+        #
+        # Written as \p{Cntrl} rather than the POSIX [:cntrl:] bracket class:
+        # \s and [:cntrl:] overlap (tab, newline, CR are in both), and Ruby
+        # warns "character class has duplicated range" when they're combined
+        # in one -- fatal here, since this suite's -w run treats warnings as
+        # errors (see test_strict_warnings.rb). \p{Cntrl} matches the same
+        # bytes without the overlap warning.
         def required?(key)
-          !key.ascii_only? || /\s/.match?(key)
+          !key.ascii_only? || /[\p{Cntrl}\s]/.match?(key)
         end
 
         def encode(key)

data/lib/dalli/protocol/meta.rb

@@ -26,22 +26,23 @@ module Dalli
       def get(key, options = nil)
         # 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: key, skip_flags: skip_flags)
+        req = RequestFormatter.meta_get(key: key, skip_flags: skip_flags, **routing_token_kwargs(options))
         flushed_write(req)
-        response_processor.meta_get_with_value(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
-      def quiet_get_request(key)
+      def quiet_get_request(key, options = nil)
         # Skip bitflags in raw mode - saves 2 bytes per request and skips parsing
-        RequestFormatter.meta_get(key: key, return_cas: true, quiet: true, skip_flags: raw_mode?)
+        RequestFormatter.meta_get(key: key, return_cas: true, quiet: true, skip_flags: raw_mode?,
+                                  **routing_token_kwargs(options))
       end
 
       def gat(key, ttl, options = nil)
         ttl = TtlSanitizer.sanitize(ttl)
         skip_flags = raw_mode? || (options && options[:raw])
-        req = RequestFormatter.meta_get(key: key, ttl: ttl, skip_flags: skip_flags)
+        req = RequestFormatter.meta_get(key: key, ttl: ttl, skip_flags: skip_flags, **routing_token_kwargs(options))
         flushed_write(req)
-        response_processor.meta_get_with_value(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
@@ -54,9 +55,9 @@ module Dalli
       # TODO: This is confusing, as there's a cas command in memcached
       # and this isn't it.  Maybe rename?  Maybe eliminate?
       def cas(key, options = nil)
-        req = RequestFormatter.meta_get(key: key, value: true, return_cas: true, skip_flags: raw_request?(options))
+        req = RequestFormatter.meta_get(key: key, value: true, return_cas: true, **routing_token_kwargs(options))
         flushed_write(req)
-        response_processor.meta_get_with_value_and_cas(raw: raw_request?(options))
+        response_processor.meta_get_with_value_and_cas
       end
 
       # Comprehensive meta get with support for all metadata flags.
@@ -85,15 +86,19 @@ module Dalli
       #   - :last_access - seconds since last access (only if return_last_access: true)
       def meta_get(key, options = {})
         req = RequestFormatter.meta_get(
-          key: key, value: true, return_cas: true, skip_flags: raw_request?(options),
+          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]
+          return_last_access: options[:return_last_access],
+          return_ttl_remaining: options[:return_ttl_remaining],
+          skip_lru_bump: options[:skip_lru_bump],
+          **routing_token_kwargs(options)
         )
         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], raw: raw_request?(options)
+          return_last_access: options[:return_last_access],
+          return_ttl_remaining: options[:return_ttl_remaining]
         )
       end
 
@@ -137,34 +142,41 @@ module Dalli
         ttl = TtlSanitizer.sanitize(ttl) if ttl
         req = RequestFormatter.meta_set(key: key, value: value,
                                         bitflags: bitflags, cas: cas,
-                                        ttl: ttl, mode: mode, quiet: quiet)
+                                        ttl: ttl, mode: mode, quiet: quiet,
+                                        **routing_token_kwargs(options))
         write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet
       end
       # rubocop:enable Metrics/ParameterLists
 
-      def append(key, value)
-        write_append_prepend_req(:append, key, value)
+      def append(key, value, options = nil)
+        write_append_prepend_req(:append, key, value, nil, nil, options)
         response_processor.meta_set_append_prepend unless quiet?
       end
 
-      def prepend(key, value)
-        write_append_prepend_req(:prepend, key, value)
+      def prepend(key, value, options = nil)
+        write_append_prepend_req(:prepend, key, value, nil, nil, options)
         response_processor.meta_set_append_prepend unless quiet?
       end
 
-      # rubocop:disable-next Metrics/ParameterLists
-      def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, _options = {})
+      # rubocop:disable Metrics/ParameterLists
+      def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, options = nil)
         ttl = TtlSanitizer.sanitize(ttl) if ttl
         req = RequestFormatter.meta_set(key: key, value: value,
-                                        cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
+                                        cas: cas, ttl: ttl, mode: mode, quiet: quiet?,
+                                        **routing_token_kwargs(options))
         write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet?
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # Delete Commands
-      def delete(key, cas)
-        req = RequestFormatter.meta_delete(key: key, cas: cas, quiet: quiet?)
+      #
+      # `options` supports the meta-delete keys :invalidate, :tombstone_ttl and
+      # :drop_value, plus :p_token/:l_token; see Dalli::Client#delete.
+      def delete(key, cas, options = nil)
+        req = RequestFormatter.meta_delete(key: key, cas: cas, quiet: quiet?,
+                                           **tombstone_kwargs(options), **routing_token_kwargs(options))
         write(req)
         @connection_manager.flush unless quiet?
         response_processor.meta_delete unless quiet?
@@ -172,8 +184,9 @@ module Dalli
 
       # Pipelined delete - writes a quiet delete request without reading response.
       # Used by PipelinedDeleter for bulk operations.
-      def pipelined_delete(key)
-        req = RequestFormatter.meta_delete(key: key, quiet: true)
+      def pipelined_delete(key, req_options = nil)
+        req = RequestFormatter.meta_delete(key: key, quiet: true,
+                                           **tombstone_kwargs(req_options), **routing_token_kwargs(req_options))
         write(req)
       end
 
@@ -183,21 +196,23 @@ module Dalli
       end
 
       # Arithmetic Commands
-      def decr(key, count, ttl, initial)
-        decr_incr false, key, count, ttl, initial
+      def decr(key, count, ttl, initial, options = nil)
+        decr_incr false, key, count, ttl, initial, options
       end
 
-      def incr(key, count, ttl, initial)
-        decr_incr true, key, count, ttl, initial
+      def incr(key, count, ttl, initial, options = nil)
+        decr_incr true, key, count, ttl, initial, options
       end
 
-      def decr_incr(incr, key, delta, ttl, initial)
+      # rubocop:disable Metrics/ParameterLists
+      def decr_incr(incr, key, delta, ttl, initial, options = nil)
         ttl = initial ? TtlSanitizer.sanitize(ttl) : nil # Only set a TTL if we want to set a value on miss
         write(RequestFormatter.meta_arithmetic(key: key, delta: delta, initial: initial, incr: incr, ttl: ttl,
-                                               quiet: quiet?))
+                                               quiet: quiet?, **routing_token_kwargs(options)))
         @connection_manager.flush unless quiet?
         response_processor.decr_incr unless quiet?
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # Other Commands
       def flush(delay = 0)
@@ -235,14 +250,52 @@ module Dalli
       # 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)
+      def read_multi_req(keys, options = nil)
         is_raw = raw_mode?
-        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw)
+        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw, **routing_token_kwargs(options))
         flushed_write(buffer)
         buffer.clear
         read_multi_get_responses(is_raw)
       end
 
+      # Stale-aware bulk get.  Returns { key => { value:, cas:, stale:, miss: } }
+      # for the keys the server returned.  Keys that were not found are absent
+      # from the hash, matching read_multi_req and the get_multi family; a
+      # tombstoned item is present (it answers VA with the X flag) with
+      # stale: true, which is the distinction callers need.
+      #
+      # Shared by both the single-server fast path and PipelinedGetter's
+      # per-server-group request, so this one change covers both routes.
+      def read_multi_with_metadata_req(keys, options = nil)
+        is_raw = raw_mode?
+        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw, return_cas: true,
+                                                       **routing_token_kwargs(options))
+        flushed_write(buffer)
+        buffer.clear
+        read_multi_metadata_responses(is_raw)
+      end
+
+      # Unlike read_multi_get_responses this locates tokens by flag rather than
+      # by position, because the c flag shifts the key's index.
+      def read_multi_metadata_responses(is_raw)
+        hash = {}
+        while (line = @connection_manager.read_line)
+          break if line.start_with?('MN')
+          next unless line.start_with?('VA ')
+
+          tokens = line.chomp!(TERMINATOR).split
+          value = @connection_manager.read(tokens[1].to_i + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+          stale = response_processor.stale_from_tokens(tokens)
+          cas = response_processor.cas_from_tokens(tokens)
+          bitflags = is_raw ? 0 : response_processor.bitflags_from_tokens(tokens)
+          key = response_processor.key_from_tokens(tokens)
+          next if key.nil?
+
+          hash[key] = { value: @value_marshaller.retrieve(value, bitflags), cas: cas, stale: stale, miss: false }
+        end
+        hash
+      end
+
       def read_multi_get_responses(is_raw)
         hash = {}
         key_index = is_raw ? 2 : 3
@@ -258,9 +311,7 @@ module Dalli
 
       def parse_multi_get_value(line, key_index, is_raw)
         tokens = line.chomp!(TERMINATOR).split
-        size = tokens[1].to_i
-        response_processor.check_value_size!(size)
-        value = @connection_manager.read(size + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+        value = @connection_manager.read(tokens[1].to_i + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
         raw_key = tokens[key_index]
         return unless raw_key
 
@@ -278,7 +329,7 @@ module Dalli
           [key, @value_marshaller.store(key, raw_value, req_options)]
         end
 
-        buffer = RequestFormatter.multi_meta_set(entries, ttl: ttl)
+        buffer = RequestFormatter.multi_meta_set(entries, ttl: ttl, **routing_token_kwargs(req_options))
         flushed_write(buffer)
         buffer.clear
         response_processor.consume_all_responses_until_mn
@@ -286,8 +337,9 @@ module Dalli
 
       # 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)
-        buffer = RequestFormatter.multi_meta_delete(keys)
+      def delete_multi_req(keys, req_options = nil)
+        buffer = RequestFormatter.multi_meta_delete(keys, **tombstone_kwargs(req_options),
+                                                    **routing_token_kwargs(req_options))
         flushed_write(buffer)
         buffer.clear
         keys.size - response_processor.pipelined_delete_non_deletions