Class WorkflowServiceGrpc.WorkflowServiceFutureStub

java.lang.Object
io.grpc.stub.AbstractStub<WorkflowServiceGrpc.WorkflowServiceFutureStub>
io.grpc.stub.AbstractFutureStub<WorkflowServiceGrpc.WorkflowServiceFutureStub>
io.temporal.api.workflowservice.v1.WorkflowServiceGrpc.WorkflowServiceFutureStub
Enclosing class:
WorkflowServiceGrpc
public static final class WorkflowServiceGrpc.WorkflowServiceFutureStub extends io.grpc.stub.AbstractFutureStub<WorkflowServiceGrpc.WorkflowServiceFutureStub>
 WorkflowService API defines how Temporal SDKs and other clients interact with the Temporal server
 to create and interact with workflows and activities.
 Users are expected to call `StartWorkflowExecution` to create a new workflow execution.
 To drive workflows, a worker using a Temporal SDK must exist which regularly polls for workflow
 and activity tasks from the service. For each workflow task, the sdk must process the
 (incremental or complete) event history and respond back with any newly generated commands.
 For each activity task, the worker is expected to execute the user's code which implements that
 activity, responding with completion or failure.

  • Method Details

    • build

      protected WorkflowServiceGrpc.WorkflowServiceFutureStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions)
      Specified by:
      build in class io.grpc.stub.AbstractStub<WorkflowServiceGrpc.WorkflowServiceFutureStub>

    • registerNamespace

      public com.google.common.util.concurrent.ListenableFuture<RegisterNamespaceResponse> registerNamespace(RegisterNamespaceRequest request)
       RegisterNamespace creates a new namespace which can be used as a container for all resources.
 A Namespace is a top level entity within Temporal, and is used as a container for resources
 like workflow executions, task queues, etc. A Namespace acts as a sandbox and provides
 isolation for all resources within the namespace. All resources belongs to exactly one
 namespace.

    • describeNamespace

      public com.google.common.util.concurrent.ListenableFuture<DescribeNamespaceResponse> describeNamespace(DescribeNamespaceRequest request)
       DescribeNamespace returns the information and configuration for a registered namespace.

    • listNamespaces

      public com.google.common.util.concurrent.ListenableFuture<ListNamespacesResponse> listNamespaces(ListNamespacesRequest request)
       ListNamespaces returns the information and configuration for all namespaces.

    • updateNamespace

      public com.google.common.util.concurrent.ListenableFuture<UpdateNamespaceResponse> updateNamespace(UpdateNamespaceRequest request)
       UpdateNamespace is used to update the information and configuration of a registered
 namespace.

    • deprecateNamespace

      public com.google.common.util.concurrent.ListenableFuture<DeprecateNamespaceResponse> deprecateNamespace(DeprecateNamespaceRequest request)
       DeprecateNamespace is used to update the state of a registered namespace to DEPRECATED.
 Once the namespace is deprecated it cannot be used to start new workflow executions. Existing
 workflow executions will continue to run on deprecated namespaces.
 Deprecated.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: Deprecated --)

    • startWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<StartWorkflowExecutionResponse> startWorkflowExecution(StartWorkflowExecutionRequest request)
       StartWorkflowExecution starts a new workflow execution.
 It will create the execution with a `WORKFLOW_EXECUTION_STARTED` event in its history and
 also schedule the first workflow task. Returns `WorkflowExecutionAlreadyStarted`, if an
 instance already exists with same workflow id.

    • executeMultiOperation

      public com.google.common.util.concurrent.ListenableFuture<ExecuteMultiOperationResponse> executeMultiOperation(ExecuteMultiOperationRequest request)
       ExecuteMultiOperation executes multiple operations within a single workflow.
 Operations are started atomically, meaning if *any* operation fails to be started, none are,
 and the request fails. Upon start, the API returns only when *all* operations have a response.
 Upon failure, it returns `MultiOperationExecutionFailure` where the status code
 equals the status code of the *first* operation that failed to be started.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: To be exposed over HTTP in the future. --)

    • getWorkflowExecutionHistory

      public com.google.common.util.concurrent.ListenableFuture<GetWorkflowExecutionHistoryResponse> getWorkflowExecutionHistory(GetWorkflowExecutionHistoryRequest request)
       GetWorkflowExecutionHistory returns the history of specified workflow execution. Fails with
 `NotFound` if the specified workflow execution is unknown to the service.

    • getWorkflowExecutionHistoryReverse

      public com.google.common.util.concurrent.ListenableFuture<GetWorkflowExecutionHistoryReverseResponse> getWorkflowExecutionHistoryReverse(GetWorkflowExecutionHistoryReverseRequest request)
       GetWorkflowExecutionHistoryReverse returns the history of specified workflow execution in reverse
 order (starting from last event). Fails with`NotFound` if the specified workflow execution is
 unknown to the service.

    • pollWorkflowTaskQueue

      public com.google.common.util.concurrent.ListenableFuture<PollWorkflowTaskQueueResponse> pollWorkflowTaskQueue(PollWorkflowTaskQueueRequest request)
       PollWorkflowTaskQueue is called by workers to make progress on workflows.
 A WorkflowTask is dispatched to callers for active workflow executions with pending workflow
 tasks. The worker is expected to call `RespondWorkflowTaskCompleted` when it is done
 processing the task. The service will create a `WorkflowTaskStarted` event in the history for
 this task before handing it to the worker.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • respondWorkflowTaskCompleted

      public com.google.common.util.concurrent.ListenableFuture<RespondWorkflowTaskCompletedResponse> respondWorkflowTaskCompleted(RespondWorkflowTaskCompletedRequest request)
       RespondWorkflowTaskCompleted is called by workers to successfully complete workflow tasks
 they received from `PollWorkflowTaskQueue`.
 Completing a WorkflowTask will write a `WORKFLOW_TASK_COMPLETED` event to the workflow's
 history, along with events corresponding to whatever commands the SDK generated while
 executing the task (ex timer started, activity task scheduled, etc).
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • respondWorkflowTaskFailed

      public com.google.common.util.concurrent.ListenableFuture<RespondWorkflowTaskFailedResponse> respondWorkflowTaskFailed(RespondWorkflowTaskFailedRequest request)
       RespondWorkflowTaskFailed is called by workers to indicate the processing of a workflow task
 failed.
 This results in a `WORKFLOW_TASK_FAILED` event written to the history, and a new workflow
 task will be scheduled. This API can be used to report unhandled failures resulting from
 applying the workflow task.
 Temporal will only append first WorkflowTaskFailed event to the history of workflow execution
 for consecutive failures.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • pollActivityTaskQueue

      public com.google.common.util.concurrent.ListenableFuture<PollActivityTaskQueueResponse> pollActivityTaskQueue(PollActivityTaskQueueRequest request)
       PollActivityTaskQueue is called by workers to process activity tasks from a specific task
 queue.
 The worker is expected to call one of the `RespondActivityTaskXXX` methods when it is done
 processing the task.
 An activity task is dispatched whenever a `SCHEDULE_ACTIVITY_TASK` command is produced during
 workflow execution. An in memory `ACTIVITY_TASK_STARTED` event is written to mutable state
 before the task is dispatched to the worker. The started event, and the final event
 (`ACTIVITY_TASK_COMPLETED` / `ACTIVITY_TASK_FAILED` / `ACTIVITY_TASK_TIMED_OUT`) will both be
 written permanently to Workflow execution history when Activity is finished. This is done to
 avoid writing many events in the case of a failure/retry loop.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • recordActivityTaskHeartbeat

      public com.google.common.util.concurrent.ListenableFuture<RecordActivityTaskHeartbeatResponse> recordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest request)
       RecordActivityTaskHeartbeat is optionally called by workers while they execute activities.
 If a worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task,
 then the current attempt times out. Depending on RetryPolicy, this may trigger a retry or
 time out the activity.
 For workflow activities, an `ACTIVITY_TASK_TIMED_OUT` event will be written to the workflow
 history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in such situations,
 in that event, the SDK should request cancellation of the activity.
 The request may contain response `details` which will be persisted by the server and may be
 used by the activity to checkpoint progress. The `cancel_requested` field in the response
 indicates whether cancellation has been requested for the activity.

    • recordActivityTaskHeartbeatById

      public com.google.common.util.concurrent.ListenableFuture<RecordActivityTaskHeartbeatByIdResponse> recordActivityTaskHeartbeatById(RecordActivityTaskHeartbeatByIdRequest request)
       See `RecordActivityTaskHeartbeat`. This version allows clients to record heartbeats by
 namespace/workflow id/activity id instead of task token.
 (-- api-linter: core::0136::prepositions=disabled
     aip.dev/not-precedent: "By" is used to indicate request type. --)

    • respondActivityTaskCompleted

      public com.google.common.util.concurrent.ListenableFuture<RespondActivityTaskCompletedResponse> respondActivityTaskCompleted(RespondActivityTaskCompletedRequest request)
       RespondActivityTaskCompleted is called by workers when they successfully complete an activity
 task.
 For workflow activities, this results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history
 and a new workflow task created for the workflow. Fails with `NotFound` if the task token is
 no longer valid due to activity timeout, already being completed, or never having existed.

    • respondActivityTaskCompletedById

      public com.google.common.util.concurrent.ListenableFuture<RespondActivityTaskCompletedByIdResponse> respondActivityTaskCompletedById(RespondActivityTaskCompletedByIdRequest request)
       See `RespondActivityTaskCompleted`. This version allows clients to record completions by
 namespace/workflow id/activity id instead of task token.
 (-- api-linter: core::0136::prepositions=disabled
     aip.dev/not-precedent: "By" is used to indicate request type. --)

    • respondActivityTaskFailed

      public com.google.common.util.concurrent.ListenableFuture<RespondActivityTaskFailedResponse> respondActivityTaskFailed(RespondActivityTaskFailedRequest request)
       RespondActivityTaskFailed is called by workers when processing an activity task fails.
 This results in a new `ACTIVITY_TASK_FAILED` event being written to the workflow history and
 a new workflow task created for the workflow. Fails with `NotFound` if the task token is no
 longer valid due to activity timeout, already being completed, or never having existed.

    • respondActivityTaskFailedById

      public com.google.common.util.concurrent.ListenableFuture<RespondActivityTaskFailedByIdResponse> respondActivityTaskFailedById(RespondActivityTaskFailedByIdRequest request)
       See `RecordActivityTaskFailed`. This version allows clients to record failures by
 namespace/workflow id/activity id instead of task token.
 (-- api-linter: core::0136::prepositions=disabled
     aip.dev/not-precedent: "By" is used to indicate request type. --)

    • respondActivityTaskCanceled

      public com.google.common.util.concurrent.ListenableFuture<RespondActivityTaskCanceledResponse> respondActivityTaskCanceled(RespondActivityTaskCanceledRequest request)
       RespondActivityTaskFailed is called by workers when processing an activity task fails.
 For workflow activities, this results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history
 and a new workflow task created for the workflow. Fails with `NotFound` if the task token is
 no longer valid due to activity timeout, already being completed, or never having existed.

    • respondActivityTaskCanceledById

      public com.google.common.util.concurrent.ListenableFuture<RespondActivityTaskCanceledByIdResponse> respondActivityTaskCanceledById(RespondActivityTaskCanceledByIdRequest request)
       See `RespondActivityTaskCanceled`. This version allows clients to record failures by
 namespace/workflow id/activity id instead of task token.
 (-- api-linter: core::0136::prepositions=disabled
     aip.dev/not-precedent: "By" is used to indicate request type. --)

    • requestCancelWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<RequestCancelWorkflowExecutionResponse> requestCancelWorkflowExecution(RequestCancelWorkflowExecutionRequest request)
       RequestCancelWorkflowExecution is called by workers when they want to request cancellation of
 a workflow execution.
 This results in a new `WORKFLOW_EXECUTION_CANCEL_REQUESTED` event being written to the
 workflow history and a new workflow task created for the workflow. It returns success if the requested
 workflow is already closed. It fails with 'NotFound' if the requested workflow doesn't exist.

    • signalWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<SignalWorkflowExecutionResponse> signalWorkflowExecution(SignalWorkflowExecutionRequest request)
       SignalWorkflowExecution is used to send a signal to a running workflow execution.
 This results in a `WORKFLOW_EXECUTION_SIGNALED` event recorded in the history and a workflow
 task being created for the execution.

    • signalWithStartWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<SignalWithStartWorkflowExecutionResponse> signalWithStartWorkflowExecution(SignalWithStartWorkflowExecutionRequest request)
       SignalWithStartWorkflowExecution is used to ensure a signal is sent to a workflow, even if
 it isn't yet started.
 If the workflow is running, a `WORKFLOW_EXECUTION_SIGNALED` event is recorded in the history
 and a workflow task is generated.
 If the workflow is not running or not found, then the workflow is created with
 `WORKFLOW_EXECUTION_STARTED` and `WORKFLOW_EXECUTION_SIGNALED` events in its history, and a
 workflow task is generated.
 (-- api-linter: core::0136::prepositions=disabled
     aip.dev/not-precedent: "With" is used to indicate combined operation. --)

    • resetWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<ResetWorkflowExecutionResponse> resetWorkflowExecution(ResetWorkflowExecutionRequest request)
       ResetWorkflowExecution will reset an existing workflow execution to a specified
 `WORKFLOW_TASK_COMPLETED` event (exclusive). It will immediately terminate the current
 execution instance. "Exclusive" means the identified completed event itself is not replayed
 in the reset history; the preceding `WORKFLOW_TASK_STARTED` event remains and will be marked as failed
 immediately, and a new workflow task will be scheduled to retry it.

    • terminateWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<TerminateWorkflowExecutionResponse> terminateWorkflowExecution(TerminateWorkflowExecutionRequest request)
       TerminateWorkflowExecution terminates an existing workflow execution by recording a
 `WORKFLOW_EXECUTION_TERMINATED` event in the history and immediately terminating the
 execution instance.

    • deleteWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<DeleteWorkflowExecutionResponse> deleteWorkflowExecution(DeleteWorkflowExecutionRequest request)
       DeleteWorkflowExecution asynchronously deletes a specific Workflow Execution (when
 WorkflowExecution.run_id is provided) or the latest Workflow Execution (when
 WorkflowExecution.run_id is not provided). If the Workflow Execution is Running, it will be
 terminated before deletion.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: Workflow deletion not exposed to HTTP, users should use cancel or terminate. --)

    • listOpenWorkflowExecutions

      public com.google.common.util.concurrent.ListenableFuture<ListOpenWorkflowExecutionsResponse> listOpenWorkflowExecutions(ListOpenWorkflowExecutionsRequest request)
       ListOpenWorkflowExecutions is a visibility API to list the open executions in a specific namespace.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)

    • listClosedWorkflowExecutions

      public com.google.common.util.concurrent.ListenableFuture<ListClosedWorkflowExecutionsResponse> listClosedWorkflowExecutions(ListClosedWorkflowExecutionsRequest request)
       ListClosedWorkflowExecutions is a visibility API to list the closed executions in a specific namespace.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)

    • listWorkflowExecutions

      public com.google.common.util.concurrent.ListenableFuture<ListWorkflowExecutionsResponse> listWorkflowExecutions(ListWorkflowExecutionsRequest request)
       ListWorkflowExecutions is a visibility API to list workflow executions in a specific namespace.

    • listArchivedWorkflowExecutions

      public com.google.common.util.concurrent.ListenableFuture<ListArchivedWorkflowExecutionsResponse> listArchivedWorkflowExecutions(ListArchivedWorkflowExecutionsRequest request)
       ListArchivedWorkflowExecutions is a visibility API to list archived workflow executions in a specific namespace.

    • scanWorkflowExecutions

      public com.google.common.util.concurrent.ListenableFuture<ScanWorkflowExecutionsResponse> scanWorkflowExecutions(ScanWorkflowExecutionsRequest request)
       ScanWorkflowExecutions _was_ a visibility API to list large amount of workflow executions in a specific namespace without order.
 It has since been deprecated in favor of `ListWorkflowExecutions` and rewritten to use `ListWorkflowExecutions` internally.
 Deprecated: Replaced with `ListWorkflowExecutions`.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)

    • countWorkflowExecutions

      public com.google.common.util.concurrent.ListenableFuture<CountWorkflowExecutionsResponse> countWorkflowExecutions(CountWorkflowExecutionsRequest request)
       CountWorkflowExecutions is a visibility API to count of workflow executions in a specific namespace.

    • getSearchAttributes

      public com.google.common.util.concurrent.ListenableFuture<GetSearchAttributesResponse> getSearchAttributes(GetSearchAttributesRequest request)
       GetSearchAttributes is a visibility API to get all legal keys that could be used in list APIs
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose this search attribute API to HTTP (but may expose on OperatorService). --)

    • respondQueryTaskCompleted

      public com.google.common.util.concurrent.ListenableFuture<RespondQueryTaskCompletedResponse> respondQueryTaskCompleted(RespondQueryTaskCompletedRequest request)
       RespondQueryTaskCompleted is called by workers to complete queries which were delivered on
 the `query` (not `queries`) field of a `PollWorkflowTaskQueueResponse`.
 Completing the query will unblock the corresponding client call to `QueryWorkflow` and return
 the query result a response.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • resetStickyTaskQueue

      public com.google.common.util.concurrent.ListenableFuture<ResetStickyTaskQueueResponse> resetStickyTaskQueue(ResetStickyTaskQueueRequest request)
       ResetStickyTaskQueue resets the sticky task queue related information in the mutable state of
 a given workflow. This is prudent for workers to perform if a workflow has been paged out of
 their cache.
 Things cleared are:
 1. StickyTaskQueue
 2. StickyScheduleToStartTimeout
 When possible, ShutdownWorker should be preferred over
 ResetStickyTaskQueue (particularly when a worker is shutting down or
 cycling).
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • shutdownWorker

      public com.google.common.util.concurrent.ListenableFuture<ShutdownWorkerResponse> shutdownWorker(ShutdownWorkerRequest request)
       ShutdownWorker is used to indicate that the given sticky task
 queue is no longer being polled by its worker. Following the completion of
 ShutdownWorker, newly-added workflow tasks will instead be placed
 in the normal task queue, eligible for any worker to pick up.
 ShutdownWorker should be called by workers while shutting down,
 after they've shut down their pollers. If another sticky poll
 request is issued, the sticky task queue will be revived.
 As of Temporal Server v1.25.0, ShutdownWorker hasn't yet been implemented.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • queryWorkflow

      public com.google.common.util.concurrent.ListenableFuture<QueryWorkflowResponse> queryWorkflow(QueryWorkflowRequest request)
       QueryWorkflow requests a query be executed for a specified workflow execution.

    • describeWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<DescribeWorkflowExecutionResponse> describeWorkflowExecution(DescribeWorkflowExecutionRequest request)
       DescribeWorkflowExecution returns information about the specified workflow execution.

    • describeTaskQueue

      public com.google.common.util.concurrent.ListenableFuture<DescribeTaskQueueResponse> describeTaskQueue(DescribeTaskQueueRequest request)
       DescribeTaskQueue returns the following information about the target task queue, broken down by Build ID:
   - List of pollers
   - Workflow Reachability status
   - Backlog info for Workflow and/or Activity tasks

    • getClusterInfo

      public com.google.common.util.concurrent.ListenableFuture<GetClusterInfoResponse> getClusterInfo(GetClusterInfoRequest request)
       GetClusterInfo returns information about temporal cluster

    • getSystemInfo

      public com.google.common.util.concurrent.ListenableFuture<GetSystemInfoResponse> getSystemInfo(GetSystemInfoRequest request)
       GetSystemInfo returns information about the system.

    • listTaskQueuePartitions

      public com.google.common.util.concurrent.ListenableFuture<ListTaskQueuePartitionsResponse> listTaskQueuePartitions(ListTaskQueuePartitionsRequest request)
       (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose this low-level API to HTTP. --)

    • createSchedule

      public com.google.common.util.concurrent.ListenableFuture<CreateScheduleResponse> createSchedule(CreateScheduleRequest request)
       Creates a new schedule.

    • describeSchedule

      public com.google.common.util.concurrent.ListenableFuture<DescribeScheduleResponse> describeSchedule(DescribeScheduleRequest request)
       Returns the schedule description and current state of an existing schedule.

    • updateSchedule

      public com.google.common.util.concurrent.ListenableFuture<UpdateScheduleResponse> updateSchedule(UpdateScheduleRequest request)
       Changes the configuration or state of an existing schedule.

    • patchSchedule

      public com.google.common.util.concurrent.ListenableFuture<PatchScheduleResponse> patchSchedule(PatchScheduleRequest request)
       Makes a specific change to a schedule or triggers an immediate action.

    • listScheduleMatchingTimes

      public com.google.common.util.concurrent.ListenableFuture<ListScheduleMatchingTimesResponse> listScheduleMatchingTimes(ListScheduleMatchingTimesRequest request)
       Lists matching times within a range.

    • deleteSchedule

      public com.google.common.util.concurrent.ListenableFuture<DeleteScheduleResponse> deleteSchedule(DeleteScheduleRequest request)
       Deletes a schedule, removing it from the system.

    • listSchedules

      public com.google.common.util.concurrent.ListenableFuture<ListSchedulesResponse> listSchedules(ListSchedulesRequest request)
       List all schedules in a namespace.

    • countSchedules

      public com.google.common.util.concurrent.ListenableFuture<CountSchedulesResponse> countSchedules(CountSchedulesRequest request)
       CountSchedules is a visibility API to count schedules in a specific namespace.

    • updateWorkerBuildIdCompatibility

      public com.google.common.util.concurrent.ListenableFuture<UpdateWorkerBuildIdCompatibilityResponse> updateWorkerBuildIdCompatibility(UpdateWorkerBuildIdCompatibilityRequest request)
       Deprecated. Use `UpdateWorkerVersioningRules`.
 Will be removed in server version v1.32.0.
 Allows users to specify sets of worker build id versions on a per task queue basis. Versions
 are ordered, and may be either compatible with some extant version, or a new incompatible
 version, forming sets of ids which are incompatible with each other, but whose contained
 members are compatible with one another.
 A single build id may be mapped to multiple task queues using this API for cases where a single process hosts
 multiple workers.
 To query which workers can be retired, use the `GetWorkerTaskReachability` API.
 NOTE: The number of task queues mapped to a single build id is limited by the `limit.taskQueuesPerBuildId`
 (default is 20), if this limit is exceeded this API will error with a FailedPrecondition.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do yet expose versioning API to HTTP. --)

    • getWorkerBuildIdCompatibility

      public com.google.common.util.concurrent.ListenableFuture<GetWorkerBuildIdCompatibilityResponse> getWorkerBuildIdCompatibility(GetWorkerBuildIdCompatibilityRequest request)
       Deprecated. Use `GetWorkerVersioningRules`.
 Will be removed in server version v1.32.0.
 Fetches the worker build id versioning sets for a task queue.

    • updateWorkerVersioningRules

      public com.google.common.util.concurrent.ListenableFuture<UpdateWorkerVersioningRulesResponse> updateWorkerVersioningRules(UpdateWorkerVersioningRulesRequest request)
       Use this API to manage Worker Versioning Rules for a given Task Queue. There are two types of
 rules: Build ID Assignment rules and Compatible Build ID Redirect rules.
 Assignment rules determine how to assign new executions to a Build IDs. Their primary
 use case is to specify the latest Build ID but they have powerful features for gradual rollout
 of a new Build ID.
 Once a workflow execution is assigned to a Build ID and it completes its first Workflow Task,
 the workflow stays on the assigned Build ID regardless of changes in assignment rules. This
 eliminates the need for compatibility between versions when you only care about using the new
 version for new workflows and let existing workflows finish in their own version.
 Activities, Child Workflows and Continue-as-New executions have the option to inherit the
 Build ID of their parent/previous workflow or use the latest assignment rules to independently
 select a Build ID.
 Redirect rules should only be used when you want to move workflows and activities assigned to
 one Build ID (source) to another compatible Build ID (target). You are responsible to make sure
 the target Build ID of a redirect rule is able to process event histories made by the source
 Build ID by using [Patching](https://docs.temporal.io/workflows#patching) or other means.
 Will be removed in server version v1.32.0.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do yet expose versioning API to HTTP. --)

    • getWorkerVersioningRules

      public com.google.common.util.concurrent.ListenableFuture<GetWorkerVersioningRulesResponse> getWorkerVersioningRules(GetWorkerVersioningRulesRequest request)
       Fetches the Build ID assignment and redirect rules for a Task Queue.
 Will be removed in server version v1.32.0.

    • getWorkerTaskReachability

      public com.google.common.util.concurrent.ListenableFuture<GetWorkerTaskReachabilityResponse> getWorkerTaskReachability(GetWorkerTaskReachabilityRequest request)
       Deprecated. Use `DescribeTaskQueue`.
 Will be removed in server version v1.32.0.
 Fetches task reachability to determine whether a worker may be retired.
 The request may specify task queues to query for or let the server fetch all task queues mapped to the given
 build IDs.
 When requesting a large number of task queues or all task queues associated with the given build ids in a
 namespace, all task queues will be listed in the response but some of them may not contain reachability
 information due to a server enforced limit. When reaching the limit, task queues that reachability information
 could not be retrieved for will be marked with a single TASK_REACHABILITY_UNSPECIFIED entry. The caller may issue
 another call to get the reachability for those task queues.
 Open source users can adjust this limit by setting the server's dynamic config value for
 `limit.reachabilityTaskQueueScan` with the caveat that this call can strain the visibility store.

    • describeDeployment

      public com.google.common.util.concurrent.ListenableFuture<DescribeDeploymentResponse> describeDeployment(DescribeDeploymentRequest request)
       Describes a worker deployment.
 Experimental. This API might significantly change or be removed in a future release.
 Deprecated. Replaced with `DescribeWorkerDeploymentVersion`.

    • describeWorkerDeploymentVersion

      public com.google.common.util.concurrent.ListenableFuture<DescribeWorkerDeploymentVersionResponse> describeWorkerDeploymentVersion(DescribeWorkerDeploymentVersionRequest request)
       Describes a worker deployment version.
 Experimental. This API might significantly change or be removed in a future release.

    • listDeployments

      public com.google.common.util.concurrent.ListenableFuture<ListDeploymentsResponse> listDeployments(ListDeploymentsRequest request)
       Lists worker deployments in the namespace. Optionally can filter based on deployment series
 name.
 Experimental. This API might significantly change or be removed in a future release.
 Deprecated. Replaced with `ListWorkerDeployments`.

    • getDeploymentReachability

      public com.google.common.util.concurrent.ListenableFuture<GetDeploymentReachabilityResponse> getDeploymentReachability(GetDeploymentReachabilityRequest request)
       Returns the reachability level of a worker deployment to help users decide when it is time
 to decommission a deployment. Reachability level is calculated based on the deployment's
 `status` and existing workflows that depend on the given deployment for their execution.
 Calculating reachability is relatively expensive. Therefore, server might return a recently
 cached value. In such a case, the `last_update_time` will inform you about the actual
 reachability calculation time.
 Experimental. This API might significantly change or be removed in a future release.
 Deprecated. Replaced with `DrainageInfo` returned by `DescribeWorkerDeploymentVersion`.

    • getCurrentDeployment

      public com.google.common.util.concurrent.ListenableFuture<GetCurrentDeploymentResponse> getCurrentDeployment(GetCurrentDeploymentRequest request)
       Returns the current deployment (and its info) for a given deployment series.
 Experimental. This API might significantly change or be removed in a future release.
 Deprecated. Replaced by `current_version` returned by `DescribeWorkerDeployment`.

    • setCurrentDeployment

      public com.google.common.util.concurrent.ListenableFuture<SetCurrentDeploymentResponse> setCurrentDeployment(SetCurrentDeploymentRequest request)
       Sets a deployment as the current deployment for its deployment series. Can optionally update
 the metadata of the deployment as well.
 Experimental. This API might significantly change or be removed in a future release.
 Deprecated. Replaced by `SetWorkerDeploymentCurrentVersion`.

    • setWorkerDeploymentCurrentVersion

      public com.google.common.util.concurrent.ListenableFuture<SetWorkerDeploymentCurrentVersionResponse> setWorkerDeploymentCurrentVersion(SetWorkerDeploymentCurrentVersionRequest request)
       Set/unset the Current Version of a Worker Deployment. Automatically unsets the Ramping
 Version if it is the Version being set as Current.
 Experimental. This API might significantly change or be removed in a future release.

    • describeWorkerDeployment

      public com.google.common.util.concurrent.ListenableFuture<DescribeWorkerDeploymentResponse> describeWorkerDeployment(DescribeWorkerDeploymentRequest request)
       Describes a Worker Deployment.
 Experimental. This API might significantly change or be removed in a future release.

    • deleteWorkerDeployment

      public com.google.common.util.concurrent.ListenableFuture<DeleteWorkerDeploymentResponse> deleteWorkerDeployment(DeleteWorkerDeploymentRequest request)
       Deletes records of (an old) Deployment. A deployment can only be deleted if
 it has no Version in it.
 Experimental. This API might significantly change or be removed in a future release.

    • deleteWorkerDeploymentVersion

      public com.google.common.util.concurrent.ListenableFuture<DeleteWorkerDeploymentVersionResponse> deleteWorkerDeploymentVersion(DeleteWorkerDeploymentVersionRequest request)
       Used for manual deletion of Versions. User can delete a Version only when all the
 following conditions are met:
  - It is not the Current or Ramping Version of its Deployment.
  - It has no active pollers (none of the task queues in the Version have pollers)
  - It is not draining (see WorkerDeploymentVersionInfo.drainage_info). This condition
    can be skipped by passing `skip-drainage=true`.
 Experimental. This API might significantly change or be removed in a future release.

    • setWorkerDeploymentRampingVersion

      public com.google.common.util.concurrent.ListenableFuture<SetWorkerDeploymentRampingVersionResponse> setWorkerDeploymentRampingVersion(SetWorkerDeploymentRampingVersionRequest request)
       Set/unset the Ramping Version of a Worker Deployment and its ramp percentage. Can be used for
 gradual ramp to unversioned workers too.
 Experimental. This API might significantly change or be removed in a future release.

    • listWorkerDeployments

      public com.google.common.util.concurrent.ListenableFuture<ListWorkerDeploymentsResponse> listWorkerDeployments(ListWorkerDeploymentsRequest request)
       Lists all Worker Deployments that are tracked in the Namespace.
 Experimental. This API might significantly change or be removed in a future release.

    • createWorkerDeployment

      public com.google.common.util.concurrent.ListenableFuture<CreateWorkerDeploymentResponse> createWorkerDeployment(CreateWorkerDeploymentRequest request)
       Creates a new Worker Deployment.
 Experimental. This API might significantly change or be removed in a
 future release.

    • createWorkerDeploymentVersion

      public com.google.common.util.concurrent.ListenableFuture<CreateWorkerDeploymentVersionResponse> createWorkerDeploymentVersion(CreateWorkerDeploymentVersionRequest request)
       Creates a new Worker Deployment Version.
 Experimental. This API might significantly change or be removed in a
 future release.

    • updateWorkerDeploymentVersionComputeConfig

      public com.google.common.util.concurrent.ListenableFuture<UpdateWorkerDeploymentVersionComputeConfigResponse> updateWorkerDeploymentVersionComputeConfig(UpdateWorkerDeploymentVersionComputeConfigRequest request)
       Updates the compute config attached to a Worker Deployment Version.
 Experimental. This API might significantly change or be removed in a future release.

    • validateWorkerDeploymentVersionComputeConfig

      public com.google.common.util.concurrent.ListenableFuture<ValidateWorkerDeploymentVersionComputeConfigResponse> validateWorkerDeploymentVersionComputeConfig(ValidateWorkerDeploymentVersionComputeConfigRequest request)
       Validates the compute config without attaching it to a Worker Deployment Version.
 Experimental. This API might significantly change or be removed in a future release.

    • updateWorkerDeploymentVersionMetadata

      public com.google.common.util.concurrent.ListenableFuture<UpdateWorkerDeploymentVersionMetadataResponse> updateWorkerDeploymentVersionMetadata(UpdateWorkerDeploymentVersionMetadataRequest request)
       Updates the user-given metadata attached to a Worker Deployment Version.
 Experimental. This API might significantly change or be removed in a future release.

    • setWorkerDeploymentManager

      public com.google.common.util.concurrent.ListenableFuture<SetWorkerDeploymentManagerResponse> setWorkerDeploymentManager(SetWorkerDeploymentManagerRequest request)
       Set/unset the ManagerIdentity of a Worker Deployment.
 Experimental. This API might significantly change or be removed in a future release.

    • updateWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<UpdateWorkflowExecutionResponse> updateWorkflowExecution(UpdateWorkflowExecutionRequest request)
       Invokes the specified Update function on user Workflow code.

    • pollWorkflowExecutionUpdate

      public com.google.common.util.concurrent.ListenableFuture<PollWorkflowExecutionUpdateResponse> pollWorkflowExecutionUpdate(PollWorkflowExecutionUpdateRequest request)
       Polls a Workflow Execution for the outcome of a Workflow Update
 previously issued through the UpdateWorkflowExecution RPC. The effective
 timeout on this call will be shorter of the the caller-supplied gRPC
 timeout and the server's configured long-poll timeout.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We don't expose update polling API to HTTP in favor of a potential future non-blocking form. --)

    • startBatchOperation

      public com.google.common.util.concurrent.ListenableFuture<StartBatchOperationResponse> startBatchOperation(StartBatchOperationRequest request)
       StartBatchOperation starts a new batch operation

    • stopBatchOperation

      public com.google.common.util.concurrent.ListenableFuture<StopBatchOperationResponse> stopBatchOperation(StopBatchOperationRequest request)
       StopBatchOperation stops a batch operation

    • describeBatchOperation

      public com.google.common.util.concurrent.ListenableFuture<DescribeBatchOperationResponse> describeBatchOperation(DescribeBatchOperationRequest request)
       DescribeBatchOperation returns the information about a batch operation

    • listBatchOperations

      public com.google.common.util.concurrent.ListenableFuture<ListBatchOperationsResponse> listBatchOperations(ListBatchOperationsRequest request)
       ListBatchOperations returns a list of batch operations

    • pollNexusTaskQueue

      public com.google.common.util.concurrent.ListenableFuture<PollNexusTaskQueueResponse> pollNexusTaskQueue(PollNexusTaskQueueRequest request)
       PollNexusTaskQueue is a long poll call used by workers to receive Nexus tasks.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • respondNexusTaskCompleted

      public com.google.common.util.concurrent.ListenableFuture<RespondNexusTaskCompletedResponse> respondNexusTaskCompleted(RespondNexusTaskCompletedRequest request)
       RespondNexusTaskCompleted is called by workers to respond to Nexus tasks received via PollNexusTaskQueue.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • respondNexusTaskFailed

      public com.google.common.util.concurrent.ListenableFuture<RespondNexusTaskFailedResponse> respondNexusTaskFailed(RespondNexusTaskFailedRequest request)
       RespondNexusTaskFailed is called by workers to fail Nexus tasks received via PollNexusTaskQueue.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: We do not expose worker API to HTTP. --)

    • updateActivityOptions

      public com.google.common.util.concurrent.ListenableFuture<UpdateActivityOptionsResponse> updateActivityOptions(UpdateActivityOptionsRequest request)
       UpdateActivityOptions is called by the client to update the options of an activity by its ID or type.
 If there are multiple pending activities of the provided type - all of them will be updated.
 This API will be deprecated soon and replaced with a newer UpdateActivityExecutionOptions that is better named and
 structured to work well for standalone activities.

    • updateWorkflowExecutionOptions

      public com.google.common.util.concurrent.ListenableFuture<UpdateWorkflowExecutionOptionsResponse> updateWorkflowExecutionOptions(UpdateWorkflowExecutionOptionsRequest request)
       UpdateWorkflowExecutionOptions partially updates the WorkflowExecutionOptions of an existing workflow execution.

    • pauseActivity

      public com.google.common.util.concurrent.ListenableFuture<PauseActivityResponse> pauseActivity(PauseActivityRequest request)
       PauseActivity pauses the execution of an activity specified by its ID or type.
 If there are multiple pending activities of the provided type - all of them will be paused
 Pausing an activity means:
 - If the activity is currently waiting for a retry or is running and subsequently fails,
   it will not be rescheduled until it is unpaused.
 - If the activity is already paused, calling this method will have no effect.
 - If the activity is running and finishes successfully, the activity will be completed.
 - If the activity is running and finishes with failure:
   * if there is no retry left - the activity will be completed.
   * if there are more retries left - the activity will be paused.
 For long-running activities:
 - activities in paused state will send a cancellation with "activity_paused" set to 'true' in response to 'RecordActivityTaskHeartbeat'.
 - The activity should respond to the cancellation accordingly.
 Returns a `NotFound` error if there is no pending activity with the provided ID or type
 This API will be deprecated soon and replaced with a newer PauseActivityExecution that is better named and
 structured to work well for standalone activities.

    • unpauseActivity

      public com.google.common.util.concurrent.ListenableFuture<UnpauseActivityResponse> unpauseActivity(UnpauseActivityRequest request)
       UnpauseActivity unpauses the execution of an activity specified by its ID or type.
 If there are multiple pending activities of the provided type - all of them will be unpaused.
 If activity is not paused, this call will have no effect.
 If the activity was paused while waiting for retry, it will be scheduled immediately (* see 'jitter' flag).
 Once the activity is unpaused, all timeout timers will be regenerated.
 Flags:
 'jitter': the activity will be scheduled at a random time within the jitter duration.
 'reset_attempts': the number of attempts will be reset.
 'reset_heartbeat': the activity heartbeat timer and heartbeats will be reset.
 Returns a `NotFound` error if there is no pending activity with the provided ID or type
 This API will be deprecated soon and replaced with a newer UnpauseActivityExecution that is better named and
 structured to work well for standalone activities.

    • resetActivity

      public com.google.common.util.concurrent.ListenableFuture<ResetActivityResponse> resetActivity(ResetActivityRequest request)
       ResetActivity resets the execution of an activity specified by its ID or type.
 If there are multiple pending activities of the provided type - all of them will be reset.
 Resetting an activity means:
 * number of attempts will be reset to 0.
 * activity timeouts will be reset.
 * if the activity is waiting for retry, and it is not paused or 'keep_paused' is not provided:
    it will be scheduled immediately (* see 'jitter' flag),
 Flags:
 'jitter': the activity will be scheduled at a random time within the jitter duration.
 If the activity currently paused it will be unpaused, unless 'keep_paused' flag is provided.
 'reset_heartbeats': the activity heartbeat timer and heartbeats will be reset.
 'keep_paused': if the activity is paused, it will remain paused.
 Returns a `NotFound` error if there is no pending activity with the provided ID or type.
 This API will be deprecated soon and replaced with a newer ResetActivityExecution that is better named and
 structured to work well for standalone activities.

    • createWorkflowRule

      public com.google.common.util.concurrent.ListenableFuture<CreateWorkflowRuleResponse> createWorkflowRule(CreateWorkflowRuleRequest request)
       Create a new workflow rule. The rules are used to control the workflow execution.
 The rule will be applied to all running and new workflows in the namespace.
 If the rule with such ID already exist this call will fail
 Note: the rules are part of namespace configuration and will be stored in the namespace config.
 Namespace config is eventually consistent.

    • describeWorkflowRule

      public com.google.common.util.concurrent.ListenableFuture<DescribeWorkflowRuleResponse> describeWorkflowRule(DescribeWorkflowRuleRequest request)
       DescribeWorkflowRule return the rule specification for existing rule id.
 If there is no rule with such id - NOT FOUND error will be returned.

    • deleteWorkflowRule

      public com.google.common.util.concurrent.ListenableFuture<DeleteWorkflowRuleResponse> deleteWorkflowRule(DeleteWorkflowRuleRequest request)
       Delete rule by rule id

    • listWorkflowRules

      public com.google.common.util.concurrent.ListenableFuture<ListWorkflowRulesResponse> listWorkflowRules(ListWorkflowRulesRequest request)
       Return all namespace workflow rules

    • triggerWorkflowRule

      public com.google.common.util.concurrent.ListenableFuture<TriggerWorkflowRuleResponse> triggerWorkflowRule(TriggerWorkflowRuleRequest request)
       TriggerWorkflowRule allows to:
  * trigger existing rule for a specific workflow execution;
  * trigger rule for a specific workflow execution without creating a rule;
 This is useful for one-off operations.

    • recordWorkerHeartbeat

      public com.google.common.util.concurrent.ListenableFuture<RecordWorkerHeartbeatResponse> recordWorkerHeartbeat(RecordWorkerHeartbeatRequest request)
       WorkerHeartbeat receive heartbeat request from the worker.

    • listWorkers

      public com.google.common.util.concurrent.ListenableFuture<ListWorkersResponse> listWorkers(ListWorkersRequest request)
       ListWorkers is a visibility API to list worker status information in a specific namespace.

    • countWorkers

      public com.google.common.util.concurrent.ListenableFuture<CountWorkersResponse> countWorkers(CountWorkersRequest request)
       CountWorkers counts the number of workers in a specific namespace.

    • updateTaskQueueConfig

      public com.google.common.util.concurrent.ListenableFuture<UpdateTaskQueueConfigResponse> updateTaskQueueConfig(UpdateTaskQueueConfigRequest request)
       Updates task queue configuration.
 For the overall queue rate limit: the rate limit set by this api overrides the worker-set rate limit,
 which uncouples the rate limit from the worker lifecycle.
 If the overall queue rate limit is unset, the worker-set rate limit takes effect.

    • fetchWorkerConfig

      public com.google.common.util.concurrent.ListenableFuture<FetchWorkerConfigResponse> fetchWorkerConfig(FetchWorkerConfigRequest request)
       FetchWorkerConfig returns the worker configuration for a specific worker.

    • updateWorkerConfig

      public com.google.common.util.concurrent.ListenableFuture<UpdateWorkerConfigResponse> updateWorkerConfig(UpdateWorkerConfigRequest request)
       UpdateWorkerConfig updates the worker configuration of one or more workers.
 Can be used to partially update the worker configuration.
 Can be used to update the configuration of multiple workers.

    • describeWorker

      public com.google.common.util.concurrent.ListenableFuture<DescribeWorkerResponse> describeWorker(DescribeWorkerRequest request)
       DescribeWorker returns information about the specified worker.

    • pauseWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<PauseWorkflowExecutionResponse> pauseWorkflowExecution(PauseWorkflowExecutionRequest request)
       Note: This is an experimental API and the behavior may change in a future release.
 PauseWorkflowExecution pauses the workflow execution specified in the request. Pausing a workflow execution results in
 - The workflow execution status changes to `PAUSED` and a new WORKFLOW_EXECUTION_PAUSED event is added to the history
 - No new workflow tasks or activity tasks are dispatched.
   - Any workflow task currently executing on the worker will be allowed to complete.
   - Any activity task currently executing will be paused.
 - All server-side events will continue to be processed by the server.
 - Queries & Updates on a paused workflow will be rejected.

    • unpauseWorkflowExecution

      public com.google.common.util.concurrent.ListenableFuture<UnpauseWorkflowExecutionResponse> unpauseWorkflowExecution(UnpauseWorkflowExecutionRequest request)
       Note: This is an experimental API and the behavior may change in a future release.
 UnpauseWorkflowExecution unpauses a previously paused workflow execution specified in the request.
 Unpausing a workflow execution results in
 - The workflow execution status changes to `RUNNING` and a new WORKFLOW_EXECUTION_UNPAUSED event is added to the history
 - Workflow tasks and activity tasks are resumed.

    • startActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<StartActivityExecutionResponse> startActivityExecution(StartActivityExecutionRequest request)
       StartActivityExecution starts a new activity execution.
 Returns an `ActivityExecutionAlreadyStarted` error if an instance already exists with same activity ID in this namespace
 unless permitted by the specified ID conflict policy.

    • startNexusOperationExecution

      public com.google.common.util.concurrent.ListenableFuture<StartNexusOperationExecutionResponse> startNexusOperationExecution(StartNexusOperationExecutionRequest request)
       StartNexusOperationExecution starts a new Nexus operation.
 Returns a `NexusOperationExecutionAlreadyStarted` error if an instance already exists with same operation ID in this
 namespace unless permitted by the specified ID conflict policy.

    • describeActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<DescribeActivityExecutionResponse> describeActivityExecution(DescribeActivityExecutionRequest request)
       DescribeActivityExecution returns information about an activity execution.
 It can be used to:
 - Get current activity info without waiting
 - Long-poll for next state change and return new activity info
 Response can optionally include activity input or outcome (if the activity has completed).

    • describeNexusOperationExecution

      public com.google.common.util.concurrent.ListenableFuture<DescribeNexusOperationExecutionResponse> describeNexusOperationExecution(DescribeNexusOperationExecutionRequest request)
       DescribeNexusOperationExecution returns information about a Nexus operation.
 Supported use cases include:
 - Get current operation info without waiting
 - Long-poll for next state change and return new operation info
 Response can optionally include operation input or outcome (if the operation has completed).

    • pollActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<PollActivityExecutionResponse> pollActivityExecution(PollActivityExecutionRequest request)
       PollActivityExecution long-polls for an activity execution to complete and returns the
 outcome (result or failure).

    • pollNexusOperationExecution

      public com.google.common.util.concurrent.ListenableFuture<PollNexusOperationExecutionResponse> pollNexusOperationExecution(PollNexusOperationExecutionRequest request)
       PollNexusOperationExecution long-polls for a Nexus operation for a given wait stage to complete and returns
 the outcome (result or failure).

    • listActivityExecutions

      public com.google.common.util.concurrent.ListenableFuture<ListActivityExecutionsResponse> listActivityExecutions(ListActivityExecutionsRequest request)
       ListActivityExecutions is a visibility API to list activity executions in a specific namespace.

    • listNexusOperationExecutions

      public com.google.common.util.concurrent.ListenableFuture<ListNexusOperationExecutionsResponse> listNexusOperationExecutions(ListNexusOperationExecutionsRequest request)
       ListNexusOperationExecutions is a visibility API to list Nexus operations in a specific namespace.

    • countActivityExecutions

      public com.google.common.util.concurrent.ListenableFuture<CountActivityExecutionsResponse> countActivityExecutions(CountActivityExecutionsRequest request)
       CountActivityExecutions is a visibility API to count activity executions in a specific namespace.

    • countNexusOperationExecutions

      public com.google.common.util.concurrent.ListenableFuture<CountNexusOperationExecutionsResponse> countNexusOperationExecutions(CountNexusOperationExecutionsRequest request)
       CountNexusOperationExecutions is a visibility API to count Nexus operations in a specific namespace.

    • requestCancelActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<RequestCancelActivityExecutionResponse> requestCancelActivityExecution(RequestCancelActivityExecutionRequest request)
       RequestCancelActivityExecution requests cancellation of an activity execution.
 Cancellation is cooperative: this call records the request, but the activity must detect and
 acknowledge it for the activity to reach CANCELED status. The cancellation signal is
 delivered via `cancel_requested` in the heartbeat response; SDKs surface this via
 language-idiomatic mechanisms (context cancellation, exceptions, abort signals).

    • requestCancelNexusOperationExecution

      public com.google.common.util.concurrent.ListenableFuture<RequestCancelNexusOperationExecutionResponse> requestCancelNexusOperationExecution(RequestCancelNexusOperationExecutionRequest request)
       RequestCancelNexusOperationExecution requests cancellation of a Nexus operation.
 Requesting to cancel an operation does not automatically transition the operation to canceled status.
 The operation will only transition to canceled status if it supports cancellation and the handler
 processes the cancellation request.

    • terminateActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<TerminateActivityExecutionResponse> terminateActivityExecution(TerminateActivityExecutionRequest request)
       TerminateActivityExecution terminates an existing activity execution immediately.
 Termination does not reach the worker and the activity code cannot react to it. A terminated activity may have a
 running attempt.

    • deleteActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<DeleteActivityExecutionResponse> deleteActivityExecution(DeleteActivityExecutionRequest request)
       DeleteActivityExecution asynchronously deletes a specific activity execution (when
 ActivityExecution.run_id is provided) or the latest activity execution (when
 ActivityExecution.run_id is not provided). If the activity Execution is running, it will be
 terminated before deletion.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: Activity deletion not exposed to HTTP, users should use cancel or terminate. --)

    • pauseActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<PauseActivityExecutionResponse> pauseActivityExecution(PauseActivityExecutionRequest request)
       PauseActivityExecution pauses the execution of an activity specified by its ID.
 This API can be used to target a workflow activity or a standalone activity
 Pausing an activity means:
 - If the activity is currently waiting for a retry or is running and subsequently fails,
   it will not be rescheduled until it is unpaused.
 - If the activity is already paused, calling this method will have no effect.
 - If the activity is running and finishes successfully, the activity will be completed.
 - If the activity is running and finishes with failure:
   * if there is no retry left - the activity will be completed.
   * if there are more retries left - the activity will be paused.
 For long-running activities:
 - activities in paused state will send a cancellation with "activity_paused" set to 'true' in response to 'RecordActivityTaskHeartbeat'.
 Returns a `NotFound` error if there is no pending activity with the provided ID

    • resetActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<ResetActivityExecutionResponse> resetActivityExecution(ResetActivityExecutionRequest request)
       ResetActivityExecution resets the execution of an activity specified by its ID.
 This API can be used to target a workflow activity or a standalone activity.
 Resetting an activity means:
 * number of attempts will be reset to 0.
 * activity timeouts will be reset.
 * if the activity is waiting for retry, and it is not paused or 'keep_paused' is not provided:
    it will be scheduled immediately (* see 'jitter' flag)
 Returns a `NotFound` error if there is no pending activity with the provided ID or type.

    • unpauseActivityExecution

      public com.google.common.util.concurrent.ListenableFuture<UnpauseActivityExecutionResponse> unpauseActivityExecution(UnpauseActivityExecutionRequest request)
       UnpauseActivityExecution unpauses the execution of an activity specified by its ID.
 This API can be used to target a workflow activity or a standalone activity.
 If activity is not paused, this call will have no effect.
 If the activity was paused while waiting for retry, it will be scheduled immediately (* see 'jitter' flag).
 Once the activity is unpaused, all timeout timers will be regenerated.
 Returns a `NotFound` error if there is no pending activity with the provided ID

    • updateActivityExecutionOptions

      public com.google.common.util.concurrent.ListenableFuture<UpdateActivityExecutionOptionsResponse> updateActivityExecutionOptions(UpdateActivityExecutionOptionsRequest request)
       UpdateActivityExecutionOptions is called by the client to update the options of an activity by its ID.
 This API can be used to target a workflow activity or a standalone activity.

    • terminateNexusOperationExecution

      public com.google.common.util.concurrent.ListenableFuture<TerminateNexusOperationExecutionResponse> terminateNexusOperationExecution(TerminateNexusOperationExecutionRequest request)
       TerminateNexusOperationExecution terminates an existing Nexus operation immediately.
 Termination happens immediately and the operation handler cannot react to it. A terminated operation will have
 its outcome set to a failure with a termination reason.

    • deleteNexusOperationExecution

      public com.google.common.util.concurrent.ListenableFuture<DeleteNexusOperationExecutionResponse> deleteNexusOperationExecution(DeleteNexusOperationExecutionRequest request)
       DeleteNexusOperationExecution asynchronously deletes a specific Nexus operation run (when
 run_id is provided) or the latest run (when run_id is not provided). If the operation
 is running, it will be terminated before deletion.
 (-- api-linter: core::0127::http-annotation=disabled
     aip.dev/not-precedent: Nexus operation deletion not exposed to HTTP, users should use cancel or terminate. --)