temporalio 0.0.1 → 0.0.2

data/lib/temporalio/worker/thread_pool_executor.rb

@@ -0,0 +1,51 @@
+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/worker.rb

@@ -0,0 +1,198 @@
+require 'async'
+require 'temporalio/bridge'
+require 'temporalio/data_converter'
+require 'temporalio/runtime'
+require 'temporalio/worker/activity_worker'
+require 'temporalio/worker/runner'
+require 'temporalio/worker/thread_pool_executor'
+
+module Temporalio
+  # Worker to process workflows and/or activities.
+  #
+  # Once created, workers can be run and shutdown explicitly via {#run} and {#shutdown}.
+  class Worker
+    # Run multiple workers and wait for them to be shut down.
+    #
+    # This will not return until shutdown is complete (and all running activities in all workers
+    # finished) and will raise if any of the workers raises a fatal error.
+    #
+    # @param workers [Array<Temporalio::Worker>] A list of the workers to be run.
+    # @param shutdown_signals [Array<String>] A list of process signals for the worker to stop on.
+    #   This argument can not be used with a custom block.
+    #
+    # @yield Optionally you can provide a block by the end of which all the workers will be shut
+    #   down. Any errors raised from this block will be re-raised by this method.
+    def self.run(*workers, shutdown_signals: [], &block)
+      unless shutdown_signals.empty?
+        if block
+          raise ArgumentError, 'Temporalio::Worker.run accepts :shutdown_signals or a block, but not both'
+        end
+
+        signal_queue = Queue.new
+
+        shutdown_signals.each do |signal|
+          Signal.trap(signal) { signal_queue.close }
+        end
+
+        block = -> { signal_queue.pop }
+      end
+
+      Runner.new(*workers).run(&block)
+    end
+
+    # Create a worker to process workflows and/or activities.
+    #
+    # @param connection [Temporalio::Connection] A connection to be used for this worker.
+    # @param namespace [String] A namespace.
+    # @param task_queue [String] A task queue.
+    # @param activities [Array<Class>] A list of activities (subclasses of {Temporalio::Activity}).
+    # @param data_converter [Temporalio::DataConverter] Data converter to use for all data conversions
+    #   to/from payloads.
+    # @param activity_executor [ThreadPoolExecutor] Concurrent executor for all activities. Defaults
+    #   to a {ThreadPoolExecutor} with `:max_concurrent_activities` available threads.
+    # @param max_concurrent_activities [Integer] Number of concurrently running activities.
+    # @param graceful_shutdown_timeout [Integer] Amount of time (in seconds) activities are given
+    #   after a shutdown to complete before they are cancelled. A default value of `nil` means that
+    #   activities are never cancelled when handling a shutdown.
+    #
+    # @raise [ArgumentError] When no activities or workflows have been provided.
+    def initialize(
+      connection,
+      namespace,
+      task_queue,
+      activities: [],
+      data_converter: Temporalio::DataConverter.new,
+      activity_executor: nil,
+      max_concurrent_activities: 100,
+      graceful_shutdown_timeout: nil
+    )
+      # TODO: Add worker interceptors
+      @started = false
+      @shutdown = false
+      @mutex = Mutex.new
+      @runtime = Temporalio::Runtime.instance
+      @activity_executor = activity_executor || ThreadPoolExecutor.new(max_concurrent_activities)
+      @core_worker = Temporalio::Bridge::Worker.create(
+        @runtime.core_runtime,
+        connection.core_connection,
+        namespace,
+        task_queue,
+      )
+      @activity_worker =
+        unless activities.empty?
+          Worker::ActivityWorker.new(
+            task_queue,
+            @core_worker,
+            activities,
+            data_converter,
+            @activity_executor,
+            graceful_shutdown_timeout,
+          )
+        end
+      @workflow_worker = nil
+
+      if !@activity_worker && !@workflow_worker
+        raise ArgumentError, 'At least one activity or workflow must be specified'
+      end
+    end
+
+    # Run the worker and wait on it to be shut down.
+    #
+    # This will not return until shutdown is complete (and all running activities finished) and will
+    # raise if there is a worker fatal error. To run multiple workers use the class method {.run}.
+    #
+    # @note A worker is only intended to be started once. Initialize a new worker should you need to
+    #   run it again.
+    #
+    # @yield Optionally you can provide a block by the end of which the worker will shut itself
+    #   down. You can use this to stop a worker after some time has passed, your workflow has
+    #   finished or any other arbitrary implementation has completed. Any errors raised from this
+    #   block will be re-raised by this method.
+    def run(&block)
+      Runner.new(self).run(&block)
+    end
+
+    # Start the worker asynchronously in a shared runtime.
+    #
+    # This is an internal method for advanced use-cases for those intended to implement their own
+    # worker runner.
+    #
+    # @note A worker is only intended to be started once. Initialize a new worker should you need to
+    #   start it again.
+    #
+    # @api private
+    #
+    # @param runner [Temporalio::Worker::Runner] A runner to notify when the worker is shutting down.
+    def start(runner = nil)
+      mutex.synchronize do
+        raise 'Worker is already started' if started?
+
+        @started = true
+      end
+
+      @runner = runner
+      runtime.ensure_callback_loop
+
+      runtime.reactor.async do |task|
+        if activity_worker
+          task.async do |task|
+            activity_worker.run(task)
+          rescue StandardError => e
+            shutdown(e) # initiate shutdown because of a fatal error
+          end
+        end
+
+        # TODO: Pending implementation
+        task.async { |task| workflow_worker.run(task) } if workflow_worker
+      end
+    end
+
+    # Initiate a worker shutdown and wait until complete.
+    #
+    # This can be called before the worker has even started and is safe for repeated invocations.
+    # This method will not return until the worker has completed shutting down.
+    #
+    # @param exception [Exception] An exception to be raised from {#run} or {.run} methods after a
+    #   shutdown procedure has completed.
+    def shutdown(exception = Temporalio::Error::WorkerShutdown.new('Manual shutdown'))
+      mutex.synchronize do
+        return unless running?
+
+        # First initiate Core shutdown, which will start dropping poll requests
+        core_worker.initiate_shutdown
+        # Then let the runner know we're shutting down, so it can stop other workers
+        runner&.shutdown(exception)
+        # Wait for workers to drain any outstanding tasks
+        activity_worker&.drain
+        workflow_worker&.drain
+        # Stop the executor (at this point there should already be nothing in it)
+        activity_executor.shutdown
+        # Finalize the shutdown by stopping the Core
+        core_worker.shutdown
+
+        @shutdown = true
+      end
+    end
+
+    # Whether the worker has been started.
+    #
+    # @return [Boolean]
+    def started?
+      @started
+    end
+
+    # Whether the worker is running.
+    #
+    # This is only `true` if the worker has been started and not yet shut down.
+    #
+    # @return [Boolean]
+    def running?
+      @started && !@shutdown
+    end
+
+    private
+
+    attr_reader :mutex, :runtime, :activity_executor, :core_worker, :activity_worker,
+                :workflow_worker, :runner
+  end
+end

data/lib/{temporal → temporalio}/workflow/execution_info.rb

@@ -1,8 +1,8 @@
-require 'temporal/errors'
-require 'temporal/workflow/execution_status'
+require 'temporalio/errors'
+require 'temporalio/workflow/execution_status'
 require 'google/protobuf/well_known_types'
 
-module Temporal
+module Temporalio
   class Workflow
     class ExecutionInfo < Struct.new(
       :raw,
@@ -23,7 +23,7 @@ module Temporal
     )
       def self.from_raw(response, converter)
         raw_info = response.workflow_execution_info
-        raise Temporal::Error::UnexpectedResponse, 'missing workflow_execution_info' unless raw_info
+        raise Temporalio::Error::UnexpectedResponse, 'missing workflow_execution_info' unless raw_info
 
         new(
           raw: response,

data/lib/{temporal → temporalio}/workflow/execution_status.rb

@@ -1,4 +1,4 @@
-module Temporal
+module Temporalio
   class Workflow
     module ExecutionStatus
       STATUSES = [

data/lib/{temporal → temporalio}/workflow/id_reuse_policy.rb

@@ -1,10 +1,10 @@
 require 'temporal/api/enums/v1/workflow_pb'
 
-module Temporal
+module Temporalio
   class Workflow
     # How already-in-use workflow IDs are handled on start.
     #
-    # @see Temporal::Api::Enums::V1::WorkflowIdReusePolicy
+    # @see Temporalio::Api::Enums::V1::WorkflowIdReusePolicy
     class IDReusePolicy
       POLICIES = [
         ALLOW_DUPLICATE = :ALLOW_DUPLICATE,
@@ -14,13 +14,13 @@ module Temporal
       ].freeze
 
       API_MAP = {
-        Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE =>
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE =>
           ALLOW_DUPLICATE,
-        Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY =>
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY =>
           ALLOW_DUPLICATE_FAILED_ONLY,
-        Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE =>
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE =>
           REJECT_DUPLICATE,
-        Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING =>
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING =>
           TERMINATE_IF_RUNNING,
       }.freeze
 

data/lib/{temporal → temporalio}/workflow/query_reject_condition.rb

@@ -1,10 +1,10 @@
 require 'temporal/api/enums/v1/query_pb'
 
-module Temporal
+module Temporalio
   class Workflow
     # Whether a query should be rejected in certain conditions.
     #
-    # @see Temporal::Api::Enums::V1::QueryRejectCondition
+    # @see Temporalio::Api::Enums::V1::QueryRejectCondition
     module QueryRejectCondition
       CONDITIONS = [
         NONE = :NONE,
@@ -13,11 +13,11 @@ module Temporal
       ].freeze
 
       API_MAP = {
-        Temporal::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NONE =>
+        Temporalio::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NONE =>
           NONE,
-        Temporal::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NOT_OPEN =>
+        Temporalio::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NOT_OPEN =>
           NOT_OPEN,
-        Temporal::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY =>
+        Temporalio::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY =>
           NOT_COMPLETED_CLEANLY,
       }.freeze
 

data/lib/temporalio.rb

@@ -1,3 +1,12 @@
-# This file provides the main entry-point for the gem (based on the name).
-# All the gem internals are namespaced Temporal, temporalio is onle the name of the gem.
-require_relative './temporal'
+# Protoc wants all of its generated files on the LOAD_PATH
+$LOAD_PATH << File.expand_path('./gen', File.dirname(__FILE__))
+
+require 'temporalio/activity'
+require 'temporalio/bridge'
+require 'temporalio/client'
+require 'temporalio/connection'
+require 'temporalio/version'
+require 'temporalio/worker'
+
+module Temporalio
+end

data/temporalio.gemspec

@@ -1,8 +1,8 @@
-require_relative './lib/temporal/version'
+require_relative './lib/temporalio/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'temporalio'
-  spec.version       = Temporal::VERSION
+  spec.version       = Temporalio::VERSION
   spec.summary       = 'Temporal.io Ruby SDK'
   spec.description   = 'An SDK for implementing Temporal.io workflows and activities in Ruby'
   spec.homepage      = 'https://github.com/temporalio/sdk-ruby'
@@ -19,8 +19,12 @@ Gem::Specification.new do |spec|
     Dir['bridge/**/*.*'].reject { |x| x.include?('/target/') } +
     %w[ext/Rakefile temporalio.gemspec Gemfile LICENSE README.md]
 
-  spec.required_ruby_version = '>= 2.7.0'
+  # Limited by async. While we support both v1 and v2, we only allow Ruby >= 3
+  # since async v1 with Ruby 2 has a blocking behaviour (despite identical interface):
+  # https://github.com/socketry/async/discussions/108#discussioncomment-541788
+  spec.required_ruby_version = '>= 3.0.2'
 
+  spec.add_dependency 'async' # Fiber-based reactor. Open-ended to allow Ruby 3.1+ to use v2
   spec.add_dependency 'google-protobuf', '~> 3.21.1' # Protobuf
   spec.add_dependency 'rexml', '~> 3.2.5' # Implicitly required by thermite
   spec.add_dependency 'rutie', '~> 0.0.4' # Rust bindings