clara-temporalio 0.4.3

data/lib/temporalio/internal/worker/workflow_instance/child_workflow_handle.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'temporalio/cancellation'
+require 'temporalio/workflow'
+require 'temporalio/workflow/child_workflow_handle'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Implementation of the child workflow handle.
+        class ChildWorkflowHandle < Workflow::ChildWorkflowHandle
+          attr_reader :id, :first_execution_run_id
+
+          def initialize(id:, first_execution_run_id:, instance:, cancellation:, cancel_callback_key:) # rubocop:disable Lint/MissingSuper
+            @id = id
+            @first_execution_run_id = first_execution_run_id
+            @instance = instance
+            @cancellation = cancellation
+            @cancel_callback_key = cancel_callback_key
+            @resolution = nil
+          end
+
+          def result
+            # Notice that we actually provide a detached cancellation here instead of defaulting to workflow
+            # cancellation because we don't want workflow cancellation (or a user-provided cancellation to this result
+            # call) to be able to interrupt waiting on a child that may be processing the cancellation.
+            Workflow.wait_condition(cancellation: Cancellation.new) { @resolution }
+
+            case @resolution.status
+            when :completed
+              @instance.payload_converter.from_payload(@resolution.completed.result)
+            when :failed
+              raise @instance.failure_converter.from_failure(@resolution.failed.failure, @instance.payload_converter)
+            when :cancelled
+              raise @instance.failure_converter.from_failure(@resolution.cancelled.failure, @instance.payload_converter)
+            else
+              raise "Unrecognized resolution status: #{@resolution.status}"
+            end
+          end
+
+          def _resolve(resolution)
+            @cancellation.remove_cancel_callback(@cancel_callback_key)
+            @resolution = resolution
+          end
+
+          def signal(signal, *args, cancellation: Workflow.cancellation)
+            @instance.context._signal_child_workflow(id:, signal:, args:, cancellation:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/worker/workflow_instance/context.rb

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+require 'temporalio/cancellation'
+require 'temporalio/error'
+require 'temporalio/internal/bridge/api'
+require 'temporalio/internal/proto_utils'
+require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/internal/worker/workflow_instance/external_workflow_handle'
+require 'temporalio/worker/interceptor'
+require 'temporalio/workflow'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Context for all workflow calls. All calls in the {Workflow} class should call a method on this class and then
+        # this class can delegate the call as needed to other parts of the workflow instance system.
+        class Context
+          def initialize(instance)
+            @instance = instance
+          end
+
+          def all_handlers_finished?
+            @instance.in_progress_handlers.empty?
+          end
+
+          def cancellation
+            @instance.cancellation
+          end
+
+          def continue_as_new_suggested
+            @instance.continue_as_new_suggested
+          end
+
+          def current_details
+            @instance.current_details || ''
+          end
+
+          def current_details=(details)
+            raise 'Details must be a String' unless details.nil? || details.is_a?(String)
+
+            @instance.current_details = (details || '')
+          end
+
+          def current_deployment_version
+            @instance.current_deployment_version
+          end
+
+          def current_history_length
+            @instance.current_history_length
+          end
+
+          def current_history_size
+            @instance.current_history_size
+          end
+
+          def current_update_info
+            Fiber[:__temporal_update_info]
+          end
+
+          def deprecate_patch(patch_id)
+            @instance.patch(patch_id:, deprecated: true)
+          end
+
+          def execute_activity(
+            activity,
+            *args,
+            task_queue:,
+            summary:,
+            schedule_to_close_timeout:,
+            schedule_to_start_timeout:,
+            start_to_close_timeout:,
+            heartbeat_timeout:,
+            retry_policy:,
+            cancellation:,
+            cancellation_type:,
+            activity_id:,
+            disable_eager_execution:,
+            priority:
+          )
+            activity = case activity
+                       when Class
+                         Activity::Definition::Info.from_activity(activity).name&.to_s
+                       when Symbol, String
+                         activity.to_s
+                       else
+                         raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
+                       end
+            raise 'Cannot invoke dynamic activities' unless activity
+
+            @outbound.execute_activity(
+              Temporalio::Worker::Interceptor::Workflow::ExecuteActivityInput.new(
+                activity:,
+                args:,
+                task_queue: task_queue || info.task_queue,
+                summary:,
+                schedule_to_close_timeout:,
+                schedule_to_start_timeout:,
+                start_to_close_timeout:,
+                heartbeat_timeout:,
+                retry_policy:,
+                cancellation:,
+                cancellation_type:,
+                activity_id:,
+                disable_eager_execution: disable_eager_execution || @instance.disable_eager_activity_execution,
+                priority:,
+                headers: {}
+              )
+            )
+          end
+
+          def execute_local_activity(
+            activity,
+            *args,
+            schedule_to_close_timeout:,
+            schedule_to_start_timeout:,
+            start_to_close_timeout:,
+            retry_policy:,
+            local_retry_threshold:,
+            cancellation:,
+            cancellation_type:,
+            activity_id:
+          )
+            activity = case activity
+                       when Class
+                         Activity::Definition::Info.from_activity(activity).name&.to_s
+                       when Symbol, String
+                         activity.to_s
+                       else
+                         raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
+                       end
+            raise 'Cannot invoke dynamic activities' unless activity
+
+            @outbound.execute_local_activity(
+              Temporalio::Worker::Interceptor::Workflow::ExecuteLocalActivityInput.new(
+                activity:,
+                args:,
+                schedule_to_close_timeout:,
+                schedule_to_start_timeout:,
+                start_to_close_timeout:,
+                retry_policy:,
+                local_retry_threshold:,
+                cancellation:,
+                cancellation_type:,
+                activity_id:,
+                headers: {}
+              )
+            )
+          end
+
+          def external_workflow_handle(workflow_id, run_id: nil)
+            ExternalWorkflowHandle.new(id: workflow_id, run_id:, instance: @instance)
+          end
+
+          def illegal_call_tracing_disabled(&)
+            @instance.illegal_call_tracing_disabled(&)
+          end
+
+          def info
+            @instance.info
+          end
+
+          def instance
+            @instance.instance
+          end
+
+          def initialize_continue_as_new_error(error)
+            @outbound.initialize_continue_as_new_error(
+              Temporalio::Worker::Interceptor::Workflow::InitializeContinueAsNewErrorInput.new(error:)
+            )
+          end
+
+          def io_enabled(&)
+            prev = @instance.io_enabled
+            @instance.io_enabled = true
+            begin
+              yield
+            ensure
+              @instance.io_enabled = prev
+            end
+          end
+
+          def logger
+            @instance.logger
+          end
+
+          def memo
+            @instance.memo
+          end
+
+          def metric_meter
+            @instance.metric_meter
+          end
+
+          def now
+            @instance.now
+          end
+
+          def patched(patch_id)
+            @instance.patch(patch_id:, deprecated: false)
+          end
+
+          def payload_converter
+            @instance.payload_converter
+          end
+
+          def query_handlers
+            @instance.query_handlers
+          end
+
+          def random
+            @instance.random
+          end
+
+          def replaying?
+            @instance.replaying
+          end
+
+          def search_attributes
+            @instance.search_attributes
+          end
+
+          def signal_handlers
+            @instance.signal_handlers
+          end
+
+          def sleep(duration, summary:, cancellation:)
+            @outbound.sleep(
+              Temporalio::Worker::Interceptor::Workflow::SleepInput.new(
+                duration:,
+                summary:,
+                cancellation:
+              )
+            )
+          end
+
+          def start_child_workflow(
+            workflow,
+            *args,
+            id:,
+            task_queue:,
+            static_summary:,
+            static_details:,
+            cancellation:,
+            cancellation_type:,
+            parent_close_policy:,
+            execution_timeout:,
+            run_timeout:,
+            task_timeout:,
+            id_reuse_policy:,
+            retry_policy:,
+            cron_schedule:,
+            memo:,
+            search_attributes:,
+            priority:
+          )
+            @outbound.start_child_workflow(
+              Temporalio::Worker::Interceptor::Workflow::StartChildWorkflowInput.new(
+                workflow: Workflow::Definition._workflow_type_from_workflow_parameter(workflow),
+                args:,
+                id:,
+                task_queue:,
+                static_summary:,
+                static_details:,
+                cancellation:,
+                cancellation_type:,
+                parent_close_policy:,
+                execution_timeout:,
+                run_timeout:,
+                task_timeout:,
+                id_reuse_policy:,
+                retry_policy:,
+                cron_schedule:,
+                memo:,
+                search_attributes:,
+                priority:,
+                headers: {}
+              )
+            )
+          end
+
+          def storage
+            @storage ||= {}
+          end
+
+          def timeout(duration, exception_class, *exception_args, summary:, &)
+            raise 'Block required for timeout' unless block_given?
+
+            # Run timer in background and block in foreground. This gives better stack traces than a future any-of race.
+            # We make a detached cancellation because we don't want to link to workflow cancellation.
+            sleep_cancel, sleep_cancel_proc = Cancellation.new
+            fiber = Fiber.current
+            Workflow::Future.new do
+              Workflow.sleep(duration, summary:, cancellation: sleep_cancel)
+              fiber.raise(exception_class, *exception_args) if fiber.alive? # steep:ignore
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              # Re-raise in fiber
+              fiber.raise(e) if fiber.alive?
+            end
+
+            begin
+              yield
+            ensure
+              sleep_cancel_proc.call
+            end
+          end
+
+          def update_handlers
+            @instance.update_handlers
+          end
+
+          def upsert_memo(hash)
+            # Convert to memo, apply updates, then add the command (so command adding is post validation)
+            upserted_memo = ProtoUtils.memo_to_proto(hash, payload_converter)
+            memo._update do |new_hash|
+              hash.each do |key, val|
+                # Nil means delete
+                if val.nil?
+                  new_hash.delete(key.to_s)
+                else
+                  new_hash[key.to_s] = val
+                end
+              end
+            end
+            @instance.add_command(
+              Bridge::Api::WorkflowCommands::WorkflowCommand.new(
+                modify_workflow_properties: Bridge::Api::WorkflowCommands::ModifyWorkflowProperties.new(
+                  upserted_memo:
+                )
+              )
+            )
+          end
+
+          def upsert_search_attributes(*updates)
+            # Apply updates then add the command (so command adding is post validation)
+            search_attributes._disable_mutations = false
+            search_attributes.update!(*updates)
+            @instance.add_command(
+              Bridge::Api::WorkflowCommands::WorkflowCommand.new(
+                upsert_workflow_search_attributes: Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes.new(
+                  search_attributes: updates.to_h(&:_to_proto_pair)
+                )
+              )
+            )
+          ensure
+            search_attributes._disable_mutations = true
+          end
+
+          def wait_condition(cancellation:, &)
+            @instance.scheduler.wait_condition(cancellation:, &)
+          end
+
+          def _cancel_external_workflow(id:, run_id:)
+            @outbound.cancel_external_workflow(
+              Temporalio::Worker::Interceptor::Workflow::CancelExternalWorkflowInput.new(id:, run_id:)
+            )
+          end
+
+          def _outbound=(outbound)
+            @outbound = outbound
+          end
+
+          def _signal_child_workflow(id:, signal:, args:, cancellation:)
+            @outbound.signal_child_workflow(
+              Temporalio::Worker::Interceptor::Workflow::SignalChildWorkflowInput.new(
+                id:,
+                signal: Workflow::Definition::Signal._name_from_parameter(signal),
+                args:,
+                cancellation:,
+                headers: {}
+              )
+            )
+          end
+
+          def _signal_external_workflow(id:, run_id:, signal:, args:, cancellation:)
+            @outbound.signal_external_workflow(
+              Temporalio::Worker::Interceptor::Workflow::SignalExternalWorkflowInput.new(
+                id:,
+                run_id:,
+                signal: Workflow::Definition::Signal._name_from_parameter(signal),
+                args:,
+                cancellation:,
+                headers: {}
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/worker/workflow_instance/details.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Details needed to instantiate a {WorkflowInstance}.
+        class Details
+          attr_reader :namespace, :task_queue, :definition, :initial_activation, :logger, :metric_meter,
+                      :payload_converter, :failure_converter, :interceptors, :disable_eager_activity_execution,
+                      :illegal_calls, :workflow_failure_exception_types, :unsafe_workflow_io_enabled,
+                      :assert_valid_local_activity
+
+          def initialize(
+            namespace:,
+            task_queue:,
+            definition:,
+            initial_activation:,
+            logger:,
+            metric_meter:,
+            payload_converter:,
+            failure_converter:,
+            interceptors:,
+            disable_eager_activity_execution:,
+            illegal_calls:,
+            workflow_failure_exception_types:,
+            unsafe_workflow_io_enabled:,
+            assert_valid_local_activity:
+          )
+            @namespace = namespace
+            @task_queue = task_queue
+            @definition = definition
+            @initial_activation = initial_activation
+            @logger = logger
+            @metric_meter = metric_meter
+            @payload_converter = payload_converter
+            @failure_converter = failure_converter
+            @interceptors = interceptors
+            @disable_eager_activity_execution = disable_eager_activity_execution
+            @illegal_calls = illegal_calls
+            @workflow_failure_exception_types = workflow_failure_exception_types
+            @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
+            @assert_valid_local_activity = assert_valid_local_activity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/worker/workflow_instance/external_workflow_handle.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'temporalio/cancellation'
+require 'temporalio/workflow'
+require 'temporalio/workflow/external_workflow_handle'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Implementation of the external workflow handle.
+        class ExternalWorkflowHandle < Workflow::ExternalWorkflowHandle
+          attr_reader :id, :run_id
+
+          def initialize(id:, run_id:, instance:) # rubocop:disable Lint/MissingSuper
+            @id = id
+            @run_id = run_id
+            @instance = instance
+          end
+
+          def signal(signal, *args, cancellation: Workflow.cancellation)
+            @instance.context._signal_external_workflow(id:, run_id:, signal:, args:, cancellation:)
+          end
+
+          def cancel
+            @instance.context._cancel_external_workflow(id:, run_id:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/worker/workflow_instance/externally_immutable_hash.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Delegator to a hash that does not allow external mutations. Used for memo.
+        class ExternallyImmutableHash < SimpleDelegator
+          def initialize(initial_hash)
+            super(initial_hash.freeze)
+          end
+
+          def _update(&)
+            new_hash = __getobj__.dup
+            yield new_hash
+            __setobj__(new_hash.freeze)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/worker/workflow_instance/handler_execution.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Representation of a currently-executing handler. Used to track whether any handlers are still running and warn
+        # on workflow complete as needed.
+        class HandlerExecution
+          attr_reader :name, :update_id, :unfinished_policy
+
+          def initialize(
+            name:,
+            update_id:,
+            unfinished_policy:
+          )
+            @name = name
+            @update_id = update_id
+            @unfinished_policy = unfinished_policy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/worker/workflow_instance/handler_hash.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Hash for handlers that notifies when one is added. Only `[]=` and `store` can be used to mutate it.
+        class HandlerHash < SimpleDelegator
+          def initialize(initial_frozen_hash, definition_class, &on_new_definition)
+            super(initial_frozen_hash)
+            @definition_class = definition_class
+            @on_new_definition = on_new_definition
+          end
+
+          def []=(name, definition)
+            store(name, definition)
+          end
+
+          # steep:ignore:start
+          def store(name, definition)
+            raise ArgumentError, 'Name must be a string or nil' unless name.nil? || name.is_a?(String)
+
+            unless definition.nil? || definition.is_a?(@definition_class)
+              raise ArgumentError,
+                    "Value must be a #{@definition_class.name} or nil"
+            end
+            raise ArgumentError, 'Name does not match one in definition' if definition && name != definition.name
+
+            # Do a copy-on-write op on the underlying frozen hash
+            new_hash = __getobj__.dup
+            new_hash[name] = definition
+            __setobj__(new_hash.freeze)
+            @on_new_definition&.call(definition) unless definition.nil?
+            definition
+          end
+          # steep:ignore:end
+        end
+      end
+    end
+  end
+end