dalli 5.0.4 → 5.0.6

data/lib/dalli/protocol/response_processor.rb

@@ -23,13 +23,23 @@ module Dalli
         VERSION = 'VERSION'
         SERVER_ERROR = 'SERVER_ERROR'
 
+        T_OK = [OK].freeze
+        T_RESET = [RESET].freeze
+        T_EN_HD = [EN, HD].freeze
+        T_VERSION = [VERSION].freeze
+        T_VA_EN_HD = [VA, EN, HD].freeze
+        T_HD_NF_EX = [HD, NF, EX].freeze
+        T_HD_NS_NF_EX = [HD, NS, NF, EX].freeze
+        T_VA_NF_NS_EX = [VA, NF, NS, EX].freeze
+        T_END_TOKEN_STAT = [END_TOKEN, STAT].freeze
+
         def initialize(io_source, value_marshaller)
           @io_source = io_source
           @value_marshaller = value_marshaller
         end
 
         def meta_get_with_value(cache_nils: false)
-          tokens = error_on_unexpected!([VA, EN, HD])
+          tokens = error_on_unexpected!(T_VA_EN_HD)
           return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
           return true unless tokens.first == VA
 
@@ -37,7 +47,7 @@ module Dalli
         end
 
         def meta_get_with_value_and_cas
-          tokens = error_on_unexpected!([VA, EN, HD])
+          tokens = error_on_unexpected!(T_VA_EN_HD)
           return [nil, 0] if tokens.first == EN
 
           cas = cas_from_tokens(tokens)
@@ -47,7 +57,7 @@ module Dalli
         end
 
         def meta_get_without_value
-          tokens = error_on_unexpected!([EN, HD])
+          tokens = error_on_unexpected!(T_EN_HD)
           tokens.first == EN ? nil : true
         end
 
@@ -63,7 +73,7 @@ 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)
-          tokens = error_on_unexpected!([VA, EN, HD])
+          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
@@ -87,26 +97,26 @@ module Dalli
         end
 
         def meta_set_with_cas
-          tokens = error_on_unexpected!([HD, NS, NF, EX])
+          tokens = error_on_unexpected!(T_HD_NS_NF_EX)
           return false unless tokens.first == HD
 
           cas_from_tokens(tokens)
         end
 
         def meta_set_append_prepend
-          tokens = error_on_unexpected!([HD, NS, NF, EX])
+          tokens = error_on_unexpected!(T_HD_NS_NF_EX)
           return false unless tokens.first == HD
 
           true
         end
 
         def meta_delete
-          tokens = error_on_unexpected!([HD, NF, EX])
+          tokens = error_on_unexpected!(T_HD_NF_EX)
           tokens.first == HD
         end
 
         def decr_incr
-          tokens = error_on_unexpected!([VA, NF, NS, EX])
+          tokens = error_on_unexpected!(T_VA_NF_NS_EX)
           return false if [NS, EX].include?(tokens.first)
           return nil if tokens.first == NF
 
@@ -114,7 +124,7 @@ module Dalli
         end
 
         def stats
-          tokens = error_on_unexpected!([END_TOKEN, STAT])
+          tokens = error_on_unexpected!(T_END_TOKEN_STAT)
           values = {}
           while tokens.first != END_TOKEN
             values[tokens[1]] = tokens[2]
@@ -124,19 +134,19 @@ module Dalli
         end
 
         def flush
-          error_on_unexpected!([OK])
+          error_on_unexpected!(T_OK)
 
           true
         end
 
         def reset
-          error_on_unexpected!([RESET])
+          error_on_unexpected!(T_RESET)
 
           true
         end
 
         def version
-          tokens = error_on_unexpected!([VERSION])
+          tokens = error_on_unexpected!(T_VERSION)
           tokens.last
         end
 
@@ -147,9 +157,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
 
         ##
@@ -164,24 +191,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
@@ -200,17 +229,20 @@ 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
 
         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
@@ -225,18 +257,22 @@ 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
 
         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.4'
+  VERSION = '5.0.6'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.0.4
+  version: 5.0.6
 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.10
+rubygems_version: 4.0.16
 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