dalli 5.1.6 → 5.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a14acb855194ffb54b0395ba7e9a4785a69e3d00068088e42aca53d91dcc3929
-  data.tar.gz: 3017450cd4da74f426885ae2684f562b42983ca83f85b13242611b7d32f76c02
+  metadata.gz: aedfdf5af128f44424f0d21689f66a86813b9714677716854889788fe3b62546
+  data.tar.gz: 4375bcb70c31f53ac8fbf13cc4bc16171756a87148f95c024d214d8028216795
 SHA512:
-  metadata.gz: 0b6f8bd702bb10c9f4d47ad981fbc702ac00dda484a84f82449fb0874aae98127b96c8518aad7768c7996f8c95c2772394771e84128d0c4d65278257a28540c4
-  data.tar.gz: 766ebee713280bc7ec98ec53becf3ece1a73c2734171f27379e13e2343f2dfce16649a77104254084cf9b948679646a8b6f4cbb0cb55529de354e1686d0e8b31
+  metadata.gz: ea2568b866c13f7d3bb9bf7d0c305c2164503df325c029d5aa160edb1316bc8ff01f97ec30d46e8a5113ed49350f6813c915f6202a093c7d28b21f9aed690cf0
+  data.tar.gz: 2dac25033ab69bc1819eae18a94e2f7b4b672e540438e94f6aa8d73fe414baa47b17d77a65137b667ee1a9d0c57927477e30563b34c08d1cf4dbfde5f760ca1f

data/CHANGELOG.md

@@ -4,6 +4,20 @@ Dalli Changelog
 Unreleased
 ==========
 
+5.1.8
+==========
+
+Bug fixes:
+
+- Raw values in an encoding that isn't ASCII-compatible, such as UTF-16, raised `Encoding::CompatibilityError` from `set`, `add`, `replace`, `append`, `prepend` and `set_multi`, as did a single-server `set_multi` mixing non-ASCII UTF-8 values with binary ones (such as raw Strings of both kinds, or with a JSON serializer, a value containing `é` next to a compressed one). A `p_token` or `l_token` with non-ASCII characters, such as `é`, did the same for any binary value, including every Marshal-serialized one. The error also closed the connection, so in a `quiet` block, or within one server's part of a multi-server `set_multi`, writes buffered before it were silently lost. Values are now sent as their bytes, which is what memcached stores (#1269)
+
+5.1.7
+==========
+
+Bug fixes:
+
+- `set_multi` across more than one server stored `nil` for a Symbol key or a key over 250 bytes, in place of the value given
+
 5.1.6
 ==========
 

data/lib/dalli/pipelined_setter.rb

@@ -43,9 +43,12 @@ 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)
-      groups = groups_for_keys(hash.keys)
-      make_set_requests(groups, 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.keys
     end
 
@@ -59,12 +62,10 @@ module Dalli
     # RetryableNetworkError too -- since NetworkError < DalliError -- dropping
     # this server's keys on a transient hiccup instead of retrying. Only a
     # non-network DalliError should be swallowed here.
-    def make_set_requests(groups, hash, ttl, req_options)
+    def make_set_requests(groups, pairs, ttl, req_options)
       groups.each do |server, keys_for_server|
         keys_for_server.each do |key|
-          original_key = @key_manager.key_without_namespace(key)
-          value = hash[original_key]
-          server.request(:pipelined_set, key, value, ttl, req_options)
+          server.request(:pipelined_set, key, pairs[key], ttl, req_options)
         rescue Dalli::NetworkError
           raise
         rescue Dalli::MarshalError, Dalli::ValueOverMaxSize => e
@@ -93,8 +94,7 @@ module Dalli
     end
 
     def groups_for_keys(keys)
-      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
-      groups = @ring.keys_grouped_by_server(validated_keys)
+      groups = @ring.keys_grouped_by_server(keys)
 
       if (unfound_keys = groups.delete(nil))
         Dalli.logger.debug do

data/lib/dalli/protocol/meta.rb

@@ -162,7 +162,7 @@ module Dalli
                                         bitflags: bitflags, cas: cas,
                                         ttl: ttl, mode: mode, quiet: quiet,
                                         **routing_token_kwargs(options))
-        write("#{req}#{value}#{TERMINATOR}")
+        write(request_with_value(req, value))
         @connection_manager.flush unless quiet
       end
       # rubocop:enable Metrics/ParameterLists
@@ -183,10 +183,20 @@ module Dalli
         req = RequestFormatter.meta_set(key: key, value: value,
                                         cas: cas, ttl: ttl, mode: mode, quiet: quiet?,
                                         **routing_token_kwargs(options))
-        write("#{req}#{value}#{TERMINATOR}")
+        write(request_with_value(req, value))
         @connection_manager.flush unless quiet?
       end
 
+      # Ruby refuses to join Strings whose encodings clash, such as a raw
+      # UTF-16 value, or a routing token with non-ASCII characters next to a
+      # binary value. memcached stores bytes, so join the bytes then.
+      # Joining the Strings first keeps the common case free of extra checks.
+      def request_with_value(req, value)
+        "#{req}#{value}#{TERMINATOR}"
+      rescue Encoding::CompatibilityError
+        "#{req.b}#{value.b}#{TERMINATOR}"
+      end
+
       # Delete Commands
       #
       # `options` supports the meta-delete keys :invalidate, :tombstone_ttl and

data/lib/dalli/protocol/request_formatter.rb

@@ -107,8 +107,9 @@ module Dalli
 
         def multi_meta_set(entries, ttl: nil, p_token: nil, l_token: nil)
           # Routing tokens apply to every entry in the batch, so the suffix is
-          # built once rather than per entry.
-          token_suffix = routing_tokens(p_token: p_token, l_token: l_token)
+          # built once rather than per entry. It's binary, like the buffer, so
+          # a token with non-ASCII characters doesn't turn the buffer UTF-8.
+          token_suffix = routing_tokens(p_token: p_token, l_token: l_token).b
           ttl = integer_flag(:ttl, ttl) if ttl
 
           buffer = ''.b
@@ -123,11 +124,29 @@ module Dalli
             buffer << ' b' if base64
             buffer << " F#{bitflags}" if bitflags
             buffer << " T#{ttl}" if ttl
-            buffer << ' MS q' << token_suffix << TERMINATOR << value << TERMINATOR
+            buffer << ' MS q' << token_suffix << TERMINATOR
+            append_bytes(buffer, value)
+            buffer << TERMINATOR
           end
           buffer << META_NOOP
         end
 
+        # Values are appended as bytes. One batch can hold UTF-8 and binary
+        # values, which String#<< refuses to combine, and a raw value can be in
+        # an encoding that isn't ASCII-compatible, such as UTF-16.
+        # Don't chain on the result: TruffleRuby's append_as_bytes returns its
+        # arguments rather than the buffer.
+        if String.method_defined?(:append_as_bytes)
+          def append_bytes(buffer, value)
+            buffer.append_as_bytes(value)
+          end
+        else
+          def append_bytes(buffer, value)
+            buffer << (value.encoding == Encoding::BINARY ? value : value.b)
+          end
+        end
+        private :append_bytes
+
         # 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.

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.1.6'
+  VERSION = '5.1.8'
 
   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.1.6
+  version: 5.1.8
 platform: ruby
 authors:
 - Peter M. Goldstein