amit-temporalio 0.3.0-aarch64-linux-musl

data/lib/temporalio/internal/worker/multi_runner.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'temporalio/internal/bridge/worker'
+
+module Temporalio
+  module Internal
+    module Worker
+      # Primary worker (re)actor-style event handler. This handles multiple workers, receiving events from the bridge,
+      # and handling a user block.
+      class MultiRunner
+        def initialize(workers:, shutdown_signals:)
+          @workers = workers
+          @queue = Queue.new
+
+          @shutdown_initiated_mutex = Mutex.new
+          @shutdown_initiated = false
+
+          # Trap signals to push to queue
+          shutdown_signals.each do |signal|
+            Signal.trap(signal) { @queue.push(Event::ShutdownSignalReceived.new) }
+          end
+
+          # Start pollers
+          Bridge::Worker.async_poll_all(workers.map(&:_bridge_worker), @queue)
+        end
+
+        def apply_thread_or_fiber_block(&)
+          return unless block_given?
+
+          @thread_or_fiber = if Fiber.current_scheduler
+                               Fiber.schedule do
+                                 @queue.push(Event::BlockSuccess.new(result: yield))
+                               rescue InjectEventForTesting => e
+                                 @queue.push(e.event)
+                                 @queue.push(Event::BlockSuccess.new(result: e))
+                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                                 @queue.push(Event::BlockFailure.new(error: e))
+                               end
+                             else
+                               Thread.new do
+                                 @queue.push(Event::BlockSuccess.new(result: yield))
+                               rescue InjectEventForTesting => e
+                                 @queue.push(e.event)
+                                 @queue.push(Event::BlockSuccess.new(result: e))
+                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                                 @queue.push(Event::BlockFailure.new(error: e))
+                               end
+                             end
+        end
+
+        def apply_workflow_activation_decoded(workflow_worker:, activation:)
+          @queue.push(Event::WorkflowActivationDecoded.new(workflow_worker:, activation:))
+        end
+
+        def apply_workflow_activation_complete(workflow_worker:, activation_completion:, encoded:)
+          @queue.push(Event::WorkflowActivationComplete.new(
+                        workflow_worker:, activation_completion:, encoded:, completion_complete_queue: @queue
+                      ))
+        end
+
+        def raise_in_thread_or_fiber_block(error)
+          @thread_or_fiber&.raise(error)
+        end
+
+        # Clarify this is the only thread-safe function here
+        def initiate_shutdown
+          should_call = @shutdown_initiated_mutex.synchronize do
+            break false if @shutdown_initiated
+
+            @shutdown_initiated = true
+          end
+          return unless should_call
+
+          @workers.each(&:_initiate_shutdown)
+        end
+
+        def wait_complete_and_finalize_shutdown
+          # Wait for them all to complete
+          @workers.each(&:_wait_all_complete)
+
+          # Finalize them all
+          Bridge::Worker.finalize_shutdown_all(@workers.map(&:_bridge_worker))
+        end
+
+        # Intentionally not an enumerable/enumerator since stop semantics are
+        # caller determined
+        def next_event
+          # Queue value is one of the following:
+          # * Event - non-poller event
+          # * [worker index, :activity/:workflow, bytes] - poll success
+          # * [worker index, :activity/:workflow, error] - poll fail
+          # * [worker index, :activity/:workflow, nil] - worker shutdown
+          # * [nil, nil, nil] - all pollers done
+          # * [-1, run_id_string, error_or_nil] - workflow activation completion complete
+          result = @queue.pop
+          if result.is_a?(Event)
+            result
+          else
+            first, second, third = result
+            if first.nil? || second.nil?
+              Event::AllPollersShutDown.instance
+            elsif first == -1
+              Event::WorkflowActivationCompletionComplete.new(run_id: second, error: third)
+            else
+              worker = @workers[first]
+              case third
+              when nil
+                Event::PollerShutDown.new(worker:, worker_type: second)
+              when Exception
+                Event::PollFailure.new(worker:, worker_type: second, error: third)
+              else
+                Event::PollSuccess.new(worker:, worker_type: second, bytes: third)
+              end
+            end
+          end
+        end
+
+        class Event
+          class PollSuccess < Event
+            attr_reader :worker, :worker_type, :bytes
+
+            def initialize(worker:, worker_type:, bytes:) # rubocop:disable Lint/MissingSuper
+              @worker = worker
+              @worker_type = worker_type
+              @bytes = bytes
+            end
+          end
+
+          class PollFailure < Event
+            attr_reader :worker, :worker_type, :error
+
+            def initialize(worker:, worker_type:, error:) # rubocop:disable Lint/MissingSuper
+              @worker = worker
+              @worker_type = worker_type
+              @error = error
+            end
+          end
+
+          class WorkflowActivationDecoded < Event
+            attr_reader :workflow_worker, :activation
+
+            def initialize(workflow_worker:, activation:) # rubocop:disable Lint/MissingSuper
+              @workflow_worker = workflow_worker
+              @activation = activation
+            end
+          end
+
+          class WorkflowActivationComplete < Event
+            attr_reader :workflow_worker, :activation_completion, :encoded, :completion_complete_queue
+
+            def initialize(workflow_worker:, activation_completion:, encoded:, completion_complete_queue:) # rubocop:disable Lint/MissingSuper
+              @workflow_worker = workflow_worker
+              @activation_completion = activation_completion
+              @encoded = encoded
+              @completion_complete_queue = completion_complete_queue
+            end
+          end
+
+          class WorkflowActivationCompletionComplete < Event
+            attr_reader :run_id, :error
+
+            def initialize(run_id:, error:) # rubocop:disable Lint/MissingSuper
+              @run_id = run_id
+              @error = error
+            end
+          end
+
+          class PollerShutDown < Event
+            attr_reader :worker, :worker_type
+
+            def initialize(worker:, worker_type:) # rubocop:disable Lint/MissingSuper
+              @worker = worker
+              @worker_type = worker_type
+            end
+          end
+
+          class AllPollersShutDown < Event
+            include Singleton
+          end
+
+          class BlockSuccess < Event
+            attr_reader :result
+
+            def initialize(result:) # rubocop:disable Lint/MissingSuper
+              @result = result
+            end
+          end
+
+          class BlockFailure < Event
+            attr_reader :error
+
+            def initialize(error:) # rubocop:disable Lint/MissingSuper
+              @error = error
+            end
+          end
+
+          class ShutdownSignalReceived < Event
+          end
+        end
+
+        class InjectEventForTesting < Temporalio::Error
+          attr_reader :event
+
+          def initialize(event)
+            super('Injecting event for testing')
+            @event = event
+          end
+        end
+      end
+    end
+  end
+end

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,333 @@
+# 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 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 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