phronomy 0.27.0 → 0.29.0

data/lib/phronomy/workflow/execution/workflow_execution_environment.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Phronomy
+  # Workflow-owned connection requirements. Progress, admission and durable
+  # outcome interpretation remain in Workflow; composition selects transport.
+  # @api private
+  class WorkflowExecutionEnvironment
+    class << self
+      def install_provider(provider)
+        raise ArgumentError, "Workflow execution provider must be callable" unless provider.respond_to?(:call)
+        @provider = provider
+      end
+
+      def current
+        @provider&.call || raise(Phronomy::ConfigurationError, "Workflow execution environment has not been configured")
+      end
+    end
+
+    def registry = raise(NotImplementedError)
+    def existing_registry = raise(NotImplementedError)
+    def executing? = raise(NotImplementedError)
+    def submit(**options, &operation) = raise(NotImplementedError)
+    def compile_transitions(**definition) = raise(NotImplementedError)
+    def build_session(**options) = raise(NotImplementedError)
+    def register_session(session, completion:) = raise(NotImplementedError)
+    def subscribe_cancellation(token, &callback) = raise(NotImplementedError)
+  end
+end

data/lib/phronomy/workflow/execution/workflow_execution_registry.rb

@@ -12,10 +12,14 @@ module Phronomy
       :workflow_instance_id, :owner_token, :fsm_session_id, :state
     )
     private_constant :WorkflowAdmission
+    StopTaskExecutions = Data.define(:error)
+    private_constant :StopTaskExecutions
 
-    def initialize(event_loop:)
+    def initialize(channel:)
       super
       @workflow_admissions = {}
+      @task_executions = {}
+      @draining = false
     end
 
     def post(command, admission: false, completion: nil)
@@ -24,7 +28,18 @@ module Phronomy
 
     def deliver(command)
       assert_event_loop_thread!
-      command.runner.deliver_on_event_loop(command)
+      case command
+      when WorkflowTaskReception::Notification
+        task_execution_for(command.reception)&.receive(command)
+      when WorkflowTaskReception::DeliveryFailure
+        task_execution_for(command.reception)&.delivery_failed(command.reception, command.error)
+      when WorkflowTaskReception::Cancellation
+        task_execution_for(command.reception)&.receive_cancellation(command.reception)
+      when StopTaskExecutions
+        synchronize { @task_executions.values.dup }.each { |execution| execution.stop(command.error) }
+      else
+        command.runner.deliver_on_event_loop(command)
+      end
     end
 
     def idle?
@@ -37,7 +52,49 @@ module Phronomy
     end
 
     def shutdown(error:)
-      synchronize { @workflow_admissions.clear }
+      executions = synchronize do
+        @workflow_admissions.clear
+        values = @task_executions.values
+        @task_executions.clear
+        values
+      end
+      failure = error || Phronomy::RuntimeShutdownError.new("Runtime stopped Workflow task execution")
+      executions.each { |execution| execution.retire(failure) }
+    end
+
+    # Called under Runtime's lifecycle lock. Only queue owner-side decisions;
+    # do not call application code or acquire Runtime again from here.
+    def begin_draining
+      first = synchronize do
+        next false if @draining
+        @draining = true
+      end
+      post(StopTaskExecutions.new(error: Phronomy::RuntimeShutdownError.new("Runtime stopped Workflow task execution"))) if first
+    end
+
+    def wait_until_idle(_deadline)
+      # EventLoop's existing admission/delivery accounting owns the drain wait.
+      true
+    end
+
+    def draining?
+      synchronize { @draining }
+    end
+
+    def bind_task_execution(execution)
+      assert_event_loop_thread!
+      synchronize { @task_executions[execution.owner_token] = execution }
+    end
+
+    def task_delivery_failed(reception, error)
+      return unless reception.active? && task_execution_for(reception)
+
+      failure = WorkflowTaskReception::DeliveryFailure.new(reception: reception, error: error)
+      return if post(failure)
+
+      fail_task_observer(reception, error)
+    rescue => delivery_error
+      fail_task_observer(reception, error || delivery_error)
     end
 
     # Reserves one logical Workflow execution segment before durable load or
@@ -121,13 +178,17 @@ module Phronomy
     def release_workflow(workflow_instance_id, owner_token:)
       assert_event_loop_thread!
       key = workflow_instance_id.to_s
-      synchronize do
+      execution = nil
+      released = synchronize do
         current = @workflow_admissions[key]
         next false unless current&.owner_token&.equal?(owner_token)
 
         @workflow_admissions.delete(key)
+        execution = @task_executions.delete(owner_token)
         true
       end
+      execution&.close
+      released
     end
 
     # Read-only diagnostics used by internal tests and routing assertions.
@@ -150,18 +211,26 @@ module Phronomy
     end
 
     def post_to_workflow(workflow_instance_id:, event:, payload: nil)
-      @event_loop.__route_execution_event(self) do
+      route_event(type: event.to_sym, payload: payload) do
         admission = @workflow_admissions[workflow_instance_id.to_s]
         next unless admission&.state == :executing && admission.fsm_session_id
 
-        Phronomy::Event.new(
-          type: event.to_sym, target_id: admission.fsm_session_id, payload: payload
-        )
+        admission.fsm_session_id
       end
     end
 
     private
 
+    def task_execution_for(reception)
+      synchronize { @task_executions[reception.owner_token] }
+    end
+
+    def fail_task_observer(reception, error)
+      # A fully unavailable owner cannot safely release admission or claim a
+      # durable terminal result. Settle observation only; shutdown owns cleanup.
+      task_execution_for(reception)&.result_task&.fail(error) if reception.active?
+    end
+
     def mark_workflow_recovery_required_for_session(fsm_session_id)
       synchronize do
         key, admission = @workflow_admissions.find do |_workflow_instance_id, candidate|