temporalio 0.1.1 → 0.2.0

data/lib/temporalio/worker/activity_runner.rb

@@ -1,114 +0,0 @@
-require 'google/protobuf/well_known_types'
-require 'temporalio/activity/context'
-require 'temporalio/activity/info'
-require 'temporalio/error/failure'
-require 'temporalio/errors'
-require 'temporalio/interceptor/activity_inbound'
-
-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,
-        inbound_interceptors,
-        outbound_interceptors
-      )
-        @activity_class = activity_class
-        @start = start
-        @task_queue = task_queue
-        @task_token = task_token
-        @worker = worker
-        @converter = converter
-        @inbound_interceptors = inbound_interceptors
-        @outbound_interceptors = outbound_interceptors
-      end
-
-      def run
-        activity = activity_class.new(context)
-        args = converter.from_payload_array(start.input.to_a)
-        headers = converter.from_payload_map(start.header_fields)
-        input = Temporalio::Interceptor::ActivityInbound::ExecuteActivityInput.new(
-          activity: activity_class,
-          args: args,
-          headers: headers || {},
-        )
-
-        result = inbound_interceptors.invoke(:execute_activity, input) do |i|
-          activity.execute(*i.args)
-        end
-
-        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,
-                  :inbound_interceptors, :outbound_interceptors
-
-      def context
-        return @context if @context
-
-        heartbeat_proc = ->(*details) { heartbeat(*details) }
-        @context = Temporalio::Activity::Context.new(
-          generate_activity_info,
-          heartbeat_proc,
-          outbound_interceptors,
-          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

@@ -1,164 +0,0 @@
-require 'temporalio/error/failure'
-require 'temporalio/errors'
-require 'temporalio/interceptor'
-require 'temporalio/interceptor/chain'
-require 'temporalio/worker/activity_runner'
-
-module Temporalio
-  class Worker
-    # @api private
-    class ActivityWorker
-      def initialize(
-        task_queue,
-        worker,
-        activities,
-        converter,
-        interceptors,
-        executor,
-        graceful_timeout
-      )
-        @task_queue = task_queue
-        @worker = worker
-        @activities = prepare_activities(activities)
-        @converter = converter
-        @inbound_interceptors = Temporalio::Interceptor::Chain.new(
-          Temporalio::Interceptor.filter(interceptors, :activity_inbound),
-        )
-        @outbound_interceptors = Temporalio::Interceptor::Chain.new(
-          Temporalio::Interceptor.filter(interceptors, :activity_outbound),
-        )
-        @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
-        outstanding_tasks.each(&:wait)
-        @cancelation_task&.wait
-        drain_queue.close
-      end
-
-      def setup_graceful_shutdown_timer(reactor)
-        if graceful_timeout
-          reactor.async do |async_task|
-            @cancelation_task = 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
-        end
-      end
-
-      def drain
-        drain_queue.pop
-      end
-
-      private
-
-      attr_reader :task_queue, :worker, :activities, :converter, :inbound_interceptors,
-                  :outbound_interceptors, :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,
-          inbound_interceptors,
-          outbound_interceptors,
-        )
-        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

@@ -1,46 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,124 +0,0 @@
-require 'temporal/sdk/core/activity_task/activity_task_pb'
-require 'temporal/sdk/core/core_interface_pb'
-require 'temporal/sdk/core/workflow_activation/workflow_activation_pb'
-require 'temporal/sdk/core/workflow_completion/workflow_completion_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 && Temporalio::Bridge::Api::ActivityTask::ActivityTask.decode(task), error)
-          end
-        end
-      end
-
-      def complete_activity_task_with_success(task_token, payload)
-        result = Temporalio::Bridge::Api::ActivityResult::ActivityExecutionResult.new(
-          completed: Temporalio::Bridge::Api::ActivityResult::Success.new(result: payload),
-        )
-
-        complete_activity_task(task_token, result)
-      end
-
-      def complete_activity_task_with_failure(task_token, failure)
-        result = Temporalio::Bridge::Api::ActivityResult::ActivityExecutionResult.new(
-          failed: Temporalio::Bridge::Api::ActivityResult::Failure.new(failure: failure),
-        )
-
-        complete_activity_task(task_token, result)
-      end
-
-      def complete_activity_task_with_cancellation(task_token, failure)
-        result = Temporalio::Bridge::Api::ActivityResult::ActivityExecutionResult.new(
-          cancelled: Temporalio::Bridge::Api::ActivityResult::Cancellation.new(failure: failure),
-        )
-
-        complete_activity_task(task_token, result)
-      end
-
-      def record_activity_heartbeat(task_token, payloads)
-        proto = Temporalio::Bridge::Api::CoreInterface::ActivityHeartbeat.new(
-          task_token: task_token,
-          details: payloads,
-        )
-        encoded_proto = Temporalio::Bridge::Api::CoreInterface::ActivityHeartbeat.encode(proto)
-
-        core_worker.record_activity_heartbeat(encoded_proto)
-      end
-
-      def poll_workflow_activation
-        with_queue do |done|
-          core_worker.poll_workflow_activation do |task, error|
-            done.call(task && Temporalio::Bridge::Api::WorkflowActivation::WorkflowActivation.decode(task), error)
-          end
-        end
-      end
-
-      def complete_workflow_activation_with_success(run_id, commands)
-        proto = Temporalio::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.new(
-          run_id: run_id,
-          successful: Temporalio::Bridge::Api::WorkflowCompletion::Success.new(commands: commands),
-        )
-
-        complete_workflow_activation(proto)
-      end
-
-      def complete_workflow_activation_with_failure(run_id, failure)
-        proto = Temporalio::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.new(
-          run_id: run_id,
-          failed: Temporalio::Bridge::Api::WorkflowCompletion::Failure.new(failure: failure),
-        )
-
-        complete_workflow_activation(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 = Temporalio::Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
-          task_token: task_token,
-          result: result,
-        )
-        encoded_proto = Temporalio::Bridge::Api::CoreInterface::ActivityTaskCompletion.encode(proto)
-
-        with_queue do |done|
-          core_worker.complete_activity_task(encoded_proto, &done)
-        end
-      end
-
-      def complete_workflow_activation(proto)
-        encoded_proto = Temporalio::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.encode(proto)
-
-        with_queue do |done|
-          core_worker.complete_workflow_activation(encoded_proto, &done)
-        end
-      end
-    end
-  end
-end

data/lib/temporalio/worker/thread_pool_executor.rb

@@ -1,51 +0,0 @@
-module Temporalio
-  class Worker
-    # A generic fixed thread pool.
-    #
-    # This is used to execute multiple activities concurrently and independenty of each other.
-    #
-    # @note This is a fixed thread pool that allocated threads eagerly and has an infinite buffer.
-    class ThreadPoolExecutor
-      # Generate new thread pool executor.
-      #
-      # @param size [Integer] Number of concurrently executing threads.
-      def initialize(size)
-        @queue = Queue.new
-        @pool = Array.new(size) do
-          Thread.new { poll }
-        end
-      end
-
-      # Execute a block of code inside of the threads.
-      #
-      # @yield Block of code to be executed.
-      def schedule(&block)
-        queue << block
-      end
-
-      # Stop the thread pool and wait for all threads to finish work.
-      def shutdown
-        pool.size.times do
-          schedule { throw EXIT_SYMBOL }
-        end
-
-        pool.each(&:join)
-      end
-
-      private
-
-      attr_reader :queue, :pool
-
-      EXIT_SYMBOL = :exit
-
-      def poll
-        catch(EXIT_SYMBOL) do
-          loop do
-            job = queue.pop
-            job.call
-          end
-        end
-      end
-    end
-  end
-end

data/lib/temporalio/workflow/async.rb

@@ -1,46 +0,0 @@
-require 'temporalio/workflow/future'
-
-module Temporalio
-  class Workflow
-    module Async
-      def self.run(&block)
-        Future.new do |future, resolve, reject|
-          Fiber.new do
-            Future.current = future
-            result = block.call
-            resolve.call(result)
-          rescue StandardError => e
-            reject.call(e)
-          end.resume
-        end
-      end
-
-      def self.all(*futures)
-        Future.new do |future, resolve, _reject|
-          future.on_cancel { futures.each(&:cancel) }
-
-          futures.each do |f|
-            f.then do
-              # Resolve the aggregate once all futures have been fulfilled (resolved or rejected)
-              resolve.call(nil) if futures.none?(&:pending?)
-            end
-          end
-        end
-      end
-
-      def self.any(*futures)
-        # This future is never rejected
-        Future.new do |future, resolve, _reject|
-          future.on_cancel { futures.each(&:cancel) }
-
-          futures.each do |f|
-            # Resolve the aggregate once the first future fulfills (resolved or rejected)
-            # NOTE: The the first completed future will be the resolved value and all subsequent
-            #       calls to `resolve` will have no effect.
-            f.then { resolve.call(f) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/temporalio/workflow/execution_info.rb

@@ -1,54 +0,0 @@
-require 'temporalio/errors'
-require 'temporalio/workflow/execution_status'
-require 'google/protobuf/well_known_types'
-
-module Temporalio
-  class Workflow
-    class ExecutionInfo < Struct.new(
-      :raw,
-      :workflow,
-      :id,
-      :run_id,
-      :task_queue,
-      :status,
-      :parent_id,
-      :parent_run_id,
-      :start_time,
-      :close_time,
-      :execution_time,
-      :history_length,
-      :memo,
-      :search_attributes,
-      keyword_init: true,
-    )
-      def self.from_raw(response, converter)
-        raw_info = response.workflow_execution_info
-        raise Temporalio::Error::UnexpectedResponse, 'missing workflow_execution_info' unless raw_info
-
-        new(
-          raw: response,
-          workflow: raw_info.type&.name,
-          id: raw_info.execution&.workflow_id,
-          run_id: raw_info.execution&.run_id,
-          task_queue: raw_info.task_queue,
-          status: Workflow::ExecutionStatus.from_raw(raw_info.status),
-          parent_id: raw_info.parent_execution&.workflow_id,
-          parent_run_id: raw_info.parent_execution&.run_id,
-          start_time: raw_info.start_time&.to_time,
-          close_time: raw_info.close_time&.to_time,
-          execution_time: raw_info.execution_time&.to_time,
-          history_length: raw_info.history_length,
-          memo: converter.from_payload_map(raw_info.memo&.fields),
-          search_attributes: converter.from_payload_map(raw_info.search_attributes&.indexed_fields),
-        ).freeze
-      end
-
-      # Helper methods for checking execution status
-      Workflow::ExecutionStatus::STATUSES.each do |status|
-        define_method("#{status.downcase}?") do
-          self.status == status
-        end
-      end
-    end
-  end
-end

data/lib/temporalio/workflow/execution_status.rb

@@ -1,36 +0,0 @@
-module Temporalio
-  class Workflow
-    module ExecutionStatus
-      STATUSES = [
-        RUNNING = :RUNNING,
-        COMPLETED = :COMPLETED,
-        FAILED = :FAILED,
-        CANCELED = :CANCELED,
-        TERMINATED = :TERMINATED,
-        CONTINUED_AS_NEW = :CONTINUED_AS_NEW,
-        TIMED_OUT = :TIMED_OUT,
-      ].freeze
-
-      # RBS screws up style definitions when using .freeze
-      # rubocop:disable Style/MutableConstant
-      API_MAP = {
-        WORKFLOW_EXECUTION_STATUS_RUNNING: RUNNING,
-        WORKFLOW_EXECUTION_STATUS_COMPLETED: COMPLETED,
-        WORKFLOW_EXECUTION_STATUS_FAILED: FAILED,
-        WORKFLOW_EXECUTION_STATUS_CANCELED: CANCELED,
-        WORKFLOW_EXECUTION_STATUS_TERMINATED: TERMINATED,
-        WORKFLOW_EXECUTION_STATUS_CONTINUED_AS_NEW: CONTINUED_AS_NEW,
-        WORKFLOW_EXECUTION_STATUS_TIMED_OUT: TIMED_OUT,
-      }
-      # rubocop:enable Style/MutableConstant
-
-      def self.to_raw(status)
-        API_MAP.invert[status]
-      end
-
-      def self.from_raw(raw_status)
-        API_MAP[raw_status]
-      end
-    end
-  end
-end