temporalio 0.0.1

data/lib/temporal/retry_policy.rb

@@ -0,0 +1,82 @@
+require 'temporal/api/common/v1/message_pb'
+require 'temporal/errors'
+
+module Temporal
+  # Options for retrying workflows and activities.
+  #
+  # @see https://docs.temporal.io/application-development/features/#workflow-retry-policy
+  class RetryPolicy
+    class Invalid < Temporal::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
+      Temporal::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/temporal/retry_state.rb

@@ -0,0 +1,35 @@
+module Temporal
+  # 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/temporal/runtime.rb

@@ -0,0 +1,22 @@
+require 'singleton'
+require 'temporal/bridge'
+
+module Temporal
+  class Runtime
+    include Singleton
+
+    attr_reader :core_runtime
+
+    def initialize
+      @core_runtime = Temporal::Bridge::Runtime.init
+    end
+
+    def ensure_callback_loop
+      return if @thread
+
+      @thread = Thread.new do
+        core_runtime.run_callback_loop
+      end
+    end
+  end
+end

data/lib/temporal/timeout_type.rb

@@ -0,0 +1,29 @@
+module Temporal
+  # Type of timeout for {Temporal::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/temporal/version.rb

@@ -0,0 +1,3 @@
+module Temporal
+  VERSION = '0.0.1'.freeze
+end

data/lib/temporal/workflow/execution_info.rb

@@ -0,0 +1,54 @@
+require 'temporal/errors'
+require 'temporal/workflow/execution_status'
+require 'google/protobuf/well_known_types'
+
+module Temporal
+  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 Temporal::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/temporal/workflow/execution_status.rb

@@ -0,0 +1,36 @@
+module Temporal
+  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/temporal/workflow/id_reuse_policy.rb

@@ -0,0 +1,36 @@
+require 'temporal/api/enums/v1/workflow_pb'
+
+module Temporal
+  class Workflow
+    # How already-in-use workflow IDs are handled on start.
+    #
+    # @see Temporal::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 = {
+        Temporal::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 =>
+          ALLOW_DUPLICATE_FAILED_ONLY,
+        Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE =>
+          REJECT_DUPLICATE,
+        Temporal::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/temporal/workflow/query_reject_condition.rb

@@ -0,0 +1,33 @@
+require 'temporal/api/enums/v1/query_pb'
+
+module Temporal
+  class Workflow
+    # Whether a query should be rejected in certain conditions.
+    #
+    # @see Temporal::Api::Enums::V1::QueryRejectCondition
+    module QueryRejectCondition
+      CONDITIONS = [
+        NONE = :NONE,
+        NOT_OPEN = :NOT_OPEN,
+        NOT_COMPLETED_CLEANLY = :NOT_COMPLETED_CLEANLY,
+      ].freeze
+
+      API_MAP = {
+        Temporal::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NONE =>
+          NONE,
+        Temporal::Api::Enums::V1::QueryRejectCondition::QUERY_REJECT_CONDITION_NOT_OPEN =>
+          NOT_OPEN,
+        Temporal::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/temporal.rb

@@ -0,0 +1,8 @@
+# Protoc wants all of its generated files on the LOAD_PATH
+$LOAD_PATH << File.expand_path('./gen', File.dirname(__FILE__))
+
+require 'temporal/bridge'
+require 'temporal/version'
+
+module Temporal
+end

data/lib/temporalio.rb

@@ -0,0 +1,3 @@
+# 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'

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,41 @@
+require_relative './lib/temporal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'temporalio'
+  spec.version       = Temporal::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]
+
+  spec.required_ruby_version = '>= 2.7.0'
+
+  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