solid_objects 0.2.0 → 0.3.0

data/lib/solid_objects/commit_action_registry.rb

@@ -0,0 +1,42 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  CommitActionContext = Data.define(
+    :message_id,
+    :request_id,
+    :actor_type,
+    :actor_id,
+    :activation_generation
+  )
+
+  class CommitActionRegistry
+    # @rbs @handlers: Hash[String, Proc]
+    # @rbs @mutex: Mutex
+
+    # @rbs () -> void
+    def initialize
+      @handlers = {}
+      @mutex = Mutex.new
+    end
+
+    # @rbs (String | Symbol, Proc) -> Proc
+    def register(name, handler)
+      action_name = name.to_s
+      raise ArgumentError, "commit action name cannot be empty" if action_name.empty?
+
+      mutex.synchronize { handlers[action_name] = handler }
+      handler
+    end
+
+    # @rbs (String | Symbol) -> Proc
+    def fetch(name)
+      handlers.fetch(name.to_s) do
+        raise UnknownCommitAction, "no commit action registered for #{name.inspect}"
+      end
+    end
+
+    private
+
+    attr_reader :handlers, :mutex
+  end
+end

data/lib/solid_objects/configuration.rb

@@ -20,6 +20,11 @@ module SolidObjects
     # @rbs @process_heartbeat_interval: Float
     # @rbs @process_alive_threshold: Float
     # @rbs @shutdown_timeout: Float
+    # @rbs @message_retention: Numeric
+    # @rbs @message_retention_by_actor_type: Hash[String, Numeric]
+    # @rbs @instance_retention_by_actor_type: Hash[String, Numeric]
+    # @rbs @process_retention: Numeric
+    # @rbs @prune_batch_size: Integer
     # @rbs @worker_count: Integer
     # @rbs @effect_worker_count: Integer
     # @rbs @broadcast_worker_count: Integer
@@ -53,6 +58,11 @@ module SolidObjects
       :process_heartbeat_interval,
       :process_alive_threshold,
       :shutdown_timeout,
+      :message_retention,
+      :message_retention_by_actor_type,
+      :instance_retention_by_actor_type,
+      :process_retention,
+      :prune_batch_size,
       :worker_count,
       :effect_worker_count,
       :broadcast_worker_count,
@@ -88,6 +98,11 @@ module SolidObjects
       @process_heartbeat_interval = 15.0
       @process_alive_threshold = 60.0
       @shutdown_timeout = 15.0
+      @message_retention = 30.days
+      @message_retention_by_actor_type = {}
+      @instance_retention_by_actor_type = {}
+      @process_retention = 7.days
+      @prune_batch_size = 1_000
       @worker_count = 1
       @effect_worker_count = 1
       @broadcast_worker_count = 1
@@ -128,6 +143,14 @@ module SolidObjects
       positive_values.each do |name, value|
         raise ArgumentError, "#{name} must be positive" unless value.positive?
       end
+      message_retention_by_actor_type.each do |actor_type, retention|
+        raise ArgumentError, "actor type cannot be empty" if actor_type.to_s.empty?
+        raise ArgumentError, "message retention must be positive" unless retention.positive?
+      end
+      instance_retention_by_actor_type.each do |actor_type, retention|
+        raise ArgumentError, "actor type cannot be empty" if actor_type.to_s.empty?
+        raise ArgumentError, "instance retention must be positive" unless retention.positive?
+      end
 
       self
     end
@@ -151,7 +174,10 @@ module SolidObjects
         max_attempts:,
         process_heartbeat_interval:,
         process_alive_threshold:,
-        shutdown_timeout:
+        shutdown_timeout:,
+        message_retention:,
+        process_retention:,
+        prune_batch_size:
       }
     end
 

data/lib/solid_objects/database_adapter.rb

@@ -54,9 +54,22 @@ module SolidObjects
 
     # @rbs () { () -> untyped } -> untyped
     def transaction(&block)
+      raise DatabaseDeadlineExceeded, "synchronous invocation deadline expired" if SyncDeadline.expired?
+
       with_connection do |connection|
-        connection.transaction(requires_new: true, &block)
+        with_transaction_deadline(connection) do
+          connection.transaction(requires_new: true) do
+            configure_transaction_deadline(connection)
+            block.call
+          end
+        end
       end
+    rescue => error
+      raise unless deadline_error?(error)
+
+      raise DatabaseDeadlineExceeded,
+        "database lock wait exceeded the synchronous invocation deadline",
+        cause: error
     end
 
     # @rbs (ActiveRecord::Relation[untyped]) -> ActiveRecord::Relation[untyped]
@@ -68,6 +81,20 @@ module SolidObjects
 
     attr_reader :connection_pool, :fixed_connection
 
+    # @rbs (untyped) { () -> untyped } -> untyped
+    def with_transaction_deadline(_connection)
+      yield
+    end
+
+    # @rbs (untyped) -> void
+    def configure_transaction_deadline(_connection)
+    end
+
+    # @rbs (Exception) -> bool
+    def deadline_error?(_error)
+      false
+    end
+
     # @rbs () { (untyped) -> untyped } -> untyped
     def with_connection
       return yield fixed_connection unless connection_pool

data/lib/solid_objects/database_adapters/mysql.rb

@@ -17,6 +17,52 @@ module SolidObjects
       def current_time_expression
         "CURRENT_TIMESTAMP(6)"
       end
+
+      private
+
+      # @rbs (untyped) { () -> untyped } -> untyped
+      def with_transaction_deadline(connection)
+        return yield unless SyncDeadline.active?
+
+        previous_lock_timeout = connection.select_value(
+          "SELECT @@SESSION.innodb_lock_wait_timeout"
+        ).to_i
+        previous_execution_timeout = connection.select_value(
+          "SELECT @@SESSION.max_execution_time"
+        ).to_i
+        connection.execute(
+          "SET SESSION innodb_lock_wait_timeout = #{SyncDeadline.remaining_seconds}"
+        )
+        connection.execute(
+          "SET SESSION max_execution_time = #{SyncDeadline.remaining_milliseconds}"
+        )
+        yield
+      ensure
+        if previous_lock_timeout
+          connection.execute(
+            "SET SESSION innodb_lock_wait_timeout = #{previous_lock_timeout}"
+          )
+        end
+        if previous_execution_timeout
+          connection.execute(
+            "SET SESSION max_execution_time = #{previous_execution_timeout}"
+          )
+        end
+      end
+
+      # @rbs (Exception) -> bool
+      def deadline_error?(error)
+        return false unless SyncDeadline.active?
+        return true if error.is_a?(ActiveRecord::LockWaitTimeout)
+
+        cause = error
+        while cause
+          return true if cause.respond_to?(:error_number) && cause.error_number == 3024
+
+          cause = cause.cause
+        end
+        false
+      end
     end
   end
 end

data/lib/solid_objects/database_adapters/postgresql.rb

@@ -12,6 +12,35 @@ module SolidObjects
       def claim_lock
         "FOR UPDATE SKIP LOCKED"
       end
+
+      private
+
+      # @rbs (untyped) -> void
+      def configure_transaction_deadline(connection)
+        return unless SyncDeadline.active?
+
+        connection.execute(
+          "SET LOCAL lock_timeout = #{SyncDeadline.remaining_milliseconds}"
+        )
+        connection.execute(
+          "SET LOCAL statement_timeout = #{SyncDeadline.remaining_milliseconds}"
+        )
+      end
+
+      # @rbs (Exception) -> bool
+      def deadline_error?(error)
+        return false unless SyncDeadline.active?
+        return true if error.is_a?(ActiveRecord::LockWaitTimeout)
+
+        cause = error
+        while cause
+          result = cause.respond_to?(:result) ? cause.result : nil
+          return true if result&.error_field(PG::Result::PG_DIAG_SQLSTATE) == "57014"
+
+          cause = cause.cause
+        end
+        false
+      end
     end
   end
 end

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -7,6 +7,34 @@ module SolidObjects
       def current_time_expression
         "STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')"
       end
+
+      private
+
+      # @rbs (untyped) { () -> untyped } -> untyped
+      def with_transaction_deadline(connection)
+        return yield unless SyncDeadline.active?
+
+        previous_timeout = connection.select_value("PRAGMA busy_timeout").to_i
+        connection.execute(
+          "PRAGMA busy_timeout = #{SyncDeadline.remaining_milliseconds}"
+        )
+        yield
+      ensure
+        connection.execute("PRAGMA busy_timeout = #{previous_timeout}") if previous_timeout
+      end
+
+      # @rbs (Exception) -> bool
+      def deadline_error?(error)
+        return false unless SyncDeadline.active?
+
+        cause = error
+        while cause
+          return true if cause.class.name.match?(/BusyException|BusyError/)
+
+          cause = cause.cause
+        end
+        false
+      end
     end
   end
 end

data/lib/solid_objects/doctor.rb

@@ -0,0 +1,311 @@
+# rbs_inline: enabled
+
+require "solid_objects/mailbox"
+require "solid_objects/synchronous_invocation"
+
+module SolidObjects
+  class Doctor
+    class Check
+      # @rbs @name: Symbol
+      # @rbs @status: Symbol
+      # @rbs @message: String
+
+      attr_reader :name, :status, :message
+
+      # @rbs (name: Symbol, status: Symbol, message: String) -> void
+      def initialize(name:, status:, message:)
+        @name = name
+        @status = status
+        @message = message
+        freeze
+      end
+
+      # @rbs () -> bool
+      def failed?
+        status == :fail
+      end
+    end
+
+    class Report
+      # @rbs @checks: Array[Check]
+
+      attr_reader :checks
+
+      # @rbs (checks: Array[Check]) -> void
+      def initialize(checks:)
+        @checks = checks.freeze
+        freeze
+      end
+
+      # @rbs () -> bool
+      def healthy?
+        checks.none?(&:failed?)
+      end
+
+      # @rbs (Symbol) -> Check
+      def check(name)
+        checks.find { |candidate| candidate.name == name } ||
+          raise(KeyError, "unknown doctor check #{name.inspect}")
+      end
+
+      # @rbs () -> String
+      def to_s
+        lines = [ "Solid Objects doctor #{SolidObjects::VERSION}" ]
+        lines.concat(
+          checks.map do |check|
+            "#{check.status.to_s.upcase.ljust(4)} #{check.name}: #{check.message}"
+          end
+        )
+        lines.join("\n")
+      end
+    end
+
+    EXPECTED_COLUMNS = {
+      processes: %w[id kind hostname pid last_heartbeat_at shutdown_state],
+      instances: %w[
+        id actor_type actor_id state state_version next_message_sequence
+        activation_owner_id activation_token activation_expires_at
+        activation_generation
+      ],
+      messages: %w[
+        id instance_id message_kind arguments sequence attempt_count request_id
+        result error rejection completed_at rejected_at
+      ],
+      ready_messages: %w[id message_id instance_id sequence available_at],
+      claimed_messages: %w[
+        id message_id instance_id process_id activation_token
+        activation_generation claimed_at
+      ],
+      reminders: %w[id instance_id message_name next_run_at status],
+      effects: %w[id message_id instance_id effect_id status available_at],
+      broadcasts: %w[id message_id instance_id broadcast_id status available_at],
+      dead_letters: %w[id message_id instance_id actor_type actor_id attempts]
+    }.freeze
+
+    class ProbeActor < Actor
+      actor_type "solid_objects_doctor"
+
+      # @rbs (value: String) -> String
+      def ping(value:)
+        value
+      end
+    end
+
+    # @rbs @connection: untyped
+    # @rbs @configuration: Configuration
+
+    # @rbs (?connection: untyped, ?configuration: Configuration) -> void
+    def initialize(
+      connection: SolidObjects::Record.connection,
+      configuration: SolidObjects.configuration
+    )
+      @connection = connection
+      @configuration = configuration
+    end
+
+    # @rbs () -> Report
+    def call
+      configuration_check = check_configuration
+      schema_check = check_schema
+      checks = [
+        configuration_check,
+        schema_check,
+        check_authorization,
+        schema_check.failed? ? skipped_runtime : check_runtime,
+        ready_for_round_trip?(configuration_check, schema_check) ?
+          check_sync_round_trip :
+          skipped_round_trip
+      ]
+      Report.new(checks:)
+    end
+
+    private
+
+    attr_reader :connection, :configuration
+
+    # @rbs () -> Check
+    def check_configuration
+      configuration.validate!
+      pass(:configuration, "configuration is valid")
+    rescue => error
+      fail_check(:configuration, "#{error.class}: #{error.message}")
+    end
+
+    # @rbs () -> Check
+    def check_schema
+      missing_tables = expected_table_names - connection.data_sources
+      unless missing_tables.empty?
+        return fail_check(:schema, "missing tables: #{missing_tables.join(", ")}")
+      end
+
+      missing_columns = EXPECTED_COLUMNS.each_with_object([]) do |(name, expected), missing|
+        table_name = SolidObjects.table_name(name)
+        actual = connection.columns(table_name).map(&:name)
+        (expected - actual).each { |column| missing << "#{table_name}.#{column}" }
+      end
+      unless missing_columns.empty?
+        return fail_check(:schema, "missing columns: #{missing_columns.join(", ")}")
+      end
+
+      pass(:schema, "schema matches the #{SolidObjects::VERSION} runtime")
+    rescue => error
+      fail_check(:schema, "#{error.class}: #{error.message}")
+    end
+
+    # @rbs () -> Check
+    def check_authorization
+      outcomes = policy_probes.to_h do |name, arguments|
+        outcome = configuration.public_send(name).call(**arguments) ? :allow : :deny
+        [ name, outcome ]
+      rescue
+        [ name, :unknown ]
+      end
+      allowed = outcomes.select { |_, outcome| outcome == :allow }.keys
+      unknown = outcomes.select { |_, outcome| outcome == :unknown }.keys
+
+      if allowed.empty? && unknown.empty?
+        return warn_check(
+          :authorization,
+          "all five policies denied a neutral context; review the generated initializer before use"
+        )
+      end
+      risky = allowed & %i[
+        authorize_destroy
+        authorize_subscription
+        authorize_administration
+      ]
+      unless risky.empty?
+        return warn_check(
+          :authorization,
+          "sensitive policies allowed a neutral context: #{risky.join(", ")}"
+        )
+      end
+      unless unknown.empty?
+        return warn_check(
+          :authorization,
+          "#{allowed.length} of 5 policies allowed a neutral context; " \
+            "#{unknown.join(", ")} could not evaluate without application context"
+        )
+      end
+
+      pass(:authorization, "#{allowed.length} of 5 policies allowed a neutral context")
+    end
+
+    # @rbs () -> Check
+    def check_runtime
+      cutoff = SolidObjects.database_adapter.database_now -
+        configuration.process_alive_threshold
+      counts = Process
+        .where(shutdown_state: "running", last_heartbeat_at: cutoff..)
+        .group(:kind)
+        .count
+      if counts.empty?
+        return info(
+          :runtime,
+          "no live runtime roles; workerless synchronous calls are available, asynchronous features are not"
+        )
+      end
+
+      summary = counts.sort.map { |kind, count| "#{kind}=#{count}" }.join(", ")
+      pass(:runtime, "live runtime roles: #{summary}")
+    rescue => error
+      fail_check(:runtime, "#{error.class}: #{error.message}")
+    end
+
+    # @rbs () -> Check
+    def check_sync_round_trip
+      actor_id = SecureRandom.uuid
+      value = SecureRandom.hex(8)
+      process_registry = SolidObjects.caller_process.process_registry
+      reference = ProbeActor.ref(actor_id)
+      message_reference = Mailbox.new.enqueue(
+        reference,
+        :ping,
+        { value: },
+        kind: "sync"
+      )
+      result = SynchronousInvocation.new.call(message_reference, timeout: 5.seconds)
+      raise Error, "unexpected round-trip result" unless result == value
+
+      pass(:sync_round_trip, "durable synchronous actor call completed without a worker")
+    rescue => error
+      fail_check(:sync_round_trip, "#{error.class}: #{error.message}")
+    ensure
+      Instance.where(actor_type: ProbeActor.actor_type, actor_id:).delete_all if actor_id
+      process_registry&.stop
+      process_registry&.process_record&.delete
+    end
+
+    # @rbs (Check, Check) -> bool
+    def ready_for_round_trip?(configuration_check, schema_check)
+      !configuration_check.failed? && !schema_check.failed?
+    end
+
+    # @rbs () -> Check
+    def skipped_runtime
+      skip(:runtime, "schema check failed")
+    end
+
+    # @rbs () -> Check
+    def skipped_round_trip
+      skip(:sync_round_trip, "configuration or schema check failed")
+    end
+
+    # @rbs () -> Hash[Symbol, Hash[Symbol, untyped]]
+    def policy_probes
+      actor_arguments = {
+        actor_type: ProbeActor.actor_type,
+        actor_id: "doctor",
+        authorization_context: nil
+      }
+      {
+        authorize_message: actor_arguments.merge(
+          message_name: "ping",
+          arguments: { "value" => "doctor" }
+        ),
+        authorize_query: actor_arguments.merge(
+          message_name: "value",
+          arguments: {}
+        ),
+        authorize_destroy: actor_arguments,
+        authorize_subscription: actor_arguments,
+        authorize_administration: {
+          action: "doctor",
+          resource: "runtime",
+          resource_id: nil,
+          authorization_context: nil
+        }
+      }
+    end
+
+    # @rbs () -> Array[String]
+    def expected_table_names
+      EXPECTED_COLUMNS.keys.map { |name| SolidObjects.table_name(name) }
+    end
+
+    # @rbs (Symbol, String) -> Check
+    def pass(name, message)
+      Check.new(name:, status: :pass, message:)
+    end
+
+    # @rbs (Symbol, String) -> Check
+    def info(name, message)
+      Check.new(name:, status: :info, message:)
+    end
+
+    # @rbs (Symbol, String) -> Check
+    def warn_check(name, message)
+      Check.new(name:, status: :warn, message:)
+    end
+
+    # @rbs (Symbol, String) -> Check
+    def fail_check(name, message)
+      Check.new(name:, status: :fail, message:)
+    end
+
+    # @rbs (Symbol, String) -> Check
+    def skip(name, message)
+      Check.new(name:, status: :skip, message:)
+    end
+  end
+end