Package io.temporal.api.workflowservice.v1

Class 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 Detail

      • 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.
 NOTE: Experimental API.

      • 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 worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task,
 then it will be marked as timed out and 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.

      • 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.
 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 `RecordActivityTaskCompleted`. 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.
 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 `RecordActivityTaskCanceled`. 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.
 TODO: Does exclusive here mean *just* the completed event, or also WFT started? Otherwise the task is doomed to time out?

      • 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. --)

      • scanWorkflowExecutions

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

      • 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.

      • 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

      • 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. --)

      • patchSchedule

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

      • updateWorkerBuildIdCompatibility

        public com.google.common.util.concurrent.ListenableFuture<UpdateWorkerBuildIdCompatibilityResponse> updateWorkerBuildIdCompatibility​(UpdateWorkerBuildIdCompatibilityRequest request)
         Deprecated. Use `UpdateWorkerVersioningRules`.
 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. --)

      • 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.
 WARNING: Worker Versioning is not yet stable and the API and behavior may change incompatibly.
 (-- 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.
 WARNING: Worker Versioning is not yet stable and the API and behavior may change incompatibly.

      • getWorkerTaskReachability

        public com.google.common.util.concurrent.ListenableFuture<GetWorkerTaskReachabilityResponse> getWorkerTaskReachability​(GetWorkerTaskReachabilityRequest request)
         Deprecated. Use `DescribeTaskQueue`.
 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`.

      • 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.

      • 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.

      • 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. --)

      • 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.

      • 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

      • 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

      • 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.