dalli 5.0.5 → 5.1.0

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

data/lib/dalli/protocol/response_processor.rb

@@ -72,11 +72,13 @@ module Dalli
         #
         # 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)
+        def meta_get_with_metadata(cache_nils: false, return_hit_status: false, return_last_access: false,
+                                   return_ttl_remaining: false)
           tokens = error_on_unexpected!(T_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[:ttl_remaining] = ttl_remaining_from_tokens(tokens) if return_ttl_remaining
           result[:value] = parse_value_from_tokens(tokens, cache_nils)
           result
         end
@@ -85,7 +87,12 @@ module Dalli
           {
             value: nil, cas: cas_from_tokens(tokens),
             won_recache: tokens.include?('W'), stale: tokens.include?('X'),
-            lost_recache: tokens.include?('Z')
+            lost_recache: tokens.include?('Z'),
+            # Explicit miss marker: EN means the key does not exist.  A tombstoned
+            # item is NOT a miss -- it answers VA/HD with the X flag set -- and a
+            # stored nil under cache_nils is not one either, so neither can be
+            # inferred from value or cas alone.
+            miss: tokens.first == EN
           }
         end
 
@@ -157,9 +164,26 @@ module Dalli
           true
         end
 
+        # Consumes the responses to a batch of quiet (pipelined) delete
+        # requests, which are terminated by a noop (MN). In quiet mode
+        # memcached suppresses the success response for each deleted key, so
+        # every line received before the terminator corresponds to a key that
+        # was NOT deleted -- a miss (NF) or an error. Returns that count so
+        # callers can derive the number of successful deletes as
+        # (keys_sent - non_deletions).
+        def pipelined_delete_non_deletions
+          non_deletions = 0
+          tokens = next_line_to_tokens
+          until tokens.first == MN
+            non_deletions += 1
+            tokens = next_line_to_tokens
+          end
+          non_deletions
+        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]
+          [tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value, resp_size]
         end
 
         ##
@@ -174,24 +198,26 @@ module Dalli
         ##
         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
+          term_idx = buf.byteindex(TERMINATOR, offset)
+          return [0] unless term_idx
 
           header = buf.byteslice(offset, term_idx - offset)
           tokens = header.split
           header_len = header.bytesize + TERMINATOR.length
+
+          # The body len is removed from the tokens array
           body_len = body_len_from_tokens(tokens)
 
           # 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?
+          return [true, header_len] 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 >= offset + resp_size
+          return [0] unless buf.bytesize >= offset + resp_size
 
           # The full response is in our buffer, so parse it and return
           # the values
@@ -210,17 +236,28 @@ module Dalli
         end
 
         def bitflags_from_tokens(tokens)
-          value_from_tokens(tokens, 'f')&.to_i
+          value_from_tokens(tokens, 'f').to_i
         end
 
         def cas_from_tokens(tokens)
-          value_from_tokens(tokens, 'c')&.to_i
+          value_from_tokens(tokens, 'c').to_i
+        end
+
+        # Detects the X presence flag, set when an item has been marked stale by a
+        # prior `md key I`.  Uses strict equality (Array#any? with a String pattern
+        # compares with ==) so a future value-bearing flag beginning with X cannot
+        # be mistaken for it.
+        def stale_from_tokens(tokens)
+          tokens.any?('X')
         end
 
         def key_from_tokens(tokens)
           encoded_key = value_from_tokens(tokens, 'k')
-          base64_encoded = tokens.any?('b')
-          KeyRegularizer.decode(encoded_key, base64_encoded)
+          if tokens.delete('b')
+            KeyRegularizer.decode(encoded_key)
+          else
+            encoded_key
+          end
         end
 
         # Returns true if item was previously hit, false if first access, nil if not requested
@@ -235,18 +272,28 @@ module Dalli
         # 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
+          value_from_tokens(tokens, 'l').to_i
+        end
+
+        # Returns seconds of TTL remaining; -1 when the item has no expiry.
+        # The t flag returns t<seconds>.
+        def ttl_remaining_from_tokens(tokens)
+          value_from_tokens(tokens, 't').to_i
         end
 
         def body_len_from_tokens(tokens)
-          value_from_tokens(tokens, 's')&.to_i
+          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..]
+          # NB: as an optimization, we're mutating the matching token in place
+          # so there is a baked assumption that we're only accessing each token at most once.
+          index = tokens.find_index { |t| t.start_with?(flag) }
+          if index
+            tokens.delete_at(index).delete_prefix!(flag)
+          else
+            0
+          end
         end
 
         def read_line

data/lib/dalli/socket.rb

@@ -12,48 +12,63 @@ module Dalli
     # Common methods for all socket implementations.
     ##
     module InstanceMethods
-      def readfull(count)
-        value = String.new(capacity: count + 1)
-        loop do
-          result = read_nonblock(count - value.bytesize, exception: false)
-          value << result if append_to_buffer?(result)
-          break if value.bytesize == count
+      def read_available(reusable_buffer = nil)
+        if reusable_buffer
+          value = read_nonblock(8196, reusable_buffer, exception: false)
+          case value
+          when :wait_writable, :wait_readable
+            return reusable_buffer.clear
+          when nil
+            raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}"
+          end
+        else
+          value = ''.b
         end
-        value
-      end
 
-      def read_available
-        value = +''
+        buffer = ''.b
         loop do
-          result = read_nonblock(8196, exception: false)
-          break if WAIT_RCS.include?(result)
-          raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
-
-          value << result
+          result = read_nonblock(8196, buffer, exception: false)
+          case result
+          when :wait_writable, :wait_readable
+            buffer.clear
+            return value
+          when nil
+            raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}"
+          else
+            value << result
+          end
         end
-        value
-      end
-
-      WAIT_RCS = %i[wait_writable wait_readable].freeze
-
-      def append_to_buffer?(result)
-        raise Timeout::Error, "IO timeout: #{logged_options.inspect}" if nonblock_timed_out?(result)
-        raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
-
-        !WAIT_RCS.include?(result)
-      end
-
-      def nonblock_timed_out?(result)
-        return true if result == :wait_readable && !wait_readable(options[:socket_timeout])
-
-        # TODO: Do we actually need this?  Looks to be only used in read_nonblock
-        result == :wait_writable && !wait_writable(options[:socket_timeout])
       end
 
       FILTERED_OUT_OPTIONS = %i[username password].freeze
       def logged_options
         options.except(*FILTERED_OUT_OPTIONS)
       end
+
+      # JRuby doesn't support IO#timeout=, so use custom readfull implementation
+      # CRuby 3.3+ has IO#timeout= which makes IO#read work with timeouts
+      if RUBY_ENGINE == 'jruby'
+        def readfull(count)
+          value = String.new(capacity: count + 1)
+
+          until value.bytesize == count
+            result = read_nonblock(count - value.bytesize, exception: false)
+            case result
+            when :wait_readable
+              wait_readable(options[:socket_timeout]) or raise Timeout::Error, "IO timeout: #{logged_options.inspect}"
+            when :wait_writable
+              wait_writable(options[:socket_timeout]) or raise Timeout::Error, "IO timeout: #{logged_options.inspect}"
+            when nil
+              raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}"
+            else
+              value << result
+            end
+          end
+
+          value
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
     end
 
     ##

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.0.5'
+  VERSION = '5.1.0'
 
-  MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
+  MIN_SUPPORTED_MEMCACHED_VERSION = '1.6.27'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.0.5
+  version: 5.1.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -44,7 +44,6 @@ files:
 - lib/dalli/instrumentation.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
-- lib/dalli/pid_cache.rb
 - lib/dalli/pipelined_deleter.rb
 - lib/dalli/pipelined_getter.rb
 - lib/dalli/pipelined_setter.rb
@@ -88,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.12
+rubygems_version: 4.0.18
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []

data/lib/dalli/pid_cache.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli
-  ##
-  # Dalli::PIDCache is a wrapper class for PID checking to avoid system calls when checking the PID.
-  ##
-  module PIDCache
-    if !Process.respond_to?(:fork) # JRuby or TruffleRuby
-      @pid = Process.pid
-      singleton_class.attr_reader(:pid)
-    elsif Process.respond_to?(:_fork) # Ruby 3.1+
-      class << self
-        attr_reader :pid
-
-        def update!
-          @pid = Process.pid # rubocop:disable ThreadSafety/ClassInstanceVariable
-        end
-      end
-      update!
-
-      ##
-      # Dalli::PIDCache::CoreExt hooks into Process to be able to reset the PID cache after fork
-      ##
-      module CoreExt
-        def _fork
-          child_pid = super
-          PIDCache.update! if child_pid.zero?
-          child_pid
-        end
-      end
-      Process.singleton_class.prepend(CoreExt)
-    else # Ruby 3.0 or older
-      class << self
-        def pid
-          Process.pid
-        end
-      end
-    end
-  end
-end