temporalio 0.0.0 → 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/temporalio/workflow/execution_info.rb

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

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

data/lib/temporalio/workflow/id_reuse_policy.rb

@@ -0,0 +1,36 @@
+require 'temporal/api/enums/v1/workflow_pb'
+
+module Temporalio
+  class Workflow
+    # How already-in-use workflow IDs are handled on start.
+    #
+    # @see Temporalio::Api::Enums::V1::WorkflowIdReusePolicy
+    class IDReusePolicy
+      POLICIES = [
+        ALLOW_DUPLICATE = :ALLOW_DUPLICATE,
+        ALLOW_DUPLICATE_FAILED_ONLY = :ALLOW_DUPLICATE_FAILED_ONLY,
+        REJECT_DUPLICATE = :REJECT_DUPLICATE,
+        TERMINATE_IF_RUNNING = :TERMINATE_IF_RUNNING,
+      ].freeze
+
+      API_MAP = {
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE =>
+          ALLOW_DUPLICATE,
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY =>
+          ALLOW_DUPLICATE_FAILED_ONLY,
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE =>
+          REJECT_DUPLICATE,
+        Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING =>
+          TERMINATE_IF_RUNNING,
+      }.freeze
+
+      def self.to_raw(policy)
+        API_MAP.invert[policy]
+      end
+
+      def self.from_raw(raw_policy)
+        API_MAP[raw_policy]
+      end
+    end
+  end
+end

data/lib/temporalio/workflow/query_reject_condition.rb

@@ -0,0 +1,33 @@
+require 'temporal/api/enums/v1/query_pb'
+
+module Temporalio
+  class Workflow
+    # Whether a query should be rejected in certain conditions.
+    #
+    # @see Temporalio::Api::Enums::V1::QueryRejectCondition
+    module QueryRejectCondition
+      CONDITIONS = [
+        NONE = :NONE,
+        NOT_OPEN = :NOT_OPEN,
+        NOT_COMPLETED_CLEANLY = :NOT_COMPLETED_CLEANLY,
+      ].freeze
+
+      API_MAP = {
+        Temporalio::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NONE =>
+          NONE,
+        Temporalio::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NOT_OPEN =>
+          NOT_OPEN,
+        Temporalio::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY =>
+          NOT_COMPLETED_CLEANLY,
+      }.freeze
+
+      def self.to_raw(condition)
+        API_MAP.invert[condition]
+      end
+
+      def self.from_raw(raw_condition)
+        API_MAP[raw_condition]
+      end
+    end
+  end
+end

data/lib/temporalio.rb

@@ -1 +1,12 @@
-require '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/lib/thermite_patch.rb

@@ -0,0 +1,23 @@
+require 'rbconfig'
+
+module Thermite
+  class Config
+    # Thermite doesn't support cross-compilation so it always assumes the binary is being
+    # built for the current architecture. It only really affects the name of the tarball.
+    def target_arch
+      @target_arch ||= ENV.fetch('TARGET_ARCH', RbConfig::CONFIG['target_cpu'])
+    end
+
+    # Use the same target for all darwin versions
+    def target_os
+      @target_os ||= RbConfig::CONFIG['target_os'].sub(/darwin\d+/, 'darwin')
+    end
+
+    # Due to the lack of cross-compilation support, thermite assumes the resulting binary
+    # is placed in target/<profile>, however it's actually in target/<target_arch>/<profile>
+    def cargo_target_path(profile, *path_components)
+      target_base = ENV.fetch('CARGO_TARGET_DIR', File.join(rust_toplevel_dir, 'target'))
+      File.join(target_base, ENV.fetch('CARGO_BUILD_TARGET', ''), profile, *path_components)
+    end
+  end
+end

data/temporalio.gemspec

@@ -0,0 +1,45 @@
+require_relative './lib/temporalio/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'temporalio'
+  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'
+  spec.licenses      = ['MIT']
+
+  spec.authors       = ['Anthony D']
+  spec.email         = ['anthony@temporal.io']
+
+  spec.require_paths = ['lib']
+  spec.extensions    = ['ext/Rakefile']
+
+  spec.files =
+    Dir['lib/**/*.*'] +
+    Dir['bridge/**/*.*'].reject { |x| x.include?('/target/') } +
+    %w[ext/Rakefile temporalio.gemspec Gemfile LICENSE README.md]
+
+  # 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
+  spec.add_dependency 'thermite', '~> 0.13.0' # For compiling Rust ext
+
+  spec.add_development_dependency 'grpc' # Ruby GRPC for the mock server
+  spec.add_development_dependency 'grpc-tools' # GRPC generator for the mock server
+  spec.add_development_dependency 'protobuf' # Ruby implementation of protobufs (for rbs_protobuf)
+  spec.add_development_dependency 'pry' # Debugger
+  spec.add_development_dependency 'rake' # rake tasks
+  spec.add_development_dependency 'rbs_protobuf' # RBS generator for protobufs
+  spec.add_development_dependency 'rspec' # specs
+  spec.add_development_dependency 'rubocop' # linter
+  spec.add_development_dependency 'rubocop-rspec' # spec linter
+  spec.add_development_dependency 'steep' # type checker
+  spec.add_development_dependency 'typeprof' # type generator
+  spec.add_development_dependency 'yard' # docs
+end