Documentation

ServiceClientInterface
in

Table of Contents

Methods

close()  : void
Close the communication channel associated with this stub.
CountWorkflowExecutions()  : CountWorkflowExecutionsResponse
CountWorkflowExecutions is a visibility API to count of workflow executions in a specific namespace.
CreateSchedule()  : CreateScheduleResponse
Creates a new schedule.
CreateWorkflowRule()  : CreateWorkflowRuleResponse
Create a new workflow rule. The rules are used to control the workflow execution.
DeleteSchedule()  : DeleteScheduleResponse
Deletes a schedule, removing it from the system.
DeleteWorkerDeployment()  : DeleteWorkerDeploymentResponse
Deletes records of (an old) Deployment. A deployment can only be deleted if it has no Version in it.
DeleteWorkerDeploymentVersion()  : DeleteWorkerDeploymentVersionResponse
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.
DeleteWorkflowExecution()  : DeleteWorkflowExecutionResponse
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.
DeleteWorkflowRule()  : DeleteWorkflowRuleResponse
Delete rule by rule id
DeprecateNamespace()  : DeprecateNamespaceResponse
DeprecateNamespace is used to update the state of a registered namespace to DEPRECATED.
DescribeBatchOperation()  : DescribeBatchOperationResponse
DescribeBatchOperation returns the information about a batch operation
DescribeDeployment()  : DescribeDeploymentResponse
Describes a worker deployment.
DescribeNamespace()  : DescribeNamespaceResponse
DescribeNamespace returns the information and configuration for a registered namespace.
DescribeSchedule()  : DescribeScheduleResponse
Returns the schedule description and current state of an existing schedule.
DescribeTaskQueue()  : DescribeTaskQueueResponse
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
DescribeWorkerDeployment()  : DescribeWorkerDeploymentResponse
Describes a Worker Deployment.
DescribeWorkerDeploymentVersion()  : DescribeWorkerDeploymentVersionResponse
Describes a worker deployment version.
DescribeWorkflowExecution()  : DescribeWorkflowExecutionResponse
DescribeWorkflowExecution returns information about the specified workflow execution.
DescribeWorkflowRule()  : DescribeWorkflowRuleResponse
DescribeWorkflowRule return the rule specification for existing rule id.
ExecuteMultiOperation()  : ExecuteMultiOperationResponse
ExecuteMultiOperation executes multiple operations within a single workflow.
GetClusterInfo()  : GetClusterInfoResponse
GetClusterInfo returns information about temporal cluster
getConnection()  : ConnectionInterface
getContext()  : ContextInterface
GetCurrentDeployment()  : GetCurrentDeploymentResponse
Returns the current deployment (and its info) for a given deployment series.
GetDeploymentReachability()  : GetDeploymentReachabilityResponse
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.
GetSearchAttributes()  : GetSearchAttributesResponse
GetSearchAttributes is a visibility API to get all legal keys that could be used in list APIs
getServerCapabilities()  : ServerCapabilities|null
GetSystemInfo()  : GetSystemInfoResponse
GetSystemInfo returns information about the system.
GetWorkerBuildIdCompatibility()  : GetWorkerBuildIdCompatibilityResponse
Deprecated. Use `GetWorkerVersioningRules`.
GetWorkerTaskReachability()  : GetWorkerTaskReachabilityResponse
Deprecated. Use `DescribeTaskQueue`.
GetWorkerVersioningRules()  : GetWorkerVersioningRulesResponse
Fetches the Build ID assignment and redirect rules for a Task Queue.
GetWorkflowExecutionHistory()  : GetWorkflowExecutionHistoryResponse
GetWorkflowExecutionHistory returns the history of specified workflow execution.
GetWorkflowExecutionHistoryReverse()  : GetWorkflowExecutionHistoryReverseResponse
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.
ListArchivedWorkflowExecutions()  : ListArchivedWorkflowExecutionsResponse
ListArchivedWorkflowExecutions is a visibility API to list archived workflow executions in a specific namespace.
ListBatchOperations()  : ListBatchOperationsResponse
ListBatchOperations returns a list of batch operations
ListClosedWorkflowExecutions()  : ListClosedWorkflowExecutionsResponse
ListClosedWorkflowExecutions is a visibility API to list the closed executions in a specific namespace.
ListDeployments()  : ListDeploymentsResponse
Lists worker deployments in the namespace. Optionally can filter based on deployment series name.
ListNamespaces()  : ListNamespacesResponse
ListNamespaces returns the information and configuration for all namespaces.
ListOpenWorkflowExecutions()  : ListOpenWorkflowExecutionsResponse
ListOpenWorkflowExecutions is a visibility API to list the open executions in a specific namespace.
ListScheduleMatchingTimes()  : ListScheduleMatchingTimesResponse
Lists matching times within a range.
ListSchedules()  : ListSchedulesResponse
List all schedules in a namespace.
ListTaskQueuePartitions()  : ListTaskQueuePartitionsResponse
(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: We do not expose this low-level API to HTTP. --)
ListWorkerDeployments()  : ListWorkerDeploymentsResponse
Lists all Worker Deployments that are tracked in the Namespace.
ListWorkflowExecutions()  : ListWorkflowExecutionsResponse
ListWorkflowExecutions is a visibility API to list workflow executions in a specific namespace.
ListWorkflowRules()  : ListWorkflowRulesResponse
Return all namespace workflow rules
PatchSchedule()  : PatchScheduleResponse
Makes a specific change to a schedule or triggers an immediate action.
PauseActivity()  : PauseActivityResponse
PauseActivity pauses the execution of an activity specified by its ID or type.
PollActivityTaskQueue()  : PollActivityTaskQueueResponse
PollActivityTaskQueue is called by workers to process activity tasks from a specific task queue.
PollNexusTaskQueue()  : PollNexusTaskQueueResponse
PollNexusTaskQueue is a long poll call used by workers to receive Nexus tasks.
PollWorkflowExecutionUpdate()  : PollWorkflowExecutionUpdateResponse
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.
PollWorkflowTaskQueue()  : PollWorkflowTaskQueueResponse
PollWorkflowTaskQueue is called by workers to make progress on workflows.
QueryWorkflow()  : QueryWorkflowResponse
QueryWorkflow requests a query be executed for a specified workflow execution.
RecordActivityTaskHeartbeat()  : RecordActivityTaskHeartbeatResponse
RecordActivityTaskHeartbeat is optionally called by workers while they execute activities.
RecordActivityTaskHeartbeatById()  : RecordActivityTaskHeartbeatByIdResponse
See `RecordActivityTaskHeartbeat`. This version allows clients to record heartbeats by namespace/workflow id/activity id instead of task token.
RegisterNamespace()  : RegisterNamespaceResponse
RegisterNamespace creates a new namespace which can be used as a container for all resources.
RequestCancelWorkflowExecution()  : RequestCancelWorkflowExecutionResponse
RequestCancelWorkflowExecution is called by workers when they want to request cancellation of a workflow execution.
ResetActivity()  : ResetActivityResponse
ResetActivity resets the execution of an activity specified by its ID or type.
ResetStickyTaskQueue()  : ResetStickyTaskQueueResponse
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.
ResetWorkflowExecution()  : ResetWorkflowExecutionResponse
ResetWorkflowExecution will reset an existing workflow execution to a specified `WORKFLOW_TASK_COMPLETED` event (exclusive). It will immediately terminate the current execution instance.
RespondActivityTaskCanceled()  : RespondActivityTaskCanceledResponse
RespondActivityTaskFailed is called by workers when processing an activity task fails.
RespondActivityTaskCanceledById()  : RespondActivityTaskCanceledByIdResponse
See `RecordActivityTaskCanceled`. This version allows clients to record failures by namespace/workflow id/activity id instead of task token.
RespondActivityTaskCompleted()  : RespondActivityTaskCompletedResponse
RespondActivityTaskCompleted is called by workers when they successfully complete an activity task.
RespondActivityTaskCompletedById()  : RespondActivityTaskCompletedByIdResponse
See `RecordActivityTaskCompleted`. This version allows clients to record completions by namespace/workflow id/activity id instead of task token.
RespondActivityTaskFailed()  : RespondActivityTaskFailedResponse
RespondActivityTaskFailed is called by workers when processing an activity task fails.
RespondActivityTaskFailedById()  : RespondActivityTaskFailedByIdResponse
See `RecordActivityTaskFailed`. This version allows clients to record failures by namespace/workflow id/activity id instead of task token.
RespondNexusTaskCompleted()  : RespondNexusTaskCompletedResponse
RespondNexusTaskCompleted is called by workers to respond to Nexus tasks received via PollNexusTaskQueue.
RespondNexusTaskFailed()  : RespondNexusTaskFailedResponse
RespondNexusTaskFailed is called by workers to fail Nexus tasks received via PollNexusTaskQueue.
RespondQueryTaskCompleted()  : RespondQueryTaskCompletedResponse
RespondQueryTaskCompleted is called by workers to complete queries which were delivered on the `query` (not `queries`) field of a `PollWorkflowTaskQueueResponse`.
RespondWorkflowTaskCompleted()  : RespondWorkflowTaskCompletedResponse
RespondWorkflowTaskCompleted is called by workers to successfully complete workflow tasks they received from `PollWorkflowTaskQueue`.
RespondWorkflowTaskFailed()  : RespondWorkflowTaskFailedResponse
RespondWorkflowTaskFailed is called by workers to indicate the processing of a workflow task failed.
ScanWorkflowExecutions()  : ScanWorkflowExecutionsResponse
ScanWorkflowExecutions is a visibility API to list large amount of workflow executions in a specific namespace without order.
SetCurrentDeployment()  : SetCurrentDeploymentResponse
Sets a deployment as the current deployment for its deployment series. Can optionally update the metadata of the deployment as well.
SetWorkerDeploymentCurrentVersion()  : SetWorkerDeploymentCurrentVersionResponse
Set/unset the Current Version of a Worker Deployment. Automatically unsets the Ramping Version if it is the Version being set as Current.
SetWorkerDeploymentRampingVersion()  : SetWorkerDeploymentRampingVersionResponse
Set/unset the Ramping Version of a Worker Deployment and its ramp percentage.
ShutdownWorker()  : ShutdownWorkerResponse
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.
SignalWithStartWorkflowExecution()  : SignalWithStartWorkflowExecutionResponse
SignalWithStartWorkflowExecution is used to ensure a signal is sent to a workflow, even if it isn't yet started.
SignalWorkflowExecution()  : SignalWorkflowExecutionResponse
SignalWorkflowExecution is used to send a signal to a running workflow execution.
StartBatchOperation()  : StartBatchOperationResponse
StartBatchOperation starts a new batch operation
StartWorkflowExecution()  : StartWorkflowExecutionResponse
StartWorkflowExecution starts a new workflow execution.
StopBatchOperation()  : StopBatchOperationResponse
StopBatchOperation stops a batch operation
TerminateWorkflowExecution()  : TerminateWorkflowExecutionResponse
TerminateWorkflowExecution terminates an existing workflow execution by recording a `WORKFLOW_EXECUTION_TERMINATED` event in the history and immediately terminating the execution instance.
TriggerWorkflowRule()  : TriggerWorkflowRuleResponse
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.
UnpauseActivity()  : UnpauseActivityResponse
UnpauseActivity unpauses the execution of an activity specified by its ID or type.
UpdateActivityOptions()  : UpdateActivityOptionsResponse
UpdateActivityOptions is called by the client to update the options of an activity by its ID or type.
UpdateNamespace()  : UpdateNamespaceResponse
UpdateNamespace is used to update the information and configuration of a registered namespace.
UpdateSchedule()  : UpdateScheduleResponse
Changes the configuration or state of an existing schedule.
UpdateWorkerBuildIdCompatibility()  : UpdateWorkerBuildIdCompatibilityResponse
Deprecated. Use `UpdateWorkerVersioningRules`.
UpdateWorkerDeploymentVersionMetadata()  : UpdateWorkerDeploymentVersionMetadataResponse
Updates the user-given metadata attached to a Worker Deployment Version.
UpdateWorkerVersioningRules()  : UpdateWorkerVersioningRulesResponse
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.
UpdateWorkflowExecution()  : UpdateWorkflowExecutionResponse
Invokes the specified Update function on user Workflow code.
UpdateWorkflowExecutionOptions()  : UpdateWorkflowExecutionOptionsResponse
UpdateWorkflowExecutionOptions partially updates the WorkflowExecutionOptions of an existing workflow execution.
withAuthKey()  : static
withContext()  : static

Methods

CountWorkflowExecutions()

CountWorkflowExecutions is a visibility API to count of workflow executions in a specific namespace.

public CountWorkflowExecutions(CountWorkflowExecutionsRequest $arg[, ContextInterface|null $ctx = null ]) : CountWorkflowExecutionsResponse
Parameters
$arg : CountWorkflowExecutionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
CountWorkflowExecutionsResponse

CreateWorkflowRule()

Create a new workflow rule. The rules are used to control the workflow execution.

public CreateWorkflowRule(CreateWorkflowRuleRequest $arg[, ContextInterface|null $ctx = null ]) : CreateWorkflowRuleResponse

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.

Parameters
$arg : CreateWorkflowRuleRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
CreateWorkflowRuleResponse

DeleteWorkerDeployment()

Deletes records of (an old) Deployment. A deployment can only be deleted if it has no Version in it.

public DeleteWorkerDeployment(DeleteWorkerDeploymentRequest $arg[, ContextInterface|null $ctx = null ]) : DeleteWorkerDeploymentResponse

Experimental. This API might significantly change or be removed in a future release.

Parameters
$arg : DeleteWorkerDeploymentRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DeleteWorkerDeploymentResponse

DeleteWorkerDeploymentVersion()

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.

public DeleteWorkerDeploymentVersion(DeleteWorkerDeploymentVersionRequest $arg[, ContextInterface|null $ctx = null ]) : DeleteWorkerDeploymentVersionResponse
  • 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.
Parameters
$arg : DeleteWorkerDeploymentVersionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DeleteWorkerDeploymentVersionResponse

DeleteWorkflowExecution()

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.

public DeleteWorkflowExecution(DeleteWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : DeleteWorkflowExecutionResponse

(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: Workflow deletion not exposed to HTTP, users should use cancel or terminate. --)

Parameters
$arg : DeleteWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DeleteWorkflowExecutionResponse

DeprecateNamespace()

DeprecateNamespace is used to update the state of a registered namespace to DEPRECATED.

public DeprecateNamespace(DeprecateNamespaceRequest $arg[, ContextInterface|null $ctx = null ]) : DeprecateNamespaceResponse

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

Parameters
$arg : DeprecateNamespaceRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DeprecateNamespaceResponse

DescribeBatchOperation()

DescribeBatchOperation returns the information about a batch operation

public DescribeBatchOperation(DescribeBatchOperationRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeBatchOperationResponse
Parameters
$arg : DescribeBatchOperationRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeBatchOperationResponse

DescribeDeployment()

Describes a worker deployment.

public DescribeDeployment(DescribeDeploymentRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeDeploymentResponse

Experimental. This API might significantly change or be removed in a future release. Deprecated. Replaced with DescribeWorkerDeploymentVersion.

Parameters
$arg : DescribeDeploymentRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeDeploymentResponse

DescribeNamespace()

DescribeNamespace returns the information and configuration for a registered namespace.

public DescribeNamespace(DescribeNamespaceRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeNamespaceResponse
Parameters
$arg : DescribeNamespaceRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeNamespaceResponse

DescribeSchedule()

Returns the schedule description and current state of an existing schedule.

public DescribeSchedule(DescribeScheduleRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeScheduleResponse
Parameters
$arg : DescribeScheduleRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeScheduleResponse

DescribeTaskQueue()

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

public DescribeTaskQueue(DescribeTaskQueueRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeTaskQueueResponse
Parameters
$arg : DescribeTaskQueueRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeTaskQueueResponse

DescribeWorkerDeployment()

Describes a Worker Deployment.

public DescribeWorkerDeployment(DescribeWorkerDeploymentRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeWorkerDeploymentResponse

Experimental. This API might significantly change or be removed in a future release.

Parameters
$arg : DescribeWorkerDeploymentRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeWorkerDeploymentResponse

DescribeWorkerDeploymentVersion()

Describes a worker deployment version.

public DescribeWorkerDeploymentVersion(DescribeWorkerDeploymentVersionRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeWorkerDeploymentVersionResponse

Experimental. This API might significantly change or be removed in a future release.

Parameters
$arg : DescribeWorkerDeploymentVersionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeWorkerDeploymentVersionResponse

DescribeWorkflowExecution()

DescribeWorkflowExecution returns information about the specified workflow execution.

public DescribeWorkflowExecution(DescribeWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeWorkflowExecutionResponse
Parameters
$arg : DescribeWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeWorkflowExecutionResponse

DescribeWorkflowRule()

DescribeWorkflowRule return the rule specification for existing rule id.

public DescribeWorkflowRule(DescribeWorkflowRuleRequest $arg[, ContextInterface|null $ctx = null ]) : DescribeWorkflowRuleResponse

If there is no rule with such id - NOT FOUND error will be returned.

Parameters
$arg : DescribeWorkflowRuleRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
DescribeWorkflowRuleResponse

ExecuteMultiOperation()

ExecuteMultiOperation executes multiple operations within a single workflow.

public ExecuteMultiOperation(ExecuteMultiOperationRequest $arg[, ContextInterface|null $ctx = null ]) : ExecuteMultiOperationResponse

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.

Parameters
$arg : ExecuteMultiOperationRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ExecuteMultiOperationResponse

GetCurrentDeployment()

Returns the current deployment (and its info) for a given deployment series.

public GetCurrentDeployment(GetCurrentDeploymentRequest $arg[, ContextInterface|null $ctx = null ]) : GetCurrentDeploymentResponse

Experimental. This API might significantly change or be removed in a future release. Deprecated. Replaced by current_version returned by DescribeWorkerDeployment.

Parameters
$arg : GetCurrentDeploymentRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetCurrentDeploymentResponse

GetDeploymentReachability()

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.

public GetDeploymentReachability(GetDeploymentReachabilityRequest $arg[, ContextInterface|null $ctx = null ]) : GetDeploymentReachabilityResponse

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.

Parameters
$arg : GetDeploymentReachabilityRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetDeploymentReachabilityResponse

GetSearchAttributes()

GetSearchAttributes is a visibility API to get all legal keys that could be used in list APIs

public GetSearchAttributes(GetSearchAttributesRequest $arg[, ContextInterface|null $ctx = null ]) : GetSearchAttributesResponse

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

Parameters
$arg : GetSearchAttributesRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetSearchAttributesResponse

GetWorkerBuildIdCompatibility()

Deprecated. Use `GetWorkerVersioningRules`.

public GetWorkerBuildIdCompatibility(GetWorkerBuildIdCompatibilityRequest $arg[, ContextInterface|null $ctx = null ]) : GetWorkerBuildIdCompatibilityResponse

Fetches the worker build id versioning sets for a task queue.

Parameters
$arg : GetWorkerBuildIdCompatibilityRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetWorkerBuildIdCompatibilityResponse

GetWorkerTaskReachability()

Deprecated. Use `DescribeTaskQueue`.

public GetWorkerTaskReachability(GetWorkerTaskReachabilityRequest $arg[, ContextInterface|null $ctx = null ]) : GetWorkerTaskReachabilityResponse

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.

Parameters
$arg : GetWorkerTaskReachabilityRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetWorkerTaskReachabilityResponse

GetWorkerVersioningRules()

Fetches the Build ID assignment and redirect rules for a Task Queue.

public GetWorkerVersioningRules(GetWorkerVersioningRulesRequest $arg[, ContextInterface|null $ctx = null ]) : GetWorkerVersioningRulesResponse

WARNING: Worker Versioning is not yet stable and the API and behavior may change incompatibly.

Parameters
$arg : GetWorkerVersioningRulesRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetWorkerVersioningRulesResponse

GetWorkflowExecutionHistory()

GetWorkflowExecutionHistory returns the history of specified workflow execution.

public GetWorkflowExecutionHistory(GetWorkflowExecutionHistoryRequest $arg[, ContextInterface|null $ctx = null ]) : GetWorkflowExecutionHistoryResponse

Fails with NotFound if the specified workflow execution is unknown to the service.

Parameters
$arg : GetWorkflowExecutionHistoryRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetWorkflowExecutionHistoryResponse

GetWorkflowExecutionHistoryReverse()

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.

public GetWorkflowExecutionHistoryReverse(GetWorkflowExecutionHistoryReverseRequest $arg[, ContextInterface|null $ctx = null ]) : GetWorkflowExecutionHistoryReverseResponse
Parameters
$arg : GetWorkflowExecutionHistoryReverseRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
GetWorkflowExecutionHistoryReverseResponse

ListArchivedWorkflowExecutions()

ListArchivedWorkflowExecutions is a visibility API to list archived workflow executions in a specific namespace.

public ListArchivedWorkflowExecutions(ListArchivedWorkflowExecutionsRequest $arg[, ContextInterface|null $ctx = null ]) : ListArchivedWorkflowExecutionsResponse
Parameters
$arg : ListArchivedWorkflowExecutionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListArchivedWorkflowExecutionsResponse

ListClosedWorkflowExecutions()

ListClosedWorkflowExecutions is a visibility API to list the closed executions in a specific namespace.

public ListClosedWorkflowExecutions(ListClosedWorkflowExecutionsRequest $arg[, ContextInterface|null $ctx = null ]) : ListClosedWorkflowExecutionsResponse

(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)

Parameters
$arg : ListClosedWorkflowExecutionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListClosedWorkflowExecutionsResponse

ListDeployments()

Lists worker deployments in the namespace. Optionally can filter based on deployment series name.

public ListDeployments(ListDeploymentsRequest $arg[, ContextInterface|null $ctx = null ]) : ListDeploymentsResponse

Experimental. This API might significantly change or be removed in a future release. Deprecated. Replaced with ListWorkerDeployments.

Parameters
$arg : ListDeploymentsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListDeploymentsResponse

ListOpenWorkflowExecutions()

ListOpenWorkflowExecutions is a visibility API to list the open executions in a specific namespace.

public ListOpenWorkflowExecutions(ListOpenWorkflowExecutionsRequest $arg[, ContextInterface|null $ctx = null ]) : ListOpenWorkflowExecutionsResponse

(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)

Parameters
$arg : ListOpenWorkflowExecutionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListOpenWorkflowExecutionsResponse

ListScheduleMatchingTimes()

Lists matching times within a range.

public ListScheduleMatchingTimes(ListScheduleMatchingTimesRequest $arg[, ContextInterface|null $ctx = null ]) : ListScheduleMatchingTimesResponse
Parameters
$arg : ListScheduleMatchingTimesRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListScheduleMatchingTimesResponse

ListTaskQueuePartitions()

(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: We do not expose this low-level API to HTTP. --)

public ListTaskQueuePartitions(ListTaskQueuePartitionsRequest $arg[, ContextInterface|null $ctx = null ]) : ListTaskQueuePartitionsResponse
Parameters
$arg : ListTaskQueuePartitionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListTaskQueuePartitionsResponse

ListWorkerDeployments()

Lists all Worker Deployments that are tracked in the Namespace.

public ListWorkerDeployments(ListWorkerDeploymentsRequest $arg[, ContextInterface|null $ctx = null ]) : ListWorkerDeploymentsResponse

Experimental. This API might significantly change or be removed in a future release.

Parameters
$arg : ListWorkerDeploymentsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListWorkerDeploymentsResponse

ListWorkflowExecutions()

ListWorkflowExecutions is a visibility API to list workflow executions in a specific namespace.

public ListWorkflowExecutions(ListWorkflowExecutionsRequest $arg[, ContextInterface|null $ctx = null ]) : ListWorkflowExecutionsResponse
Parameters
$arg : ListWorkflowExecutionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ListWorkflowExecutionsResponse

PauseActivity()

PauseActivity pauses the execution of an activity specified by its ID or type.

public PauseActivity(PauseActivityRequest $arg[, ContextInterface|null $ctx = null ]) : PauseActivityResponse

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

Parameters
$arg : PauseActivityRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
PauseActivityResponse

PollActivityTaskQueue()

PollActivityTaskQueue is called by workers to process activity tasks from a specific task queue.

public PollActivityTaskQueue(PollActivityTaskQueueRequest $arg[, ContextInterface|null $ctx = null ]) : PollActivityTaskQueueResponse

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

Parameters
$arg : PollActivityTaskQueueRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
PollActivityTaskQueueResponse

PollNexusTaskQueue()

PollNexusTaskQueue is a long poll call used by workers to receive Nexus tasks.

public PollNexusTaskQueue(PollNexusTaskQueueRequest $arg[, ContextInterface|null $ctx = null ]) : PollNexusTaskQueueResponse

(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: We do not expose worker API to HTTP. --)

Parameters
$arg : PollNexusTaskQueueRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
PollNexusTaskQueueResponse

PollWorkflowExecutionUpdate()

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.

public PollWorkflowExecutionUpdate(PollWorkflowExecutionUpdateRequest $arg[, ContextInterface|null $ctx = null ]) : PollWorkflowExecutionUpdateResponse

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

Parameters
$arg : PollWorkflowExecutionUpdateRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
PollWorkflowExecutionUpdateResponse

PollWorkflowTaskQueue()

PollWorkflowTaskQueue is called by workers to make progress on workflows.

public PollWorkflowTaskQueue(PollWorkflowTaskQueueRequest $arg[, ContextInterface|null $ctx = null ]) : PollWorkflowTaskQueueResponse

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

Parameters
$arg : PollWorkflowTaskQueueRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
PollWorkflowTaskQueueResponse

RecordActivityTaskHeartbeat()

RecordActivityTaskHeartbeat is optionally called by workers while they execute activities.

public RecordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest $arg[, ContextInterface|null $ctx = null ]) : RecordActivityTaskHeartbeatResponse

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.

Parameters
$arg : RecordActivityTaskHeartbeatRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RecordActivityTaskHeartbeatResponse

RecordActivityTaskHeartbeatById()

See `RecordActivityTaskHeartbeat`. This version allows clients to record heartbeats by namespace/workflow id/activity id instead of task token.

public RecordActivityTaskHeartbeatById(RecordActivityTaskHeartbeatByIdRequest $arg[, ContextInterface|null $ctx = null ]) : RecordActivityTaskHeartbeatByIdResponse

(-- api-linter: core::0136::prepositions=disabled aip.dev/not-precedent: "By" is used to indicate request type. --)

Parameters
$arg : RecordActivityTaskHeartbeatByIdRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RecordActivityTaskHeartbeatByIdResponse

RegisterNamespace()

RegisterNamespace creates a new namespace which can be used as a container for all resources.

public RegisterNamespace(RegisterNamespaceRequest $arg[, ContextInterface|null $ctx = null ]) : RegisterNamespaceResponse

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.

Parameters
$arg : RegisterNamespaceRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RegisterNamespaceResponse

RequestCancelWorkflowExecution()

RequestCancelWorkflowExecution is called by workers when they want to request cancellation of a workflow execution.

public RequestCancelWorkflowExecution(RequestCancelWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : RequestCancelWorkflowExecutionResponse

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.

Parameters
$arg : RequestCancelWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RequestCancelWorkflowExecutionResponse

ResetActivity()

ResetActivity resets the execution of an activity specified by its ID or type.

public ResetActivity(ResetActivityRequest $arg[, ContextInterface|null $ctx = null ]) : ResetActivityResponse

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.

Parameters
$arg : ResetActivityRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ResetActivityResponse

ResetStickyTaskQueue()

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.

public ResetStickyTaskQueue(ResetStickyTaskQueueRequest $arg[, ContextInterface|null $ctx = null ]) : ResetStickyTaskQueueResponse

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

Parameters
$arg : ResetStickyTaskQueueRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ResetStickyTaskQueueResponse

ResetWorkflowExecution()

ResetWorkflowExecution will reset an existing workflow execution to a specified `WORKFLOW_TASK_COMPLETED` event (exclusive). It will immediately terminate the current execution instance.

public ResetWorkflowExecution(ResetWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : ResetWorkflowExecutionResponse

TODO: Does exclusive here mean just the completed event, or also WFT started? Otherwise the task is doomed to time out?

Parameters
$arg : ResetWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ResetWorkflowExecutionResponse

RespondActivityTaskCanceled()

RespondActivityTaskFailed is called by workers when processing an activity task fails.

public RespondActivityTaskCanceled(RespondActivityTaskCanceledRequest $arg[, ContextInterface|null $ctx = null ]) : RespondActivityTaskCanceledResponse

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.

Parameters
$arg : RespondActivityTaskCanceledRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondActivityTaskCanceledResponse

RespondActivityTaskCanceledById()

See `RecordActivityTaskCanceled`. This version allows clients to record failures by namespace/workflow id/activity id instead of task token.

public RespondActivityTaskCanceledById(RespondActivityTaskCanceledByIdRequest $arg[, ContextInterface|null $ctx = null ]) : RespondActivityTaskCanceledByIdResponse

(-- api-linter: core::0136::prepositions=disabled aip.dev/not-precedent: "By" is used to indicate request type. --)

Parameters
$arg : RespondActivityTaskCanceledByIdRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondActivityTaskCanceledByIdResponse

RespondActivityTaskCompleted()

RespondActivityTaskCompleted is called by workers when they successfully complete an activity task.

public RespondActivityTaskCompleted(RespondActivityTaskCompletedRequest $arg[, ContextInterface|null $ctx = null ]) : RespondActivityTaskCompletedResponse

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.

Parameters
$arg : RespondActivityTaskCompletedRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondActivityTaskCompletedResponse

RespondActivityTaskCompletedById()

See `RecordActivityTaskCompleted`. This version allows clients to record completions by namespace/workflow id/activity id instead of task token.

public RespondActivityTaskCompletedById(RespondActivityTaskCompletedByIdRequest $arg[, ContextInterface|null $ctx = null ]) : RespondActivityTaskCompletedByIdResponse

(-- api-linter: core::0136::prepositions=disabled aip.dev/not-precedent: "By" is used to indicate request type. --)

Parameters
$arg : RespondActivityTaskCompletedByIdRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondActivityTaskCompletedByIdResponse

RespondActivityTaskFailed()

RespondActivityTaskFailed is called by workers when processing an activity task fails.

public RespondActivityTaskFailed(RespondActivityTaskFailedRequest $arg[, ContextInterface|null $ctx = null ]) : RespondActivityTaskFailedResponse

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.

Parameters
$arg : RespondActivityTaskFailedRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondActivityTaskFailedResponse

RespondActivityTaskFailedById()

See `RecordActivityTaskFailed`. This version allows clients to record failures by namespace/workflow id/activity id instead of task token.

public RespondActivityTaskFailedById(RespondActivityTaskFailedByIdRequest $arg[, ContextInterface|null $ctx = null ]) : RespondActivityTaskFailedByIdResponse

(-- api-linter: core::0136::prepositions=disabled aip.dev/not-precedent: "By" is used to indicate request type. --)

Parameters
$arg : RespondActivityTaskFailedByIdRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondActivityTaskFailedByIdResponse

RespondNexusTaskCompleted()

RespondNexusTaskCompleted is called by workers to respond to Nexus tasks received via PollNexusTaskQueue.

public RespondNexusTaskCompleted(RespondNexusTaskCompletedRequest $arg[, ContextInterface|null $ctx = null ]) : RespondNexusTaskCompletedResponse

(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: We do not expose worker API to HTTP. --)

Parameters
$arg : RespondNexusTaskCompletedRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondNexusTaskCompletedResponse

RespondNexusTaskFailed()

RespondNexusTaskFailed is called by workers to fail Nexus tasks received via PollNexusTaskQueue.

public RespondNexusTaskFailed(RespondNexusTaskFailedRequest $arg[, ContextInterface|null $ctx = null ]) : RespondNexusTaskFailedResponse

(-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: We do not expose worker API to HTTP. --)

Parameters
$arg : RespondNexusTaskFailedRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondNexusTaskFailedResponse

RespondQueryTaskCompleted()

RespondQueryTaskCompleted is called by workers to complete queries which were delivered on the `query` (not `queries`) field of a `PollWorkflowTaskQueueResponse`.

public RespondQueryTaskCompleted(RespondQueryTaskCompletedRequest $arg[, ContextInterface|null $ctx = null ]) : RespondQueryTaskCompletedResponse

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

Parameters
$arg : RespondQueryTaskCompletedRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondQueryTaskCompletedResponse

RespondWorkflowTaskCompleted()

RespondWorkflowTaskCompleted is called by workers to successfully complete workflow tasks they received from `PollWorkflowTaskQueue`.

public RespondWorkflowTaskCompleted(RespondWorkflowTaskCompletedRequest $arg[, ContextInterface|null $ctx = null ]) : RespondWorkflowTaskCompletedResponse

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

Parameters
$arg : RespondWorkflowTaskCompletedRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondWorkflowTaskCompletedResponse

RespondWorkflowTaskFailed()

RespondWorkflowTaskFailed is called by workers to indicate the processing of a workflow task failed.

public RespondWorkflowTaskFailed(RespondWorkflowTaskFailedRequest $arg[, ContextInterface|null $ctx = null ]) : RespondWorkflowTaskFailedResponse

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

Parameters
$arg : RespondWorkflowTaskFailedRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
RespondWorkflowTaskFailedResponse

ScanWorkflowExecutions()

ScanWorkflowExecutions is a visibility API to list large amount of workflow executions in a specific namespace without order.

public ScanWorkflowExecutions(ScanWorkflowExecutionsRequest $arg[, ContextInterface|null $ctx = null ]) : ScanWorkflowExecutionsResponse

Deprecated: Replaced with ListWorkflowExecutions. (-- api-linter: core::0127::http-annotation=disabled aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)

Parameters
$arg : ScanWorkflowExecutionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ScanWorkflowExecutionsResponse

SetCurrentDeployment()

Sets a deployment as the current deployment for its deployment series. Can optionally update the metadata of the deployment as well.

public SetCurrentDeployment(SetCurrentDeploymentRequest $arg[, ContextInterface|null $ctx = null ]) : SetCurrentDeploymentResponse

Experimental. This API might significantly change or be removed in a future release. Deprecated. Replaced by SetWorkerDeploymentCurrentVersion.

Parameters
$arg : SetCurrentDeploymentRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
SetCurrentDeploymentResponse

SetWorkerDeploymentCurrentVersion()

Set/unset the Current Version of a Worker Deployment. Automatically unsets the Ramping Version if it is the Version being set as Current.

public SetWorkerDeploymentCurrentVersion(SetWorkerDeploymentCurrentVersionRequest $arg[, ContextInterface|null $ctx = null ]) : SetWorkerDeploymentCurrentVersionResponse

Experimental. This API might significantly change or be removed in a future release.

Parameters
$arg : SetWorkerDeploymentCurrentVersionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
SetWorkerDeploymentCurrentVersionResponse

SetWorkerDeploymentRampingVersion()

Set/unset the Ramping Version of a Worker Deployment and its ramp percentage.

public SetWorkerDeploymentRampingVersion(SetWorkerDeploymentRampingVersionRequest $arg[, ContextInterface|null $ctx = null ]) : SetWorkerDeploymentRampingVersionResponse

Can be used for gradual ramp to unversioned workers too. Experimental. This API might significantly change or be removed in a future release.

Parameters
$arg : SetWorkerDeploymentRampingVersionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
SetWorkerDeploymentRampingVersionResponse

ShutdownWorker()

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.

public ShutdownWorker(ShutdownWorkerRequest $arg[, ContextInterface|null $ctx = null ]) : ShutdownWorkerResponse

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

Parameters
$arg : ShutdownWorkerRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
ShutdownWorkerResponse

SignalWithStartWorkflowExecution()

SignalWithStartWorkflowExecution is used to ensure a signal is sent to a workflow, even if it isn't yet started.

public SignalWithStartWorkflowExecution(SignalWithStartWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : SignalWithStartWorkflowExecutionResponse

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

Parameters
$arg : SignalWithStartWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
SignalWithStartWorkflowExecutionResponse

SignalWorkflowExecution()

SignalWorkflowExecution is used to send a signal to a running workflow execution.

public SignalWorkflowExecution(SignalWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : SignalWorkflowExecutionResponse

This results in a WORKFLOW_EXECUTION_SIGNALED event recorded in the history and a workflow task being created for the execution.

Parameters
$arg : SignalWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
SignalWorkflowExecutionResponse

StartWorkflowExecution()

StartWorkflowExecution starts a new workflow execution.

public StartWorkflowExecution(StartWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : StartWorkflowExecutionResponse

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.

Parameters
$arg : StartWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
StartWorkflowExecutionResponse

TerminateWorkflowExecution()

TerminateWorkflowExecution terminates an existing workflow execution by recording a `WORKFLOW_EXECUTION_TERMINATED` event in the history and immediately terminating the execution instance.

public TerminateWorkflowExecution(TerminateWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : TerminateWorkflowExecutionResponse
Parameters
$arg : TerminateWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
TerminateWorkflowExecutionResponse

TriggerWorkflowRule()

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.

public TriggerWorkflowRule(TriggerWorkflowRuleRequest $arg[, ContextInterface|null $ctx = null ]) : TriggerWorkflowRuleResponse
Parameters
$arg : TriggerWorkflowRuleRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
TriggerWorkflowRuleResponse

UnpauseActivity()

UnpauseActivity unpauses the execution of an activity specified by its ID or type.

public UnpauseActivity(UnpauseActivityRequest $arg[, ContextInterface|null $ctx = null ]) : UnpauseActivityResponse

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

Parameters
$arg : UnpauseActivityRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UnpauseActivityResponse

UpdateActivityOptions()

UpdateActivityOptions is called by the client to update the options of an activity by its ID or type.

public UpdateActivityOptions(UpdateActivityOptionsRequest $arg[, ContextInterface|null $ctx = null ]) : UpdateActivityOptionsResponse

If there are multiple pending activities of the provided type - all of them will be updated.

Parameters
$arg : UpdateActivityOptionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UpdateActivityOptionsResponse

UpdateNamespace()

UpdateNamespace is used to update the information and configuration of a registered namespace.

public UpdateNamespace(UpdateNamespaceRequest $arg[, ContextInterface|null $ctx = null ]) : UpdateNamespaceResponse
Parameters
$arg : UpdateNamespaceRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UpdateNamespaceResponse

UpdateWorkerBuildIdCompatibility()

Deprecated. Use `UpdateWorkerVersioningRules`.

public UpdateWorkerBuildIdCompatibility(UpdateWorkerBuildIdCompatibilityRequest $arg[, ContextInterface|null $ctx = null ]) : UpdateWorkerBuildIdCompatibilityResponse

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

Parameters
$arg : UpdateWorkerBuildIdCompatibilityRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UpdateWorkerBuildIdCompatibilityResponse

UpdateWorkerDeploymentVersionMetadata()

Updates the user-given metadata attached to a Worker Deployment Version.

public UpdateWorkerDeploymentVersionMetadata(UpdateWorkerDeploymentVersionMetadataRequest $arg[, ContextInterface|null $ctx = null ]) : UpdateWorkerDeploymentVersionMetadataResponse

Experimental. This API might significantly change or be removed in a future release.

Parameters
$arg : UpdateWorkerDeploymentVersionMetadataRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UpdateWorkerDeploymentVersionMetadataResponse

UpdateWorkerVersioningRules()

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.

public UpdateWorkerVersioningRules(UpdateWorkerVersioningRulesRequest $arg[, ContextInterface|null $ctx = null ]) : UpdateWorkerVersioningRulesResponse

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

Parameters
$arg : UpdateWorkerVersioningRulesRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UpdateWorkerVersioningRulesResponse

UpdateWorkflowExecution()

Invokes the specified Update function on user Workflow code.

public UpdateWorkflowExecution(UpdateWorkflowExecutionRequest $arg[, ContextInterface|null $ctx = null ]) : UpdateWorkflowExecutionResponse
Parameters
$arg : UpdateWorkflowExecutionRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UpdateWorkflowExecutionResponse

UpdateWorkflowExecutionOptions()

UpdateWorkflowExecutionOptions partially updates the WorkflowExecutionOptions of an existing workflow execution.

public UpdateWorkflowExecutionOptions(UpdateWorkflowExecutionOptionsRequest $arg[, ContextInterface|null $ctx = null ]) : UpdateWorkflowExecutionOptionsResponse
Parameters
$arg : UpdateWorkflowExecutionOptionsRequest
$ctx : ContextInterface|null = null
Tags
throws
ServiceClientException
Return values
UpdateWorkflowExecutionOptionsResponse

withAuthKey()

public withAuthKey(Stringable|string $key) : static
Parameters
$key : Stringable|string
Return values
static 

        

        
    




    

    

                                

                

                            
    

        On this page

        
    


                

                            

            

    

        

            
Search results