activesupport 6.0.6.1 → 7.1.3.2

data/lib/active_support/cache/serializer_with_fallback.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "active_support/core_ext/kernel/reporting"
+
+module ActiveSupport
+  module Cache
+    module SerializerWithFallback # :nodoc:
+      def self.[](format)
+        if format.to_s.include?("message_pack") && !defined?(ActiveSupport::MessagePack)
+          require "active_support/message_pack"
+        end
+
+        SERIALIZERS.fetch(format)
+      end
+
+      def load(dumped)
+        if dumped.is_a?(String)
+          case
+          when MessagePackWithFallback.dumped?(dumped)
+            MessagePackWithFallback._load(dumped)
+          when Marshal71WithFallback.dumped?(dumped)
+            Marshal71WithFallback._load(dumped)
+          when Marshal70WithFallback.dumped?(dumped)
+            Marshal70WithFallback._load(dumped)
+          else
+            Cache::Store.logger&.warn("Unrecognized payload prefix #{dumped.byteslice(0).inspect}; deserializing as nil")
+            nil
+          end
+        elsif PassthroughWithFallback.dumped?(dumped)
+          PassthroughWithFallback._load(dumped)
+        else
+          Cache::Store.logger&.warn("Unrecognized payload class #{dumped.class}; deserializing as nil")
+          nil
+        end
+      end
+
+      private
+        def marshal_load(payload)
+          Marshal.load(payload)
+        rescue ArgumentError => error
+          raise Cache::DeserializationError, error.message
+        end
+
+        module PassthroughWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def dump(entry)
+            entry
+          end
+
+          def dump_compressed(entry, threshold)
+            entry.compressed(threshold)
+          end
+
+          def _load(entry)
+            entry
+          end
+
+          def dumped?(dumped)
+            dumped.is_a?(Cache::Entry)
+          end
+        end
+
+        module Marshal61WithFallback
+          include SerializerWithFallback
+          extend self
+
+          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+          def dump(entry)
+            Marshal.dump(entry)
+          end
+
+          def dump_compressed(entry, threshold)
+            Marshal.dump(entry.compressed(threshold))
+          end
+
+          alias_method :_load, :marshal_load
+          public :_load
+
+          def dumped?(dumped)
+            dumped.start_with?(MARSHAL_SIGNATURE)
+          end
+        end
+
+        module Marshal70WithFallback
+          include SerializerWithFallback
+          extend self
+
+          MARK_UNCOMPRESSED = "\x00".b.freeze
+          MARK_COMPRESSED   = "\x01".b.freeze
+
+          def dump(entry)
+            MARK_UNCOMPRESSED + Marshal.dump(entry.pack)
+          end
+
+          def dump_compressed(entry, threshold)
+            dumped = Marshal.dump(entry.pack)
+
+            if dumped.bytesize >= threshold
+              compressed = Zlib::Deflate.deflate(dumped)
+              return MARK_COMPRESSED + compressed if compressed.bytesize < dumped.bytesize
+            end
+
+            MARK_UNCOMPRESSED + dumped
+          end
+
+          def _load(marked)
+            dumped = marked.byteslice(1..-1)
+            dumped = Zlib::Inflate.inflate(dumped) if marked.start_with?(MARK_COMPRESSED)
+            Cache::Entry.unpack(marshal_load(dumped))
+          end
+
+          def dumped?(dumped)
+            dumped.start_with?(MARK_UNCOMPRESSED, MARK_COMPRESSED)
+          end
+        end
+
+        module Marshal71WithFallback
+          include SerializerWithFallback
+          extend self
+
+          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+          def dump(value)
+            Marshal.dump(value)
+          end
+
+          def _load(dumped)
+            marshal_load(dumped)
+          end
+
+          def dumped?(dumped)
+            dumped.start_with?(MARSHAL_SIGNATURE)
+          end
+        end
+
+        module MessagePackWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def dump(value)
+            ActiveSupport::MessagePack::CacheSerializer.dump(value)
+          end
+
+          def _load(dumped)
+            ActiveSupport::MessagePack::CacheSerializer.load(dumped)
+          end
+
+          def dumped?(dumped)
+            available? && ActiveSupport::MessagePack.signature?(dumped)
+          end
+
+          private
+            def available?
+              return @available if defined?(@available)
+              silence_warnings { require "active_support/message_pack" }
+              @available = true
+            rescue LoadError
+              @available = false
+            end
+        end
+
+        SERIALIZERS = {
+          passthrough: PassthroughWithFallback,
+          marshal_6_1: Marshal61WithFallback,
+          marshal_7_0: Marshal70WithFallback,
+          marshal_7_1: Marshal71WithFallback,
+          message_pack: MessagePackWithFallback,
+        }
+    end
+  end
+end

data/lib/active_support/cache/strategy/local_cache.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/duplicable"
 require "active_support/core_ext/string/inflections"
-require "active_support/per_thread_registry"
 
 module ActiveSupport
   module Cache
     module Strategy
+      # = Local \Cache \Strategy
+      #
       # Caches that implement LocalCache will be backed by an in-memory cache for the
       # duration of a block. Repeated calls to the cache for the same key will hit the
       # in-memory cache for faster access.
@@ -14,74 +14,58 @@ module ActiveSupport
         autoload :Middleware, "active_support/cache/strategy/local_cache_middleware"
 
         # Class for storing and registering the local caches.
-        class LocalCacheRegistry # :nodoc:
-          extend ActiveSupport::PerThreadRegistry
-
-          def initialize
-            @registry = {}
-          end
+        module LocalCacheRegistry # :nodoc:
+          extend self
 
           def cache_for(local_cache_key)
-            @registry[local_cache_key]
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key]
           end
 
           def set_cache_for(local_cache_key, value)
-            @registry[local_cache_key] = value
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key] = value
           end
-
-          def self.set_cache_for(l, v); instance.set_cache_for l, v; end
-          def self.cache_for(l); instance.cache_for l; end
         end
 
+        # = Local \Cache \Store
+        #
         # Simple memory backed cache. This cache is not thread safe and is intended only
         # for serving as a temporary memory cache for a single thread.
-        class LocalStore < Store
+        class LocalStore
           def initialize
-            super
             @data = {}
           end
 
-          # Don't allow synchronizing since it isn't thread safe.
-          def synchronize # :nodoc:
-            yield
-          end
-
           def clear(options = nil)
             @data.clear
           end
 
-          def read_entry(key, **options)
+          def read_entry(key)
             @data[key]
           end
 
-          def read_multi_entries(keys, **options)
-            values = {}
-
-            keys.each do |name|
-              entry = read_entry(name, **options)
-              values[name] = entry.value if entry
-            end
-
-            values
+          def read_multi_entries(keys)
+            @data.slice(*keys)
           end
 
-          def write_entry(key, value, **options)
-            @data[key] = value
+          def write_entry(key, entry)
+            @data[key] = entry
             true
           end
 
-          def delete_entry(key, **options)
+          def delete_entry(key)
             !!@data.delete(key)
           end
 
-          def fetch_entry(key, options = nil) # :nodoc:
+          def fetch_entry(key) # :nodoc:
             @data.fetch(key) { @data[key] = yield }
           end
         end
 
         # Use a local cache for the duration of block.
-        def with_local_cache
-          use_temporary_local_cache(LocalStore.new) { yield }
+        def with_local_cache(&block)
+          use_temporary_local_cache(LocalStore.new, &block)
         end
 
         # Middleware class can be inserted as a Rack handler to be local cache for the
@@ -92,78 +76,101 @@ module ActiveSupport
             local_cache_key)
         end
 
-        def clear(**options) # :nodoc:
+        def clear(options = nil) # :nodoc:
           return super unless cache = local_cache
           cache.clear(options)
           super
         end
 
-        def cleanup(**options) # :nodoc:
+        def cleanup(options = nil) # :nodoc:
           return super unless cache = local_cache
-          cache.clear
+          cache.clear(options)
           super
         end
 
-        def increment(name, amount = 1, **options) # :nodoc:
+        def delete_matched(matcher, options = nil) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear(options)
+          super
+        end
+
+        def increment(name, amount = 1, options = nil) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, **options)
+          if options
+            write_cache_value(name, value, raw: true, **options)
+          else
+            write_cache_value(name, value, raw: true)
+          end
           value
         end
 
-        def decrement(name, amount = 1, **options) # :nodoc:
+        def decrement(name, amount = 1, options = nil) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, **options)
+          if options
+            write_cache_value(name, value, raw: true, **options)
+          else
+            write_cache_value(name, value, raw: true)
+          end
           value
         end
 
         private
-          def read_entry(key, **options)
+          def read_serialized_entry(key, raw: false, **options)
             if cache = local_cache
-              cache.fetch_entry(key) { super }
+              hit = true
+              entry = cache.fetch_entry(key) do
+                hit = false
+                super
+              end
+              options[:event][:store] = cache.class.name if hit && options[:event]
+              entry
             else
               super
             end
           end
 
-          def read_multi_entries(keys, **options)
+          def read_multi_entries(names, **options)
             return super unless local_cache
 
-            local_entries = local_cache.read_multi_entries(keys, **options)
-            missed_keys = keys - local_entries.keys
+            keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
-            if missed_keys.any?
-              local_entries.merge!(super(missed_keys, **options))
+            local_entries = local_cache.read_multi_entries(keys_to_names.keys)
+            local_entries.transform_keys! { |key| keys_to_names[key] }
+            local_entries.transform_values! do |payload|
+              deserialize_entry(payload, **options)&.value
+            end
+            missed_names = names - local_entries.keys
+
+            if missed_names.any?
+              local_entries.merge!(super(missed_names, **options))
             else
               local_entries
             end
           end
 
-          def write_entry(key, entry, **options)
-            if options[:unless_exist]
-              local_cache.delete_entry(key, **options) if local_cache
+          def write_serialized_entry(key, payload, **)
+            if return_value = super
+              local_cache.write_entry(key, payload) if local_cache
             else
-              local_cache.write_entry(key, entry, **options) if local_cache
+              local_cache.delete_entry(key) if local_cache
             end
-
-            super
+            return_value
           end
 
-          def delete_entry(key, **options)
-            local_cache.delete_entry(key, **options) if local_cache
+          def delete_entry(key, **)
+            local_cache.delete_entry(key) if local_cache
             super
           end
 
           def write_cache_value(name, value, **options)
             name = normalize_key(name, options)
             cache = local_cache
-            cache.mute do
-              if value
-                cache.write(name, value, options)
-              else
-                cache.delete(name, **options)
-              end
+            if value
+              cache.write_entry(name, serialize_entry(new_entry(value, **options), **options))
+            else
+              cache.delete_entry(name)
             end
           end
 
@@ -175,8 +182,8 @@ module ActiveSupport
             LocalCacheRegistry.cache_for(local_cache_key)
           end
 
-          def bypass_local_cache
-            use_temporary_local_cache(nil) { yield }
+          def bypass_local_cache(&block)
+            use_temporary_local_cache(nil, &block)
           end
 
           def use_temporary_local_cache(temporary_cache)