temporalio 0.2.0-arm64-darwin → 0.3.0-arm64-darwin

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

@@ -0,0 +1,329 @@
+# 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_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:,
+            schedule_to_close_timeout:,
+            schedule_to_start_timeout:,
+            start_to_close_timeout:,
+            heartbeat_timeout:,
+            retry_policy:,
+            cancellation:,
+            cancellation_type:,
+            activity_id:,
+            disable_eager_execution:
+          )
+            @outbound.execute_activity(
+              Temporalio::Worker::Interceptor::Workflow::ExecuteActivityInput.new(
+                activity:,
+                args:,
+                task_queue: task_queue || info.task_queue,
+                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,
+                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:
+          )
+            @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 initialize_continue_as_new_error(error)
+            @outbound.initialize_continue_as_new_error(
+              Temporalio::Worker::Interceptor::Workflow::InitializeContinueAsNewErrorInput.new(error:)
+            )
+          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:,
+            cancellation:,
+            cancellation_type:,
+            parent_close_policy:,
+            execution_timeout:,
+            run_timeout:,
+            task_timeout:,
+            id_reuse_policy:,
+            retry_policy:,
+            cron_schedule:,
+            memo:,
+            search_attributes:
+          )
+            @outbound.start_child_workflow(
+              Temporalio::Worker::Interceptor::Workflow::StartChildWorkflowInput.new(
+                workflow:,
+                args:,
+                id:,
+                task_queue:,
+                cancellation:,
+                cancellation_type:,
+                parent_close_policy:,
+                execution_timeout:,
+                run_timeout:,
+                task_timeout:,
+                id_reuse_policy:,
+                retry_policy:,
+                cron_schedule:,
+                memo:,
+                search_attributes:,
+                headers: {}
+              )
+            )
+          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:,
+                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:,
+                args:,
+                cancellation:,
+                headers: {}
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# 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
+
+          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:
+          )
+            @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
+          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

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'temporalio/workflow'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Class that installs {::TracePoint} to disallow illegal calls.
+        class IllegalCallTracer
+          def self.frozen_validated_illegal_calls(illegal_calls)
+            illegal_calls.to_h do |key, val|
+              raise TypeError, 'Invalid illegal call map, top-level key must be a String' unless key.is_a?(String)
+
+              # @type var fixed_val: :all | Hash[Symbol, bool]
+              fixed_val = case val
+                          when Array
+                            val.to_h do |sub_val|
+                              unless sub_val.is_a?(Symbol)
+                                raise TypeError,
+                                      'Invalid illegal call map, each value must be a Symbol'
+                              end
+
+                              [sub_val, true]
+                            end.freeze
+                          when :all
+                            :all
+                          else
+                            raise TypeError, 'Invalid illegal call map, top-level value must be an Array or :all'
+                          end
+
+              [key.frozen? ? key : key.dup.freeze, fixed_val]
+            end.freeze
+          end
+
+          # Illegal calls are Hash[String, :all | Hash[Symbol, Bool]]
+          def initialize(illegal_calls)
+            @tracepoint = TracePoint.new(:call, :c_call) do |tp|
+              # Manual check for proper thread since we have seen issues in Ruby 3.2 where it leaks
+              next unless Thread.current == @enabled_thread
+
+              cls = tp.defined_class
+              next unless cls.is_a?(Module)
+
+              # Extract the class name from the defined class. This is more difficult than it seems because you have to
+              # resolve the attached object of the singleton class. But in older Ruby (at least <= 3.1), the singleton
+              # class of things like `Date` does not have `attached_object` so you have to fall back in these rare cases
+              # to parsing the string output. Reaching the string parsing component is rare, so this should not have
+              # significant performance impact.
+              cls_name = if cls.singleton_class?
+                           if cls.respond_to?(:attached_object)
+                             cls = cls.attached_object # steep:ignore
+                             next unless cls.is_a?(Module)
+
+                             cls.name.to_s
+                           else
+                             cls.to_s.delete_prefix('#<Class:').delete_suffix('>')
+                           end
+                         else
+                           cls.name.to_s
+                         end
+
+              # Check if the call is considered illegal
+              vals = illegal_calls[cls_name]
+              if vals == :all || vals&.[](tp.callee_id) # steep:ignore
+                raise Workflow::NondeterminismError,
+                      "Cannot access #{cls_name} #{tp.callee_id} from inside a " \
+                      'workflow. If this is known to be safe, the code can be run in ' \
+                      'a Temporalio::Workflow::Unsafe.illegal_call_tracing_disabled block.'
+              end
+            end
+          end
+
+          def enable(&block)
+            # We've seen leaking issues in Ruby 3.2 where the TracePoint inadvertently remains enabled even for threads
+            # that it was not started on. So we will check the thread ourselves.
+            @enabled_thread = Thread.current
+            @tracepoint.enable do
+              block.call
+            ensure
+              @enabled_thread = nil
+            end
+          end
+
+          def disable(&block)
+            previous_thread = @enabled_thread
+            @tracepoint.disable do
+              block.call
+            ensure
+              @enabled_thread = previous_thread
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/worker/interceptor'
+require 'temporalio/workflow'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Root implementation of the inbound interceptor.
+        class InboundImplementation < Temporalio::Worker::Interceptor::Workflow::Inbound
+          def initialize(instance)
+            super(nil) # steep:ignore
+            @instance = instance
+          end
+
+          def init(outbound)
+            @instance.context._outbound = outbound
+          end
+
+          def execute(input)
+            @instance.instance.execute(*input.args)
+          end
+
+          def handle_signal(input)
+            invoke_handler(input.signal, input)
+          end
+
+          def handle_query(input)
+            invoke_handler(input.query, input)
+          end
+
+          def validate_update(input)
+            invoke_handler(input.update, input, to_invoke: input.definition.validator_to_invoke)
+          end
+
+          def handle_update(input)
+            invoke_handler(input.update, input)
+          end
+
+          private
+
+          def invoke_handler(name, input, to_invoke: input.definition.to_invoke)
+            args = input.args
+            # Add name as first param if dynamic
+            args = [name] + args if input.definition.name.nil?
+            # Assume symbol or proc
+            case to_invoke
+            when Symbol
+              @instance.instance.send(to_invoke, *args)
+            when Proc
+              to_invoke.call(*args)
+            else
+              raise "Unrecognized invocation type #{to_invoke.class}"
+            end
+          end
+        end
+      end
+    end
+  end
+end