temporalio 0.0.1 → 0.1.0

data/lib/temporalio/activity/context.rb

@@ -0,0 +1,102 @@
+require 'temporalio/error/failure'
+require 'temporalio/errors'
+
+module Temporalio
+  class Activity
+    # This class provides methods that can be called from activity classes.
+    class Context
+      # @api private
+      def initialize(info, heartbeat_proc, interceptors, shielded: false)
+        @thread = Thread.current
+        @info = info
+        @heartbeat_proc = heartbeat_proc
+        @interceptors = interceptors
+        @pending_cancellation = nil
+        @shielded = shielded
+        @mutex = Mutex.new
+      end
+
+      # Information about the running activity.
+      #
+      # @return [Temporalio::Activity::Info]
+      def info
+        interceptors.invoke(:activity_info) { @info }
+      end
+
+      # Send a heartbeat for the current activity.
+      #
+      # @param details [Array<any>] Data to store with the heartbeat.
+      def heartbeat(*details)
+        interceptors.invoke(:heartbeat, *details) do |*d|
+          @heartbeat_proc.call(*d)
+        end
+      end
+
+      # Protect a part of activity's implementation from cancellations.
+      #
+      # Activity cancellations are implemented using the `Thread#raise`, which can unsafely
+      # terminate your implementation. To disable this behaviour make sure to wrap critical parts of
+      # your business logic in this method.
+      #
+      # For shielding a whole activity consider using {Temporalio::Activity.shielded!}.
+      #
+      # A cancellation that got requested while in a shielded block will not interrupt the execution
+      # and will raise a {Temporalio::Error::CancelledError} right after the block has finished.
+      #
+      # @yield Block to be protected from cancellations.
+      def shield(&block)
+        # The whole activity is shielded, called from a nested shield
+        #   or while handling a CancelledError (in a rescue or ensure blocks)
+        return block.call if @shielded || cancelled?
+
+        if Thread.current != thread
+          # TODO: Use logger instead when implemented
+          warn "Activity shielding is not intended to be used outside of activity's thread."
+          return block.call
+        end
+
+        mutex.synchronize do
+          @shielded = true
+          result = block.call
+          # RBS: StandardError fallback is only needed to satisfy steep - https://github.com/soutaro/steep/issues/477
+          raise @pending_cancellation || StandardError if cancelled?
+
+          result
+        ensure # runs while still holding the lock
+          @shielded = false
+        end
+      end
+
+      # Whether a cancellation was ever requested on this activity.
+      #
+      # @return [Boolean] true if the activity has had a cancellation request, false otherwise.
+      def cancelled?
+        !!@pending_cancellation
+      end
+
+      # Cancel the running activity by raising a provided error.
+      #
+      # @param reason [String] Reason for cancellation.
+      # @param by_request [Boolean] Cancellation requested by the server or not.
+      #
+      # @api private
+      def cancel(reason, by_request: false)
+        error = Temporalio::Error::ActivityCancelled.new(reason, by_request)
+        @pending_cancellation = error
+
+        locked = mutex.try_lock
+        # @shielded inside the lock means the whole activity is shielded
+        if locked && !@shielded
+          thread.raise(error)
+        end
+      ensure
+        # only release the lock if we locked it
+        mutex.unlock if locked
+      end
+
+      private
+
+      attr_reader :thread, :interceptors, :mutex
+    end
+  end
+end

data/lib/temporalio/activity/info.rb

@@ -0,0 +1,67 @@
+module Temporalio
+  class Activity
+    # Class containing information about an activity.
+    class Info < Struct.new(
+      :activity_id,
+      :activity_type,
+      :attempt,
+      :current_attempt_scheduled_time,
+      :heartbeat_details,
+      :heartbeat_timeout,
+      :local,
+      :schedule_to_close_timeout,
+      :scheduled_time,
+      :start_to_close_timeout,
+      :started_time,
+      :task_queue,
+      :task_token,
+      :workflow_id,
+      :workflow_namespace,
+      :workflow_run_id,
+      :workflow_type,
+      keyword_init: true,
+    )
+      # @!attribute [r] activity_id
+      #   @return [String] Activity ID.
+      # @!attribute [r] activity_type
+      #   @return [String] Name of the activity.
+      # @!attribute [r] attempt
+      #   @return [Integer] Activity's execution attempt.
+      # @!attribute [r] current_attempt_scheduled_time
+      #   @return [Time] Scheduled time of the current attempt.
+      # @!attribute [r] heartbeat_details
+      #   @return [Array<any>] Details submitted with the last heartbeat.
+      # @!attribute [r] heartbeat_timeout
+      #   @return [Float] Max time between heartbeats (in seconds).
+      # @!attribute [r] local
+      #   @return [Boolean] Whether activity is local or not.
+      # @!attribute [r] schedule_to_close_timeout
+      #   @return [Float] Max overall activity execution time (in seconds).
+      # @!attribute [r] scheduled_time
+      #   @return [Time] Time when activity was first scheduled.
+      # @!attribute [r] start_to_close_timeout
+      #   @return [Float] Max time of a single invocation (in seconds).
+      # @!attribute [r] started_time
+      #   @return [Time] Time when activity was started.
+      # @!attribute [r] task_queue
+      #   @return [String] Task queue on which the activity got scheduled.
+      # @!attribute [r] task_token
+      #   @return [String] A token for completing the activity.
+      # @!attribute [r] workflow_id
+      #   @return [String] Workflow ID.
+      # @!attribute [r] workflow_namespace
+      #   @return [String] Workflow namespace.
+      # @!attribute [r] workflow_run_id
+      #   @return [String] Workflow run ID.
+      # @!attribute [r] workflow_type
+      #   @return [String] Name of the workflow.
+
+      # Whether activity is local or not
+      #
+      # @return [Boolean] True for local activities, falst otherwise.
+      def local?
+        local
+      end
+    end
+  end
+end

data/lib/temporalio/activity.rb

@@ -0,0 +1,85 @@
+module Temporalio
+  # This is an abstract superclass for implementing activities.
+  #
+  # Temporal SDK users are expected to subclass it and implement the {#execute} method by adding
+  # their desired business logic.
+  #
+  # @abstract
+  #
+  # @example "Hello World" Activity
+  #   class HelloWorld < Temporalio::Activity
+  #     def execute(name)
+  #       "Hello, #{name}!"
+  #     end
+  #   end
+  class Activity
+    # Specify a custom name to be used for this activity.
+    #
+    # By default a full class (with any namespace modules/classes) name will be used.
+    #
+    # @param new_name [String] Name to be used for this activity
+    #
+    # @example
+    #   class Test < Temporalio::Activity
+    #     activity_name 'custom-activity-name'
+    #
+    #     def execute
+    #       ...
+    #     end
+    #   end
+    def self.activity_name(new_name)
+      @activity_name = new_name
+    end
+
+    # Mark the activity as shielded from cancellations.
+    #
+    # Activity cancellations are implemented using the `Thread#raise`, which can unsafely terminate
+    # your implementation. To disable this behaviour make sure to mark critical activities as
+    # `shielded!`. For shielding a part of your activity consider using
+    # {Temporalio::Activity::Context#shield}.
+    #
+    # @example
+    #   class Test < Temporalio::Activity
+    #     shielded!
+    #
+    #     def execute
+    #       ...
+    #     end
+    #   end
+    def self.shielded!
+      @shielded = true
+    end
+
+    # @api private
+    def self._name
+      @activity_name || name || ''
+    end
+
+    # @api private
+    def self._shielded
+      @shielded || false
+    end
+
+    # @api private
+    def initialize(context)
+      @context = context
+    end
+
+    # This is the main body of your activity's implementation.
+    #
+    # When implementing this method, you can use as many positional arguments as needed, which will
+    # get converted based on the activity invocation in your workflow.
+    #
+    # Inside of this method you have access to activity's context using the `activity` method. Check
+    # out {Temporalio::Activity::Context} for more information on how to use it.
+    def execute(*_args)
+      raise NoMethodError, 'must implement #execute'
+    end
+
+    private
+
+    def activity
+      @context
+    end
+  end
+end

data/lib/temporalio/bridge/connect_options.rb

@@ -0,0 +1,15 @@
+module Temporalio
+  module Bridge
+    class ConnectOptions
+      attr_reader :url, :tls, :client_version, :metadata, :retry_config
+
+      def initialize(url:, tls:, client_version:, metadata:, retry_config:)
+        @url = url
+        @tls = tls
+        @metadata = metadata
+        @retry_config = retry_config
+        @client_version = client_version
+      end
+    end
+  end
+end

data/lib/temporalio/bridge/error.rb

@@ -0,0 +1,8 @@
+module Temporalio
+  module Bridge
+    # @api private
+    class Error < StandardError
+      class WorkerShutdown < Error; end
+    end
+  end
+end

data/lib/temporalio/bridge/retry_config.rb

@@ -0,0 +1,24 @@
+module Temporalio
+  module Bridge
+    class RetryConfig
+      attr_reader :initial_interval_millis, :randomization_factor, :multiplier,
+                  :max_interval_millis, :max_elapsed_time_millis, :max_retries
+
+      def initialize(
+        initial_interval_millis:,
+        randomization_factor:,
+        multiplier:,
+        max_interval_millis:,
+        max_retries:,
+        max_elapsed_time_millis:
+      )
+        @initial_interval_millis = initial_interval_millis
+        @randomization_factor = randomization_factor
+        @multiplier = multiplier
+        @max_interval_millis = max_interval_millis
+        @max_retries = max_retries
+        @max_elapsed_time_millis = max_elapsed_time_millis
+      end
+    end
+  end
+end

data/lib/temporalio/bridge/tls_options.rb

@@ -0,0 +1,19 @@
+module Temporalio
+  module Bridge
+    class TlsOptions
+      attr_reader :server_root_ca_cert, :client_cert, :client_private_key, :server_name_override
+
+      def initialize(
+        server_root_ca_cert:,
+        client_cert:,
+        client_private_key:,
+        server_name_override:
+      )
+        @server_root_ca_cert = server_root_ca_cert
+        @client_cert = client_cert
+        @client_private_key = client_private_key
+        @server_name_override = server_name_override
+      end
+    end
+  end
+end

data/lib/temporalio/bridge.rb

@@ -0,0 +1,14 @@
+require 'rutie'
+require 'temporalio/bridge/error'
+
+# RBS: for some reason __dir__ has a type of (String | nil)
+BRIDGE_DIR = File.expand_path('..', __dir__ || '.')
+
+module Temporalio
+  # @api private
+  module Bridge
+    Rutie
+      .new(:bridge, lib_path: '', lib_suffix: 'so', lib_prefix: '')
+      .init('init_bridge', BRIDGE_DIR)
+  end
+end

data/lib/{temporal → temporalio}/client/implementation.rb

@@ -1,17 +1,18 @@
 require 'socket'
 require 'temporal/api/workflowservice/v1/request_response_pb'
-require 'temporal/client/workflow_handle'
-require 'temporal/error/failure'
-require 'temporal/error/workflow_failure'
-require 'temporal/interceptor/chain'
-require 'temporal/timeout_type'
-require 'temporal/version'
-require 'temporal/workflow/execution_info'
-require 'temporal/workflow/id_reuse_policy'
-require 'temporal/workflow/query_reject_condition'
-
-module Temporal
+require 'temporalio/client/workflow_handle'
+require 'temporalio/error/failure'
+require 'temporalio/error/workflow_failure'
+require 'temporalio/interceptor/chain'
+require 'temporalio/timeout_type'
+require 'temporalio/version'
+require 'temporalio/workflow/execution_info'
+require 'temporalio/workflow/id_reuse_policy'
+require 'temporalio/workflow/query_reject_condition'
+
+module Temporalio
   class Client
+    # @api private
     class Implementation
       def initialize(connection, namespace, converter, interceptors)
         @connection = connection
@@ -59,20 +60,20 @@ module Temporal
 
       def await_workflow_result(id, run_id, follow_runs, rpc_metadata, rpc_timeout)
         rpc_params = { metadata: rpc_metadata, timeout: rpc_timeout }
-        request = Temporal::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest.new(
+        request = Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest.new(
           namespace: namespace.to_s,
-          execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+          execution: Temporalio::Api::Common::V1::WorkflowExecution.new(
             workflow_id: id,
             run_id: run_id || '',
           ),
           history_event_filter_type:
-            Temporal::Api::Enums::V1::HistoryEventFilterType::HISTORY_EVENT_FILTER_TYPE_CLOSE_EVENT,
+            Temporalio::Api::Enums::V1::HistoryEventFilterType::HISTORY_EVENT_FILTER_TYPE_CLOSE_EVENT,
           wait_new_event: true,
           skip_archival: true,
         )
 
         loop do
-          response = connection.get_workflow_execution_history(request, **rpc_params)
+          response = connection.workflow_service.get_workflow_execution_history(request, **rpc_params)
           next_run_id = catch(:next) do
             # this will return out of the loop only if :next wasn't thrown
             return process_workflow_result_from(response, follow_runs)
@@ -88,7 +89,7 @@ module Temporal
       def convert_headers(headers)
         return if headers.empty?
 
-        Temporal::Api::Common::V1::Header.new(
+        Temporalio::Api::Common::V1::Header.new(
           fields: converter.to_payload_map(headers),
         )
       end
@@ -97,11 +98,11 @@ module Temporal
         input.retry_policy&.validate!
 
         if input.memo
-          memo = Temporal::Api::Common::V1::Memo.new(fields: converter.to_payload_map(input.memo))
+          memo = Temporalio::Api::Common::V1::Memo.new(fields: converter.to_payload_map(input.memo))
         end
 
         if input.search_attributes
-          search_attributes = Temporal::Api::Common::V1::SearchAttributes.new(
+          search_attributes = Temporalio::Api::Common::V1::SearchAttributes.new(
             indexed_fields: converter.to_payload_map(input.search_attributes),
           )
         end
@@ -111,9 +112,9 @@ module Temporal
           identity: identity,
           request_id: SecureRandom.uuid,
           namespace: namespace,
-          workflow_type: Temporal::Api::Common::V1::WorkflowType.new(name: input.workflow.to_s),
+          workflow_type: Temporalio::Api::Common::V1::WorkflowType.new(name: input.workflow.to_s),
           workflow_id: input.id,
-          task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(name: input.task_queue.to_s),
+          task_queue: Temporalio::Api::TaskQueue::V1::TaskQueue.new(name: input.task_queue.to_s),
           input: converter.to_payloads(input.args),
           workflow_execution_timeout: input.execution_timeout,
           workflow_run_timeout: input.run_timeout,
@@ -133,15 +134,15 @@ module Temporal
             signal_input: converter.to_payloads(input.start_signal_args),
           )
 
-          klass = Temporal::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest
+          klass = Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest
           request = klass.new(**params)
 
-          response = connection.signal_with_start_workflow_execution(request, **rpc_params)
+          response = connection.workflow_service.signal_with_start_workflow_execution(request, **rpc_params)
         else
-          klass = Temporal::Api::WorkflowService::V1::StartWorkflowExecutionRequest
+          klass = Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest
           request = klass.new(**params)
 
-          response = connection.start_workflow_execution(request, **rpc_params)
+          response = connection.workflow_service.start_workflow_execution(request, **rpc_params)
           first_execution_run_id = response.run_id
         end
 
@@ -151,10 +152,10 @@ module Temporal
           result_run_id: response.run_id,
           first_execution_run_id: first_execution_run_id,
         )
-      rescue Temporal::Bridge::Error => e
+      rescue Temporalio::Bridge::Error => e
         # TODO: Raise a better error from the bridge
         if e.message.include?('AlreadyExists')
-          raise Temporal::Error::WorkflowExecutionAlreadyStarted, 'Workflow execution already started'
+          raise Temporalio::Error::WorkflowExecutionAlreadyStarted, 'Workflow execution already started'
         else
           raise # re-raise
         end
@@ -162,28 +163,28 @@ module Temporal
 
       def handle_describe_workflow(input)
         rpc_params = { metadata: input.rpc_metadata, timeout: input.rpc_timeout }
-        request = Temporal::Api::WorkflowService::V1::DescribeWorkflowExecutionRequest.new(
+        request = Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionRequest.new(
           namespace: namespace.to_s,
-          execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+          execution: Temporalio::Api::Common::V1::WorkflowExecution.new(
             workflow_id: input.id,
             run_id: input.run_id || '',
           ),
         )
 
-        response = connection.describe_workflow_execution(request, **rpc_params)
+        response = connection.workflow_service.describe_workflow_execution(request, **rpc_params)
 
         Workflow::ExecutionInfo.from_raw(response, converter)
       end
 
       def handle_query_workflow(input)
         rpc_params = { metadata: input.rpc_metadata, timeout: input.rpc_timeout }
-        request = Temporal::Api::WorkflowService::V1::QueryWorkflowRequest.new(
+        request = Temporalio::Api::WorkflowService::V1::QueryWorkflowRequest.new(
           namespace: namespace.to_s,
-          execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+          execution: Temporalio::Api::Common::V1::WorkflowExecution.new(
             workflow_id: input.id,
             run_id: input.run_id,
           ),
-          query: Temporal::Api::Query::V1::WorkflowQuery.new(
+          query: Temporalio::Api::Query::V1::WorkflowQuery.new(
             query_type: input.query.to_s,
             query_args: converter.to_payloads(input.args),
             header: convert_headers(input.headers),
@@ -191,26 +192,26 @@ module Temporal
           query_reject_condition: Workflow::QueryRejectCondition.to_raw(input.reject_condition),
         )
 
-        response = connection.query_workflow(request, **rpc_params)
+        response = connection.workflow_service.query_workflow(request, **rpc_params)
 
         if response.query_rejected
           status = Workflow::ExecutionStatus.from_raw(response.query_rejected.status)
-          raise Temporal::Error::QueryRejected, status
+          raise Temporalio::Error::QueryRejected, status
         end
 
         converter.from_payloads(response.query_result)&.first
-      rescue Temporal::Bridge::Error => e
+      rescue Temporalio::Bridge::Error => e
         # TODO: Raise a better error from the bridge
-        raise Temporal::Error::QueryFailed, e.message
+        raise Temporalio::Error::QueryFailed, e.message
       end
 
       def handle_signal_workflow(input)
         rpc_params = { metadata: input.rpc_metadata, timeout: input.rpc_timeout }
-        request = Temporal::Api::WorkflowService::V1::SignalWorkflowExecutionRequest.new(
+        request = Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionRequest.new(
           identity: identity,
           request_id: SecureRandom.uuid,
           namespace: namespace.to_s,
-          workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+          workflow_execution: Temporalio::Api::Common::V1::WorkflowExecution.new(
             workflow_id: input.id,
             run_id: input.run_id || '',
           ),
@@ -219,18 +220,18 @@ module Temporal
           header: convert_headers(input.headers),
         )
 
-        connection.signal_workflow_execution(request, **rpc_params)
+        connection.workflow_service.signal_workflow_execution(request, **rpc_params)
 
         return
       end
 
       def handle_cancel_workflow(input)
         rpc_params = { metadata: input.rpc_metadata, timeout: input.rpc_timeout }
-        request = Temporal::Api::WorkflowService::V1::RequestCancelWorkflowExecutionRequest.new(
+        request = Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionRequest.new(
           identity: identity,
           request_id: SecureRandom.uuid,
           namespace: namespace.to_s,
-          workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+          workflow_execution: Temporalio::Api::Common::V1::WorkflowExecution.new(
             workflow_id: input.id,
             run_id: input.run_id || '',
           ),
@@ -238,17 +239,17 @@ module Temporal
           reason: input.reason,
         )
 
-        connection.request_cancel_workflow_execution(request, **rpc_params)
+        connection.workflow_service.request_cancel_workflow_execution(request, **rpc_params)
 
         return
       end
 
       def handle_terminate_workflow(input)
         rpc_params = { metadata: input.rpc_metadata, timeout: input.rpc_timeout }
-        request = Temporal::Api::WorkflowService::V1::TerminateWorkflowExecutionRequest.new(
+        request = Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionRequest.new(
           identity: identity,
           namespace: namespace.to_s,
-          workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+          workflow_execution: Temporalio::Api::Common::V1::WorkflowExecution.new(
             workflow_id: input.id,
             run_id: input.run_id || '',
           ),
@@ -257,7 +258,7 @@ module Temporal
           details: converter.to_payloads(input.args),
         )
 
-        connection.terminate_workflow_execution(request, **rpc_params)
+        connection.workflow_service.terminate_workflow_execution(request, **rpc_params)
 
         return
       end
@@ -268,11 +269,11 @@ module Temporal
         if !events || events.empty?
           throw(:next, nil) # next loop, same run_id
         elsif events.length != 1
-          raise Temporal::Error, "Expected single close event, got #{events.length}"
+          raise Temporalio::Error, "Expected single close event, got #{events.length}"
         end
 
         event = events.first
-        raise Temporal::Error::UnexpectedResponse, 'Missing final history event' unless event
+        raise Temporalio::Error::UnexpectedResponse, 'Missing final history event' unless event
 
         case event.event_type
         when :EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
@@ -286,15 +287,15 @@ module Temporal
           attributes = event.workflow_execution_failed_event_attributes
           follow(attributes&.new_execution_run_id) if follow_runs
 
-          raise Temporal::Error::WorkflowFailure.new(
+          raise Temporalio::Error::WorkflowFailure.new(
             cause: converter.from_failure(attributes&.failure),
           )
 
         when :EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED
           attributes = event.workflow_execution_canceled_event_attributes
 
-          raise Temporal::Error::WorkflowFailure.new(
-            cause: Temporal::Error::CancelledError.new(
+          raise Temporalio::Error::WorkflowFailure.new(
+            cause: Temporalio::Error::CancelledError.new(
               'Workflow execution cancelled',
               details: converter.from_payloads(attributes&.details),
             ),
@@ -303,8 +304,8 @@ module Temporal
         when :EVENT_TYPE_WORKFLOW_EXECUTION_TERMINATED
           attributes = event.workflow_execution_terminated_event_attributes
 
-          raise Temporal::Error::WorkflowFailure.new(
-            cause: Temporal::Error::TerminatedError.new(
+          raise Temporalio::Error::WorkflowFailure.new(
+            cause: Temporalio::Error::TerminatedError.new(
               attributes&.reason || 'Workflow execution terminated',
             ),
           )
@@ -313,10 +314,10 @@ module Temporal
           attributes = event.workflow_execution_timed_out_event_attributes
           follow(attributes&.new_execution_run_id) if follow_runs
 
-          raise Temporal::Error::WorkflowFailure.new(
-            cause: Temporal::Error::TimeoutError.new(
+          raise Temporalio::Error::WorkflowFailure.new(
+            cause: Temporalio::Error::TimeoutError.new(
               'Workflow execution timed out',
-              type: Temporal::TimeoutType::START_TO_CLOSE,
+              type: Temporalio::TimeoutType::START_TO_CLOSE,
             ),
           )
 
@@ -325,7 +326,7 @@ module Temporal
           follow(attributes&.new_execution_run_id) if follow_runs
 
           # TODO: Use more specific error and decode failure
-          raise Temporal::Error, 'Workflow execution continued as new'
+          raise Temporalio::Error, 'Workflow execution continued as new'
         end
       end