temporalio 0.0.0 → 0.0.2

data/lib/temporalio/payload_converter/nil.rb

@@ -0,0 +1,26 @@
+require 'temporalio/payload_converter/encoding_base'
+
+module Temporalio
+  module PayloadConverter
+    # A payload converter for encoding/decoding nils.
+    class Nil < EncodingBase
+      ENCODING = 'binary/null'.freeze
+
+      def encoding
+        ENCODING
+      end
+
+      def from_payload(_payload)
+        nil
+      end
+
+      def to_payload(data)
+        return nil unless data.nil?
+
+        Temporalio::Api::Common::V1::Payload.new(
+          metadata: { 'encoding' => ENCODING },
+        )
+      end
+    end
+  end
+end

data/lib/temporalio/payload_converter.rb

@@ -0,0 +1,14 @@
+require 'temporalio/payload_converter/bytes'
+require 'temporalio/payload_converter/composite'
+require 'temporalio/payload_converter/json'
+require 'temporalio/payload_converter/nil'
+
+module Temporalio
+  module PayloadConverter
+    DEFAULT = Temporalio::PayloadConverter::Composite.new(
+      Temporalio::PayloadConverter::Nil.new,
+      Temporalio::PayloadConverter::Bytes.new,
+      Temporalio::PayloadConverter::JSON.new,
+    )
+  end
+end

data/lib/temporalio/retry_policy.rb

@@ -0,0 +1,82 @@
+require 'temporal/api/common/v1/message_pb'
+require 'temporalio/errors'
+
+module Temporalio
+  # Options for retrying workflows and activities.
+  #
+  # @see https://docs.temporal.io/application-development/features/#workflow-retry-policy
+  class RetryPolicy
+    class Invalid < Temporalio::Error; end
+
+    # @return [Integer] Backoff interval for the first retry.
+    attr_reader :initial_interval
+
+    # @return [Float] Coefficient to multiply previous backoff interval by to get new interval.
+    attr_reader :backoff
+
+    # @return [Integer, nil] Maximum backoff interval between retries. Default 100x
+    #   {#initial_interval}.
+    attr_reader :max_interval
+
+    # @return [Integer] Maximum number of attempts. If 0, the default, there is no maximum.
+    attr_reader :max_attempts
+
+    # @return [Array<String>] List of error types that are not retryable.
+    attr_reader :non_retriable_errors
+
+    # @param initial_interval [Integer] Backoff interval (in seconds) for the first retry.
+    # @param backoff [Float] Coefficient to multiply previous backoff interval by to get new
+    #   interval.
+    # @param max_interval [Integer] Maximum backoff interval between retries. Default 100x
+    #   {#initial_interval}.
+    # @param max_attempts [Integer] Maximum number of attempts. If 0, there is no maximum.
+    # @param non_retriable_errors [Array<String>] List of error types that are not retryable.
+    def initialize(
+      initial_interval: 1,
+      backoff: 2.0,
+      max_interval: nil,
+      max_attempts: 0,
+      non_retriable_errors: []
+    )
+      @initial_interval = initial_interval
+      @backoff = backoff
+      @max_interval = max_interval
+      @max_attempts = max_attempts
+      @non_retriable_errors = non_retriable_errors
+    end
+
+    def validate!
+      # Retries disabled
+      return if max_attempts == 1
+
+      # Maximum attempts
+      raise Invalid, 'Maximum attempts must be specified' unless max_attempts
+      raise Invalid, 'Maximum attempts cannot be negative' if max_attempts.negative?
+
+      # Initial interval
+      raise Invalid, 'Initial interval must be specified' unless initial_interval
+      raise Invalid, 'Initial interval cannot be negative' if initial_interval.negative?
+      raise Invalid, 'Initial interval must be in whole seconds' unless initial_interval.is_a?(Integer)
+
+      # Backoff coefficient
+      raise Invalid, 'Backoff coefficient must be specified' unless backoff
+      raise Invalid, 'Backoff coefficient cannot be less than 1' if backoff < 1
+
+      # Maximum interval
+      if max_interval
+        raise Invalid, 'Maximum interval cannot be negative' if max_interval.negative?
+        raise Invalid, 'Maximum interval cannot be less than initial interval' if max_interval < initial_interval
+      end
+    end
+
+    def to_proto
+      Temporalio::Api::Common::V1::RetryPolicy.new(
+        initial_interval: Google::Protobuf::Duration.new(seconds: initial_interval),
+        backoff_coefficient: backoff,
+        maximum_interval: max_interval ? Google::Protobuf::Duration.new(seconds: max_interval) : nil,
+        maximum_attempts: max_attempts,
+        non_retryable_error_types: non_retriable_errors.map(&:name).compact,
+      )
+    end
+  end
+end

data/lib/temporalio/retry_state.rb

@@ -0,0 +1,35 @@
+module Temporalio
+  # Current retry state of the workflow/activity during error.
+  module RetryState
+    STATES = [
+      IN_PROGRESS = :IN_PROGRESS,
+      NON_RETRYABLE_FAILURE = :NON_RETRYABLE_FAILURE,
+      TIMEOUT = :TIMEOUT,
+      MAXIMUM_ATTEMPTS_REACHED = :MAXIMUM_ATTEMPTS_REACHED,
+      RETRY_POLICY_NOT_SET = :RETRY_POLICY_NOT_SET,
+      INTERNAL_SERVER_ERROR = :INTERNAL_SERVER_ERROR,
+      CANCEL_REQUESTED = :CANCEL_REQUESTED,
+    ].freeze
+
+    # RBS screws up style definitions when using .freeze
+    # rubocop:disable Style/MutableConstant
+    API_MAP = {
+      RETRY_STATE_IN_PROGRESS: IN_PROGRESS,
+      RETRY_STATE_NON_RETRYABLE_FAILURE: NON_RETRYABLE_FAILURE,
+      RETRY_STATE_TIMEOUT: TIMEOUT,
+      RETRY_STATE_MAXIMUM_ATTEMPTS_REACHED: MAXIMUM_ATTEMPTS_REACHED,
+      RETRY_STATE_RETRY_POLICY_NOT_SET: RETRY_POLICY_NOT_SET,
+      RETRY_STATE_INTERNAL_SERVER_ERROR: INTERNAL_SERVER_ERROR,
+      RETRY_STATE_CANCEL_REQUESTED: CANCEL_REQUESTED,
+    }
+    # rubocop:enable Style/MutableConstant
+
+    def self.to_raw(state)
+      API_MAP.invert[state] || :RETRY_STATE_UNSPECIFIED
+    end
+
+    def self.from_raw(raw_state)
+      API_MAP[raw_state]
+    end
+  end
+end

data/lib/temporalio/runtime.rb

@@ -0,0 +1,25 @@
+require 'singleton'
+require 'temporalio/bridge'
+require 'temporalio/worker/reactor'
+
+module Temporalio
+  # @api private
+  class Runtime
+    include Singleton
+
+    attr_reader :core_runtime, :reactor
+
+    def initialize
+      @core_runtime = Temporalio::Bridge::Runtime.init
+      @reactor = Temporalio::Worker::Reactor.new
+    end
+
+    def ensure_callback_loop
+      return if @thread
+
+      @thread = Thread.new do
+        core_runtime.run_callback_loop
+      end
+    end
+  end
+end

data/lib/temporalio/timeout_type.rb

@@ -0,0 +1,29 @@
+module Temporalio
+  # Type of timeout for {Temporalio::TimeoutError}.
+  module TimeoutType
+    TYPES = [
+      START_TO_CLOSE = :START_TO_CLOSE,
+      SCHEDULE_TO_START = :SCHEDULE_TO_START,
+      SCHEDULE_TO_CLOSE = :SCHEDULE_TO_CLOSE,
+      HEARTBEAT = :HEARTBEAT,
+    ].freeze
+
+    # RBS screws up style definitions when using .freeze
+    # rubocop:disable Style/MutableConstant
+    API_MAP = {
+      TIMEOUT_TYPE_START_TO_CLOSE: START_TO_CLOSE,
+      TIMEOUT_TYPE_SCHEDULE_TO_START: SCHEDULE_TO_START,
+      TIMEOUT_TYPE_SCHEDULE_TO_CLOSE: SCHEDULE_TO_CLOSE,
+      TIMEOUT_TYPE_HEARTBEAT: HEARTBEAT,
+    }
+    # rubocop:enable Style/MutableConstant
+
+    def self.to_raw(type)
+      API_MAP.invert[type] || :TIMEOUT_TYPE_UNSPECIFIED
+    end
+
+    def self.from_raw(raw_type)
+      API_MAP[raw_type]
+    end
+  end
+end

data/lib/temporalio/version.rb

@@ -0,0 +1,3 @@
+module Temporalio
+  VERSION = '0.0.2'.freeze
+end

data/lib/temporalio/worker/activity_runner.rb

@@ -0,0 +1,92 @@
+require 'google/protobuf/well_known_types'
+require 'temporalio/activity/context'
+require 'temporalio/activity/info'
+require 'temporalio/error/failure'
+require 'temporalio/errors'
+
+module Temporalio
+  class Worker
+    # The main class for handling activity processing. It is expected to be executed from
+    # some threaded or async executor's context since methods called here might be blocking
+    # and this should not affect the main worker reactor.
+    #
+    # @api private
+    class ActivityRunner
+      def initialize(activity_class, start, task_queue, task_token, worker, converter)
+        @activity_class = activity_class
+        @start = start
+        @task_queue = task_queue
+        @task_token = task_token
+        @worker = worker
+        @converter = converter
+      end
+
+      def run
+        activity = activity_class.new(context)
+        input = converter.from_payload_array(start.input.to_a)
+
+        result = activity.execute(*input)
+
+        converter.to_payload(result)
+      rescue StandardError => e
+        # Temporal server ignores cancellation failures that were not requested by the server.
+        # However within the SDK cancellations are also used during the worker shutdown. In order
+        # to provide a seamless handling experience (same error raised within the Activity) we are
+        # using the ActivityCancelled error and then swapping it with a CancelledError here.
+        #
+        # In the future this will be handled by the SDK Core — https://github.com/temporalio/sdk-core/issues/461
+        if e.is_a?(Temporalio::Error::ActivityCancelled) && e.by_request?
+          e = Temporalio::Error::CancelledError.new(e.message)
+        end
+
+        converter.to_failure(e)
+      end
+
+      def cancel(reason, by_request:)
+        context.cancel(reason, by_request: by_request)
+      end
+
+      private
+
+      attr_reader :activity_class, :start, :task_queue, :task_token, :worker, :converter
+
+      def context
+        return @context if @context
+
+        heartbeat_proc = ->(*details) { heartbeat(*details) }
+        @context = Temporalio::Activity::Context.new(
+          generate_activity_info,
+          heartbeat_proc,
+          shielded: activity_class._shielded,
+        )
+      end
+
+      def generate_activity_info
+        Temporalio::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: converter.from_payload_array(start.heartbeat_details.to_a),
+          heartbeat_timeout: start.heartbeat_timeout&.to_f,
+          local: !start.is_local.nil?,
+          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: task_queue,
+          task_token: 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
+      end
+
+      def heartbeat(*details)
+        payloads = converter.to_payload_array(details)
+        worker.record_activity_heartbeat(task_token, payloads)
+      end
+    end
+  end
+end

data/lib/temporalio/worker/activity_worker.rb

@@ -0,0 +1,138 @@
+require 'temporalio/error/failure'
+require 'temporalio/errors'
+require 'temporalio/worker/activity_runner'
+require 'temporalio/worker/sync_worker'
+
+module Temporalio
+  class Worker
+    # @api private
+    class ActivityWorker
+      def initialize(task_queue, core_worker, activities, converter, executor, graceful_timeout)
+        @task_queue = task_queue
+        @worker = SyncWorker.new(core_worker)
+        @activities = prepare_activities(activities)
+        @converter = converter
+        @executor = executor
+        @graceful_timeout = graceful_timeout
+        @running_activities = {}
+        @cancellations = []
+        @drain_queue = Queue.new
+      end
+
+      def run(reactor)
+        # @type var outstanding_tasks: Array[Async::Task]
+        outstanding_tasks = []
+
+        loop do
+          activity_task = worker.poll_activity_task
+          outstanding_tasks << reactor.async do |async_task|
+            if activity_task.start
+              handle_start_activity(activity_task.task_token, activity_task.start)
+            elsif activity_task.cancel
+              handle_cancel_activity(activity_task.task_token, activity_task.cancel)
+            end
+          ensure
+            outstanding_tasks.delete(async_task)
+          end
+        end
+      rescue Temporalio::Bridge::Error::WorkerShutdown
+        # No need to re-raise this error, it's a part of a normal shutdown
+      ensure
+        reactor.async do |async_task|
+          cancelation_task =
+            if graceful_timeout
+              async_task.async do
+                sleep graceful_timeout
+                running_activities.each_value do |activity_runner|
+                  activity_runner.cancel('Worker is shutting down', by_request: false)
+                end
+              end
+            end
+
+          outstanding_tasks.each(&:wait)
+          cancelation_task&.stop # all tasks completed, stop cancellations
+          drain_queue.close
+        end
+      end
+
+      def drain
+        drain_queue.pop
+      end
+
+      private
+
+      attr_reader :task_queue, :worker, :activities, :converter, :executor, :graceful_timeout,
+                  :running_activities, :cancellations, :drain_queue
+
+      def prepare_activities(activities)
+        activities.each_with_object({}) do |activity, result|
+          unless activity.ancestors.include?(Temporalio::Activity)
+            raise ArgumentError, 'Activity must be a subclass of Temporalio::Activity'
+          end
+
+          if result[activity._name]
+            raise ArgumentError, "More than one activity named #{activity._name}"
+          end
+
+          result[activity._name] = activity
+          result
+        end
+      end
+
+      def lookup_activity(activity_type)
+        activities.fetch(activity_type) do
+          activity_names = activities.keys.sort.join(', ')
+          raise Temporalio::Error::ApplicationError.new(
+            "Activity #{activity_type} is not registered on this worker, available activities: #{activity_names}",
+            type: 'NotFoundError',
+          )
+        end
+      end
+
+      def run_activity(token, start)
+        activity_class = lookup_activity(start.activity_type)
+        runner = ActivityRunner.new(activity_class, start, task_queue, token, worker, converter)
+        running_activities[token] = runner
+        queue = Queue.new
+
+        executor.schedule do
+          queue << runner.run
+        end
+
+        queue.pop
+      rescue StandardError => e
+        converter.to_failure(e)
+      end
+
+      def handle_start_activity(task_token, start)
+        result = run_activity(task_token, start)
+
+        case result
+        when Temporalio::Api::Common::V1::Payload
+          worker.complete_activity_task_with_success(task_token, result)
+        when Temporalio::Api::Failure::V1::Failure
+          # only respond with a cancellation when it was requested, otherwise it's a regular failure
+          if result.canceled_failure_info && cancellations.include?(task_token)
+            worker.complete_activity_task_with_cancellation(task_token, result)
+          else
+            worker.complete_activity_task_with_failure(task_token, result)
+          end
+        end
+
+        running_activities.delete(task_token)
+        cancellations.delete(task_token)
+      end
+
+      def handle_cancel_activity(task_token, _cancel)
+        runner = running_activities.fetch(task_token) do
+          # TODO: Use logger instead when implemented
+          warn "Cannot find activity to cancel for token #{task_token}"
+          return # early escape
+        end
+
+        cancellations << task_token
+        runner&.cancel('Activity cancellation requested', by_request: true)
+      end
+    end
+  end
+end

data/lib/temporalio/worker/reactor.rb

@@ -0,0 +1,46 @@
+require 'async'
+
+module Temporalio
+  class Worker
+    # A shared async reactor.
+    #
+    # This class allows multiple workers to access the same Async reactor
+    # without forcing the SDK users to wrap their execution in an Async block. This
+    # is handled using a queue that is polled from within a running Async reactor,
+    # so all the blocks end up being executed within it.
+    #
+    # @api private
+    class Reactor
+      def initialize
+        @queue = Queue.new
+        @thread = nil
+        @mutex = Mutex.new
+      end
+
+      def async(&block)
+        ensure_reactor_thread
+        queue << block
+      end
+
+      private
+
+      attr_reader :queue, :mutex
+
+      def ensure_reactor_thread
+        mutex.synchronize do
+          @thread ||= Thread.new { run_loop }
+        end
+      end
+
+      def run_loop
+        reactor = Async::Reactor.new
+        reactor.run do |task|
+          loop do
+            block = queue.pop
+            task.async { |subtask| block.call(subtask) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/worker/runner.rb

@@ -0,0 +1,63 @@
+require 'temporalio/errors'
+
+module Temporalio
+  class Worker
+    # A class used to manage the lifecycle of running any number of workers.
+    #
+    # @api private
+    class Runner
+      def initialize(*workers)
+        if workers.empty?
+          raise ArgumentError, 'Must be initialized with at least one worker'
+        end
+
+        @workers = workers
+        @mutex = Mutex.new
+        @started = false
+        @shutdown = false
+      end
+
+      def run(&block)
+        @thread = Thread.current
+        @started = true
+        workers.each { |worker| worker.start(self) }
+
+        block ? block.call : sleep
+      rescue Temporalio::Error::WorkerShutdown
+        # Explicit shutdown requested, no need to raise
+      ensure
+        @shutdown = true
+        shutdown_workers
+      end
+
+      def shutdown(exception = Temporalio::Error::WorkerShutdown.new('Manual shutdown'))
+        mutex.synchronize do
+          return unless running?
+
+          @shutdown = true
+        end
+
+        # propagate shutdown to the running thread
+        thread&.raise(exception)
+      end
+
+      private
+
+      attr_reader :workers, :mutex, :thread
+
+      def running?
+        @started && !@shutdown
+      end
+
+      def shutdown_workers
+        # Protect shutdown from any outside raises
+        Thread.handle_interrupt(StandardError => :never) do
+          workers.map do |worker|
+            # Shut down each worker (and wait for it) concurrently in separate threads
+            Thread.new { worker.shutdown }
+          end.each(&:join)
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/worker/sync_worker.rb

@@ -0,0 +1,88 @@
+require 'temporal/sdk/core/activity_task/activity_task_pb'
+require 'temporal/sdk/core/core_interface_pb'
+
+module Temporalio
+  class Worker
+    # This is a wrapper class for the Core Worker (provided via the Bridge) to abstract
+    # away its async nature allowing other modules/classes to interact with it without
+    # any callbacks (simplifying the code).
+    #
+    # CAUTION: This class will block the thread its running in unless it is used from
+    #          within an Async reactor.
+    #
+    # @api private
+    class SyncWorker
+      def initialize(core_worker)
+        @core_worker = core_worker
+      end
+
+      def poll_activity_task
+        with_queue do |done|
+          core_worker.poll_activity_task do |task, error|
+            done.call(task && Coresdk::ActivityTask::ActivityTask.decode(task), error)
+          end
+        end
+      end
+
+      def complete_activity_task_with_success(task_token, payload)
+        result = Coresdk::ActivityResult::ActivityExecutionResult.new(
+          completed: Coresdk::ActivityResult::Success.new(result: payload),
+        )
+
+        complete_activity_task(task_token, result)
+      end
+
+      def complete_activity_task_with_failure(task_token, failure)
+        result = Coresdk::ActivityResult::ActivityExecutionResult.new(
+          failed: Coresdk::ActivityResult::Failure.new(failure: failure),
+        )
+
+        complete_activity_task(task_token, result)
+      end
+
+      def complete_activity_task_with_cancellation(task_token, failure)
+        result = Coresdk::ActivityResult::ActivityExecutionResult.new(
+          cancelled: Coresdk::ActivityResult::Cancellation.new(failure: failure),
+        )
+
+        complete_activity_task(task_token, result)
+      end
+
+      def record_activity_heartbeat(task_token, payloads)
+        proto = Coresdk::ActivityHeartbeat.new(
+          task_token: task_token,
+          details: payloads,
+        )
+        encoded_proto = Coresdk::ActivityHeartbeat.encode(proto)
+
+        core_worker.record_activity_heartbeat(encoded_proto)
+      end
+
+      private
+
+      attr_reader :core_worker
+
+      def with_queue(&block)
+        queue = Queue.new
+        done = ->(result, error = nil) { queue << [result, error] }
+        block.call(done)
+        (result, exception) = queue.pop
+        raise exception if exception
+
+        result
+      end
+
+      def complete_activity_task(task_token, result)
+        proto = Coresdk::ActivityTaskCompletion.new(
+          task_token: task_token,
+          result: result,
+        )
+        encoded_proto = Coresdk::ActivityTaskCompletion.encode(proto)
+
+        with_queue do |done|
+          core_worker.complete_activity_task(encoded_proto, &done)
+        end
+      end
+    end
+  end
+end