temporalio 0.0.1 → 0.0.2

data/lib/{temporal → temporalio}/payload_codec/base.rb

@@ -1,4 +1,4 @@
-module Temporal
+module Temporalio
   module PayloadCodec
     # @abstract Use this Interface for implementing your payload codecs.
     #
@@ -6,10 +6,10 @@ module Temporal
     class Base
       # Encode the given payloads.
       #
-      # @param _payloads [Array<Temporal::Api::Common::V1::Payload>] Payloads to encode.
+      # @param _payloads [Array<Temporalio::Api::Common::V1::Payload>] Payloads to encode.
       #   This value should not be mutated.
       #
-      # @return [Array<Temporal::Api::Common::V1::Payload>] Encoded payloads. Note, this does not
+      # @return [Array<Temporalio::Api::Common::V1::Payload>] Encoded payloads. Note, this does not
       #   have to be the same number as payloads given, but must be at least one and cannot be more
       #   than was given.
       def encode(_payloads)
@@ -18,10 +18,10 @@ module Temporal
 
       # Decode the given payloads.
       #
-      # @param _payloads [Array<Temporal::Api::Common::V1::Payload>] Payloads to decode. This value
+      # @param _payloads [Array<Temporalio::Api::Common::V1::Payload>] Payloads to decode. This value
       #   should not be mutated.
       #
-      # @return [Array<Temporal::Api::Common::V1::Payload>] Decoded payloads. Note, this does not
+      # @return [Array<Temporalio::Api::Common::V1::Payload>] Decoded payloads. Note, this does not
       #   have to be the same number as payloads given, but must be at least one and cannot be more
       #   than was given.
       def decode(_payloads)

data/lib/{temporal → temporalio}/payload_converter/base.rb

@@ -1,4 +1,4 @@
-module Temporal
+module Temporalio
   module PayloadConverter
     # @abstract Use this Interface for implementing your payload converter.
     class Base
@@ -6,14 +6,14 @@ module Temporal
       #
       # @param _data [any] Ruby value to be converted.
       #
-      # @return [Temporal::Api::Common::V1::Payload]
+      # @return [Temporalio::Api::Common::V1::Payload]
       def to_payload(_data)
         raise NoMethodError, 'must implement #to_payload'
       end
 
       # Convert a proto Payload to a Ruby value.
       #
-      # @param _payload [Temporal::Api::Common::V1::Payload] Proto Payload to be converted.
+      # @param _payload [Temporalio::Api::Common::V1::Payload] Proto Payload to be converted.
       #
       # @return [any]
       def from_payload(_payload)

data/lib/{temporal → temporalio}/payload_converter/bytes.rb

@@ -1,7 +1,8 @@
-require 'temporal/payload_converter/encoding_base'
+require 'temporalio/payload_converter/encoding_base'
 
-module Temporal
+module Temporalio
   module PayloadConverter
+    # A payload converter for encoding/decoding byte strings.
     class Bytes < EncodingBase
       ENCODING = 'binary/plain'.freeze
 
@@ -16,7 +17,7 @@ module Temporal
       def to_payload(data)
         return nil unless data.is_a?(String) && data.encoding == Encoding::ASCII_8BIT
 
-        Temporal::Api::Common::V1::Payload.new(
+        Temporalio::Api::Common::V1::Payload.new(
           metadata: { 'encoding' => ENCODING },
           data: data,
         )

data/lib/{temporal → temporalio}/payload_converter/composite.rb

@@ -1,12 +1,14 @@
-require 'temporal/payload_converter/base'
-require 'temporal/errors'
+require 'temporalio/payload_converter/base'
+require 'temporalio/errors'
 
-module Temporal
+module Temporalio
   module PayloadConverter
+    # A payload converter for combining multiple payload converters together.
     class Composite < Base
-      class ConverterNotFound < Temporal::Error; end
-      class EncodingNotSet < Temporal::Error; end
+      class ConverterNotFound < Temporalio::Error; end
+      class EncodingNotSet < Temporalio::Error; end
 
+      # @param converters [Array<Temporalio::PayloadConverter::Base>] List of converters
       def initialize(*converters)
         super()
 

data/lib/{temporal → temporalio}/payload_converter/encoding_base.rb

@@ -1,9 +1,9 @@
 require 'temporal/api/common/v1/message_pb'
 
-module Temporal
+module Temporalio
   module PayloadConverter
     # @abstract Use this Interface for implementing an encoding payload converter.
-    #   This is used as a converter for the {Temporal::PayloadConverter::Composite}.
+    #   This is used as a converter for the {Temporalio::PayloadConverter::Composite}.
     class EncodingBase
       # A mime-type for the converter's encoding.
       #
@@ -16,7 +16,7 @@ module Temporal
       #
       # @param _data [any] Ruby value to be converted.
       #
-      # @return [Temporal::Api::Common::V1::Payload, nil] Return `nil` if the received value is not
+      # @return [Temporalio::Api::Common::V1::Payload, nil] Return `nil` if the received value is not
       #   supported by this converter.
       def to_payload(_data)
         raise NoMethodError, 'must implement #to_payload'
@@ -24,7 +24,7 @@ module Temporal
 
       # Convert a proto Payload to a Ruby value.
       #
-      # @param _payload [Temporal::Api::Common::V1::Payload] Proto Payload to be converted.
+      # @param _payload [Temporalio::Api::Common::V1::Payload] Proto Payload to be converted.
       #
       # @return [any]
       def from_payload(_payload)

data/lib/{temporal → temporalio}/payload_converter/json.rb

@@ -1,8 +1,9 @@
 require 'json/ext'
-require 'temporal/payload_converter/encoding_base'
+require 'temporalio/payload_converter/encoding_base'
 
-module Temporal
+module Temporalio
   module PayloadConverter
+    # A payload converter for encoding/decoding JSON data.
     class JSON < EncodingBase
       ENCODING = 'json/plain'.freeze
 
@@ -15,7 +16,7 @@ module Temporal
       end
 
       def to_payload(data)
-        Temporal::Api::Common::V1::Payload.new(
+        Temporalio::Api::Common::V1::Payload.new(
           metadata: { 'encoding' => ENCODING },
           data: ::JSON.generate(data).b,
         )

data/lib/{temporal → temporalio}/payload_converter/nil.rb

@@ -1,7 +1,8 @@
-require 'temporal/payload_converter/encoding_base'
+require 'temporalio/payload_converter/encoding_base'
 
-module Temporal
+module Temporalio
   module PayloadConverter
+    # A payload converter for encoding/decoding nils.
     class Nil < EncodingBase
       ENCODING = 'binary/null'.freeze
 
@@ -16,7 +17,7 @@ module Temporal
       def to_payload(data)
         return nil unless data.nil?
 
-        Temporal::Api::Common::V1::Payload.new(
+        Temporalio::Api::Common::V1::Payload.new(
           metadata: { 'encoding' => ENCODING },
         )
       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/{temporal → temporalio}/retry_policy.rb

@@ -1,12 +1,12 @@
 require 'temporal/api/common/v1/message_pb'
-require 'temporal/errors'
+require 'temporalio/errors'
 
-module Temporal
+module Temporalio
   # Options for retrying workflows and activities.
   #
   # @see https://docs.temporal.io/application-development/features/#workflow-retry-policy
   class RetryPolicy
-    class Invalid < Temporal::Error; end
+    class Invalid < Temporalio::Error; end
 
     # @return [Integer] Backoff interval for the first retry.
     attr_reader :initial_interval
@@ -70,7 +70,7 @@ module Temporal
     end
 
     def to_proto
-      Temporal::Api::Common::V1::RetryPolicy.new(
+      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,

data/lib/{temporal → temporalio}/retry_state.rb

@@ -1,4 +1,4 @@
-module Temporal
+module Temporalio
   # Current retry state of the workflow/activity during error.
   module RetryState
     STATES = [

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/{temporal → temporalio}/timeout_type.rb

@@ -1,5 +1,5 @@
-module Temporal
-  # Type of timeout for {Temporal::TimeoutError}.
+module Temporalio
+  # Type of timeout for {Temporalio::TimeoutError}.
   module TimeoutType
     TYPES = [
       START_TO_CLOSE = :START_TO_CLOSE,

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