dalli 5.1.4 → 5.2.0

data/lib/dalli/protocol/response_processor.rb

@@ -24,9 +24,10 @@ module Dalli
         SERVER_ERROR = 'SERVER_ERROR'
 
         VA_PREFIX = 'VA '
-        # memcached can't store an item larger than 1 GiB (its -I maximum)
-        MAX_VALUE_BYTES = 1024 * 1024 * 1024
+        HD_PREFIX = 'HD '
         FLAGS_TOKEN_PREFIX = ' f'
+        CAS_TOKEN_PREFIX = ' c'
+        KEY_TOKEN_PREFIX = ' k'
         BYTE_B = 'b'.ord
         BYTE_C = 'c'.ord
         BYTE_F = 'f'.ord
@@ -48,15 +49,12 @@ module Dalli
           @value_marshaller = value_marshaller
         end
 
-        # raw: true (a request made with raw: true) returns the value as stored,
-        # ignoring any flags in the reply. The request didn't ask for flags, so
-        # a reply carrying them anyway must not get the value deserialized.
-        def meta_get_with_value(cache_nils: false, raw: false)
+        def meta_get_with_value(cache_nils: false)
           line = read_line
           # A hit ("VA <size> f<flags>") is parsed in place rather than split
           # into tokens, which saves several allocations on the hottest path.
           if line&.start_with?(VA_PREFIX)
-            return retrieve(read_data(size_from_va_line(line)), raw ? 0 : bitflags_from_va_line(line), raw)
+            return @value_marshaller.retrieve(read_data(size_from_va_line(line)), bitflags_from_va_line(line))
           end
 
           tokens = line&.split || []
@@ -64,7 +62,7 @@ module Dalli
           when EN
             cache_nils ? ::Dalli::NOT_FOUND : nil
           when VA # only reached for an unusually formatted hit line
-            retrieve(read_data(tokens[1].to_i), raw ? 0 : bitflags_from_tokens(tokens), raw)
+            @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
           when HD
             true
           else
@@ -72,14 +70,14 @@ module Dalli
           end
         end
 
-        def meta_get_with_value_and_cas(raw: false)
+        def meta_get_with_value_and_cas
           tokens = error_on_unexpected!(T_VA_EN_HD)
           return [nil, 0] if tokens.first == EN
 
           cas = cas_from_tokens(tokens)
           return [nil, cas] unless tokens.first == VA
 
-          [retrieve(read_data(tokens[1].to_i), raw ? 0 : bitflags_from_tokens(tokens), raw), cas]
+          [@value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens)), cas]
         end
 
         def meta_get_without_value
@@ -99,13 +97,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,
-                                   return_ttl_remaining: false, raw: 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, raw)
+          result[:value] = parse_value_from_tokens(tokens, cache_nils)
           result
         end
 
@@ -122,15 +120,21 @@ module Dalli
           }
         end
 
-        def parse_value_from_tokens(tokens, cache_nils, raw = false) # rubocop:disable Style/OptionalBooleanParameter
+        def parse_value_from_tokens(tokens, cache_nils)
           return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
           return unless tokens.first == VA
 
-          retrieve(read_data(tokens[1].to_i), raw ? 0 : bitflags_from_tokens(tokens), raw)
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
         end
 
         def meta_set_with_cas
-          tokens = error_on_unexpected!(T_HD_NS_NF_EX)
+          line = read_line
+          # A stored item ("HD c<cas>") is parsed in place rather than split into tokens
+          # Search from just after "HD": the " c" token starts at the space that follows it
+          return flag_from_line(line, CAS_TOKEN_PREFIX, HD.bytesize) if line&.start_with?(HD_PREFIX)
+
+          tokens = line&.split || []
+          raise_unexpected!(tokens) unless T_HD_NS_NF_EX.include?(tokens.first)
           return false unless tokens.first == HD
 
           cas_from_tokens(tokens)
@@ -144,7 +148,13 @@ module Dalli
         end
 
         def meta_delete
-          tokens = error_on_unexpected!(T_HD_NF_EX)
+          line = read_line
+          # The two common replies, compared as whole lines instead of split into tokens
+          return true if line == HD
+          return false if line == NF
+
+          tokens = line&.split || []
+          raise_unexpected!(tokens) unless T_HD_NF_EX.include?(tokens.first)
           tokens.first == HD
         end
 
@@ -217,13 +227,16 @@ module Dalli
         # The remaining three values in the array are the ResponseHeader,
         # key, and value.
         ##
-        # raw: true returns values as stored, ignoring flags in the replies;
-        # see meta_get_with_value.
-        def getk_response_from_buffer(buf, offset = 0, raw: false)
+        def getk_response_from_buffer(buf, offset = 0)
           # Find the header terminator starting from offset
           term_idx = buf.byteindex(TERMINATOR, offset)
           return [0] unless term_idx
 
+          if buf.byteslice(offset, VA_PREFIX.bytesize) == VA_PREFIX
+            response = va_response_from_buffer(buf, offset, term_idx)
+            return response if response
+          end
+
           header = buf.byteslice(offset, term_idx - offset)
           tokens = header.split
           header_len = header.bytesize + TERMINATOR.length
@@ -241,20 +254,16 @@ module Dalli
             when BYTE_B then base64 ||= token == 'b'
             end
           end
-          # memcached also gives the size positionally ("VA <size> ..."); use it
-          # when there's no s flag rather than reading the value as replies
-          body_len = size ? flag_int(size, 's') : positional_size(tokens)
-
-          # A complete response with no body. Only the terminating noop's MN
-          # ends the pipeline. Any other bodyless reply (CLIENT_ERROR,
-          # SERVER_ERROR, ...) answers one key's request: report it with a
-          # false status so the caller skips it and keeps reading. Treating it
-          # as the end would leave the remaining replies on the connection for
-          # later commands to read as their own. A hit on an empty value (VA 0)
-          # still has a body -- just its terminator -- so it's parsed below.
-          return [tokens.first == MN, header_len] if body_len.zero? && tokens.first != VA
-
-          check_value_size!(body_len)
+          body_len = flag_int(size, 's')
+
+          # 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. A hit
+          # on an empty value (VA 0) still has a body -- just
+          # its terminator -- so it's parsed below as a value.
+          return [true, header_len] if body_len.zero? && tokens.first != VA
+
           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
@@ -263,19 +272,47 @@ module Dalli
           # The full response is in our buffer, so parse it and return
           # the values
           body = buf.byteslice(offset + header_len, body_len)
-          value = retrieve(body, raw ? 0 : flag_int(bitflags, 'f'), raw)
-          # A hit with no key can't be matched to a request: skip it (false
-          # status) rather than yield it, or take it for the end of the pipeline
-          return [false, resp_size] unless key
-
-          key = key.delete_prefix!('k')
+          value = @value_marshaller.retrieve(body, flag_int(bitflags, 'f'))
+          key = key ? key.delete_prefix!('k') : 0
           key = KeyRegularizer.decode(key) if base64
           [tokens.first == VA, flag_int(cas, 'c'), key, value, resp_size]
         end
 
-        # Values from a raw request are returned as stored
-        def retrieve(value, bitflags, raw)
-          raw ? value : @value_marshaller.retrieve(value, bitflags)
+        # getk_response_from_buffer for a "VA ..." header, read in place
+        # without allocating the header, its tokens or the flag strings.
+        # Gives the same result as the token path. Returns nil to fall back to
+        # it when the header has no s flag or a zero size.
+        def va_response_from_buffer(buf, offset, term_idx)
+          size = bitflags = cas = key = nil
+          base64 = false
+          pos = buf.byteindex(' ', offset + VA_PREFIX.bytesize)
+          while pos && pos < term_idx
+            start = pos + 1
+            pos = buf.byteindex(' ', start)
+            stop = pos && pos < term_idx ? pos : term_idx
+            case buf.getbyte(start)
+            when BYTE_S then size ||= flag_int_at(buf, start, stop)
+            when BYTE_F then bitflags ||= flag_int_at(buf, start, stop)
+            when BYTE_C then cas ||= flag_int_at(buf, start, stop)
+            when BYTE_K then key ||= buf.byteslice(start + 1, stop - start - 1)
+            when BYTE_B then base64 ||= stop == start + 1
+            end
+          end
+          return nil if size.nil? || size.zero?
+
+          header_len = term_idx - offset + TERMINATOR.length
+          resp_size = header_len + size + TERMINATOR.length
+          return [0] unless buf.bytesize >= offset + resp_size
+
+          value = @value_marshaller.retrieve(buf.byteslice(offset + header_len, size), bitflags || 0)
+          key = KeyRegularizer.decode(key) if base64 && key
+          [true, cas || 0, key || 0, value, resp_size]
+        end
+
+        # Integer value of a flag's token in buf, after its one-byte prefix,
+        # as flag_int would read it
+        def flag_int_at(buf, start, stop)
+          buf.byteslice(start + 1, stop - start - 1).to_i
         end
 
         # Integer value of a flag token such as "f123", or 0 when absent.
@@ -309,8 +346,29 @@ module Dalli
         end
 
         def bitflags_from_va_line(line)
-          idx = line.index(FLAGS_TOKEN_PREFIX, VA_PREFIX.bytesize)
-          idx ? line.byteslice(idx + FLAGS_TOKEN_PREFIX.bytesize, line.bytesize).to_i : 0
+          flag_from_line(line, FLAGS_TOKEN_PREFIX, VA_PREFIX.bytesize)
+        end
+
+        # The key from a VA line's k flag, decoded when the line has the b flag,
+        # or nil when there is no k flag
+        def key_from_va_line(line)
+          idx = line.index(KEY_TOKEN_PREFIX, VA_PREFIX.bytesize)
+          return unless idx
+
+          start = idx + KEY_TOKEN_PREFIX.bytesize
+          stop = line.index(' ', start) || line.index(TERMINATOR, start) || line.bytesize
+          key = line.byteslice(start, stop - start)
+          base64_flag_in_line?(line) ? KeyRegularizer.decode(key) : key
+        end
+
+        def base64_flag_in_line?(line)
+          line.include?(' b ') || line.end_with?(" b#{TERMINATOR}", ' b')
+        end
+
+        # Integer value of the first " <flag><digits>" token at or after start, or 0
+        def flag_from_line(line, token_prefix, start)
+          idx = line.index(token_prefix, start)
+          idx ? line.byteslice(idx + token_prefix.bytesize, line.bytesize).to_i : 0
         end
 
         def cas_from_tokens(tokens)
@@ -366,19 +424,6 @@ module Dalli
           end
         end
 
-        # A pipelined reply claiming an impossible size would otherwise have the
-        # buffer wait for (and accumulate) that many bytes
-        # The size given right after "VA", or 0 when it isn't a number
-        def positional_size(tokens)
-          tokens.first == VA && tokens[1]&.match?(/\A\d+\z/) ? tokens[1].to_i : 0
-        end
-
-        def check_value_size!(size)
-          return if size.between?(0, MAX_VALUE_BYTES)
-
-          raise Dalli::DalliError, "Reply value size #{size} is out of range"
-        end
-
         def read_line
           @io_source.read_line&.chomp!(TERMINATOR)
         end
@@ -389,9 +434,6 @@ module Dalli
         end
 
         def read_data(data_size)
-          # Checked before the terminator is added: -1 or -2 would otherwise
-          # read 1 or 0 bytes and leave the connection out of step
-          check_value_size!(data_size)
           @io_source.read(data_size + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
         end
       end

data/lib/dalli/protocol/value_compressor.rb

@@ -15,17 +15,11 @@ module Dalli
         compress: true,
         compressor: ::Dalli::Compressor,
         # min byte size to attempt compression
-        compression_min_size: 4 * 1024, # 4K
-        # max size a stored value may decompress to (nil: no limit). Guards
-        # against a small compressed value expanding into gigabytes on read.
-        decompressed_max_bytes: 128 * 1024 * 1024 # 128 MiB
+        compression_min_size: 4 * 1024 # 4K
       }.freeze
 
       OPTIONS = DEFAULTS.keys.freeze
 
-      KEYWORD_PARAMETER_TYPES = %i[key keyreq].freeze
-      private_constant :KEYWORD_PARAMETER_TYPES
-
       def initialize(client_options)
         @compression_options =
           DEFAULTS.merge(client_options.slice(*OPTIONS))
@@ -40,16 +34,8 @@ module Dalli
       end
 
       def retrieve(value, bitflags)
-        return value unless bitflags.anybits?(Flags::COMPRESSED)
-
-        max_bytes = @compression_options[:decompressed_max_bytes]
-        # Custom compressors that only define decompress(data) keep working,
-        # without the limit
-        if max_bytes && compressor_accepts_max_bytes?
-          compressor.decompress(value, max_bytes: max_bytes)
-        else
-          compressor.decompress(value)
-        end
+        compressed = bitflags.anybits?(Flags::COMPRESSED)
+        compressed ? compressor.decompress(value) : value
 
       # TODO: We likely want to move this rescue into the Dalli::Compressor / Dalli::GzipCompressor
       # itself, since not all compressors necessarily use Zlib.  For now keep it here, so the behavior
@@ -58,19 +44,6 @@ module Dalli
         raise UnmarshalError, "Unable to uncompress value: #{$ERROR_INFO.message}"
       end
 
-      def compressor_accepts_max_bytes?
-        return @compressor_accepts_max_bytes if defined?(@compressor_accepts_max_bytes)
-
-        @compressor_accepts_max_bytes =
-          begin
-            compressor.method(:decompress).parameters.any? do |type, name|
-              name == :max_bytes && KEYWORD_PARAMETER_TYPES.include?(type)
-            end
-          rescue NameError # an object without a reflectable decompress method
-            false
-          end
-      end
-
       def compress_by_default?
         @compression_options[:compress]
       end

data/lib/dalli/protocol/value_serializer.rb

@@ -100,7 +100,7 @@ module Dalli
         Dalli.logger.warn 'SECURITY WARNING: Dalli is using Marshal for serialization. ' \
                           'Marshal can execute arbitrary code during deserialization. ' \
                           'If your memcached server could be compromised, consider using ' \
-                          'a safer serializer: Dalli::Client.new(servers, serializer: Dalli::JSONSerializer)'
+                          'a safer serializer like JSON: Dalli::Client.new(servers, serializer: JSON)'
         @@marshal_warning_logged = true # rubocop:disable Style/ClassVars
       end
     end

data/lib/dalli/ring.rb

@@ -36,9 +36,10 @@ module Dalli
 
     def continuum=(entries)
       @continuum = entries
-      # Plain integers, so the binary search in server_for_hash_key needn't
-      # call Entry#value at each step
+      # Plain integers, so the lookup in server_for_hash_key needn't call
+      # Entry#value at each step
       @continuum_values = entries&.map(&:value)
+      build_buckets
     end
 
     # alive_cache (optional) remembers each server's alive? result, so a
@@ -55,15 +56,17 @@ module Dalli
       raise Dalli::RingError, 'No server available'
     end
 
+    # Tries the key's own server first, then (with failover) up to 19
+    # rehashes of "<try><key>". The first try is outside the loop because it
+    # is almost always the one that's used.
     def server_from_continuum(key, alive_cache = nil)
-      hkey = hash_for(key)
-      20.times do |try|
-        server = server_for_hash_key(hkey)
+      server = server_for_hash_key(hash_for(key))
+      return server if server_alive?(server, alive_cache)
+      return nil unless @failover
 
+      19.times do |try|
+        server = server_for_hash_key(hash_for("#{try}#{key}"))
         return server if server_alive?(server, alive_cache)
-        break unless @failover
-
-        hkey = hash_for("#{try}#{key}")
       end
       nil
     end
@@ -87,8 +90,13 @@ module Dalli
       end
     end
 
+    # Drains the replies left by quiet requests. Only servers that were sent a
+    # quiet request need it, so the others (and servers never connected) are
+    # skipped rather than each costing a noop round trip.
     def pipeline_consume_and_ignore_responses
       @servers.each do |s|
+        next unless s.quiet_responses_pending?
+
         s.request(:noop)
       rescue Dalli::NetworkError
         # Ignore this error, as it indicates the socket is unavailable
@@ -121,22 +129,41 @@ module Dalli
     def server_alive?(server, alive_cache)
       return server.alive? unless alive_cache
 
-      alive_cache.fetch(server) { alive_cache[server] = server.alive? }
+      alive = alive_cache[server]
+      alive.nil? ? (alive_cache[server] = server.alive?) : alive
     end
 
     def entry_count_for(server, total_servers, total_weight)
       ((total_servers * POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
     end
 
-    def server_for_hash_key(hash_key)
-      # Find the closest index in the Ring with value <= the given value
-      entryidx = @continuum_values.bsearch_index { |value| value > hash_key }
-      if entryidx.nil?
-        entryidx = @continuum.size - 1
-      else
-        entryidx -= 1
+    # Hash values are 32 bits. Splitting that range into about one bucket per
+    # continuum entry, and noting the first entry at or after each bucket's
+    # start, lets server_for_hash_key skip the binary search: it starts at the
+    # key's bucket and steps over the few entries before the key's hash.
+    def build_buckets
+      return unless @continuum_values
+
+      bits = [@continuum_values.size.bit_length, 1].max
+      @bucket_shift = 32 - bits
+      @bucket_first = Array.new(1 << bits)
+      idx = 0
+      size = @continuum_values.size
+      @bucket_first.each_index do |bucket|
+        floor = bucket << @bucket_shift
+        idx += 1 while idx < size && @continuum_values[idx] < floor
+        @bucket_first[bucket] = idx
       end
-      @continuum[entryidx].server
+    end
+
+    def server_for_hash_key(hash_key)
+      # Find the last entry with value <= hash_key, wrapping around to the
+      # last entry when every value is greater (idx - 1 is then -1)
+      idx = @bucket_first[hash_key >> @bucket_shift]
+      values = @continuum_values
+      size = values.size
+      idx += 1 while idx < size && values[idx] <= hash_key
+      @continuum[idx - 1].server
     end
 
     def build_continuum(servers)

data/lib/dalli/socket.rb

@@ -12,22 +12,29 @@ module Dalli
     # Common methods for all socket implementations.
     ##
     module InstanceMethods
+      READ_CHUNK_SIZE = 8196
+
+      # Reads whatever is available without blocking. A read that returns less
+      # than a full chunk means the socket was drained, so we stop there rather
+      # than spend another read_nonblock call just to get :wait_readable back.
+      # Callers keep waiting on IO.select for anything that arrives later.
       def read_available(reusable_buffer = nil)
         if reusable_buffer
-          value = read_nonblock(8196, reusable_buffer, exception: false)
+          value = read_nonblock(READ_CHUNK_SIZE, 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
+          return value if drained_after?(value)
         else
           value = ''.b
         end
 
         buffer = ''.b
         loop do
-          result = read_nonblock(8196, buffer, exception: false)
+          result = read_nonblock(READ_CHUNK_SIZE, buffer, exception: false)
           case result
           when :wait_writable, :wait_readable
             buffer.clear
@@ -36,10 +43,21 @@ module Dalli
             raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}"
           else
             value << result
+            return value if drained_after?(result)
           end
         end
       end
 
+      # True when a read came back short and nothing is left buffered in-process.
+      def drained_after?(chunk)
+        chunk.bytesize < READ_CHUNK_SIZE && !buffered_data?
+      end
+
+      # Plain sockets keep nothing buffered in-process. See SSLSocket.
+      def buffered_data?
+        false
+      end
+
       FILTERED_OUT_OPTIONS = %i[username password].freeze
       def logged_options
         options.except(*FILTERED_OUT_OPTIONS)
@@ -83,6 +101,13 @@ module Dalli
         io.options
       end
 
+      # OpenSSL can hold decrypted bytes that IO.select won't report as readable.
+      # With OpenSSL's default (no read-ahead) a short read has already used up
+      # the current record, so this is normally 0; it guards read-ahead setups.
+      def buffered_data?
+        pending.positive?
+      end
+
       unless method_defined?(:wait_readable)
         def wait_readable(timeout = nil)
           to_io.wait_readable(timeout)

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.1.4'
+  VERSION = '5.2.0'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.6.27'
 end

data/lib/dalli.rb

@@ -62,8 +62,8 @@ require_relative 'dalli/version'
 require_relative 'dalli/instrumentation'
 
 require_relative 'dalli/flags'
-require_relative 'dalli/json_serializer'
 require_relative 'dalli/compressor'
+require_relative 'dalli/cache_result'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.1.4
+  version: 5.2.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -37,12 +37,12 @@ files:
 - LICENSE
 - README.md
 - lib/dalli.rb
+- lib/dalli/cache_result.rb
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
 - lib/dalli/flags.rb
 - lib/dalli/instrumentation.rb
-- lib/dalli/json_serializer.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
 - lib/dalli/pipelined_deleter.rb

data/lib/dalli/json_serializer.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Dalli
-  ##
-  # A serializer that stores values as JSON and never creates Ruby objects
-  # from what it reads.
-  #
-  # Passing the JSON module itself as the serializer (serializer: JSON) reads
-  # values back with JSON.load, which on json gem versions before 3.0 honors
-  # "json_class" and instantiates other classes when the json gem's additions
-  # are loaded. This serializer reads with JSON.parse, so a value written to
-  # memcached by someone else can only come back as plain hashes, arrays,
-  # strings, numbers, booleans and nil.
-  #
-  #   Dalli::Client.new(servers, serializer: Dalli::JSONSerializer)
-  ##
-  module JSONSerializer
-    def self.dump(value)
-      JSON.generate(value)
-    end
-
-    def self.load(data)
-      JSON.parse(data)
-    end
-  end
-end