omg-activesupport 8.0.0.alpha1

data/lib/active_support/cache/file_store.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/file/atomic"
+require "active_support/core_ext/string/conversions"
+require "uri/common"
+
+module ActiveSupport
+  module Cache
+    # = \File \Cache \Store
+    #
+    # A cache store implementation which stores everything on the filesystem.
+    class FileStore < Store
+      attr_reader :cache_path
+
+      DIR_FORMATTER = "%03X"
+      FILENAME_MAX_SIZE = 226 # max filename size on file system is 255, minus room for timestamp, pid, and random characters appended by Tempfile (used by atomic write)
+      FILEPATH_MAX_SIZE = 900 # max is 1024, plus some room
+      GITKEEP_FILES = [".gitkeep", ".keep"].freeze
+
+      def initialize(cache_path, **options)
+        super(options)
+        @cache_path = cache_path.to_s
+      end
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      # Deletes all items from the cache. In this case it deletes all the entries in the specified
+      # file store directory except for .keep or .gitkeep. Be careful which directory is specified in your
+      # config file when using +FileStore+ because everything in that directory will be deleted.
+      def clear(options = nil)
+        root_dirs = (Dir.children(cache_path) - GITKEEP_FILES)
+        FileUtils.rm_r(root_dirs.collect { |f| File.join(cache_path, f) })
+      rescue Errno::ENOENT, Errno::ENOTEMPTY
+      end
+
+      # Preemptively iterates through all stored keys and removes the ones which have expired.
+      def cleanup(options = nil)
+        options = merged_options(options)
+        search_dir(cache_path) do |fname|
+          entry = read_entry(fname, **options)
+          delete_entry(fname, **options) if entry && entry.expired?
+        end
+      end
+
+      # Increment a cached integer value. Returns the updated value.
+      #
+      # If the key is unset, it starts from +0+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.increment("baz") # => 6
+      #
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
+          modify_value(name, amount, options)
+        end
+      end
+
+      # Decrement a cached integer value. Returns the updated value.
+      #
+      # If the key is unset, it will be set to +-amount+.
+      #
+      #   cache.decrement("foo") # => -1
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.decrement("baz") # => 4
+      #
+      def decrement(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
+          modify_value(name, -amount, options)
+        end
+      end
+
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        matcher = key_matcher(matcher, options)
+
+        instrument(:delete_matched, matcher.inspect) do
+          search_dir(cache_path) do |path|
+            key = file_path_key(path)
+            delete_entry(path, **options) if key.match(matcher)
+          end
+        end
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name} cache_path=#{@cache_path}, options=#{@options.inspect}>"
+      end
+
+      private
+        def read_entry(key, **options)
+          if payload = read_serialized_entry(key, **options)
+            entry = deserialize_entry(payload)
+            entry if entry.is_a?(Cache::Entry)
+          end
+        end
+
+        def read_serialized_entry(key, **)
+          File.binread(key) if File.exist?(key)
+        rescue => error
+          logger.error("FileStoreError (#{error}): #{error.message}") if logger
+          nil
+        end
+
+        def write_entry(key, entry, **options)
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, payload, **options)
+          return false if options[:unless_exist] && File.exist?(key)
+          ensure_cache_path(File.dirname(key))
+          File.atomic_write(key, cache_path) { |f| f.write(payload) }
+          true
+        end
+
+        def delete_entry(key, **options)
+          if File.exist?(key)
+            begin
+              File.delete(key)
+              delete_empty_directories(File.dirname(key))
+              true
+            rescue
+              # Just in case the error was caused by another process deleting the file first.
+              raise if File.exist?(key)
+              false
+            end
+          else
+            false
+          end
+        end
+
+        # Lock a file for a block so only one process can modify it at a time.
+        def lock_file(file_name, &block)
+          if File.exist?(file_name)
+            File.open(file_name, "r+") do |f|
+              f.flock File::LOCK_EX
+              yield
+            ensure
+              f.flock File::LOCK_UN
+            end
+          else
+            yield
+          end
+        end
+
+        # Translate a key into a file path.
+        def normalize_key(key, options)
+          key = super
+          fname = URI.encode_www_form_component(key)
+
+          if fname.size > FILEPATH_MAX_SIZE
+            fname = ActiveSupport::Digest.hexdigest(key)
+          end
+
+          hash = Zlib.adler32(fname)
+          hash, dir_1 = hash.divmod(0x1000)
+          dir_2 = hash.modulo(0x1000)
+
+          # Make sure file name doesn't exceed file system limits.
+          if fname.length < FILENAME_MAX_SIZE
+            fname_paths = fname
+          else
+            fname_paths = []
+            begin
+              fname_paths << fname[0, FILENAME_MAX_SIZE]
+              fname = fname[FILENAME_MAX_SIZE..-1]
+            end until fname.blank?
+          end
+
+          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, fname_paths)
+        end
+
+        # Translate a file path into a key.
+        def file_path_key(path)
+          fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last.delete(File::SEPARATOR)
+          URI.decode_www_form_component(fname, Encoding::UTF_8)
+        end
+
+        # Delete empty directories in the cache.
+        def delete_empty_directories(dir)
+          return if File.realpath(dir) == File.realpath(cache_path)
+          if Dir.children(dir).empty?
+            Dir.delete(dir) rescue nil
+            delete_empty_directories(File.dirname(dir))
+          end
+        end
+
+        # Make sure a file path's directories exist.
+        def ensure_cache_path(path)
+          FileUtils.makedirs(path) unless File.exist?(path)
+        end
+
+        def search_dir(dir, &callback)
+          return if !File.exist?(dir)
+          Dir.each_child(dir) do |d|
+            name = File.join(dir, d)
+            if File.directory?(name)
+              search_dir(name, &callback)
+            else
+              callback.call name
+            end
+          end
+        end
+
+        # Modifies the amount of an integer value that is stored in the cache.
+        # If the key is not found it is created and set to +amount+.
+        def modify_value(name, amount, options)
+          options = merged_options(options)
+          key = normalize_key(name, options)
+          version = normalize_version(name, options)
+          amount = Integer(amount)
+
+          lock_file(key) do
+            entry = read_entry(key, **options)
+
+            if !entry || entry.expired? || entry.mismatched?(version)
+              write(name, amount, options)
+              amount
+            else
+              num = entry.value.to_i + amount
+              entry = Entry.new(num, expires_at: entry.expires_at, version: entry.version)
+              write_entry(key, entry)
+              num
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_support/cache/mem_cache_store.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+begin
+  require "dalli"
+rescue LoadError => e
+  warn "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+
+require "connection_pool"
+require "delegate"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/numeric/time"
+
+module ActiveSupport
+  module Cache
+    # = Memcached \Cache \Store
+    #
+    # A cache store implementation which stores data in Memcached:
+    # https://memcached.org
+    #
+    # This is currently the most popular cache store for production websites.
+    #
+    # Special features:
+    # - Clustering and load balancing. One can specify multiple memcached servers,
+    #   and +MemCacheStore+ will load balance between all available servers. If a
+    #   server goes down, then +MemCacheStore+ will ignore it until it comes back up.
+    #
+    # +MemCacheStore+ implements the Strategy::LocalCache strategy which
+    # implements an in-memory cache inside of a block.
+    class MemCacheStore < Store
+      # These options represent behavior overridden by this implementation and should
+      # not be allowed to get down to the Dalli client
+      OVERRIDDEN_OPTIONS = UNIVERSAL_OPTIONS
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      prepend Strategy::LocalCache
+
+      KEY_MAX_SIZE = 250
+      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
+
+      # Creates a new Dalli::Client instance with specified addresses and options.
+      # If no addresses are provided, we give nil to Dalli::Client, so it uses its fallbacks:
+      # - ENV["MEMCACHE_SERVERS"] (if defined)
+      # - "127.0.0.1:11211"        (otherwise)
+      #
+      #   ActiveSupport::Cache::MemCacheStore.build_mem_cache
+      #     # => #<Dalli::Client:0x007f98a47d2028 @servers=["127.0.0.1:11211"], @options={}, @ring=nil>
+      #   ActiveSupport::Cache::MemCacheStore.build_mem_cache('localhost:10290')
+      #     # => #<Dalli::Client:0x007f98a47b3a60 @servers=["localhost:10290"], @options={}, @ring=nil>
+      def self.build_mem_cache(*addresses) # :nodoc:
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        addresses = nil if addresses.compact.empty?
+        pool_options = retrieve_pool_options(options)
+
+        if pool_options
+          ConnectionPool.new(pool_options) { Dalli::Client.new(addresses, options.merge(threadsafe: false)) }
+        else
+          Dalli::Client.new(addresses, options)
+        end
+      end
+
+      # Creates a new +MemCacheStore+ object, with the given memcached server
+      # addresses. Each address is either a host name, or a host-with-port string
+      # in the form of "host_name:port". For example:
+      #
+      #   ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
+      #
+      # If no addresses are provided, but <tt>ENV['MEMCACHE_SERVERS']</tt> is defined, it will be used instead. Otherwise,
+      # +MemCacheStore+ will connect to localhost:11211 (the default memcached port).
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        if options.key?(:cache_nils)
+          options[:skip_nil] = !options.delete(:cache_nils)
+        end
+        super(options)
+
+        unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
+          raise ArgumentError, "First argument must be an empty array, address, or array of addresses."
+        end
+
+        @mem_cache_options = options.dup
+        # The value "compress: false" prevents duplicate compression within Dalli.
+        @mem_cache_options[:compress] = false
+        (OVERRIDDEN_OPTIONS - %i(compress)).each { |name| @mem_cache_options.delete(name) }
+        @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
+      end
+
+      def inspect
+        instance = @data || @mem_cache_options
+        "#<#{self.class} options=#{options.inspect} mem_cache=#{instance.inspect}>"
+      end
+
+      ##
+      # :method: write
+      # :call-seq: write(name, value, options = nil)
+      #
+      # Behaves the same as ActiveSupport::Cache::Store#write, but supports
+      # additional options specific to memcached.
+      #
+      # ==== Additional Options
+      #
+      # * <tt>raw: true</tt> - Sends the value directly to the server as raw
+      #   bytes. The value must be a string or number. You can use memcached
+      #   direct operations like +increment+ and +decrement+ only on raw values.
+      #
+      # * <tt>unless_exist: true</tt> - Prevents overwriting an existing cache
+      #   entry.
+
+      # Increment a cached integer value using the memcached incr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.increment("baz") # => 6
+      #
+      # Incrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
+          rescue_error_with nil do
+            @data.with { |c| c.incr(key, amount, options[:expires_in], amount) }
+          end
+        end
+      end
+
+      # Decrement a cached integer value using the memcached decr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to 0. Memcached
+      # does not support negative counters.
+      #
+      #   cache.decrement("foo") # => 0
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.decrement("baz") # => 4
+      #
+      # Decrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      def decrement(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
+          rescue_error_with nil do
+            @data.with { |c| c.decr(key, amount, options[:expires_in], 0) }
+          end
+        end
+      end
+
+      # Clear the entire cache on all memcached servers. This method should
+      # be used with care when shared cache is being used.
+      def clear(options = nil)
+        rescue_error_with(nil) { @data.with { |c| c.flush_all } }
+      end
+
+      # Get the statistics from the memcached servers.
+      def stats
+        @data.with { |c| c.stats }
+      end
+
+      private
+        # Read an entry from the cache.
+        def read_entry(key, **options)
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, **options)
+          rescue_error_with(nil) do
+            @data.with { |c| c.get(key, options) }
+          end
+        end
+
+        # Write an entry to the cache.
+        def write_entry(key, entry, **options)
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, payload, **options)
+          method = options[:unless_exist] ? :add : :set
+          expires_in = options[:expires_in].to_i
+          if options[:race_condition_ttl] && expires_in > 0 && !options[:raw]
+            # Set the memcache expire a few minutes in the future to support race condition ttls on read
+            expires_in += 5.minutes
+          end
+          rescue_error_with nil do
+            # Don't pass compress option to Dalli since we are already dealing with compression.
+            options.delete(:compress)
+            @data.with { |c| !!c.send(method, key, payload, expires_in, **options) }
+          end
+        end
+
+        # Reads multiple entries from the cache implementation.
+        def read_multi_entries(names, **options)
+          keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+          raw_values = begin
+            @data.with { |c| c.get_multi(keys_to_names.keys) }
+          rescue Dalli::UnmarshalError
+            {}
+          end
+
+          values = {}
+
+          raw_values.each do |key, value|
+            entry = deserialize_entry(value, raw: options[:raw])
+
+            unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
+              begin
+                values[keys_to_names[key]] = entry.value
+              rescue DeserializationError
+              end
+            end
+          end
+
+          values
+        end
+
+        # Delete an entry from the cache.
+        def delete_entry(key, **options)
+          rescue_error_with(false) { @data.with { |c| c.delete(key) } }
+        end
+
+        def serialize_entry(entry, raw: false, **options)
+          if raw
+            entry.value.to_s
+          else
+            super(entry, raw: raw, **options)
+          end
+        end
+
+        # Memcache keys are binaries. So we need to force their encoding to binary
+        # before applying the regular expression to ensure we are escaping all
+        # characters properly.
+        def normalize_key(key, options)
+          key = super
+          if key
+            key = key.dup.force_encoding(Encoding::ASCII_8BIT)
+            key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+
+            if key.size > KEY_MAX_SIZE
+              key_separator = ":hash:"
+              key_hash = ActiveSupport::Digest.hexdigest(key)
+              key_trim_size = KEY_MAX_SIZE - key_separator.size - key_hash.size
+              key = "#{key[0, key_trim_size]}#{key_separator}#{key_hash}"
+            end
+          end
+          key
+        end
+
+        def deserialize_entry(payload, raw: false, **)
+          if payload && raw
+            Entry.new(payload)
+          else
+            super(payload)
+          end
+        end
+
+        def rescue_error_with(fallback)
+          yield
+        rescue Dalli::DalliError => error
+          logger.error("DalliError (#{error}): #{error.message}") if logger
+          ActiveSupport.error_reporter&.report(
+            error,
+            severity: :warning,
+            source: "mem_cache_store.active_support",
+          )
+          fallback
+        end
+    end
+  end
+end