activesupport 7.0.6 → 7.1.3.4

data/lib/active_support/message_encryptors.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "active_support/messages/rotation_coordinator"
+
+module ActiveSupport
+  class MessageEncryptors < Messages::RotationCoordinator
+    ##
+    # :attr_accessor: transitional
+    #
+    # If true, the first two rotation option sets are swapped when building
+    # message encryptors. For example, with the following configuration, message
+    # encryptors will encrypt messages using <tt>serializer: Marshal, url_safe: true</tt>,
+    # and will able to decrypt messages that were encrypted using any of the
+    # three option sets:
+    #
+    #   encryptors = ActiveSupport::MessageEncryptors.new { ... }
+    #   encryptors.rotate(serializer: JSON, url_safe: true)
+    #   encryptors.rotate(serializer: Marshal, url_safe: true)
+    #   encryptors.rotate(serializer: Marshal, url_safe: false)
+    #   encryptors.transitional = true
+    #
+    # This can be useful when performing a rolling deploy of an application,
+    # wherein servers that have not yet been updated must still be able to
+    # decrypt messages from updated servers. In such a scenario, first perform a
+    # rolling deploy with the new rotation (e.g. <tt>serializer: JSON, url_safe: true</tt>)
+    # as the first rotation and <tt>transitional = true</tt>. Then, after all
+    # servers have been updated, perform a second rolling deploy with
+    # <tt>transitional = false</tt>.
+
+    ##
+    # :method: initialize
+    # :call-seq: initialize(&secret_generator)
+    #
+    # Initializes a new instance. +secret_generator+ must accept a salt and a
+    # +secret_length+ kwarg, and return a suitable secret (string) or secrets
+    # (array of strings). +secret_generator+ may also accept other arbitrary
+    # kwargs. If #rotate is called with any options matching those kwargs, those
+    # options will be passed to +secret_generator+ instead of to the message
+    # encryptor.
+    #
+    #   encryptors = ActiveSupport::MessageEncryptors.new do |salt, secret_length:, base:|
+    #     MySecretGenerator.new(base).generate(salt, secret_length)
+    #   end
+    #
+    #   encryptors.rotate(base: "...")
+
+    ##
+    # :method: []
+    # :call-seq: [](salt)
+    #
+    # Returns a MessageEncryptor configured with a secret derived from the
+    # given +salt+, and options from #rotate. MessageEncryptor instances will
+    # be memoized, so the same +salt+ will return the same instance.
+
+    ##
+    # :method: []=
+    # :call-seq: []=(salt, encryptor)
+    #
+    # Overrides a MessageEncryptor instance associated with a given +salt+.
+
+    ##
+    # :method: rotate
+    # :call-seq:
+    #   rotate(**options)
+    #   rotate(&block)
+    #
+    # Adds +options+ to the list of option sets. Messages will be encrypted
+    # using the first set in the list. When decrypting, however, each set will
+    # be tried, in order, until one succeeds.
+    #
+    # Notably, the +:secret_generator+ option can specify a different secret
+    # generator than the one initially specified. The secret generator must
+    # respond to +call+, accept a salt and a +secret_length+ kwarg, and return
+    # a suitable secret (string) or secrets (array of strings). The secret
+    # generator may also accept other arbitrary kwargs.
+    #
+    # If any options match the kwargs of the operative secret generator, those
+    # options will be passed to the secret generator instead of to the message
+    # encryptor.
+    #
+    # For fine-grained per-salt rotations, a block form is supported. The block
+    # will receive the salt, and should return an appropriate options Hash. The
+    # block may also return +nil+ to indicate that the rotation does not apply
+    # to the given salt. For example:
+    #
+    #   encryptors = ActiveSupport::MessageEncryptors.new { ... }
+    #
+    #   encryptors.rotate do |salt|
+    #     case salt
+    #     when :foo
+    #       { serializer: JSON, url_safe: true }
+    #     when :bar
+    #       { serializer: Marshal, url_safe: true }
+    #     end
+    #   end
+    #
+    #   encryptors.rotate(serializer: Marshal, url_safe: false)
+    #
+    #   # Uses `serializer: JSON, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: false`.
+    #   encryptors[:foo]
+    #
+    #   # Uses `serializer: Marshal, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: false`.
+    #   encryptors[:bar]
+    #
+    #   # Uses `serializer: Marshal, url_safe: false`.
+    #   encryptors[:baz]
+
+    ##
+    # :method: rotate_defaults
+    # :call-seq: rotate_defaults
+    #
+    # Invokes #rotate with the default options.
+
+    ##
+    # :method: clear_rotations
+    # :call-seq: clear_rotations
+    #
+    # Clears the list of option sets.
+
+    ##
+    # :method: on_rotation
+    # :call-seq: on_rotation(&callback)
+    #
+    # Sets a callback to invoke when a message is decrypted using an option set
+    # other than the first.
+    #
+    # For example, this callback could log each time it is called, and thus
+    # indicate whether old option sets are still in use or can be removed from
+    # rotation.
+
+    ##
+    private
+      def build(salt, secret_generator:, secret_generator_options:, **options)
+        secret_length = MessageEncryptor.key_len(*options[:cipher])
+        secret = secret_generator.call(salt, secret_length: secret_length, **secret_generator_options)
+        MessageEncryptor.new(*Array(secret), **options)
+      end
+  end
+end

data/lib/active_support/message_pack/cache_serializer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "serializer"
+
+module ActiveSupport
+  module MessagePack
+    module CacheSerializer
+      include Serializer
+      extend self
+
+      def load(dumped)
+        super
+      rescue ActiveSupport::MessagePack::MissingClassError
+        # Treat missing class as cache miss => return nil
+      end
+
+      private
+        def install_unregistered_type_handler
+          Extensions.install_unregistered_type_fallback(message_pack_factory)
+        end
+    end
+  end
+end

data/lib/active_support/message_pack/extensions.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "ipaddr"
+require "pathname"
+require "uri/generic"
+require "msgpack/bigint"
+require "active_support/hash_with_indifferent_access"
+require "active_support/time"
+
+module ActiveSupport
+  module MessagePack
+    class UnserializableObjectError < StandardError; end
+    class MissingClassError < StandardError; end # :nodoc:
+
+    module Extensions # :nodoc:
+      extend self
+
+      def install(registry)
+        registry.register_type 0, Symbol,
+          packer: :to_msgpack_ext,
+          unpacker: :from_msgpack_ext,
+          optimized_symbols_parsing: true
+
+        registry.register_type 1, Integer,
+          packer: ::MessagePack::Bigint.method(:to_msgpack_ext),
+          unpacker: ::MessagePack::Bigint.method(:from_msgpack_ext),
+          oversized_integer_extension: true
+
+        registry.register_type 2, BigDecimal,
+          packer: :_dump,
+          unpacker: :_load
+
+        registry.register_type 3, Rational,
+          packer: method(:write_rational),
+          unpacker: method(:read_rational),
+          recursive: true
+
+        registry.register_type 4, Complex,
+          packer: method(:write_complex),
+          unpacker: method(:read_complex),
+          recursive: true
+
+        registry.register_type 5, DateTime,
+          packer: method(:write_datetime),
+          unpacker: method(:read_datetime),
+          recursive: true
+
+        registry.register_type 6, Date,
+          packer: method(:write_date),
+          unpacker: method(:read_date),
+          recursive: true
+
+        registry.register_type 7, Time,
+          packer: method(:write_time),
+          unpacker: method(:read_time),
+          recursive: true
+
+        registry.register_type 8, ActiveSupport::TimeWithZone,
+          packer: method(:write_time_with_zone),
+          unpacker: method(:read_time_with_zone),
+          recursive: true
+
+        registry.register_type 9, ActiveSupport::TimeZone,
+          packer: method(:dump_time_zone),
+          unpacker: method(:load_time_zone)
+
+        registry.register_type 10, ActiveSupport::Duration,
+          packer: method(:write_duration),
+          unpacker: method(:read_duration),
+          recursive: true
+
+        registry.register_type 11, Range,
+          packer: method(:write_range),
+          unpacker: method(:read_range),
+          recursive: true
+
+        registry.register_type 12, Set,
+          packer: method(:write_set),
+          unpacker: method(:read_set),
+          recursive: true
+
+        registry.register_type 13, URI::Generic,
+          packer: :to_s,
+          unpacker: URI.method(:parse)
+
+        registry.register_type 14, IPAddr,
+          packer: :to_s,
+          unpacker: :new
+
+        registry.register_type 15, Pathname,
+          packer: :to_s,
+          unpacker: :new
+
+        registry.register_type 16, Regexp,
+          packer: :to_s,
+          unpacker: :new
+
+        registry.register_type 17, ActiveSupport::HashWithIndifferentAccess,
+          packer: method(:write_hash_with_indifferent_access),
+          unpacker: method(:read_hash_with_indifferent_access),
+          recursive: true
+      end
+
+      def install_unregistered_type_error(registry)
+        registry.register_type 127, Object,
+          packer: method(:raise_unserializable),
+          unpacker: method(:raise_invalid_format)
+      end
+
+      def install_unregistered_type_fallback(registry)
+        registry.register_type 127, Object,
+          packer: method(:write_object),
+          unpacker: method(:read_object),
+          recursive: true
+      end
+
+      def write_rational(rational, packer)
+        packer.write(rational.numerator)
+        packer.write(rational.denominator) unless rational.numerator.zero?
+      end
+
+      def read_rational(unpacker)
+        numerator = unpacker.read
+        Rational(numerator, numerator.zero? ? 1 : unpacker.read)
+      end
+
+      def write_complex(complex, packer)
+        packer.write(complex.real)
+        packer.write(complex.imaginary)
+      end
+
+      def read_complex(unpacker)
+        Complex(unpacker.read, unpacker.read)
+      end
+
+      def write_datetime(datetime, packer)
+        packer.write(datetime.jd)
+        packer.write(datetime.hour)
+        packer.write(datetime.min)
+        packer.write(datetime.sec)
+        write_rational(datetime.sec_fraction, packer)
+        write_rational(datetime.offset, packer)
+      end
+
+      def read_datetime(unpacker)
+        DateTime.jd(unpacker.read, unpacker.read, unpacker.read, unpacker.read + read_rational(unpacker), read_rational(unpacker))
+      end
+
+      def write_date(date, packer)
+        packer.write(date.jd)
+      end
+
+      def read_date(unpacker)
+        Date.jd(unpacker.read)
+      end
+
+      def write_time(time, packer)
+        packer.write(time.tv_sec)
+        packer.write(time.tv_nsec)
+        packer.write(time.utc_offset)
+      end
+
+      def read_time(unpacker)
+        Time.at_without_coercion(unpacker.read, unpacker.read, :nanosecond, in: unpacker.read)
+      end
+
+      def write_time_with_zone(twz, packer)
+        write_time(twz.utc, packer)
+        write_time_zone(twz.time_zone, packer)
+      end
+
+      def read_time_with_zone(unpacker)
+        ActiveSupport::TimeWithZone.new(read_time(unpacker), read_time_zone(unpacker))
+      end
+
+      def dump_time_zone(time_zone)
+        time_zone.name
+      end
+
+      def load_time_zone(name)
+        ActiveSupport::TimeZone[name]
+      end
+
+      def write_time_zone(time_zone, packer)
+        packer.write(dump_time_zone(time_zone))
+      end
+
+      def read_time_zone(unpacker)
+        load_time_zone(unpacker.read)
+      end
+
+      def write_duration(duration, packer)
+        packer.write(duration.value)
+        packer.write(duration._parts.values_at(*ActiveSupport::Duration::PARTS))
+      end
+
+      def read_duration(unpacker)
+        value = unpacker.read
+        parts = ActiveSupport::Duration::PARTS.zip(unpacker.read).to_h
+        parts.compact!
+        ActiveSupport::Duration.new(value, parts)
+      end
+
+      def write_range(range, packer)
+        packer.write(range.begin)
+        packer.write(range.end)
+        packer.write(range.exclude_end?)
+      end
+
+      def read_range(unpacker)
+        Range.new(unpacker.read, unpacker.read, unpacker.read)
+      end
+
+      def write_set(set, packer)
+        packer.write(set.to_a)
+      end
+
+      def read_set(unpacker)
+        Set.new(unpacker.read)
+      end
+
+      def write_hash_with_indifferent_access(hwia, packer)
+        packer.write(hwia.to_h)
+      end
+
+      def read_hash_with_indifferent_access(unpacker)
+        ActiveSupport::HashWithIndifferentAccess.new(unpacker.read)
+      end
+
+      def raise_unserializable(object, *)
+        raise UnserializableObjectError, "Unsupported type #{object.class} for object #{object.inspect}"
+      end
+
+      def raise_invalid_format(*)
+        raise "Invalid format"
+      end
+
+      def dump_class(klass)
+        raise UnserializableObjectError, "Cannot serialize anonymous class" unless klass.name
+        klass.name
+      end
+
+      def load_class(name)
+        Object.const_get(name)
+      rescue NameError => error
+        if error.name.to_s == name
+          raise MissingClassError, "Missing class: #{name}"
+        else
+          raise
+        end
+      end
+
+      def write_class(klass, packer)
+        packer.write(dump_class(klass))
+      end
+
+      def read_class(unpacker)
+        load_class(unpacker.read)
+      end
+
+      LOAD_WITH_MSGPACK_EXT = 0
+      LOAD_WITH_JSON_CREATE = 1
+
+      def write_object(object, packer)
+        if object.class.respond_to?(:from_msgpack_ext)
+          packer.write(LOAD_WITH_MSGPACK_EXT)
+          write_class(object.class, packer)
+          packer.write(object.to_msgpack_ext)
+        elsif object.class.respond_to?(:json_create)
+          packer.write(LOAD_WITH_JSON_CREATE)
+          write_class(object.class, packer)
+          packer.write(object.as_json)
+        else
+          raise_unserializable(object)
+        end
+      end
+
+      def read_object(unpacker)
+        case unpacker.read
+        when LOAD_WITH_MSGPACK_EXT
+          read_class(unpacker).from_msgpack_ext(unpacker.read)
+        when LOAD_WITH_JSON_CREATE
+          read_class(unpacker).json_create(unpacker.read)
+        else
+          raise_invalid_format
+        end
+      end
+    end
+  end
+end

data/lib/active_support/message_pack/serializer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "extensions"
+
+module ActiveSupport
+  module MessagePack
+    module Serializer # :nodoc:
+      SIGNATURE = "\xCC\x80".b.freeze # == 128.to_msgpack
+      SIGNATURE_INT = 128
+
+      def dump(object)
+        message_pack_pool.packer do |packer|
+          packer.write(SIGNATURE_INT)
+          packer.write(object)
+          packer.full_pack
+        end
+      end
+
+      def load(dumped)
+        message_pack_pool.unpacker do |unpacker|
+          unpacker.feed_reference(dumped)
+          raise "Invalid serialization format" unless unpacker.read == SIGNATURE_INT
+          unpacker.full_unpack
+        end
+      end
+
+      def signature?(dumped)
+        dumped.getbyte(0) == SIGNATURE.getbyte(0) && dumped.getbyte(1) == SIGNATURE.getbyte(1)
+      end
+
+      def message_pack_factory
+        @message_pack_factory ||= ::MessagePack::Factory.new
+      end
+
+      def message_pack_factory=(factory)
+        @message_pack_pool = nil
+        @message_pack_factory = factory
+      end
+
+      delegate :register_type, to: :message_pack_factory
+
+      def warmup
+        message_pack_pool # eagerly compute
+      end
+
+      private
+        def message_pack_pool
+          @message_pack_pool ||= begin
+            unless message_pack_factory.frozen?
+              Extensions.install(message_pack_factory)
+              install_unregistered_type_handler
+              message_pack_factory.freeze
+            end
+            message_pack_factory.pool(ENV.fetch("RAILS_MAX_THREADS", 5).to_i)
+          end
+        end
+
+        def install_unregistered_type_handler
+          Extensions.install_unregistered_type_error(message_pack_factory)
+        end
+    end
+  end
+end

data/lib/active_support/message_pack.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+begin
+  gem "msgpack", ">= 1.7.0"
+  require "msgpack"
+rescue LoadError => error
+  warn "ActiveSupport::MessagePack requires the msgpack gem, version 1.7.0 or later. " \
+    "Please add it to your Gemfile: `gem \"msgpack\", \">= 1.7.0\"`"
+  raise error
+end
+
+require_relative "message_pack/cache_serializer"
+require_relative "message_pack/serializer"
+
+module ActiveSupport
+  module MessagePack
+    extend Serializer
+
+    ##
+    # :singleton-method: dump
+    # :call-seq: dump(object)
+    #
+    # Dumps an object. Raises ActiveSupport::MessagePack::UnserializableObjectError
+    # if the object type is not supported.
+    #
+    #--
+    # Implemented by Serializer#dump.
+
+    ##
+    # :singleton-method: load
+    # :call-seq: load(dumped)
+    #
+    # Loads an object dump created by ::dump.
+    #
+    #--
+    # Implemented by Serializer#load.
+
+    ##
+    # :singleton-method: signature?
+    # :call-seq: signature?(dumped)
+    #
+    # Returns true if the given dump begins with an +ActiveSupport::MessagePack+
+    # signature.
+    #
+    #--
+    # Implemented by Serializer#signature?.
+
+    ActiveSupport.run_load_hooks(:message_pack, self)
+  end
+end