temporalio 1.5.0 → 1.7.0

data/sig/temporalio/internal/bridge/worker.rbs

@@ -0,0 +1,203 @@
+module Temporalio
+  module Internal
+    module Bridge
+      class Worker
+        class Options
+          attr_accessor namespace: String
+          attr_accessor task_queue: String
+          attr_accessor tuner: TunerOptions
+          attr_accessor identity_override: String?
+          attr_accessor max_cached_workflows: Integer
+          attr_accessor workflow_task_poller_behavior: PollerBehaviorSimpleMaximum | PollerBehaviorAutoscaling
+          attr_accessor nonsticky_to_sticky_poll_ratio: Float
+          attr_accessor activity_task_poller_behavior: PollerBehaviorSimpleMaximum | PollerBehaviorAutoscaling
+          attr_accessor enable_workflows: bool
+          attr_accessor enable_local_activities: bool
+          attr_accessor enable_remote_activities: bool
+          attr_accessor enable_nexus: bool
+          attr_accessor sticky_queue_schedule_to_start_timeout: Float
+          attr_accessor max_heartbeat_throttle_interval: Float
+          attr_accessor default_heartbeat_throttle_interval: Float
+          attr_accessor max_worker_activities_per_second: Float?
+          attr_accessor max_task_queue_activities_per_second: Float?
+          attr_accessor max_eager_activity_reservations_per_workflow_task: Integer
+          attr_accessor graceful_shutdown_period: Float
+          attr_accessor nondeterminism_as_workflow_fail: bool
+          attr_accessor nondeterminism_as_workflow_fail_for_types: Array[String]
+          attr_accessor deployment_options: DeploymentOptions?
+          attr_accessor plugins: Array[String]
+          attr_accessor disable_payload_error_limit: bool
+
+          def initialize: (
+            namespace: String,
+            task_queue: String,
+            tuner: TunerOptions,
+            identity_override: String?,
+            max_cached_workflows: Integer,
+            workflow_task_poller_behavior: PollerBehaviorSimpleMaximum | PollerBehaviorAutoscaling,
+            nonsticky_to_sticky_poll_ratio: Float,
+            activity_task_poller_behavior: PollerBehaviorSimpleMaximum | PollerBehaviorAutoscaling,
+            enable_workflows: bool,
+            enable_local_activities: bool,
+            enable_remote_activities: bool,
+            enable_nexus: bool,
+            sticky_queue_schedule_to_start_timeout: Float,
+            max_heartbeat_throttle_interval: Float,
+            default_heartbeat_throttle_interval: Float,
+            max_worker_activities_per_second: Float?,
+            max_task_queue_activities_per_second: Float?,
+            max_eager_activity_reservations_per_workflow_task: Integer,
+            graceful_shutdown_period: Float,
+            nondeterminism_as_workflow_fail: bool,
+            nondeterminism_as_workflow_fail_for_types: Array[String],
+            deployment_options: DeploymentOptions?,
+            plugins: Array[String],
+            disable_payload_error_limit: bool
+          ) -> void
+        end
+
+        class TunerOptions
+          attr_accessor workflow_slot_supplier: TunerSlotSupplierOptions
+          attr_accessor activity_slot_supplier: TunerSlotSupplierOptions
+          attr_accessor local_activity_slot_supplier: TunerSlotSupplierOptions
+
+          def initialize: (
+            workflow_slot_supplier: TunerSlotSupplierOptions,
+            activity_slot_supplier: TunerSlotSupplierOptions,
+            local_activity_slot_supplier: TunerSlotSupplierOptions
+          ) -> void
+        end
+
+        class TunerSlotSupplierOptions
+          attr_accessor fixed_size: Integer?
+          attr_accessor resource_based: TunerResourceBasedSlotSupplierOptions?
+          attr_accessor custom: CustomSlotSupplier?
+
+          def initialize: (
+            fixed_size: Integer?,
+            resource_based: TunerResourceBasedSlotSupplierOptions?,
+            custom: CustomSlotSupplier?
+          ) -> void
+        end
+
+        class TunerResourceBasedSlotSupplierOptions
+          attr_accessor target_mem_usage: Float
+          attr_accessor target_cpu_usage: Float
+          attr_accessor min_slots: Integer?
+          attr_accessor max_slots: Integer?
+          attr_accessor ramp_throttle: Float?
+
+          def initialize: (
+            target_mem_usage: Float,
+            target_cpu_usage: Float,
+            min_slots: Integer?,
+            max_slots: Integer?,
+            ramp_throttle: Float?
+          ) -> void
+        end
+
+        def self.finalize_shutdown_all: (Array[Worker] workers) -> void
+
+        def validate: -> void
+
+        def complete_activity_task: (untyped proto) -> void
+
+        def complete_activity_task_in_background: (untyped proto) -> void
+
+        class CustomSlotSupplier
+          def initialize: (
+            slot_supplier: Temporalio::Worker::Tuner::SlotSupplier::Custom,
+            thread_pool: Temporalio::Worker::ThreadPool?
+          ) -> void
+
+          def reserve_slot: (
+            Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext context,
+            Temporalio::Cancellation cancellation
+          ) { (untyped) -> void } -> void
+
+          def try_reserve_slot: (
+            Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext context
+          ) { (untyped) -> void } -> void
+
+          def mark_slot_used: (
+            Temporalio::Worker::Tuner::SlotSupplier::Custom::MarkUsedContext context
+          ) { (untyped) -> void } -> void
+
+          def release_slot: (
+            Temporalio::Worker::Tuner::SlotSupplier::Custom::ReleaseContext context
+          ) { (untyped) -> void } -> void
+
+          def run_user_code: [T] { -> T } -> T
+        end
+
+        # Defined in Rust
+
+        def self.new: (Client client, Options options) -> Worker
+
+        def self.async_poll_all: (
+          Array[Worker] workers,
+          Queue queue
+        ) -> void
+
+        def self.async_finalize_all: (
+          Array[Worker] workers,
+          Queue queue
+        ) -> void
+
+        def async_validate: (Queue queue) -> void
+
+        def async_complete_activity_task: (String proto, Queue queue) -> void
+
+        def async_complete_workflow_activation: (String run_id, String proto, Queue queue) -> void
+
+        def record_activity_heartbeat: (String proto) -> void
+
+        def replace_client: (Client client) -> void
+
+        def initiate_shutdown: -> void
+
+        class WorkerDeploymentVersion
+          attr_accessor deployment_name: String
+          attr_accessor build_id: String
+
+          def initialize: (
+            deployment_name: String,
+            build_id: String
+          ) -> void
+        end
+
+        class DeploymentOptions
+          attr_accessor version: WorkerDeploymentVersion
+          attr_accessor use_worker_versioning: bool
+          attr_accessor default_versioning_behavior: Integer
+
+          def initialize: (
+            version: WorkerDeploymentVersion,
+            use_worker_versioning: bool,
+            default_versioning_behavior: Integer
+          ) -> void
+        end
+
+        class PollerBehaviorSimpleMaximum
+          attr_accessor simple_maximum: Integer
+
+          def initialize: (simple_maximum: Integer) -> void
+        end
+
+        class PollerBehaviorAutoscaling
+          attr_accessor minimum: Integer
+          attr_accessor maximum: Integer
+          attr_accessor initial: Integer
+
+          def initialize: (minimum: Integer, maximum: Integer, initial: Integer) -> void
+        end
+
+        class WorkflowReplayer
+          def self.new: (Runtime runtime, Options options) -> [WorkflowReplayer, Worker]
+
+          def push_history: (String workflow_id, String proto) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/bridge.rbs

@@ -0,0 +1,36 @@
+module Temporalio
+  module Internal
+    module Bridge
+      # Whether the bridge was compiled with the FIPS-mode crypto backend. Defined in Rust.
+      FIPS: bool
+
+      def self.assert_fiber_compatibility!: -> void
+      def self.assert_fips_compatibility!: -> void
+      def self.fibers_supported: -> bool
+
+      module EnvConfig
+        def self.load_client_connect_config: (
+          String? profile,
+          String? path,
+          String? data,
+          bool disable_file,
+          bool disable_env,
+          bool config_file_strict,
+          Hash[String, String]? override_env_vars
+        ) -> Hash[Symbol, untyped]
+
+        def self.load_client_config: (
+          String? path,
+          String? data,
+          bool config_file_strict,
+          Hash[String, String]? override_env_vars
+        ) -> Hash[String, Hash[Symbol, untyped]]
+      end
+
+      # Defined in Rust
+
+      class Error < StandardError
+      end
+    end
+  end
+end

data/sig/temporalio/internal/client/implementation.rbs

@@ -0,0 +1,33 @@
+module Temporalio
+  module Internal
+    module Client
+      class Implementation < Temporalio::Client::Interceptor::Outbound
+        STANDALONE_ACTIVITY_RESOURCE_ID_PREFIX: String
+
+        def self._activity_id_reference_request_fields: (Temporalio::Client::ActivityIDReference ref) -> Hash[Symbol, String?]
+
+        def self.with_default_rpc_options: (Temporalio::Client::RPCOptions? user_rpc_options) -> Temporalio::Client::RPCOptions
+
+        def initialize: (Temporalio::Client client) -> void
+
+        def _start_workflow_request_from_with_start_options: (
+          untyped klass, Temporalio::Client::WithStartWorkflowOperation::Options start_options
+        ) -> untyped
+
+        def start_activity: (Temporalio::Client::Interceptor::StartActivityInput input) -> Temporalio::Client::ActivityHandle
+
+        def describe_activity: (Temporalio::Client::Interceptor::DescribeActivityInput input) -> Temporalio::Client::ActivityExecution::Description
+
+        def cancel_activity: (Temporalio::Client::Interceptor::CancelActivityInput input) -> void
+
+        def terminate_activity: (Temporalio::Client::Interceptor::TerminateActivityInput input) -> void
+
+        def list_activities: (Temporalio::Client::Interceptor::ListActivitiesInput input) -> Enumerator[Temporalio::Client::ActivityExecution, Temporalio::Client::ActivityExecution]
+
+        def count_activities: (Temporalio::Client::Interceptor::CountActivitiesInput input) -> Temporalio::Client::ActivityExecutionCount
+
+        def fetch_activity_outcome: (Temporalio::Client::Interceptor::FetchActivityOutcomeInput input) -> Temporalio::Api::Activity::V1::ActivityExecutionOutcome?
+      end
+    end
+  end
+end

data/sig/temporalio/internal/google_protobuf.rbs

@@ -0,0 +1,7 @@
+module Temporalio
+  module Internal
+    module GoogleProtobuf
+      def self.in_call_stack?: (Array[Thread::Backtrace::Location] | nil locations) -> bool
+    end
+  end
+end

data/sig/temporalio/internal/metric.rbs

@@ -0,0 +1,35 @@
+module Temporalio
+  module Internal
+    class Metric < Temporalio::Metric
+      def initialize: (
+        metric_type: (:counter | :histogram | :gauge),
+        name: String,
+        description: String?,
+        unit: String?,
+        value_type: (:integer | :float | :duration),
+        bridge: Bridge::Metric,
+        bridge_attrs: Bridge::Metric::Attributes
+      ) -> void
+
+      class Meter < Temporalio::Metric::Meter
+        def self.create_from_runtime: (Runtime runtime) -> Meter?
+
+        def initialize: (Bridge::Metric::Meter bridge, Bridge::Metric::Attributes bridge_attrs) -> void
+      end
+
+      class NullMeter < Temporalio::Metric::Meter
+        def self.instance: -> NullMeter
+      end
+
+      class NullMetric < Temporalio::Metric
+        def initialize: (
+          metric_type: (:counter | :histogram | :gauge),
+          name: String,
+          description: String?,
+          unit: String?,
+          value_type: (:integer | :float | :duration)
+        ) -> void
+      end
+    end
+  end
+end

data/sig/temporalio/internal/proto_utils.rbs

@@ -0,0 +1,94 @@
+module Temporalio
+  module Internal
+    module ProtoUtils
+      def self.seconds_to_duration: (duration? seconds_numeric) -> Google::Protobuf::Duration?
+
+      def self.duration_to_seconds: (Google::Protobuf::Duration? duration) -> Float?
+
+      def self.time_to_timestamp: (Time? time) -> Google::Protobuf::Timestamp?
+
+      def self.timestamp_to_time: (Google::Protobuf::Timestamp? timestamp) -> Time?
+
+      def self.memo_to_proto: (
+        Hash[String | Symbol, Object?]? hash,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Api::Common::V1::Memo?
+
+      def self.memo_to_proto_hash: (
+        Hash[String | Symbol, Object?]? hash,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Hash[String, Api::Common::V1::Payload]?
+
+      def self.memo_from_proto: (
+        Api::Common::V1::Memo? memo,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Hash[String, Object?]?
+
+      def self.headers_to_proto: (
+        Hash[String, Object?]? hash,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Api::Common::V1::Header?
+
+      def self.headers_to_proto_hash: (
+        Hash[String, Object?]? hash,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Hash[String, Api::Common::V1::Payload]?
+
+      def self.headers_from_proto: (
+        Api::Common::V1::Header? headers,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Hash[String, Object?]?
+
+      def self.headers_from_proto_map: (
+        (Hash[String, Api::Common::V1::Payload] | Google::Protobuf::Map[String, Api::Common::V1::Payload])? headers,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Hash[String, Object?]?
+
+      def self.string_or: (String? str, ?nil default) -> String?
+                        | (String? str, String default) -> String
+
+      def self.enum_to_int: (untyped enum_mod, untyped enum_val, ?zero_means_nil: bool) -> Integer
+
+      def self.convert_from_payload_array: (
+        Converters::DataConverter | Converters::PayloadConverter converter,
+        Array[Api::Common::V1::Payload] | Google::Protobuf::RepeatedField payloads,
+        hints: Array[Object]?
+      ) -> Array[Object?]
+
+      def self.convert_to_payload_array: (
+        Converters::DataConverter | Converters::PayloadConverter converter,
+        Array[Object?] values,
+        hints: Array[Object]?
+      ) -> Array[Api::Common::V1::Payload]
+
+      def self.assert_non_reserved_name: (String | Symbol | nil name) -> void
+      def self.reserved_name?: (String | Symbol | nil name) -> bool
+
+      def self.to_user_metadata: (
+        String? summary,
+        String? details,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> Api::Sdk::V1::UserMetadata?
+
+      def self.from_user_metadata: (
+        Api::Sdk::V1::UserMetadata? metadata,
+        Converters::DataConverter | Converters::PayloadConverter converter
+      ) -> [String?, String?]
+
+      class LazyMemo
+        def initialize: (
+          Api::Common::V1::Memo? raw_memo,
+          Converters::DataConverter | Converters::PayloadConverter converter,
+        ) -> void
+
+        def get: -> Hash[String, Object?]?
+      end
+
+      class LazySearchAttributes
+        def initialize: (Api::Common::V1::SearchAttributes? raw_search_attributes) -> void
+
+        def get: -> SearchAttributes?
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/activity_worker.rbs

@@ -0,0 +1,64 @@
+module Temporalio
+  module Internal
+    module Worker
+      class ActivityWorker
+        LOG_TASKS: bool
+
+        attr_reader worker: Temporalio::Worker
+        attr_reader bridge_worker: Bridge::Worker
+
+        def initialize: (
+          worker: Temporalio::Worker,
+          bridge_worker: Bridge::Worker,
+        ) -> void
+
+        def set_running_activity: (String task_token, RunningActivity? activity) -> void
+        def get_running_activity: (String task_token) -> RunningActivity?
+        def remove_running_activity: (String task_token) -> void
+        def wait_all_complete: -> void
+
+        def handle_task: (untyped task) -> void
+        def handle_start_task: (String task_token, untyped start) -> void
+        def handle_cancel_task: (String task_token, untyped cancel) -> void
+
+        def execute_activity: (String task_token, Activity::Definition::Info defn, untyped start) -> void
+        def run_activity: (
+          Activity::Definition::Info defn,
+          RunningActivity activity,
+          Temporalio::Worker::Interceptor::Activity::ExecuteInput input
+        ) -> void
+
+        def assert_valid_activity: (String activity) -> void
+
+        class RunningActivity < Activity::Context
+          attr_reader _server_requested_cancel: bool
+          attr_accessor instance: Activity::Definition?
+          attr_accessor _outbound_impl: Temporalio::Worker::Interceptor::Activity::Outbound?
+
+          def initialize: (
+            worker: Temporalio::Worker,
+            info: Activity::Info,
+            cancellation: Cancellation,
+            worker_shutdown_cancellation: Cancellation,
+            payload_converter: Converters::PayloadConverter,
+            logger: ScopedLogger,
+            runtime_metric_meter: Metric::Meter
+          ) -> void
+
+          def _cancel: (
+            reason: String,
+            details: Activity::CancellationDetails
+          ) -> void
+        end
+
+        class InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound
+          def initialize: (ActivityWorker worker) -> void
+        end
+
+        class OutboundImplementation < Temporalio::Worker::Interceptor::Activity::Outbound
+          def initialize: (ActivityWorker worker, String task_token) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/multi_runner.rbs

@@ -0,0 +1,132 @@
+module Temporalio
+  module Internal
+    module Worker
+      class MultiRunner
+        interface _Worker
+          def _bridge_worker: -> Bridge::Worker
+          def _initiate_shutdown: -> void
+          def _wait_all_complete: -> void
+        end
+
+
+        def initialize: (workers: Array[_Worker], shutdown_signals: Array[String | Integer]) -> void
+
+        def apply_thread_or_fiber_block: ?{ (?) -> untyped } -> void
+
+        def apply_workflow_activation_decoded: (
+          workflow_worker: WorkflowWorker,
+          activation: untyped
+        ) -> void
+
+        def apply_workflow_activation_complete: (
+          workflow_worker: WorkflowWorker,
+          activation_completion: untyped,
+          encoded: bool
+        ) -> void
+
+        def raise_in_thread_or_fiber_block: (Exception error) -> void
+
+        def initiate_shutdown: -> void
+
+        def wait_complete_and_finalize_shutdown: -> void
+
+        def next_event: -> Event
+
+        class Event
+          class PollSuccess < Event
+            attr_reader worker: _Worker
+            attr_reader worker_type: Symbol
+            attr_reader bytes: String
+
+            def initialize: (
+              worker: _Worker,
+              worker_type: Symbol,
+              bytes: String
+            ) -> void
+          end
+
+          class WorkflowActivationDecoded < Event
+            attr_reader workflow_worker: WorkflowWorker
+            attr_reader activation: untyped
+
+            def initialize: (
+              workflow_worker: WorkflowWorker,
+              activation: untyped
+            ) -> void
+          end
+
+          class WorkflowActivationComplete < Event
+            attr_reader workflow_worker: WorkflowWorker
+            attr_reader activation_completion: untyped
+            attr_reader encoded: bool
+            attr_reader completion_complete_queue: Queue
+
+            def initialize: (
+              workflow_worker: WorkflowWorker,
+              activation_completion: untyped,
+              encoded: bool,
+              completion_complete_queue: Queue
+            ) -> void
+          end
+
+          class WorkflowActivationCompletionComplete < Event
+            attr_reader run_id: String
+            attr_reader error: Exception
+
+            def initialize: (
+              run_id: String,
+              error: Exception
+            ) -> void
+          end
+
+          class PollFailure < Event
+            attr_reader worker: _Worker
+            attr_reader worker_type: Symbol
+            attr_reader error: Exception
+
+            def initialize: (
+              worker: _Worker,
+              worker_type: Symbol,
+              error: Exception
+            ) -> void
+          end
+
+          class PollerShutDown < Event
+            attr_reader worker: _Worker
+            attr_reader worker_type: Symbol
+
+            def initialize: (
+              worker: _Worker,
+              worker_type: Symbol
+            ) -> void
+          end
+
+          class AllPollersShutDown < Event
+            def self.instance: -> AllPollersShutDown
+          end
+
+          class BlockSuccess < Event
+            attr_reader result: Object?
+
+            def initialize: (result: Object?) -> void
+          end
+
+          class BlockFailure < Event
+            attr_reader error: Exception
+
+            def initialize: (error: Exception) -> void
+          end
+
+          class ShutdownSignalReceived < Event
+          end
+        end
+
+        class InjectEventForTesting < Temporalio::Error
+          attr_reader event: Event
+
+          def initialize: (Event event) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/child_workflow_handle.rbs

@@ -0,0 +1,22 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class ChildWorkflowHandle < Workflow::ChildWorkflowHandle
+          def initialize: (
+            id: String,
+            first_execution_run_id: String,
+            instance: WorkflowInstance,
+            cancellation: Cancellation,
+            cancel_callback_key: Object,
+            result_hint: Object?
+          ) -> void
+
+          def _resolve: (
+            Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult resolution
+          ) -> void
+        end
+      end
+    end
+  end
+end