temporalio 1.5.0 → 1.6.0

data/sig/temporalio/worker/thread_pool.rbs

@@ -0,0 +1,44 @@
+module Temporalio
+  class Worker
+    class ThreadPool
+      def self.default: -> ThreadPool
+
+      def self._monotonic_time: -> Float
+
+      def initialize: (
+        ?max_threads: Integer?,
+        ?idle_timeout: Float
+      ) -> void
+
+      def execute: { -> void } -> void
+
+      def largest_length: -> Integer
+      def scheduled_task_count: -> Integer
+      def completed_task_count: -> Integer
+      def active_count: -> Integer
+      def length: -> Integer
+      def queue_length: -> Integer
+      def shutdown: -> void
+      def kill: -> void
+
+      def _remove_busy_worker: (Worker worker) -> void
+      def _ready_worker: (Worker worker, Float last_message) -> void
+      def _worker_died: (Worker worker) -> void
+      def _worker_task_completed: -> void
+      private def locked_assign_worker: { (?) -> untyped } -> void
+      private def locked_enqueue: { (?) -> untyped } -> void
+      private def locked_add_busy_worker: -> Worker?
+      private def locked_prune_pool: -> void
+      private def locked_remove_busy_worker: (Worker worker) -> void
+      private def locked_ready_worker: (Worker worker, Float last_message) -> void
+      private def locked_worker_died: (Worker worker) -> void
+
+      class Worker
+        def initialize: (ThreadPool pool, Integer id) -> void
+        def <<: (Proc block) -> void
+        def stop: -> void
+        def kill: -> void
+      end
+    end
+  end
+end

data/sig/temporalio/worker/tuner.rbs

@@ -0,0 +1,121 @@
+module Temporalio
+  class Worker
+    class Tuner
+      class SlotSupplier
+        class Fixed < SlotSupplier
+          attr_reader slots: Integer
+
+          def initialize: (Integer slots) -> void
+        end
+
+        class ResourceBased < SlotSupplier
+          attr_reader tuner_options: ResourceBasedTunerOptions
+          attr_reader slot_options: ResourceBasedSlotOptions
+
+          def initialize: (
+            tuner_options: ResourceBasedTunerOptions,
+            slot_options: ResourceBasedSlotOptions
+          ) -> void
+        end
+
+        class Custom < SlotSupplier
+          def reserve_slot: (ReserveContext context, Cancellation cancellation) { (untyped) -> void } -> void
+
+          def try_reserve_slot: (ReserveContext context) -> untyped
+
+          def mark_slot_used: (MarkUsedContext context) -> void
+
+          def release_slot: (ReleaseContext context) -> void
+
+          class ReserveContext
+            attr_reader slot_type: :workflow | :activity | :local_activity | :nexus
+            attr_reader task_queue: String
+            attr_reader worker_identity: String
+            attr_reader worker_deployment_name: String
+            attr_reader worker_build_id: String
+            attr_reader sticky?: bool
+          end
+
+          class MarkUsedContext
+            attr_reader slot_info: SlotInfo::Workflow | SlotInfo::Activity | SlotInfo::LocalActivity | SlotInfo::Nexus
+            attr_reader permit: untyped
+          end
+
+          class ReleaseContext
+            attr_reader slot_info: SlotInfo::Workflow | SlotInfo::Activity | SlotInfo::LocalActivity | SlotInfo::Nexus | nil
+            attr_reader permit: untyped
+          end
+
+          module SlotInfo
+            class Workflow
+              attr_reader workflow_type: String
+              attr_reader sticky?: bool
+            end
+            class Activity
+              attr_reader activity_type: String
+            end
+            class LocalActivity
+              attr_reader activity_type: String
+            end
+            class Nexus
+              attr_reader service: String
+              attr_reader operation: String
+            end
+          end
+        end
+
+        def _to_bridge_options: (Tuner tuner) -> Internal::Bridge::Worker::TunerSlotSupplierOptions
+      end
+
+      class ResourceBasedTunerOptions
+        attr_reader target_memory_usage: Float
+        attr_reader target_cpu_usage: Float
+
+        def initialize: (
+          target_memory_usage: Float,
+          target_cpu_usage: Float
+        ) -> void
+      end
+
+      class ResourceBasedSlotOptions
+        attr_reader min_slots: Integer?
+        attr_reader max_slots: Integer?
+        attr_reader ramp_throttle: Float?
+
+        def initialize: (
+          min_slots: Integer?,
+          max_slots: Integer?,
+          ramp_throttle: Float?
+        ) -> void
+      end
+
+      def self.create_fixed: (
+        ?workflow_slots: Integer,
+        ?activity_slots: Integer,
+        ?local_activity_slots: Integer
+      ) -> Tuner
+
+      def self.create_resource_based: (
+        target_memory_usage: Float,
+        target_cpu_usage: Float,
+        ?workflow_options: ResourceBasedSlotOptions,
+        ?activity_options: ResourceBasedSlotOptions,
+        ?local_activity_options: ResourceBasedSlotOptions
+      ) -> Tuner
+
+      attr_reader workflow_slot_supplier: SlotSupplier
+      attr_reader activity_slot_supplier: SlotSupplier
+      attr_reader local_activity_slot_supplier: SlotSupplier
+      attr_reader custom_slot_supplier_thread_pool: ThreadPool?
+
+      def initialize: (
+        workflow_slot_supplier: SlotSupplier,
+        activity_slot_supplier: SlotSupplier,
+        local_activity_slot_supplier: SlotSupplier,
+        ?custom_slot_supplier_thread_pool: ThreadPool?
+      ) -> void
+
+      def _to_bridge_options: -> Internal::Bridge::Worker::TunerOptions
+    end
+  end
+end

data/sig/temporalio/worker/workflow_executor/thread_pool.rbs

@@ -0,0 +1,58 @@
+module Temporalio
+  class Worker
+    class WorkflowExecutor
+      class ThreadPool < WorkflowExecutor
+        def self.default: -> ThreadPool
+
+        def initialize: (
+          ?max_threads: Integer,
+          ?thread_pool: Temporalio::Worker::ThreadPool
+        ) -> void
+
+        def _thread_pool: -> Temporalio::Worker::ThreadPool
+
+        def _remove_workflow: (
+          Internal::Worker::WorkflowWorker::State worker_state,
+          String run_id
+        ) -> void
+
+        class Worker
+          LOG_ACTIVATIONS: bool
+
+          attr_accessor workflow_count: Integer
+
+          def initialize: (ThreadPool executor) -> void
+
+          def enqueue_activation: (
+            untyped activation,
+            Internal::Worker::WorkflowWorker::State worker_state
+          ) { (untyped completion) -> void } -> void
+
+          def shutdown: -> void
+
+          def run: -> void
+
+          def activate: (
+            untyped activation,
+            Internal::Worker::WorkflowWorker::State worker_state
+          ) { (untyped completion) -> void } -> void
+
+          def create_instance: (
+            untyped initial_activation,
+            Internal::Worker::WorkflowWorker::State worker_state
+          ) -> Internal::Worker::WorkflowInstance
+
+          def evict: (
+            Internal::Worker::WorkflowWorker::State worker_state,
+            String run_id,
+            untyped cache_remove_job
+          ) -> void
+        end
+
+        class DeadlockError < Exception
+          include Internal::WorkflowTaskFailureError
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/worker/workflow_executor.rbs

@@ -0,0 +1,15 @@
+module Temporalio
+  class Worker
+    class WorkflowExecutor
+      def _validate_worker: (
+        Internal::Worker::WorkflowWorker workflow_worker,
+        Internal::Worker::WorkflowWorker::State worker_state
+      ) -> void
+
+      def _activate: (
+        untyped activation,
+        Internal::Worker::WorkflowWorker::State worker_state
+      ) { (untyped completion) -> void } -> void
+    end
+  end
+end

data/sig/temporalio/worker/workflow_replayer.rbs

@@ -0,0 +1,105 @@
+module Temporalio
+  class Worker
+    class WorkflowReplayer
+      class Options
+        attr_reader workflows: Array[singleton(Workflow::Definition) | Workflow::Definition::Info]
+        attr_reader namespace: String
+        attr_reader task_queue: String
+        attr_reader data_converter: Converters::DataConverter
+        attr_reader workflow_executor: Worker::WorkflowExecutor
+        attr_reader plugins: Array[Plugin]
+        attr_reader interceptors: Array[Interceptor::Workflow]
+        attr_reader identity: String?
+        attr_reader logger: Logger
+        attr_reader illegal_workflow_calls: Hash[String, :all | Array[Symbol]]
+        attr_reader workflow_failure_exception_types: Array[singleton(Exception)]
+        attr_reader workflow_payload_codec_thread_pool: ThreadPool?
+        attr_reader unsafe_workflow_io_enabled: bool
+        attr_reader debug_mode: bool
+        attr_reader runtime: Runtime
+
+        def initialize: (
+          workflows: Array[singleton(Workflow::Definition) | Workflow::Definition::Info],
+          namespace: String,
+          task_queue: String,
+          data_converter: Converters::DataConverter,
+          workflow_executor: Worker::WorkflowExecutor,
+          plugins: Array[Plugin],
+          interceptors: Array[Interceptor::Workflow],
+          identity: String?,
+          logger: Logger,
+          illegal_workflow_calls: Hash[String, :all | Array[Symbol]],
+          workflow_failure_exception_types: Array[singleton(Exception)],
+          workflow_payload_codec_thread_pool: ThreadPool?,
+          unsafe_workflow_io_enabled: bool,
+          debug_mode: bool,
+          runtime: Runtime
+        ) -> void
+
+        def with: (**Object kwargs) -> Options
+      end
+
+      attr_reader options: Options
+
+      def initialize: (
+        workflows: Array[singleton(Workflow::Definition) | Workflow::Definition::Info],
+        ?namespace: String,
+        ?task_queue: String,
+        ?data_converter: Converters::DataConverter,
+        ?workflow_executor: Worker::WorkflowExecutor,
+        ?plugins: Array[Plugin],
+        ?interceptors: Array[Interceptor::Workflow],
+        ?identity: String?,
+        ?logger: Logger,
+        ?illegal_workflow_calls: Hash[String, :all | Array[Symbol]],
+        ?workflow_failure_exception_types: Array[singleton(Exception)],
+        ?workflow_payload_codec_thread_pool: ThreadPool?,
+        ?unsafe_workflow_io_enabled: bool,
+        ?debug_mode: bool,
+        ?runtime: Runtime
+      ) ?{ (ReplayWorker worker) -> untyped } -> void
+
+      def replay_workflow: (
+        WorkflowHistory history,
+        ?raise_on_replay_failure: bool
+      ) -> ReplayResult
+
+      def replay_workflows: (
+        Enumerable[WorkflowHistory] histories,
+        ?raise_on_replay_failure: bool
+      ) -> Array[ReplayResult]
+
+      def with_replay_worker: [T] { (ReplayWorker worker) -> T } -> T
+
+      class ReplayResult
+        attr_reader history: WorkflowHistory
+        attr_reader replay_failure: Exception?
+
+        def initialize: (history: WorkflowHistory, replay_failure: Exception?) -> void
+      end
+
+      class ReplayWorker
+        def initialize: (
+          options: Options,
+          workflow_definitions: Hash[String?, Workflow::Definition::Info],
+          nondeterminism_as_workflow_fail: bool,
+          nondeterminism_as_workflow_fail_for_types: Array[String]
+        ) -> void
+
+        def replay_workflow: (
+          WorkflowHistory history,
+          ?raise_on_replay_failure: bool
+        ) -> ReplayResult
+
+        def _shutdown: -> void
+        def _bridge_worker: -> Internal::Bridge::Worker
+        def _initiate_shutdown: -> void
+        def _wait_all_complete: -> void
+
+        private
+
+        def workflow_activation_work_drained?: -> bool
+      end
+    end
+  end
+end

data/sig/temporalio/worker.rbs

@@ -0,0 +1,168 @@
+module Temporalio
+  class Worker
+    class PatchActivationInput
+      attr_reader workflow_info: Workflow::Info
+      attr_reader patch_id: String
+
+      def initialize: (workflow_info: Workflow::Info, patch_id: String) -> void
+      def with: (**Object kwargs) -> PatchActivationInput
+    end
+
+    class Options
+      attr_reader client: Client
+      attr_reader task_queue: String
+      attr_reader activities: Array[Activity::Definition | singleton(Activity::Definition) | Activity::Definition::Info]
+      attr_reader workflows: Array[singleton(Workflow::Definition) | Workflow::Definition::Info]
+      attr_reader tuner: Tuner
+      attr_reader activity_executors: Hash[Symbol, Worker::ActivityExecutor]
+      attr_reader workflow_executor: Worker::WorkflowExecutor
+      attr_reader plugins: Array[Plugin]
+      attr_reader interceptors: Array[Interceptor::Activity | Interceptor::Workflow]
+      attr_reader identity: String
+      attr_reader logger: Logger
+      attr_reader max_cached_workflows: Integer
+      attr_reader max_concurrent_workflow_task_polls: Integer
+      attr_reader nonsticky_to_sticky_poll_ratio: Float
+      attr_reader max_concurrent_activity_task_polls: Integer
+      attr_reader no_remote_activities: bool
+      attr_reader sticky_queue_schedule_to_start_timeout: Float
+      attr_reader max_heartbeat_throttle_interval: Float
+      attr_reader default_heartbeat_throttle_interval: Float
+      attr_reader max_activities_per_second: Float?
+      attr_reader max_task_queue_activities_per_second: Float?
+      attr_reader graceful_shutdown_period: Float
+      attr_reader disable_eager_activity_execution: bool
+      attr_reader illegal_workflow_calls: Hash[String, :all | Array[Symbol | IllegalWorkflowCallValidator] | IllegalWorkflowCallValidator]
+      attr_reader workflow_failure_exception_types: Array[singleton(Exception)]
+      attr_reader workflow_payload_codec_thread_pool: ThreadPool?
+      attr_reader unsafe_workflow_io_enabled: bool
+      attr_reader workflow_task_poller_behavior: PollerBehavior
+      attr_reader activity_task_poller_behavior: PollerBehavior
+      attr_reader deployment_options: Worker::DeploymentOptions
+      attr_reader patch_activation_callback: Proc?
+      attr_reader debug_mode: bool
+
+      def initialize: (
+        client: Client,
+        task_queue: String,
+        activities: Array[Activity::Definition | singleton(Activity::Definition) | Activity::Definition::Info],
+        workflows: Array[singleton(Workflow::Definition) | Workflow::Definition::Info],
+        tuner: Tuner,
+        activity_executors: Hash[Symbol, Worker::ActivityExecutor],
+        workflow_executor: Worker::WorkflowExecutor,
+        plugins: Array[Plugin],
+        interceptors: Array[Interceptor::Activity | Interceptor::Workflow],
+        identity: String?,
+        logger: Logger,
+        max_cached_workflows: Integer,
+        max_concurrent_workflow_task_polls: Integer,
+        nonsticky_to_sticky_poll_ratio: Float,
+        max_concurrent_activity_task_polls: Integer,
+        no_remote_activities: bool,
+        sticky_queue_schedule_to_start_timeout: Float,
+        max_heartbeat_throttle_interval: Float,
+        default_heartbeat_throttle_interval: Float,
+        max_activities_per_second: Float?,
+        max_task_queue_activities_per_second: Float?,
+        graceful_shutdown_period: Float,
+        disable_eager_activity_execution: bool,
+        illegal_workflow_calls: Hash[String, :all | Array[Symbol | IllegalWorkflowCallValidator] | IllegalWorkflowCallValidator],
+        workflow_failure_exception_types: Array[singleton(Exception)],
+        workflow_payload_codec_thread_pool: ThreadPool?,
+        unsafe_workflow_io_enabled: bool,
+        workflow_task_poller_behavior: PollerBehavior,
+        activity_task_poller_behavior: PollerBehavior,
+        deployment_options: Worker::DeploymentOptions,
+        patch_activation_callback: Proc?,
+        debug_mode: bool
+      ) -> void
+
+      def with: (**Object kwargs) -> Options
+    end
+
+    def self.default_build_id: -> String
+    def self._load_default_build_id: -> String
+    def self.default_deployment_options: -> Worker::DeploymentOptions
+
+    def self.run_all: [T] (
+      *Worker workers,
+      ?cancellation: Cancellation,
+      ?shutdown_signals: Array[String | Integer],
+      ?raise_in_block_on_shutdown: Exception?,
+      ?wait_block_complete: bool
+    ) ?{ -> T } -> T
+
+    def self._run_all_root: [T] (
+      *Worker workers,
+      cancellation: Cancellation,
+      shutdown_signals: Array[String | Integer],
+      raise_in_block_on_shutdown: Exception?,
+      wait_block_complete: bool
+    ) ?{ -> T } -> T
+
+    def self.default_illegal_workflow_calls: -> Hash[String, :all | Array[Symbol | IllegalWorkflowCallValidator] | IllegalWorkflowCallValidator]
+
+    def self._validate_plugins!: (Array[Plugin] plugins) -> void
+
+    attr_reader options: Options
+
+    def initialize: (
+      client: Client,
+      task_queue: String,
+      ?activities: Array[Activity::Definition | singleton(Activity::Definition) | Activity::Definition::Info],
+      ?workflows: Array[singleton(Workflow::Definition) | Workflow::Definition::Info],
+      ?tuner: Tuner,
+      ?activity_executors: Hash[Symbol, Worker::ActivityExecutor],
+      ?workflow_executor: Worker::WorkflowExecutor,
+      ?plugins: Array[Plugin],
+      ?interceptors: Array[Interceptor::Activity | Interceptor::Workflow],
+      ?identity: String?,
+      ?logger: Logger,
+      ?max_cached_workflows: Integer,
+      ?max_concurrent_workflow_task_polls: Integer,
+      ?nonsticky_to_sticky_poll_ratio: Float,
+      ?max_concurrent_activity_task_polls: Integer,
+      ?no_remote_activities: bool,
+      ?sticky_queue_schedule_to_start_timeout: Float,
+      ?max_heartbeat_throttle_interval: Float,
+      ?default_heartbeat_throttle_interval: Float,
+      ?max_activities_per_second: Float?,
+      ?max_task_queue_activities_per_second: Float?,
+      ?graceful_shutdown_period: Float,
+      ?disable_eager_activity_execution: bool,
+      ?illegal_workflow_calls: Hash[String, :all | Array[Symbol | IllegalWorkflowCallValidator] | IllegalWorkflowCallValidator],
+      ?workflow_failure_exception_types: Array[singleton(Exception)],
+      ?workflow_payload_codec_thread_pool: ThreadPool?,
+      ?unsafe_workflow_io_enabled: bool,
+      ?workflow_task_poller_behavior: PollerBehavior,
+      ?activity_task_poller_behavior: PollerBehavior,
+      ?deployment_options: Worker::DeploymentOptions,
+      ?patch_activation_callback: Proc?,
+      ?debug_mode: bool
+    ) -> void
+
+    def _initialize_from_options: -> void
+
+    def task_queue: -> String
+
+    def client: -> Client
+    def client=: (Client new_client) -> void
+
+    def run: [T] (
+      ?cancellation: Cancellation,
+      ?shutdown_signals: Array[String | Integer],
+      ?raise_in_block_on_shutdown: Exception?,
+      ?wait_block_complete: bool
+    ) ?{ -> T } -> T
+
+    def _worker_shutdown_cancellation: -> Cancellation
+    def _initiate_shutdown: -> void
+    def _wait_all_complete: -> void
+    def _bridge_worker: -> Internal::Bridge::Worker
+    def _activity_interceptors: -> Array[Interceptor::Activity]
+    def _on_poll_bytes: (Internal::Worker::MultiRunner runner, Symbol worker_type, String bytes) -> void
+    def _on_shutdown_complete: -> void
+    def _assert_valid_local_activity: (String) -> void
+    def _plugins: -> Array[Plugin]
+  end
+end

data/sig/temporalio/worker_deployment_version.rbs

@@ -0,0 +1,17 @@
+module Temporalio
+  class WorkerDeploymentVersion
+    attr_reader deployment_name: String
+    attr_reader build_id: String
+
+    def self.from_canonical_string: (String canonical) -> WorkerDeploymentVersion
+
+    def self._from_bridge: (Internal::Bridge::Worker::WorkerDeploymentVersion? bridge) -> WorkerDeploymentVersion?
+
+    def initialize: (deployment_name: String, build_id: String) -> void
+
+    def to_canonical_string: -> String
+
+    def _to_bridge_options: -> Internal::Bridge::Worker::WorkerDeploymentVersion
+    def _to_proto: -> Api::Deployment::V1::WorkerDeploymentVersion
+  end
+end

data/sig/temporalio/workflow/activity_cancellation_type.rbs

@@ -0,0 +1,11 @@
+module Temporalio
+  module Workflow
+    module ActivityCancellationType
+      type enum = Integer
+
+      TRY_CANCEL: enum
+      WAIT_CANCELLATION_COMPLETED: enum
+      ABANDON: enum
+    end
+  end
+end

data/sig/temporalio/workflow/child_workflow_cancellation_type.rbs

@@ -0,0 +1,12 @@
+module Temporalio
+  module Workflow
+    module ChildWorkflowCancellationType
+      type enum = Integer
+
+      ABANDON: enum
+      TRY_CANCEL: enum
+      WAIT_CANCELLATION_COMPLETED: enum
+      WAIT_CANCELLATION_REQUESTED: enum
+    end
+  end
+end

data/sig/temporalio/workflow/child_workflow_handle.rbs

@@ -0,0 +1,18 @@
+module Temporalio
+  module Workflow
+    class ChildWorkflowHandle
+      def id: -> String
+      def first_execution_run_id: -> String
+      def result_hint: -> Object?
+
+      def result: (?result_hint: Object?) -> Object?
+
+      def signal: (
+        Workflow::Definition::Signal | Symbol | String signal,
+        *Object? args,
+        ?cancellation: Cancellation,
+        ?arg_hints: Array[Object]?
+      ) -> void
+    end
+  end
+end