dalli 4.3.10 → 5.0.0

data/lib/dalli/compressor.rb

@@ -13,54 +13,8 @@ module Dalli
       Zlib::Deflate.deflate(data)
     end
 
-    # DEFLATE can't expand data by more than about 1032:1
-    MAX_EXPANSION = 1032
-    # Compressed input is fed to zlib this many bytes at a time. MRI's zlib
-    # yields the output in small chunks; one that returns it instead still
-    # produces at most MAX_EXPANSION times this per step.
-    INFLATE_SLICE_BYTES = 64 * 1024
-
-    # max_bytes caps the decompressed size; inflating stops and raises as soon
-    # as the output passes it, so a small compressed value can't expand into
-    # gigabytes of memory.
-    def self.decompress(data, max_bytes: nil)
-      return Zlib::Inflate.inflate(data) unless may_exceed?(data, max_bytes)
-
-      inflate_within_limit(Zlib::Inflate.new, data, max_bytes)
-    end
-
-    # False when even the largest possible expansion stays within max_bytes,
-    # so the value can be inflated in one step
-    def self.may_exceed?(data, max_bytes)
-      max_bytes ? data.bytesize * MAX_EXPANSION > max_bytes : false
-    end
-
-    def self.inflate_within_limit(inflater, data, max_bytes)
-      out = String.new(encoding: Encoding::BINARY)
-      0.step(data.bytesize - 1, INFLATE_SLICE_BYTES) do |pos|
-        inflate_slice(inflater, data.byteslice(pos, INFLATE_SLICE_BYTES), out, max_bytes)
-        # Anything after the end of the stream isn't part of the value, as
-        # with Zlib::Inflate.inflate; finish would return it as output
-        break if inflater.finished?
-      end
-      return out if inflater.finished?
-
-      append_within_limit(out, inflater.finish, max_bytes)
-    ensure
-      inflater.close
-    end
-
-    # Both yielded and returned output count toward the limit
-    def self.inflate_slice(inflater, slice, out, max_bytes)
-      rest = inflater.inflate(slice) { |chunk| append_within_limit(out, chunk, max_bytes) }
-      append_within_limit(out, rest, max_bytes)
-    end
-
-    def self.append_within_limit(out, chunk, max_bytes)
-      out << chunk if chunk
-      return out if out.bytesize <= max_bytes
-
-      raise Dalli::UnmarshalError, "Decompressed value exceeds #{max_bytes} bytes (decompressed_max_bytes)"
+    def self.decompress(data)
+      Zlib::Inflate.inflate(data)
     end
   end
 
@@ -78,11 +32,9 @@ module Dalli
       io.string
     end
 
-    def self.decompress(data, max_bytes: nil)
-      return Zlib::GzipReader.new(StringIO.new(data, 'rb')).read unless Compressor.may_exceed?(data, max_bytes)
-
-      # MAX_WBITS + 16 makes zlib read the gzip format (and check its CRC)
-      Compressor.inflate_within_limit(Zlib::Inflate.new(Zlib::MAX_WBITS + 16), data, max_bytes)
+    def self.decompress(data)
+      io = StringIO.new(data, 'rb')
+      Zlib::GzipReader.new(io).read
     end
   end
 end

data/lib/dalli/instrumentation.rb

@@ -8,7 +8,7 @@ module Dalli
   # When OpenTelemetry is loaded, Dalli automatically creates spans for cache operations.
   # When OpenTelemetry is not available, all tracing methods are no-ops with zero overhead.
   #
-  # Dalli 4.3.2 uses the stable OTel semantic conventions for database spans.
+  # Dalli 5.0 uses the stable OTel semantic conventions for database spans.
   #
   # == Span Attributes
   #

data/lib/dalli/key_manager.rb

@@ -41,9 +41,6 @@ module Dalli
 
       @namespace = namespace_from_options
       @namespace_separator = @key_options[:namespace_separator]
-      # The meta protocol base64-encodes keys with whitespace or non-ASCII
-      # characters, so their length on the wire differs from their length here
-      @meta_protocol = client_options[:protocol]&.to_s == 'meta'
     end
 
     ##
@@ -61,7 +58,7 @@ module Dalli
       raise ArgumentError, 'key cannot be blank' unless key&.length&.positive?
 
       key = key_with_namespace(key)
-      wire_length(key) > MAX_KEY_LENGTH ? truncated_key(key) : key
+      key.length > MAX_KEY_LENGTH ? truncated_key(key) : key
     end
 
     ##
@@ -125,30 +122,7 @@ module Dalli
     ##
     def truncated_key(key)
       digest = digest_class.hexdigest(key)
-      prefix = key[0, [prefix_length(digest), 0].max]
-      truncated = "#{prefix}#{TRUNCATED_KEY_SEPARATOR}#{digest}"
-      # A prefix with whitespace or non-ASCII characters sends the whole key
-      # base64-encoded, which can still be too long on the wire; shorten it.
-      while wire_length(truncated) > MAX_KEY_LENGTH && !prefix.empty?
-        prefix = prefix[0...-1]
-        truncated = "#{prefix}#{TRUNCATED_KEY_SEPARATOR}#{digest}"
-      end
-      return truncated if wire_length(truncated) <= MAX_KEY_LENGTH
-
-      # Only possible with a digest_class whose digests aren't short hex strings
-      raise ArgumentError, "#{digest_class} digests are too long to fit in a truncated key"
-    end
-
-    # memcached's key limit applies to the key as sent: in bytes, and, with
-    # the meta protocol, after base64 encoding when the key needs it. A key
-    # within the limit in characters can still be too long. With the meta
-    # protocol memcached rejects it with a CLIENT_ERROR that must never reach
-    # a pipelined get; with the binary protocol it drops the connection.
-    def wire_length(key)
-      return key.bytesize unless @meta_protocol
-
-      encoded, = Dalli::Protocol::Meta::KeyRegularizer.encode(key)
-      encoded.bytesize
+      "#{key[0, prefix_length(digest)]}#{TRUNCATED_KEY_SEPARATOR}#{digest}"
     end
 
     def prefix_length(digest)

data/lib/dalli/options.rb

@@ -6,7 +6,7 @@ module Dalli
   # Make Dalli threadsafe by using a lock around all
   # public server methods.
   #
-  # Dalli::Protocol::Binary.extend(Dalli::Threadsafe)
+  # Dalli::Protocol::Meta.extend(Dalli::Threadsafe)
   #
   module Threadsafe
     def self.extended(obj)
@@ -43,7 +43,7 @@ module Dalli
       end
     end
 
-    def pipeline_abort(...)
+    def pipeline_abort
       @lock.synchronize do
         super
       end

data/lib/dalli/pipelined_getter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module Dalli
   ##
   # Contains logic for the pipelined gets implemented by the client.
@@ -26,21 +24,15 @@ module Dalli
       return {} if keys.empty?
 
       @ring.lock do
-        # The servers with replies still to read, updated in place
-        servers = []
-        begin
-          # Stores partial results collected during interleaved send phase
-          @partial_results = {}
-          setup_requests(servers, keys)
-          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        # Stores partial results collected during interleaved send phase
+        @partial_results = {}
+        servers = setup_requests(keys)
+        start_time = Time.now
 
-          # First yield any partial results collected during interleaved send
-          yield_partial_results(&block)
+        # First yield any partial results collected during interleaved send
+        yield_partial_results(&block)
 
-          fetch_responses(servers, start_time, @ring.socket_timeout, &block) until servers.empty?
-        ensure
-          abort_unfinished(servers)
-        end
+        servers = fetch_responses(servers, start_time, @ring.socket_timeout, &block) until servers.empty?
       end
     rescue Dalli::RetryableNetworkError => e
       Dalli.logger.debug { e.inspect }
@@ -57,15 +49,12 @@ module Dalli
       @partial_results.clear
     end
 
-    # Adds the servers with a pending response to servers before writing
-    # their queries, so #process can abort them if it stops early.
-    def setup_requests(servers, keys)
+    def setup_requests(keys)
       groups = groups_for_keys(keys)
-      servers.concat(groups.keys)
       make_getkq_requests(groups)
 
       # TODO: How does this exit on a NetworkError
-      finish_queries(servers)
+      finish_queries(groups.keys)
     end
 
     ##
@@ -127,39 +116,29 @@ module Dalli
       raise
     end
 
-    # Swallows Dalli::NetworkError. Empties servers, so they aren't aborted
-    # again.
+    # Swallows Dalli::NetworkError
     def abort_without_timeout(servers)
       servers.each(&:pipeline_abort)
-      servers.clear
     end
 
-    # When #process stops before reading every server's replies (the caller's
-    # block raises or breaks, a Timeout.timeout fires, a value can't be
-    # deserialized), the rest are still on the socket and some may be in the
-    # response buffer. Closing those connections keeps them from being read
-    # as a later request's replies. Aborts that #process already handled
-    # emptied servers.
-    def abort_unfinished(servers)
-      servers.each { |server| server.pipeline_abort(timed_out: false) }
-      servers.clear
-    end
-
-    # Reads the replies available, removing finished servers from servers
     def fetch_responses(servers, start_time, timeout, &block)
       # Remove any servers which are not connected
       servers.select!(&:connected?)
-      return if servers.empty?
+      return [] if servers.empty?
 
       time_left = remaining_time(start_time, timeout)
       readable_servers = servers_with_response(servers, time_left)
-      return abort_with_timeout(servers) if readable_servers.empty?
+      if readable_servers.empty?
+        abort_with_timeout(servers)
+        return []
+      end
 
       # Loop through the servers with responses, and
       # delete any from our list that are finished
       readable_servers.each do |server|
         servers.delete(server) if process_server(server, &block)
       end
+      servers
     rescue NetworkError
       # Abort and raise if we encountered a network error.  This triggers
       # a retry at the top level on RetryableNetworkError.
@@ -168,7 +147,7 @@ module Dalli
     end
 
     def remaining_time(start, timeout)
-      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      elapsed = Time.now - start
       return 0 if elapsed > timeout
 
       timeout - elapsed
@@ -176,17 +155,19 @@ module Dalli
 
     # Swallows Dalli::NetworkError
     def abort_with_timeout(servers)
+      abort_without_timeout(servers)
       servers.each do |server|
         Dalli.logger.debug { "memcached at #{server.name} did not response within timeout" }
       end
-      abort_without_timeout(servers)
+
+      true # Required to simplify caller
     end
 
     # Processes responses from a server.  Returns true if there are no
     # additional responses from this server.
     def process_server(server)
-      server.pipeline_next_responses do |key, value, cas|
-        yield @key_manager.key_without_namespace(key), [value, cas]
+      server.pipeline_next_responses.each_pair do |key, value_list|
+        yield @key_manager.key_without_namespace(key), value_list
       end
 
       server.pipeline_complete?
@@ -195,13 +176,18 @@ module Dalli
     def servers_with_response(servers, timeout)
       return [] if servers.empty?
 
-      sockets = servers.map(&:sock)
-      readable, = IO.select(sockets, nil, nil, timeout)
+      # TODO: - This is a bit challenging.  Essentially the PipelinedGetter
+      # is a reactor, but without the benefit of a Fiber or separate thread.
+      # My suspicion is that we may want to try and push this down into the
+      # individual servers, but I'm not sure.  For now, we keep the
+      # mapping between the alerted object (the socket) and the
+      # corrresponding server here.
+      server_map = servers.each_with_object({}) { |s, h| h[s.sock] = s }
+
+      readable, = IO.select(server_map.keys, nil, nil, timeout)
       return [] if readable.nil?
 
-      # For typical server counts (1-5), linear scan is faster than
-      # building and looking up a hash map
-      readable.filter_map { |sock| servers.find { |s| s.sock == sock } }
+      readable.map { |sock| server_map[sock] }
     end
 
     def groups_for_keys(*keys)

data/lib/dalli/pipelined_setter.rb

@@ -16,9 +16,6 @@ module Dalli
     # Writes multiple key-value pairs to memcached.
     # Raises an error if any server is unavailable.
     #
-    # A value that can't be marshalled or is over value_max_bytes is skipped;
-    # the other keys are still stored, then the first such error is raised.
-    #
     # @param hash [Hash] key-value pairs to set
     # @param ttl [Integer] time-to-live in seconds
     # @param req_options [Hash] options passed to each set operation
@@ -27,12 +24,10 @@ module Dalli
     def process(hash, ttl, req_options)
       return if hash.empty?
 
-      @value_error = nil
       @ring.lock do
         servers = setup_requests(hash, ttl, req_options)
         finish_requests(servers)
       end
-      raise @value_error if @value_error
     rescue Dalli::RetryableNetworkError => e
       Dalli.logger.debug { e.inspect }
       Dalli.logger.debug { 'retrying pipelined sets because of network error' }
@@ -41,12 +36,9 @@ module Dalli
 
     private
 
-    # Values are looked up by each key as sent. The caller's key can't be
-    # rebuilt from it: a long key is digested, and a Symbol becomes a String.
     def setup_requests(hash, ttl, req_options)
-      pairs = hash.transform_keys { |k| @key_manager.validate_key(k.to_s) }
-      groups = groups_for_keys(pairs.keys)
-      make_set_requests(groups, pairs, ttl, req_options)
+      groups = groups_for_keys(hash.keys)
+      make_set_requests(groups, hash, ttl, req_options)
       groups.keys
     end
 
@@ -54,14 +46,12 @@ module Dalli
     # Loop through the server-grouped sets of keys, writing
     # the corresponding quiet set requests to the appropriate servers
     ##
-    def make_set_requests(groups, pairs, ttl, req_options)
+    def make_set_requests(groups, hash, ttl, req_options)
       groups.each do |server, keys_for_server|
         keys_for_server.each do |key|
-          server.request(:pipelined_set, key, pairs[key], ttl, req_options)
-        rescue Dalli::MarshalError, Dalli::ValueOverMaxSize => e
-          # Nothing was written for this key, so the server's other keys are
-          # unaffected; raised by #process once the batch is complete
-          @value_error ||= e
+          original_key = @key_manager.key_without_namespace(key)
+          value = hash[original_key]
+          server.request(:pipelined_set, key, value, ttl, req_options)
         rescue DalliError, NetworkError => e
           Dalli.logger.debug { e.inspect }
           Dalli.logger.debug { "unable to set key #{key} for server #{server.name}" }
@@ -82,7 +72,8 @@ module Dalli
     end
 
     def groups_for_keys(keys)
-      groups = @ring.keys_grouped_by_server(keys)
+      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
+      groups = @ring.keys_grouped_by_server(validated_keys)
 
       if (unfound_keys = groups.delete(nil))
         Dalli.logger.debug do