temporalio 0.2.0-x86_64-linux

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

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+require 'temporalio/activity'
+require 'temporalio/activity/definition'
+require 'temporalio/cancellation'
+require 'temporalio/internal/bridge/api'
+require 'temporalio/internal/proto_utils'
+require 'temporalio/scoped_logger'
+require 'temporalio/worker/interceptor'
+
+module Temporalio
+  module Internal
+    module Worker
+      class ActivityWorker
+        LOG_TASKS = false
+
+        attr_reader :worker, :bridge_worker
+
+        def initialize(worker, bridge_worker)
+          @worker = worker
+          @bridge_worker = bridge_worker
+
+          # Create shared logger that gives scoped activity details
+          @scoped_logger = ScopedLogger.new(@worker.options.logger)
+          @scoped_logger.scoped_values_getter = proc {
+            Activity::Context.current_or_nil&._scoped_logger_info
+          }
+
+          # Build up activity hash by name, failing if any fail validation
+          @activities = worker.options.activities.each_with_object({}) do |act, hash|
+            # Class means create each time, instance means just call, definition
+            # does nothing special
+            defn = Activity::Definition.from_activity(act)
+            # Confirm name not in use
+            raise ArgumentError, "Multiple activities named #{defn.name}" if hash.key?(defn.name)
+
+            # Confirm executor is a known executor and let it initialize
+            executor = worker.options.activity_executors[defn.executor]
+            raise ArgumentError, "Unknown executor '#{defn.executor}'" if executor.nil?
+
+            executor.initialize_activity(defn)
+
+            hash[defn.name] = defn
+          end
+
+          # Need mutex for the rest of these
+          @running_activities_mutex = Mutex.new
+          @running_activities = {}
+          @running_activities_empty_condvar = ConditionVariable.new
+        end
+
+        def set_running_activity(task_token, activity)
+          @running_activities_mutex.synchronize do
+            @running_activities[task_token] = activity
+          end
+        end
+
+        def get_running_activity(task_token)
+          @running_activities_mutex.synchronize do
+            @running_activities[task_token]
+          end
+        end
+
+        def remove_running_activity(task_token)
+          @running_activities_mutex.synchronize do
+            @running_activities.delete(task_token)
+            @running_activities_empty_condvar.broadcast if @running_activities.empty?
+          end
+        end
+
+        def wait_all_complete
+          @running_activities_mutex.synchronize do
+            @running_activities_empty_condvar.wait(@running_activities_mutex) until @running_activities.empty?
+          end
+        end
+
+        def handle_task(task)
+          @scoped_logger.debug("Received activity task: #{task}") if LOG_TASKS
+          if !task.start.nil?
+            handle_start_task(task.task_token, task.start)
+          elsif !task.cancel.nil?
+            handle_cancel_task(task.task_token, task.cancel)
+          else
+            raise "Unrecognized activity task: #{task}"
+          end
+        end
+
+        def handle_start_task(task_token, start)
+          set_running_activity(task_token, nil)
+
+          # Find activity definition
+          defn = @activities[start.activity_type]
+          if defn.nil?
+            raise Error::ApplicationError.new(
+              "Activity #{start.activity_type} for workflow #{start.workflow_execution.workflow_id} " \
+              "is not registered on this worker, available activities: #{@activities.keys.sort.join(', ')}",
+              type: 'NotFoundError'
+            )
+          end
+
+          # Run everything else in the excecutor
+          executor = @worker.options.activity_executors[defn.executor]
+          executor.execute_activity(defn) do
+            # Set current executor
+            Activity::Context._current_executor = executor
+            # Execute with error handling
+            execute_activity(task_token, defn, start)
+          ensure
+            # Unset at the end
+            Activity::Context._current_executor = nil
+          end
+        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+          remove_running_activity(task_token)
+          @scoped_logger.warn("Failed starting activity #{start.activity_type}")
+          @scoped_logger.warn(e)
+
+          # We need to complete the activity task as failed, but this is on the
+          # hot path for polling, so we want to complete it in the background
+          begin
+            @bridge_worker.complete_activity_task_in_background(
+              Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
+                task_token:,
+                result: Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                  failed: Bridge::Api::ActivityResult::Failure.new(
+                    # TODO(cretz): If failure conversion does slow failure
+                    # encoding, it can gum up the system
+                    failure: @worker.options.client.data_converter.to_failure(e)
+                  )
+                )
+              )
+            )
+          rescue StandardError => e_inner
+            @scoped_logger.error("Failed building start failure to return for #{start.activity_type}")
+            @scoped_logger.error(e_inner)
+          end
+        end
+
+        def handle_cancel_task(task_token, cancel)
+          activity = get_running_activity(task_token)
+          if activity.nil?
+            @scoped_logger.warn("Cannot find activity to cancel for token #{task_token}")
+            return
+          end
+          activity._server_requested_cancel = true
+          _, cancel_proc = activity.cancellation
+          begin
+            cancel_proc.call(reason: cancel.reason.to_s)
+          rescue StandardError => e
+            @scoped_logger.warn("Failed cancelling activity #{activity.info.activity_type} \
+              with ID #{activity.info.activity_id}")
+            @scoped_logger.warn(e)
+          end
+        end
+
+        def execute_activity(task_token, defn, start)
+          # Build info
+          info = Activity::Info.new(
+            activity_id: start.activity_id,
+            activity_type: start.activity_type,
+            attempt: start.attempt,
+            current_attempt_scheduled_time: start.current_attempt_scheduled_time.to_time,
+            heartbeat_details: ProtoUtils.convert_from_payload_array(
+              @worker.options.client.data_converter,
+              start.heartbeat_details.to_ary
+            ),
+            heartbeat_timeout: start.heartbeat_timeout&.to_f,
+            local?: start.is_local,
+            schedule_to_close_timeout: start.schedule_to_close_timeout&.to_f,
+            scheduled_time: start.scheduled_time.to_time,
+            start_to_close_timeout: start.start_to_close_timeout&.to_f,
+            started_time: start.started_time.to_time,
+            task_queue: @worker.options.task_queue,
+            task_token:,
+            workflow_id: start.workflow_execution.workflow_id,
+            workflow_namespace: start.workflow_namespace,
+            workflow_run_id: start.workflow_execution.run_id,
+            workflow_type: start.workflow_type
+          ).freeze
+
+          # Build input
+          input = Temporalio::Worker::Interceptor::ExecuteActivityInput.new(
+            proc: defn.proc,
+            args: ProtoUtils.convert_from_payload_array(
+              @worker.options.client.data_converter,
+              start.input.to_ary
+            ),
+            headers: start.header_fields
+          )
+
+          # Run
+          activity = RunningActivity.new(
+            info:,
+            cancellation: Cancellation.new,
+            worker_shutdown_cancellation: @worker._worker_shutdown_cancellation,
+            payload_converter: @worker.options.client.data_converter.payload_converter,
+            logger: @scoped_logger
+          )
+          Activity::Context._current_executor&.set_activity_context(defn, activity)
+          set_running_activity(task_token, activity)
+          run_activity(activity, input)
+        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+          @scoped_logger.warn("Failed starting or sending completion for activity #{start.activity_type}")
+          @scoped_logger.warn(e)
+          # This means that the activity couldn't start or send completion (run
+          # handles its own errors).
+          begin
+            @bridge_worker.complete_activity_task(
+              Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
+                task_token:,
+                result: Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                  failed: Bridge::Api::ActivityResult::Failure.new(
+                    failure: @worker.options.client.data_converter.to_failure(e)
+                  )
+                )
+              )
+            )
+          rescue StandardError => e_inner
+            @scoped_logger.error("Failed sending failure for activity #{start.activity_type}")
+            @scoped_logger.error(e_inner)
+          end
+        ensure
+          Activity::Context._current_executor&.set_activity_context(defn, nil)
+          remove_running_activity(task_token)
+        end
+
+        def run_activity(activity, input)
+          result = begin
+            # Build impl with interceptors
+            # @type var impl: Temporalio::Worker::Interceptor::ActivityInbound
+            impl = InboundImplementation.new(self)
+            impl = @worker._all_interceptors.reverse_each.reduce(impl) do |acc, int|
+              int.intercept_activity(acc)
+            end
+            impl.init(OutboundImplementation.new(self))
+
+            # Execute
+            result = impl.execute(input)
+
+            # Success
+            Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+              completed: Bridge::Api::ActivityResult::Success.new(
+                result: @worker.options.client.data_converter.to_payload(result)
+              )
+            )
+          rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+            if e.is_a?(Activity::CompleteAsyncError)
+              # Wanting to complete async
+              @scoped_logger.debug('Completing activity asynchronously')
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                will_complete_async: Bridge::Api::ActivityResult::WillCompleteAsync.new
+              )
+            elsif e.is_a?(Error::CanceledError) && activity._server_requested_cancel
+              # Server requested cancel
+              @scoped_logger.debug('Completing activity as canceled')
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                cancelled: Bridge::Api::ActivityResult::Cancellation.new(
+                  failure: @worker.options.client.data_converter.to_failure(e)
+                )
+              )
+            else
+              # General failure
+              @scoped_logger.warn('Completing activity as failed')
+              @scoped_logger.warn(e)
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                failed: Bridge::Api::ActivityResult::Failure.new(
+                  failure: @worker.options.client.data_converter.to_failure(e)
+                )
+              )
+            end
+          end
+
+          @scoped_logger.debug("Sending activity completion: #{result}") if LOG_TASKS
+          @bridge_worker.complete_activity_task(
+            Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
+              task_token: activity.info.task_token,
+              result:
+            )
+          )
+        end
+
+        class RunningActivity < Activity::Context
+          attr_reader :info, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
+          attr_accessor :_outbound_impl, :_server_requested_cancel
+
+          def initialize( # rubocop:disable Lint/MissingSuper
+            info:,
+            cancellation:,
+            worker_shutdown_cancellation:,
+            payload_converter:,
+            logger:
+          )
+            @info = info
+            @cancellation = cancellation
+            @worker_shutdown_cancellation = worker_shutdown_cancellation
+            @payload_converter = payload_converter
+            @logger = logger
+            @_outbound_impl = nil
+            @_server_requested_cancel = false
+          end
+
+          def heartbeat(*details)
+            raise 'Implementation not set yet' if _outbound_impl.nil?
+
+            _outbound_impl.heartbeat(Temporalio::Worker::Interceptor::HeartbeatActivityInput.new(details:))
+          end
+        end
+
+        class InboundImplementation < Temporalio::Worker::Interceptor::ActivityInbound
+          def initialize(worker)
+            super(nil) # steep:ignore
+            @worker = worker
+          end
+
+          def init(outbound)
+            context = Activity::Context.current
+            raise 'Unexpected context type' unless context.is_a?(RunningActivity)
+
+            context._outbound_impl = outbound
+          end
+
+          def execute(input)
+            input.proc.call(*input.args)
+          end
+        end
+
+        class OutboundImplementation < Temporalio::Worker::Interceptor::ActivityOutbound
+          def initialize(worker)
+            super(nil) # steep:ignore
+            @worker = worker
+          end
+
+          def heartbeat(input)
+            @worker.bridge_worker.record_activity_heartbeat(
+              Bridge::Api::CoreInterface::ActivityHeartbeat.new(
+                task_token: Activity::Context.current.info.task_token,
+                details: ProtoUtils.convert_to_payload_array(@worker.worker.options.client.data_converter,
+                                                             input.details)
+              ).to_proto
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'temporalio/internal/bridge/worker'
+
+module Temporalio
+  module Internal
+    module Worker
+      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 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
+          result = @queue.pop
+          if result.is_a?(Event)
+            result
+          else
+            worker_index, worker_type, poll_result = result
+            if worker_index.nil? || worker_type.nil?
+              Event::AllPollersShutDown.instance
+            else
+              worker = @workers[worker_index]
+              case poll_result
+              when nil
+                Event::PollerShutDown.new(worker:, worker_type:)
+              when Exception
+                Event::PollFailure.new(worker:, worker_type:, error: poll_result)
+              else
+                Event::PollSuccess.new(worker:, worker_type:, bytes: poll_result)
+              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 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.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Temporalio
+  # @!visibility private
+  module Internal
+  end
+end

data/lib/temporalio/retry_policy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'temporalio/internal/proto_utils'
+
+module Temporalio
+  # Options for retrying workflows and activities.
+  #
+  # @!attribute initial_interval
+  #   @return [Float] Backoff interval in seconds for the first retry. Default 1.0.
+  # @!attribute backoff_coefficient
+  #   @return [Float] Coefficient to multiply previous backoff interval by to get new interval. Default 2.0.
+  # @!attribute max_interval
+  #   @return [Float, nil] Maximum backoff interval in seconds between retries. Default 100x `initial_interval`.
+  # @!attribute max_attempts
+  #   @return [Integer] Maximum number of attempts. If `0`, the default, there is no maximum.
+  # @!attribute non_retryable_error_types
+  #   @return [Array<String>, nil] List of error types that are not retryable.
+  RetryPolicy = Struct.new(
+    :initial_interval,
+    :backoff_coefficient,
+    :max_interval,
+    :max_attempts,
+    :non_retryable_error_types,
+    keyword_init: true
+  ) do
+    def initialize(*, **kwargs)
+      kwargs[:initial_interval] = 1.0 unless kwargs.key?(:initial_interval)
+      kwargs[:backoff_coefficient] = 2.0 unless kwargs.key?(:backoff_coefficient)
+      kwargs[:max_attempts] = 0 unless kwargs.key?(:max_attempts)
+      super
+    end
+
+    # @!visibility private
+    def to_proto
+      # @type self: RetryPolicy
+      raise 'Initial interval cannot be negative' if initial_interval.negative?
+      raise 'Backoff coefficient cannot be less than 1' if backoff_coefficient < 1
+      raise 'Max interval cannot be negative' if max_interval&.negative?
+      raise 'Max interval cannot be less than initial interval' if max_interval && max_interval < initial_interval
+      raise 'Max attempts cannot be negative' if max_attempts.negative?
+
+      Api::Common::V1::RetryPolicy.new(
+        initial_interval: Internal::ProtoUtils.seconds_to_duration(initial_interval),
+        backoff_coefficient:,
+        maximum_interval: Internal::ProtoUtils.seconds_to_duration(max_interval),
+        maximum_attempts: max_attempts,
+        non_retryable_error_types:
+      )
+    end
+  end
+end