temporalio 1.4.1 → 1.5.0

data/lib/temporalio/internal/client/implementation.rb

@@ -4,6 +4,9 @@ require 'google/protobuf/well_known_types'
 require 'securerandom'
 require 'temporalio/activity'
 require 'temporalio/api'
+require 'temporalio/client/activity_execution'
+require 'temporalio/client/activity_execution_count'
+require 'temporalio/client/activity_handle'
 require 'temporalio/client/activity_id_reference'
 require 'temporalio/client/async_activity_handle'
 require 'temporalio/client/connection'
@@ -27,6 +30,35 @@ module Temporalio
   module Internal
     module Client
       class Implementation < Temporalio::Client::Interceptor::Outbound
+        # Proto routing convention for standalone activity completion: `*_by_id` requests carry
+        # `resource_id = "activity:<activity_id>"`. See the resource_id field comment on
+        # `RecordActivityTaskHeartbeatByIdRequest` (and the analogous Completed/Failed/Canceled
+        # requests) in `workflowservice/v1/request_response.proto`. Workflow-scheduled activities
+        # leave resource_id empty.
+        STANDALONE_ACTIVITY_RESOURCE_ID_PREFIX = 'activity:'
+
+        # Returns the activity_id / workflow_id / run_id / resource_id fields for a `*_by_id`
+        # async-completion request, depending on whether the reference is the standalone or
+        # workflow-bound form. Splat into the request constructor's kwargs alongside the
+        # request-specific fields.
+        def self._activity_id_reference_request_fields(ref)
+          if ref.standalone?
+            {
+              workflow_id: nil,
+              run_id: ref.activity_run_id,
+              activity_id: ref.activity_id,
+              resource_id: "#{STANDALONE_ACTIVITY_RESOURCE_ID_PREFIX}#{ref.activity_id}"
+            }
+          else
+            {
+              workflow_id: ref.workflow_id,
+              run_id: ref.run_id,
+              activity_id: ref.activity_id,
+              resource_id: nil
+            }
+          end
+        end
+
         def self.with_default_rpc_options(user_rpc_options)
           # If the user did not provide an override_retry, we need to make sure
           # we use an option set that has it as "true"
@@ -185,7 +217,7 @@ module Temporalio
             end
 
             # If the user wants to wait until completed, we must poll until outcome if not already there
-            if input.wait_for_stage == Temporalio::Client::WorkflowUpdateWaitStage::COMPLETED && update_resp.outcome
+            if input.wait_for_stage == Temporalio::Client::WorkflowUpdateWaitStage::COMPLETED && !update_resp.outcome
               update_resp.outcome = @client._impl.poll_workflow_update(
                 Temporalio::Client::Interceptor::PollWorkflowUpdateInput.new(
                   workflow_id: start_options.id,
@@ -327,7 +359,8 @@ module Temporalio
             user_metadata: ProtoUtils.to_user_metadata(
               start_options.static_summary, start_options.static_details, @client.data_converter
             ),
-            header: ProtoUtils.headers_to_proto(start_options.headers, @client.data_converter)
+            header: ProtoUtils.headers_to_proto(start_options.headers, @client.data_converter),
+            priority: start_options.priority._to_proto
           )
         end
 
@@ -807,12 +840,11 @@ module Temporalio
         end
 
         def heartbeat_async_activity(input)
-          resp = if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          resp = if ref.is_a?(Temporalio::Client::ActivityIDReference)
                    @client.workflow_service.record_activity_task_heartbeat_by_id(
                      Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest.new(
-                       workflow_id: input.task_token_or_id_reference.workflow_id,
-                       run_id: input.task_token_or_id_reference.run_id,
-                       activity_id: input.task_token_or_id_reference.activity_id,
+                       **Implementation._activity_id_reference_request_fields(ref),
                        namespace: @client.namespace,
                        identity: @client.connection.identity,
                        details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -822,7 +854,7 @@ module Temporalio
                  else
                    @client.workflow_service.record_activity_task_heartbeat(
                      Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest.new(
-                       task_token: input.task_token_or_id_reference,
+                       task_token: ref,
                        namespace: @client.namespace,
                        identity: @client.connection.identity,
                        details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -840,12 +872,11 @@ module Temporalio
         end
 
         def complete_async_activity(input)
-          if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          if ref.is_a?(Temporalio::Client::ActivityIDReference)
             @client.workflow_service.respond_activity_task_completed_by_id(
               Api::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest.new(
-                workflow_id: input.task_token_or_id_reference.workflow_id,
-                run_id: input.task_token_or_id_reference.run_id,
-                activity_id: input.task_token_or_id_reference.activity_id,
+                **Implementation._activity_id_reference_request_fields(ref),
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 result: @client.data_converter.to_payloads([input.result], hints: Array(input.result_hint))
@@ -855,7 +886,7 @@ module Temporalio
           else
             @client.workflow_service.respond_activity_task_completed(
               Api::WorkflowService::V1::RespondActivityTaskCompletedRequest.new(
-                task_token: input.task_token_or_id_reference,
+                task_token: ref,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 result: @client.data_converter.to_payloads([input.result], hints: Array(input.result_hint))
@@ -875,12 +906,11 @@ module Temporalio
                                        hints: input.last_heartbeat_detail_hints
                                      )
                                    end
-          if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          if ref.is_a?(Temporalio::Client::ActivityIDReference)
             @client.workflow_service.respond_activity_task_failed_by_id(
               Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest.new(
-                workflow_id: input.task_token_or_id_reference.workflow_id,
-                run_id: input.task_token_or_id_reference.run_id,
-                activity_id: input.task_token_or_id_reference.activity_id,
+                **Implementation._activity_id_reference_request_fields(ref),
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 failure: @client.data_converter.to_failure(input.error),
@@ -891,7 +921,7 @@ module Temporalio
           else
             @client.workflow_service.respond_activity_task_failed(
               Api::WorkflowService::V1::RespondActivityTaskFailedRequest.new(
-                task_token: input.task_token_or_id_reference,
+                task_token: ref,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 failure: @client.data_converter.to_failure(input.error),
@@ -904,12 +934,11 @@ module Temporalio
         end
 
         def report_cancellation_async_activity(input)
-          if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          if ref.is_a?(Temporalio::Client::ActivityIDReference)
             @client.workflow_service.respond_activity_task_canceled_by_id(
               Api::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest.new(
-                workflow_id: input.task_token_or_id_reference.workflow_id,
-                run_id: input.task_token_or_id_reference.run_id,
-                activity_id: input.task_token_or_id_reference.activity_id,
+                **Implementation._activity_id_reference_request_fields(ref),
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -919,7 +948,7 @@ module Temporalio
           else
             @client.workflow_service.respond_activity_task_canceled(
               Api::WorkflowService::V1::RespondActivityTaskCanceledRequest.new(
-                task_token: input.task_token_or_id_reference,
+                task_token: ref,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -929,6 +958,168 @@ module Temporalio
           end
           nil
         end
+
+        def start_activity(input)
+          raise ArgumentError, 'activity_id is required' if input.activity_id.nil? || input.activity_id.empty?
+          raise ArgumentError, 'task_queue is required' if input.task_queue.nil? || input.task_queue.to_s.empty?
+          if input.schedule_to_close_timeout.nil? && input.start_to_close_timeout.nil?
+            raise ArgumentError, 'either schedule_to_close_timeout or start_to_close_timeout is required'
+          end
+          raise ArgumentError, 'start_delay must be non-negative' if input.start_delay&.negative?
+
+          req = Api::WorkflowService::V1::StartActivityExecutionRequest.new(
+            namespace: @client.namespace,
+            identity: @client.connection.identity,
+            request_id: SecureRandom.uuid,
+            activity_id: input.activity_id,
+            activity_type: Api::Common::V1::ActivityType.new(name: input.activity),
+            task_queue: Api::TaskQueue::V1::TaskQueue.new(name: input.task_queue.to_s),
+            input: @client.data_converter.to_payloads(input.args, hints: input.arg_hints),
+            schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
+            schedule_to_start_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_start_timeout),
+            start_to_close_timeout: ProtoUtils.seconds_to_duration(input.start_to_close_timeout),
+            heartbeat_timeout: ProtoUtils.seconds_to_duration(input.heartbeat_timeout),
+            id_reuse_policy: input.id_reuse_policy,
+            id_conflict_policy: input.id_conflict_policy,
+            retry_policy: input.retry_policy&._to_proto,
+            search_attributes: input.search_attributes&._to_proto,
+            user_metadata: ProtoUtils.to_user_metadata(
+              input.static_summary, input.static_details, @client.data_converter
+            ),
+            header: ProtoUtils.headers_to_proto(input.headers, @client.data_converter),
+            priority: input.priority._to_proto,
+            start_delay: ProtoUtils.seconds_to_duration(input.start_delay)
+          )
+
+          begin
+            resp = @client.workflow_service.start_activity_execution(
+              req,
+              rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+            )
+          rescue Error::RPCError => e
+            if e.code == Error::RPCError::Code::ALREADY_EXISTS && e.grpc_status.details.first
+              details = e.grpc_status.details.first.unpack(
+                Api::ErrorDetails::V1::ActivityExecutionAlreadyStartedFailure
+              )
+              if details
+                raise Error::ActivityAlreadyStartedError.new(
+                  activity_id: input.activity_id,
+                  activity_type: input.activity,
+                  activity_run_id: details.run_id
+                )
+              end
+            end
+            raise
+          end
+
+          Temporalio::Client::ActivityHandle.new(
+            client: @client,
+            id: input.activity_id,
+            run_id: resp.run_id,
+            result_hint: input.result_hint
+          )
+        end
+
+        def describe_activity(input)
+          resp = @client.workflow_service.describe_activity_execution(
+            Api::WorkflowService::V1::DescribeActivityExecutionRequest.new(
+              namespace: @client.namespace,
+              activity_id: input.activity_id,
+              run_id: input.activity_run_id || ''
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          Temporalio::Client::ActivityExecution::Description.new(resp, @client.data_converter)
+        end
+
+        def cancel_activity(input)
+          @client.workflow_service.request_cancel_activity_execution(
+            Api::WorkflowService::V1::RequestCancelActivityExecutionRequest.new(
+              namespace: @client.namespace,
+              activity_id: input.activity_id,
+              run_id: input.activity_run_id || '',
+              identity: @client.connection.identity,
+              request_id: SecureRandom.uuid,
+              reason: input.reason
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          nil
+        end
+
+        def terminate_activity(input)
+          @client.workflow_service.terminate_activity_execution(
+            Api::WorkflowService::V1::TerminateActivityExecutionRequest.new(
+              namespace: @client.namespace,
+              activity_id: input.activity_id,
+              run_id: input.activity_run_id || '',
+              identity: @client.connection.identity,
+              request_id: SecureRandom.uuid,
+              reason: input.reason
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          nil
+        end
+
+        def list_activities(input)
+          Enumerator.new do |yielder|
+            req = Api::WorkflowService::V1::ListActivityExecutionsRequest.new(
+              namespace: @client.namespace,
+              query: input.query || ''
+            )
+            loop do
+              resp = @client.workflow_service.list_activity_executions(
+                req,
+                rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+              )
+              resp.executions.each do |raw_info|
+                yielder << Temporalio::Client::ActivityExecution.new(raw_info)
+              end
+              break if resp.next_page_token.empty?
+
+              req.next_page_token = resp.next_page_token
+            end
+          end
+        end
+
+        def count_activities(input)
+          resp = @client.workflow_service.count_activity_executions(
+            Api::WorkflowService::V1::CountActivityExecutionsRequest.new(
+              namespace: @client.namespace,
+              query: input.query || ''
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          Temporalio::Client::ActivityExecutionCount.new(
+            resp.count,
+            resp.groups.map do |group|
+              Temporalio::Client::ActivityExecutionCount::AggregationGroup.new(
+                group.count,
+                group.group_values.map { |payload| SearchAttributes._value_from_payload(payload) }
+              )
+            end
+          )
+        end
+
+        # Long-polls PollActivityExecution until the activity reaches a terminal state. Returns the
+        # ActivityExecutionOutcome. The server's long-poll deadline may expire before the activity
+        # completes; in that case PollActivityExecutionResponse comes back with an unpopulated
+        # `outcome` field and the call must be reissued.
+        def fetch_activity_outcome(input)
+          req = Api::WorkflowService::V1::PollActivityExecutionRequest.new(
+            namespace: @client.namespace,
+            activity_id: input.activity_id,
+            run_id: input.activity_run_id || ''
+          )
+          loop do
+            resp = @client.workflow_service.poll_activity_execution(
+              req,
+              rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+            )
+            return resp.outcome if resp.outcome
+          end
+        end
       end
     end
   end

data/lib/temporalio/internal/worker/activity_worker.rb

@@ -168,9 +168,18 @@ module Temporalio
         end
 
         def execute_activity(task_token, defn, start)
-          # Build info
+          # Build info. Standalone activities have some empty fields on the wire; translate
+          # empty strings to nil for the user-facing Info fields.
+          workflow_id = Internal::ProtoUtils.string_or(start.workflow_execution&.workflow_id, nil)
+          workflow_run_id = Internal::ProtoUtils.string_or(start.workflow_execution&.run_id, nil)
+          workflow_type = Internal::ProtoUtils.string_or(start.workflow_type, nil)
+          activity_run_id = Internal::ProtoUtils.string_or(start.run_id, nil)
+          # `namespace` is always set. `workflow_namespace` is the deprecated accessor, nil for standalone activities.
+          namespace = Internal::ProtoUtils.string_or(start.workflow_namespace, @worker.options.client.namespace)
+          workflow_namespace = workflow_id.nil? ? nil : namespace
           info = Activity::Info.new(
             activity_id: start.activity_id,
+            activity_run_id: activity_run_id,
             activity_type: start.activity_type,
             attempt: start.attempt,
             current_attempt_scheduled_time: Internal::ProtoUtils.timestamp_to_time(
@@ -178,6 +187,7 @@ module Temporalio
             ) || raise, # Never nil
             heartbeat_timeout: Internal::ProtoUtils.duration_to_seconds(start.heartbeat_timeout),
             local?: start.is_local,
+            namespace: namespace,
             priority: Priority._from_proto(start.priority),
             raw_heartbeat_details: begin
               payloads = start.heartbeat_details.to_ary
@@ -192,10 +202,10 @@ module Temporalio
             started_time: Internal::ProtoUtils.timestamp_to_time(start.started_time) || raise, # Never nil
             task_queue: @worker.options.task_queue,
             task_token:,
-            workflow_id: start.workflow_execution.workflow_id,
-            workflow_namespace: start.workflow_namespace,
-            workflow_run_id: start.workflow_execution.run_id,
-            workflow_type: start.workflow_type
+            workflow_id: workflow_id,
+            workflow_namespace: workflow_namespace,
+            workflow_run_id: workflow_run_id,
+            workflow_type: workflow_type
           )
 
           # Build input

data/lib/temporalio/internal/worker/workflow_instance/outbound_implementation.rb

@@ -481,15 +481,25 @@ module Temporalio
               @instance.pending_nexus_operation_starts.delete(seq)
             end
 
-            # Handle start failure
-            if resolution.failed
+            # Handle start resolution
+            case resolution.status
+            when :operation_token
+              operation_token = resolution.operation_token
+            when :started_sync
+              operation_token = nil
+            when :failed
+              input.cancellation.remove_cancel_callback(cancel_callback_key)
+              raise @instance.failure_converter.from_failure(
+                resolution.failed, @instance.payload_converter
+              )
+            else
               input.cancellation.remove_cancel_callback(cancel_callback_key)
-              raise @instance.failure_converter.from_failure(resolution.failed, @instance.payload_converter)
+              raise "Unknown Nexus operation start status: #{resolution.status.inspect}"
             end
 
             # Create handle and add to pending operations (result will come via resolve_nexus_operation)
             handle = NexusOperationHandle.new(
-              operation_token: resolution.operation_token,
+              operation_token:,
               instance: @instance,
               cancellation: input.cancellation,
               cancel_callback_key:,

data/lib/temporalio/testing/activity_environment.rb

@@ -18,11 +18,13 @@ module Temporalio
       def self.default_info
         @default_info ||= Activity::Info.new(
           activity_id: 'test',
+          activity_run_id: nil,
           activity_type: 'unknown',
           attempt: 1,
           current_attempt_scheduled_time: Time.at(0),
           heartbeat_timeout: nil,
           local?: false,
+          namespace: 'default',
           priority: Temporalio::Priority.default,
           raw_heartbeat_details: [],
           retry_policy: RetryPolicy.new,

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '1.4.1'
+  VERSION = '1.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: temporalio
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Temporal Technologies Inc
@@ -138,6 +138,10 @@ files:
 - lib/temporalio/api/workflowservice/v1/service.rb
 - lib/temporalio/cancellation.rb
 - lib/temporalio/client.rb
+- lib/temporalio/client/activity_execution.rb
+- lib/temporalio/client/activity_execution_count.rb
+- lib/temporalio/client/activity_execution_status.rb
+- lib/temporalio/client/activity_handle.rb
 - lib/temporalio/client/activity_id_reference.rb
 - lib/temporalio/client/async_activity_handle.rb
 - lib/temporalio/client/connection.rb
@@ -147,6 +151,7 @@ files:
 - lib/temporalio/client/connection/test_service.rb
 - lib/temporalio/client/connection/workflow_service.rb
 - lib/temporalio/client/interceptor.rb
+- lib/temporalio/client/pending_activity_state.rb
 - lib/temporalio/client/plugin.rb
 - lib/temporalio/client/schedule.rb
 - lib/temporalio/client/schedule_handle.rb