dalli 3.2.8 → 4.3.3

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

@@ -189,16 +189,6 @@ module Dalli
           [resp_header.status, content]
         end
 
-        def contains_header?(buf)
-          return false unless buf
-
-          buf.bytesize >= ResponseHeader::SIZE
-        end
-
-        def response_header_from_buffer(buf)
-          ResponseHeader.new(buf)
-        end
-
         ##
         # This method returns an array of values used in a pipelined
         # getk process.  The first value is the number of bytes by
@@ -209,11 +199,11 @@ module Dalli
         # The remaining three values in the array are the ResponseHeader,
         # key, and value.
         ##
-        def getk_response_from_buffer(buf)
+        def getk_response_from_buffer(buf, offset = 0)
           # There's no header in the buffer, so don't advance
-          return [0, nil, nil, nil, nil] unless contains_header?(buf)
+          return [0, nil, nil, nil, nil] unless buf && buf.bytesize >= offset + ResponseHeader::SIZE
 
-          resp_header = response_header_from_buffer(buf)
+          resp_header = ResponseHeader.new(buf.byteslice(offset, ResponseHeader::SIZE))
           body_len = resp_header.body_len
 
           # We have a complete response that has no body.
@@ -225,11 +215,11 @@ module Dalli
           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, 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.byteslice(ResponseHeader::SIZE, body_len)
+          body = buf.byteslice(offset + ResponseHeader::SIZE, body_len)
           key, value = unpack_response_body(resp_header, body, true)
           [resp_size, resp_header.ok?, resp_header.cas, key, value]
         end

data/lib/dalli/protocol/binary.rb

@@ -22,6 +22,7 @@ module Dalli
       def get(key, options = nil)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
+        @connection_manager.flush
         response_processor.get(cache_nils: cache_nils?(options))
       end
 
@@ -33,12 +34,14 @@ module Dalli
         ttl = TtlSanitizer.sanitize(ttl)
         req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
         write(req)
+        @connection_manager.flush
         response_processor.get(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
         ttl = TtlSanitizer.sanitize(ttl)
         write(RequestFormatter.standard_request(opkey: :touch, key: key, ttl: ttl))
+        @connection_manager.flush
         response_processor.generic_response
       end
 
@@ -47,6 +50,7 @@ module Dalli
       def cas(key)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
+        @connection_manager.flush
         response_processor.data_cas_response
       end
 
@@ -56,6 +60,12 @@ module Dalli
         storage_req(opkey, key, value, ttl, cas, options)
       end
 
+      # Pipelined set - writes a quiet set request without reading response.
+      # Used by PipelinedSetter for bulk operations.
+      def pipelined_set(key, value, ttl, options)
+        storage_req(:setq, key, value, ttl, 0, options)
+      end
+
       def add(key, value, ttl, options)
         opkey = quiet? ? :addq : :add
         storage_req(opkey, key, value, ttl, 0, options)
@@ -75,6 +85,7 @@ module Dalli
                                                 value: value, bitflags: bitflags,
                                                 ttl: ttl, cas: cas)
         write(req)
+        @connection_manager.flush unless quiet?
         response_processor.storage_response unless quiet?
       end
       # rubocop:enable Metrics/ParameterLists
@@ -91,6 +102,7 @@ module Dalli
 
       def write_append_prepend(opkey, key, value)
         write(RequestFormatter.standard_request(opkey: opkey, key: key, value: value))
+        @connection_manager.flush unless quiet?
         response_processor.no_body_response unless quiet?
       end
 
@@ -99,9 +111,17 @@ module Dalli
         opkey = quiet? ? :deleteq : :delete
         req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
         write(req)
+        @connection_manager.flush unless quiet?
         response_processor.delete unless quiet?
       end
 
+      # Pipelined delete - writes a quiet delete request without reading response.
+      # Used by PipelinedDeleter for bulk operations.
+      def pipelined_delete(key)
+        req = RequestFormatter.standard_request(opkey: :deleteq, key: key, cas: 0)
+        write(req)
+      end
+
       # Arithmetic Commands
       def decr(key, count, ttl, initial)
         opkey = quiet? ? :decrq : :decr
@@ -119,12 +139,14 @@ module Dalli
       # if the key doesn't already exist, rather than
       # setting the initial value
       NOT_FOUND_EXPIRY = 0xFFFFFFFF
+      private_constant :NOT_FOUND_EXPIRY
 
       def decr_incr(opkey, key, count, ttl, initial)
         expiry = initial ? TtlSanitizer.sanitize(ttl) : NOT_FOUND_EXPIRY
         initial ||= 0
         write(RequestFormatter.decr_incr_request(opkey: opkey, key: key,
                                                  count: count, initial: initial, expiry: expiry))
+        @connection_manager.flush unless quiet?
         response_processor.decr_incr unless quiet?
       end
 
@@ -132,6 +154,7 @@ module Dalli
       def flush(ttl = 0)
         opkey = quiet? ? :flushq : :flush
         write(RequestFormatter.standard_request(opkey: opkey, ttl: ttl))
+        @connection_manager.flush unless quiet?
         response_processor.no_body_response unless quiet?
       end
 
@@ -145,22 +168,26 @@ module Dalli
       def stats(info = '')
         req = RequestFormatter.standard_request(opkey: :stat, key: info)
         write(req)
+        @connection_manager.flush
         response_processor.stats
       end
 
       def reset_stats
         write(RequestFormatter.standard_request(opkey: :stat, key: 'reset'))
+        @connection_manager.flush
         response_processor.reset
       end
 
       def version
         write(RequestFormatter.standard_request(opkey: :version))
+        @connection_manager.flush
         response_processor.version
       end
 
       def write_noop
         req = RequestFormatter.standard_request(opkey: :noop)
         write(req)
+        @connection_manager.flush
       end
 
       require_relative 'binary/request_formatter'

data/lib/dalli/protocol/connection_manager.rb

@@ -53,6 +53,7 @@ module Dalli
         Dalli.logger.debug { "Dalli::Server#connect #{name}" }
 
         @sock = memcached_socket
+        @sock.sync = false # Enable buffered I/O for better performance
         @pid = PIDCache.pid
         @request_in_progress = false
       rescue SystemCallError, *TIMEOUT_ERRORS, EOFError, SocketError => e
@@ -100,13 +101,13 @@ module Dalli
 
       def confirm_ready!
         close if request_in_progress?
-        close_on_fork if fork_detected?
+        reconnect_on_fork if fork_detected?
       end
 
       def confirm_in_progress!
         raise '[Dalli] No request in progress. This may be a bug in Dalli.' unless request_in_progress?
 
-        close_on_fork if fork_detected?
+        reconnect_on_fork if fork_detected?
       end
 
       def close
@@ -150,19 +151,25 @@ module Dalli
         data = @sock.gets("\r\n")
         error_on_request!('EOF in read_line') if data.nil?
         data
-      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
+      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
         error_on_request!(e)
       end
 
       def read(count)
         @sock.readfull(count)
-      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
+      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
         error_on_request!(e)
       end
 
       def write(bytes)
         @sock.write(bytes)
-      rescue SystemCallError, *TIMEOUT_ERRORS => e
+      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS => e
+        error_on_request!(e)
+      end
+
+      def flush
+        @sock.flush
+      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS => e
         error_on_request!(e)
       end
 
@@ -192,7 +199,7 @@ module Dalli
       def reconnect!(message)
         close
         sleep(options[:socket_failure_delay]) if options[:socket_failure_delay]
-        raise Dalli::NetworkError, message
+        raise Dalli::RetryableNetworkError, message
       end
 
       def reset_down_info
@@ -212,20 +219,18 @@ module Dalli
       end
 
       def log_warn_message(err_or_string)
-        detail = err_or_string.is_a?(String) ? err_or_string : "#{err_or_string.class}: #{err_or_string.message}"
         Dalli.logger.warn do
           detail = err_or_string.is_a?(String) ? err_or_string : "#{err_or_string.class}: #{err_or_string.message}"
           "#{name} failed (count: #{@fail_count}) #{detail}"
         end
       end
 
-      def close_on_fork
+      def reconnect_on_fork
         message = 'Fork detected, re-connecting child process...'
         Dalli.logger.info { message }
-        # Close socket on a fork, setting us up for reconnect
-        # on next request.
+        # Close socket on a fork and reconnect immediately
         close
-        raise Dalli::NetworkError, message
+        establish_connection
       end
 
       def fork_detected?

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

@@ -10,7 +10,7 @@ module Dalli
       # 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
+        WHITESPACE = /\s/
 
         def self.encode(key)
           return [key, false] if key.ascii_only? && !WHITESPACE.match(key)

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

@@ -13,16 +13,45 @@ module Dalli
         # 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)
+        #
+        # Meta get flags:
+        #
+        # Thundering herd protection:
+        # - vivify_ttl (N flag): On miss, create a stub item and return W flag. The TTL
+        #   specifies how long the stub lives. Other clients see X (stale) and Z (lost race).
+        # - recache_ttl (R flag): If item's remaining TTL is below this threshold, return W
+        #   flag to indicate this client should recache. Other clients get Z (lost race).
+        #
+        # Metadata flags:
+        # - return_hit_status (h flag): Return whether item has been hit before (0 or 1)
+        # - return_last_access (l flag): Return seconds since item was last accessed
+        # - skip_lru_bump (u flag): Don't bump item in LRU, don't update hit status or last access
+        #
+        # Response flags (parsed by response processor):
+        # - W: Client won the right to recache this item
+        # - X: Item is stale (another client is regenerating)
+        # - 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}"
-          cmd << ' v f' if value
+          # 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
+          cmd << " R#{recache_ttl}" if recache_ttl # Thundering herd: win recache if TTL below threshold
+          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
         end
 
@@ -36,15 +65,17 @@ module Dalli
           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)
+        # 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
           cmd << cas_string(cas)
           cmd << " T#{ttl}" if ttl
+          cmd << ' I' if stale # Mark stale instead of deleting
           cmd << ' q' if quiet
           cmd + TERMINATOR
         end
@@ -62,7 +93,6 @@ module Dalli
           cmd + TERMINATOR
         end
         # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/ParameterLists
         # rubocop:enable Metrics/PerceivedComplexity
 
@@ -81,13 +111,16 @@ module Dalli
           cmd + TERMINATOR
         end
 
+        ALLOWED_STATS_ARGS = [nil, '', 'items', 'slabs', 'settings', 'reset'].freeze
+
         def self.stats(arg = nil)
+          raise ArgumentError, "Invalid stats argument: #{arg.inspect}" unless ALLOWED_STATS_ARGS.include?(arg)
+
           cmd = +'stats'
-          cmd << " #{arg}" if arg
+          cmd << " #{arg}" if arg && !arg.empty?
           cmd + TERMINATOR
         end
 
-        # rubocop:disable Metrics/MethodLength
         def self.mode_to_token(mode)
           case mode
           when :add
@@ -102,7 +135,6 @@ module Dalli
             'S'
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def self.cas_string(cas)
           cas = parse_to_64_bit_int(cas, nil)

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

@@ -21,6 +21,7 @@ module Dalli
         STAT = 'STAT'
         VA = 'VA'
         VERSION = 'VERSION'
+        SERVER_ERROR = 'SERVER_ERROR'
 
         def initialize(io_source, value_marshaller)
           @io_source = io_source
@@ -32,7 +33,7 @@ module Dalli
           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))
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
         end
 
         def meta_get_with_value_and_cas
@@ -42,7 +43,7 @@ module Dalli
           cas = cas_from_tokens(tokens)
           return [nil, cas] unless tokens.first == VA
 
-          [@value_marshaller.retrieve(read_line, bitflags_from_tokens(tokens)), cas]
+          [@value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens)), cas]
         end
 
         def meta_get_without_value
@@ -50,6 +51,41 @@ module Dalli
           tokens.first == EN ? nil : true
         end
 
+        # Returns a hash with all requested metadata:
+        # - :value - the cached value (or nil if miss)
+        # - :cas - the CAS value (if return_cas was requested)
+        # - :won_recache - true if client won the right to recache (W flag)
+        # - :stale - true if the item is stale (X flag)
+        # - :lost_recache - true if another client is already recaching (Z flag)
+        # - :hit_before - true/false if item was previously accessed (h flag, if requested)
+        # - :last_access - seconds since last access (l flag, if requested)
+        #
+        # Used by meta_get for comprehensive metadata retrieval.
+        # Supports thundering herd protection (N/R flags) and metadata flags (h/l/u).
+        def meta_get_with_metadata(cache_nils: false, return_hit_status: false, return_last_access: false)
+          tokens = error_on_unexpected!([VA, EN, HD])
+          result = build_metadata_result(tokens)
+          result[:hit_before] = hit_status_from_tokens(tokens) if return_hit_status
+          result[:last_access] = last_access_from_tokens(tokens) if return_last_access
+          result[:value] = parse_value_from_tokens(tokens, cache_nils)
+          result
+        end
+
+        def build_metadata_result(tokens)
+          {
+            value: nil, cas: cas_from_tokens(tokens),
+            won_recache: tokens.include?('W'), stale: tokens.include?('X'),
+            lost_recache: tokens.include?('Z')
+          }
+        end
+
+        def parse_value_from_tokens(tokens, cache_nils)
+          return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
+          return unless tokens.first == VA
+
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
+        end
+
         def meta_set_with_cas
           tokens = error_on_unexpected!([HD, NS, NF, EX])
           return false unless tokens.first == HD
@@ -111,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]
@@ -134,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
@@ -149,27 +181,22 @@ 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
-          raise Dalli::DalliError, "Response error: #{tokens.first}" unless expected_codes.include?(tokens.first)
 
-          tokens
+          return tokens if expected_codes.include?(tokens.first)
+
+          raise Dalli::ServerError, tokens.join(' ').to_s if tokens.first == SERVER_ERROR
+
+          raise Dalli::DalliError, "Response error: #{tokens.first}"
         end
 
         def bitflags_from_tokens(tokens)
@@ -186,6 +213,21 @@ module Dalli
           KeyRegularizer.decode(encoded_key, base64_encoded)
         end
 
+        # Returns true if item was previously hit, false if first access, nil if not requested
+        # The h flag returns h0 (first access) or h1 (previously accessed)
+        def hit_status_from_tokens(tokens)
+          hit_token = tokens.find { |t| t.start_with?('h') && t.length == 2 }
+          return nil unless hit_token
+
+          hit_token[1] == '1'
+        end
+
+        # Returns seconds since last access, or nil if not requested
+        # The l flag returns l<seconds>
+        def last_access_from_tokens(tokens)
+          value_from_tokens(tokens, 'l')&.to_i
+        end
+
         def body_len_from_tokens(tokens)
           value_from_tokens(tokens, 's')&.to_i
         end
@@ -205,6 +247,10 @@ module Dalli
           line = read_line
           line&.split || []
         end
+
+        def read_data(data_size)
+          @io_source.read(data_size + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+        end
       end
     end
   end