Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.temporal.api.workflowservice.v1.WorkflowServiceGrpc Maven / Gradle / Ivy
package io.temporal.api.workflowservice.v1;
import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
/**
*
* 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.
*
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.34.1)",
comments = "Source: temporal/api/workflowservice/v1/service.proto")
public final class WorkflowServiceGrpc {
private WorkflowServiceGrpc() {}
public static final String SERVICE_NAME = "temporal.api.workflowservice.v1.WorkflowService";
// Static method descriptors that strictly reflect the proto.
private static volatile io.grpc.MethodDescriptor getRegisterNamespaceMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RegisterNamespace",
requestType = io.temporal.api.workflowservice.v1.RegisterNamespaceRequest.class,
responseType = io.temporal.api.workflowservice.v1.RegisterNamespaceResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRegisterNamespaceMethod() {
io.grpc.MethodDescriptor getRegisterNamespaceMethod;
if ((getRegisterNamespaceMethod = WorkflowServiceGrpc.getRegisterNamespaceMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRegisterNamespaceMethod = WorkflowServiceGrpc.getRegisterNamespaceMethod) == null) {
WorkflowServiceGrpc.getRegisterNamespaceMethod = getRegisterNamespaceMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RegisterNamespace"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RegisterNamespaceRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RegisterNamespaceResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RegisterNamespace"))
.build();
}
}
}
return getRegisterNamespaceMethod;
}
private static volatile io.grpc.MethodDescriptor getDescribeNamespaceMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DescribeNamespace",
requestType = io.temporal.api.workflowservice.v1.DescribeNamespaceRequest.class,
responseType = io.temporal.api.workflowservice.v1.DescribeNamespaceResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDescribeNamespaceMethod() {
io.grpc.MethodDescriptor getDescribeNamespaceMethod;
if ((getDescribeNamespaceMethod = WorkflowServiceGrpc.getDescribeNamespaceMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDescribeNamespaceMethod = WorkflowServiceGrpc.getDescribeNamespaceMethod) == null) {
WorkflowServiceGrpc.getDescribeNamespaceMethod = getDescribeNamespaceMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DescribeNamespace"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeNamespaceRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeNamespaceResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DescribeNamespace"))
.build();
}
}
}
return getDescribeNamespaceMethod;
}
private static volatile io.grpc.MethodDescriptor getListNamespacesMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListNamespaces",
requestType = io.temporal.api.workflowservice.v1.ListNamespacesRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListNamespacesResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListNamespacesMethod() {
io.grpc.MethodDescriptor getListNamespacesMethod;
if ((getListNamespacesMethod = WorkflowServiceGrpc.getListNamespacesMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListNamespacesMethod = WorkflowServiceGrpc.getListNamespacesMethod) == null) {
WorkflowServiceGrpc.getListNamespacesMethod = getListNamespacesMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListNamespaces"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListNamespacesRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListNamespacesResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListNamespaces"))
.build();
}
}
}
return getListNamespacesMethod;
}
private static volatile io.grpc.MethodDescriptor getUpdateNamespaceMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "UpdateNamespace",
requestType = io.temporal.api.workflowservice.v1.UpdateNamespaceRequest.class,
responseType = io.temporal.api.workflowservice.v1.UpdateNamespaceResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getUpdateNamespaceMethod() {
io.grpc.MethodDescriptor getUpdateNamespaceMethod;
if ((getUpdateNamespaceMethod = WorkflowServiceGrpc.getUpdateNamespaceMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getUpdateNamespaceMethod = WorkflowServiceGrpc.getUpdateNamespaceMethod) == null) {
WorkflowServiceGrpc.getUpdateNamespaceMethod = getUpdateNamespaceMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateNamespace"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateNamespaceRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateNamespaceResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("UpdateNamespace"))
.build();
}
}
}
return getUpdateNamespaceMethod;
}
private static volatile io.grpc.MethodDescriptor getDeprecateNamespaceMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DeprecateNamespace",
requestType = io.temporal.api.workflowservice.v1.DeprecateNamespaceRequest.class,
responseType = io.temporal.api.workflowservice.v1.DeprecateNamespaceResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDeprecateNamespaceMethod() {
io.grpc.MethodDescriptor getDeprecateNamespaceMethod;
if ((getDeprecateNamespaceMethod = WorkflowServiceGrpc.getDeprecateNamespaceMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDeprecateNamespaceMethod = WorkflowServiceGrpc.getDeprecateNamespaceMethod) == null) {
WorkflowServiceGrpc.getDeprecateNamespaceMethod = getDeprecateNamespaceMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeprecateNamespace"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DeprecateNamespaceRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DeprecateNamespaceResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DeprecateNamespace"))
.build();
}
}
}
return getDeprecateNamespaceMethod;
}
private static volatile io.grpc.MethodDescriptor getStartWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "StartWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.StartWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.StartWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getStartWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getStartWorkflowExecutionMethod;
if ((getStartWorkflowExecutionMethod = WorkflowServiceGrpc.getStartWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getStartWorkflowExecutionMethod = WorkflowServiceGrpc.getStartWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getStartWorkflowExecutionMethod = getStartWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "StartWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.StartWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.StartWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("StartWorkflowExecution"))
.build();
}
}
}
return getStartWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getGetWorkflowExecutionHistoryMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetWorkflowExecutionHistory",
requestType = io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryRequest.class,
responseType = io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetWorkflowExecutionHistoryMethod() {
io.grpc.MethodDescriptor getGetWorkflowExecutionHistoryMethod;
if ((getGetWorkflowExecutionHistoryMethod = WorkflowServiceGrpc.getGetWorkflowExecutionHistoryMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getGetWorkflowExecutionHistoryMethod = WorkflowServiceGrpc.getGetWorkflowExecutionHistoryMethod) == null) {
WorkflowServiceGrpc.getGetWorkflowExecutionHistoryMethod = getGetWorkflowExecutionHistoryMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetWorkflowExecutionHistory"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("GetWorkflowExecutionHistory"))
.build();
}
}
}
return getGetWorkflowExecutionHistoryMethod;
}
private static volatile io.grpc.MethodDescriptor getGetWorkflowExecutionHistoryReverseMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetWorkflowExecutionHistoryReverse",
requestType = io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseRequest.class,
responseType = io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetWorkflowExecutionHistoryReverseMethod() {
io.grpc.MethodDescriptor getGetWorkflowExecutionHistoryReverseMethod;
if ((getGetWorkflowExecutionHistoryReverseMethod = WorkflowServiceGrpc.getGetWorkflowExecutionHistoryReverseMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getGetWorkflowExecutionHistoryReverseMethod = WorkflowServiceGrpc.getGetWorkflowExecutionHistoryReverseMethod) == null) {
WorkflowServiceGrpc.getGetWorkflowExecutionHistoryReverseMethod = getGetWorkflowExecutionHistoryReverseMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetWorkflowExecutionHistoryReverse"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("GetWorkflowExecutionHistoryReverse"))
.build();
}
}
}
return getGetWorkflowExecutionHistoryReverseMethod;
}
private static volatile io.grpc.MethodDescriptor getPollWorkflowTaskQueueMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "PollWorkflowTaskQueue",
requestType = io.temporal.api.workflowservice.v1.PollWorkflowTaskQueueRequest.class,
responseType = io.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getPollWorkflowTaskQueueMethod() {
io.grpc.MethodDescriptor getPollWorkflowTaskQueueMethod;
if ((getPollWorkflowTaskQueueMethod = WorkflowServiceGrpc.getPollWorkflowTaskQueueMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getPollWorkflowTaskQueueMethod = WorkflowServiceGrpc.getPollWorkflowTaskQueueMethod) == null) {
WorkflowServiceGrpc.getPollWorkflowTaskQueueMethod = getPollWorkflowTaskQueueMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "PollWorkflowTaskQueue"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PollWorkflowTaskQueueRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("PollWorkflowTaskQueue"))
.build();
}
}
}
return getPollWorkflowTaskQueueMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondWorkflowTaskCompletedMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondWorkflowTaskCompleted",
requestType = io.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondWorkflowTaskCompletedMethod() {
io.grpc.MethodDescriptor getRespondWorkflowTaskCompletedMethod;
if ((getRespondWorkflowTaskCompletedMethod = WorkflowServiceGrpc.getRespondWorkflowTaskCompletedMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondWorkflowTaskCompletedMethod = WorkflowServiceGrpc.getRespondWorkflowTaskCompletedMethod) == null) {
WorkflowServiceGrpc.getRespondWorkflowTaskCompletedMethod = getRespondWorkflowTaskCompletedMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondWorkflowTaskCompleted"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondWorkflowTaskCompleted"))
.build();
}
}
}
return getRespondWorkflowTaskCompletedMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondWorkflowTaskFailedMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondWorkflowTaskFailed",
requestType = io.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondWorkflowTaskFailedMethod() {
io.grpc.MethodDescriptor getRespondWorkflowTaskFailedMethod;
if ((getRespondWorkflowTaskFailedMethod = WorkflowServiceGrpc.getRespondWorkflowTaskFailedMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondWorkflowTaskFailedMethod = WorkflowServiceGrpc.getRespondWorkflowTaskFailedMethod) == null) {
WorkflowServiceGrpc.getRespondWorkflowTaskFailedMethod = getRespondWorkflowTaskFailedMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondWorkflowTaskFailed"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondWorkflowTaskFailed"))
.build();
}
}
}
return getRespondWorkflowTaskFailedMethod;
}
private static volatile io.grpc.MethodDescriptor getPollActivityTaskQueueMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "PollActivityTaskQueue",
requestType = io.temporal.api.workflowservice.v1.PollActivityTaskQueueRequest.class,
responseType = io.temporal.api.workflowservice.v1.PollActivityTaskQueueResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getPollActivityTaskQueueMethod() {
io.grpc.MethodDescriptor getPollActivityTaskQueueMethod;
if ((getPollActivityTaskQueueMethod = WorkflowServiceGrpc.getPollActivityTaskQueueMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getPollActivityTaskQueueMethod = WorkflowServiceGrpc.getPollActivityTaskQueueMethod) == null) {
WorkflowServiceGrpc.getPollActivityTaskQueueMethod = getPollActivityTaskQueueMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "PollActivityTaskQueue"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PollActivityTaskQueueRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PollActivityTaskQueueResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("PollActivityTaskQueue"))
.build();
}
}
}
return getPollActivityTaskQueueMethod;
}
private static volatile io.grpc.MethodDescriptor getRecordActivityTaskHeartbeatMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RecordActivityTaskHeartbeat",
requestType = io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatRequest.class,
responseType = io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRecordActivityTaskHeartbeatMethod() {
io.grpc.MethodDescriptor getRecordActivityTaskHeartbeatMethod;
if ((getRecordActivityTaskHeartbeatMethod = WorkflowServiceGrpc.getRecordActivityTaskHeartbeatMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRecordActivityTaskHeartbeatMethod = WorkflowServiceGrpc.getRecordActivityTaskHeartbeatMethod) == null) {
WorkflowServiceGrpc.getRecordActivityTaskHeartbeatMethod = getRecordActivityTaskHeartbeatMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RecordActivityTaskHeartbeat"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RecordActivityTaskHeartbeat"))
.build();
}
}
}
return getRecordActivityTaskHeartbeatMethod;
}
private static volatile io.grpc.MethodDescriptor getRecordActivityTaskHeartbeatByIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RecordActivityTaskHeartbeatById",
requestType = io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdRequest.class,
responseType = io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRecordActivityTaskHeartbeatByIdMethod() {
io.grpc.MethodDescriptor getRecordActivityTaskHeartbeatByIdMethod;
if ((getRecordActivityTaskHeartbeatByIdMethod = WorkflowServiceGrpc.getRecordActivityTaskHeartbeatByIdMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRecordActivityTaskHeartbeatByIdMethod = WorkflowServiceGrpc.getRecordActivityTaskHeartbeatByIdMethod) == null) {
WorkflowServiceGrpc.getRecordActivityTaskHeartbeatByIdMethod = getRecordActivityTaskHeartbeatByIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RecordActivityTaskHeartbeatById"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RecordActivityTaskHeartbeatById"))
.build();
}
}
}
return getRecordActivityTaskHeartbeatByIdMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondActivityTaskCompletedMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondActivityTaskCompleted",
requestType = io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondActivityTaskCompletedMethod() {
io.grpc.MethodDescriptor getRespondActivityTaskCompletedMethod;
if ((getRespondActivityTaskCompletedMethod = WorkflowServiceGrpc.getRespondActivityTaskCompletedMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondActivityTaskCompletedMethod = WorkflowServiceGrpc.getRespondActivityTaskCompletedMethod) == null) {
WorkflowServiceGrpc.getRespondActivityTaskCompletedMethod = getRespondActivityTaskCompletedMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondActivityTaskCompleted"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondActivityTaskCompleted"))
.build();
}
}
}
return getRespondActivityTaskCompletedMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondActivityTaskCompletedByIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondActivityTaskCompletedById",
requestType = io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondActivityTaskCompletedByIdMethod() {
io.grpc.MethodDescriptor getRespondActivityTaskCompletedByIdMethod;
if ((getRespondActivityTaskCompletedByIdMethod = WorkflowServiceGrpc.getRespondActivityTaskCompletedByIdMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondActivityTaskCompletedByIdMethod = WorkflowServiceGrpc.getRespondActivityTaskCompletedByIdMethod) == null) {
WorkflowServiceGrpc.getRespondActivityTaskCompletedByIdMethod = getRespondActivityTaskCompletedByIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondActivityTaskCompletedById"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondActivityTaskCompletedById"))
.build();
}
}
}
return getRespondActivityTaskCompletedByIdMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondActivityTaskFailedMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondActivityTaskFailed",
requestType = io.temporal.api.workflowservice.v1.RespondActivityTaskFailedRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondActivityTaskFailedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondActivityTaskFailedMethod() {
io.grpc.MethodDescriptor getRespondActivityTaskFailedMethod;
if ((getRespondActivityTaskFailedMethod = WorkflowServiceGrpc.getRespondActivityTaskFailedMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondActivityTaskFailedMethod = WorkflowServiceGrpc.getRespondActivityTaskFailedMethod) == null) {
WorkflowServiceGrpc.getRespondActivityTaskFailedMethod = getRespondActivityTaskFailedMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondActivityTaskFailed"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskFailedRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskFailedResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondActivityTaskFailed"))
.build();
}
}
}
return getRespondActivityTaskFailedMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondActivityTaskFailedByIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondActivityTaskFailedById",
requestType = io.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondActivityTaskFailedByIdMethod() {
io.grpc.MethodDescriptor getRespondActivityTaskFailedByIdMethod;
if ((getRespondActivityTaskFailedByIdMethod = WorkflowServiceGrpc.getRespondActivityTaskFailedByIdMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondActivityTaskFailedByIdMethod = WorkflowServiceGrpc.getRespondActivityTaskFailedByIdMethod) == null) {
WorkflowServiceGrpc.getRespondActivityTaskFailedByIdMethod = getRespondActivityTaskFailedByIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondActivityTaskFailedById"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondActivityTaskFailedById"))
.build();
}
}
}
return getRespondActivityTaskFailedByIdMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondActivityTaskCanceledMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondActivityTaskCanceled",
requestType = io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondActivityTaskCanceledMethod() {
io.grpc.MethodDescriptor getRespondActivityTaskCanceledMethod;
if ((getRespondActivityTaskCanceledMethod = WorkflowServiceGrpc.getRespondActivityTaskCanceledMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondActivityTaskCanceledMethod = WorkflowServiceGrpc.getRespondActivityTaskCanceledMethod) == null) {
WorkflowServiceGrpc.getRespondActivityTaskCanceledMethod = getRespondActivityTaskCanceledMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondActivityTaskCanceled"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondActivityTaskCanceled"))
.build();
}
}
}
return getRespondActivityTaskCanceledMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondActivityTaskCanceledByIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondActivityTaskCanceledById",
requestType = io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondActivityTaskCanceledByIdMethod() {
io.grpc.MethodDescriptor getRespondActivityTaskCanceledByIdMethod;
if ((getRespondActivityTaskCanceledByIdMethod = WorkflowServiceGrpc.getRespondActivityTaskCanceledByIdMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondActivityTaskCanceledByIdMethod = WorkflowServiceGrpc.getRespondActivityTaskCanceledByIdMethod) == null) {
WorkflowServiceGrpc.getRespondActivityTaskCanceledByIdMethod = getRespondActivityTaskCanceledByIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondActivityTaskCanceledById"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondActivityTaskCanceledById"))
.build();
}
}
}
return getRespondActivityTaskCanceledByIdMethod;
}
private static volatile io.grpc.MethodDescriptor getRequestCancelWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RequestCancelWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRequestCancelWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getRequestCancelWorkflowExecutionMethod;
if ((getRequestCancelWorkflowExecutionMethod = WorkflowServiceGrpc.getRequestCancelWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRequestCancelWorkflowExecutionMethod = WorkflowServiceGrpc.getRequestCancelWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getRequestCancelWorkflowExecutionMethod = getRequestCancelWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RequestCancelWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RequestCancelWorkflowExecution"))
.build();
}
}
}
return getRequestCancelWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getSignalWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "SignalWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.SignalWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.SignalWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getSignalWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getSignalWorkflowExecutionMethod;
if ((getSignalWorkflowExecutionMethod = WorkflowServiceGrpc.getSignalWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getSignalWorkflowExecutionMethod = WorkflowServiceGrpc.getSignalWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getSignalWorkflowExecutionMethod = getSignalWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "SignalWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.SignalWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.SignalWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("SignalWorkflowExecution"))
.build();
}
}
}
return getSignalWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getSignalWithStartWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "SignalWithStartWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getSignalWithStartWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getSignalWithStartWorkflowExecutionMethod;
if ((getSignalWithStartWorkflowExecutionMethod = WorkflowServiceGrpc.getSignalWithStartWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getSignalWithStartWorkflowExecutionMethod = WorkflowServiceGrpc.getSignalWithStartWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getSignalWithStartWorkflowExecutionMethod = getSignalWithStartWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "SignalWithStartWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("SignalWithStartWorkflowExecution"))
.build();
}
}
}
return getSignalWithStartWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getResetWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ResetWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.ResetWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.ResetWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getResetWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getResetWorkflowExecutionMethod;
if ((getResetWorkflowExecutionMethod = WorkflowServiceGrpc.getResetWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getResetWorkflowExecutionMethod = WorkflowServiceGrpc.getResetWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getResetWorkflowExecutionMethod = getResetWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ResetWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ResetWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ResetWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ResetWorkflowExecution"))
.build();
}
}
}
return getResetWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getTerminateWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "TerminateWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.TerminateWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.TerminateWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getTerminateWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getTerminateWorkflowExecutionMethod;
if ((getTerminateWorkflowExecutionMethod = WorkflowServiceGrpc.getTerminateWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getTerminateWorkflowExecutionMethod = WorkflowServiceGrpc.getTerminateWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getTerminateWorkflowExecutionMethod = getTerminateWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "TerminateWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.TerminateWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.TerminateWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("TerminateWorkflowExecution"))
.build();
}
}
}
return getTerminateWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getDeleteWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DeleteWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.DeleteWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.DeleteWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDeleteWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getDeleteWorkflowExecutionMethod;
if ((getDeleteWorkflowExecutionMethod = WorkflowServiceGrpc.getDeleteWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDeleteWorkflowExecutionMethod = WorkflowServiceGrpc.getDeleteWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getDeleteWorkflowExecutionMethod = getDeleteWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DeleteWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DeleteWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DeleteWorkflowExecution"))
.build();
}
}
}
return getDeleteWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getListOpenWorkflowExecutionsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListOpenWorkflowExecutions",
requestType = io.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListOpenWorkflowExecutionsMethod() {
io.grpc.MethodDescriptor getListOpenWorkflowExecutionsMethod;
if ((getListOpenWorkflowExecutionsMethod = WorkflowServiceGrpc.getListOpenWorkflowExecutionsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListOpenWorkflowExecutionsMethod = WorkflowServiceGrpc.getListOpenWorkflowExecutionsMethod) == null) {
WorkflowServiceGrpc.getListOpenWorkflowExecutionsMethod = getListOpenWorkflowExecutionsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListOpenWorkflowExecutions"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListOpenWorkflowExecutions"))
.build();
}
}
}
return getListOpenWorkflowExecutionsMethod;
}
private static volatile io.grpc.MethodDescriptor getListClosedWorkflowExecutionsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListClosedWorkflowExecutions",
requestType = io.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListClosedWorkflowExecutionsMethod() {
io.grpc.MethodDescriptor getListClosedWorkflowExecutionsMethod;
if ((getListClosedWorkflowExecutionsMethod = WorkflowServiceGrpc.getListClosedWorkflowExecutionsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListClosedWorkflowExecutionsMethod = WorkflowServiceGrpc.getListClosedWorkflowExecutionsMethod) == null) {
WorkflowServiceGrpc.getListClosedWorkflowExecutionsMethod = getListClosedWorkflowExecutionsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListClosedWorkflowExecutions"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListClosedWorkflowExecutions"))
.build();
}
}
}
return getListClosedWorkflowExecutionsMethod;
}
private static volatile io.grpc.MethodDescriptor getListWorkflowExecutionsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListWorkflowExecutions",
requestType = io.temporal.api.workflowservice.v1.ListWorkflowExecutionsRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListWorkflowExecutionsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListWorkflowExecutionsMethod() {
io.grpc.MethodDescriptor getListWorkflowExecutionsMethod;
if ((getListWorkflowExecutionsMethod = WorkflowServiceGrpc.getListWorkflowExecutionsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListWorkflowExecutionsMethod = WorkflowServiceGrpc.getListWorkflowExecutionsMethod) == null) {
WorkflowServiceGrpc.getListWorkflowExecutionsMethod = getListWorkflowExecutionsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListWorkflowExecutions"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListWorkflowExecutionsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListWorkflowExecutionsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListWorkflowExecutions"))
.build();
}
}
}
return getListWorkflowExecutionsMethod;
}
private static volatile io.grpc.MethodDescriptor getListArchivedWorkflowExecutionsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListArchivedWorkflowExecutions",
requestType = io.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListArchivedWorkflowExecutionsMethod() {
io.grpc.MethodDescriptor getListArchivedWorkflowExecutionsMethod;
if ((getListArchivedWorkflowExecutionsMethod = WorkflowServiceGrpc.getListArchivedWorkflowExecutionsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListArchivedWorkflowExecutionsMethod = WorkflowServiceGrpc.getListArchivedWorkflowExecutionsMethod) == null) {
WorkflowServiceGrpc.getListArchivedWorkflowExecutionsMethod = getListArchivedWorkflowExecutionsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListArchivedWorkflowExecutions"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListArchivedWorkflowExecutions"))
.build();
}
}
}
return getListArchivedWorkflowExecutionsMethod;
}
private static volatile io.grpc.MethodDescriptor getScanWorkflowExecutionsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ScanWorkflowExecutions",
requestType = io.temporal.api.workflowservice.v1.ScanWorkflowExecutionsRequest.class,
responseType = io.temporal.api.workflowservice.v1.ScanWorkflowExecutionsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getScanWorkflowExecutionsMethod() {
io.grpc.MethodDescriptor getScanWorkflowExecutionsMethod;
if ((getScanWorkflowExecutionsMethod = WorkflowServiceGrpc.getScanWorkflowExecutionsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getScanWorkflowExecutionsMethod = WorkflowServiceGrpc.getScanWorkflowExecutionsMethod) == null) {
WorkflowServiceGrpc.getScanWorkflowExecutionsMethod = getScanWorkflowExecutionsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ScanWorkflowExecutions"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ScanWorkflowExecutionsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ScanWorkflowExecutionsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ScanWorkflowExecutions"))
.build();
}
}
}
return getScanWorkflowExecutionsMethod;
}
private static volatile io.grpc.MethodDescriptor getCountWorkflowExecutionsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "CountWorkflowExecutions",
requestType = io.temporal.api.workflowservice.v1.CountWorkflowExecutionsRequest.class,
responseType = io.temporal.api.workflowservice.v1.CountWorkflowExecutionsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getCountWorkflowExecutionsMethod() {
io.grpc.MethodDescriptor getCountWorkflowExecutionsMethod;
if ((getCountWorkflowExecutionsMethod = WorkflowServiceGrpc.getCountWorkflowExecutionsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getCountWorkflowExecutionsMethod = WorkflowServiceGrpc.getCountWorkflowExecutionsMethod) == null) {
WorkflowServiceGrpc.getCountWorkflowExecutionsMethod = getCountWorkflowExecutionsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "CountWorkflowExecutions"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.CountWorkflowExecutionsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.CountWorkflowExecutionsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("CountWorkflowExecutions"))
.build();
}
}
}
return getCountWorkflowExecutionsMethod;
}
private static volatile io.grpc.MethodDescriptor getGetSearchAttributesMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetSearchAttributes",
requestType = io.temporal.api.workflowservice.v1.GetSearchAttributesRequest.class,
responseType = io.temporal.api.workflowservice.v1.GetSearchAttributesResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetSearchAttributesMethod() {
io.grpc.MethodDescriptor getGetSearchAttributesMethod;
if ((getGetSearchAttributesMethod = WorkflowServiceGrpc.getGetSearchAttributesMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getGetSearchAttributesMethod = WorkflowServiceGrpc.getGetSearchAttributesMethod) == null) {
WorkflowServiceGrpc.getGetSearchAttributesMethod = getGetSearchAttributesMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSearchAttributes"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetSearchAttributesRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetSearchAttributesResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("GetSearchAttributes"))
.build();
}
}
}
return getGetSearchAttributesMethod;
}
private static volatile io.grpc.MethodDescriptor getRespondQueryTaskCompletedMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RespondQueryTaskCompleted",
requestType = io.temporal.api.workflowservice.v1.RespondQueryTaskCompletedRequest.class,
responseType = io.temporal.api.workflowservice.v1.RespondQueryTaskCompletedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRespondQueryTaskCompletedMethod() {
io.grpc.MethodDescriptor getRespondQueryTaskCompletedMethod;
if ((getRespondQueryTaskCompletedMethod = WorkflowServiceGrpc.getRespondQueryTaskCompletedMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getRespondQueryTaskCompletedMethod = WorkflowServiceGrpc.getRespondQueryTaskCompletedMethod) == null) {
WorkflowServiceGrpc.getRespondQueryTaskCompletedMethod = getRespondQueryTaskCompletedMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RespondQueryTaskCompleted"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondQueryTaskCompletedRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.RespondQueryTaskCompletedResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("RespondQueryTaskCompleted"))
.build();
}
}
}
return getRespondQueryTaskCompletedMethod;
}
private static volatile io.grpc.MethodDescriptor getResetStickyTaskQueueMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ResetStickyTaskQueue",
requestType = io.temporal.api.workflowservice.v1.ResetStickyTaskQueueRequest.class,
responseType = io.temporal.api.workflowservice.v1.ResetStickyTaskQueueResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getResetStickyTaskQueueMethod() {
io.grpc.MethodDescriptor getResetStickyTaskQueueMethod;
if ((getResetStickyTaskQueueMethod = WorkflowServiceGrpc.getResetStickyTaskQueueMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getResetStickyTaskQueueMethod = WorkflowServiceGrpc.getResetStickyTaskQueueMethod) == null) {
WorkflowServiceGrpc.getResetStickyTaskQueueMethod = getResetStickyTaskQueueMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ResetStickyTaskQueue"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ResetStickyTaskQueueRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ResetStickyTaskQueueResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ResetStickyTaskQueue"))
.build();
}
}
}
return getResetStickyTaskQueueMethod;
}
private static volatile io.grpc.MethodDescriptor getQueryWorkflowMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "QueryWorkflow",
requestType = io.temporal.api.workflowservice.v1.QueryWorkflowRequest.class,
responseType = io.temporal.api.workflowservice.v1.QueryWorkflowResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getQueryWorkflowMethod() {
io.grpc.MethodDescriptor getQueryWorkflowMethod;
if ((getQueryWorkflowMethod = WorkflowServiceGrpc.getQueryWorkflowMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getQueryWorkflowMethod = WorkflowServiceGrpc.getQueryWorkflowMethod) == null) {
WorkflowServiceGrpc.getQueryWorkflowMethod = getQueryWorkflowMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "QueryWorkflow"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.QueryWorkflowRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.QueryWorkflowResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("QueryWorkflow"))
.build();
}
}
}
return getQueryWorkflowMethod;
}
private static volatile io.grpc.MethodDescriptor getDescribeWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DescribeWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.DescribeWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.DescribeWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDescribeWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getDescribeWorkflowExecutionMethod;
if ((getDescribeWorkflowExecutionMethod = WorkflowServiceGrpc.getDescribeWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDescribeWorkflowExecutionMethod = WorkflowServiceGrpc.getDescribeWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getDescribeWorkflowExecutionMethod = getDescribeWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DescribeWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DescribeWorkflowExecution"))
.build();
}
}
}
return getDescribeWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getDescribeTaskQueueMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DescribeTaskQueue",
requestType = io.temporal.api.workflowservice.v1.DescribeTaskQueueRequest.class,
responseType = io.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDescribeTaskQueueMethod() {
io.grpc.MethodDescriptor getDescribeTaskQueueMethod;
if ((getDescribeTaskQueueMethod = WorkflowServiceGrpc.getDescribeTaskQueueMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDescribeTaskQueueMethod = WorkflowServiceGrpc.getDescribeTaskQueueMethod) == null) {
WorkflowServiceGrpc.getDescribeTaskQueueMethod = getDescribeTaskQueueMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DescribeTaskQueue"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeTaskQueueRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DescribeTaskQueue"))
.build();
}
}
}
return getDescribeTaskQueueMethod;
}
private static volatile io.grpc.MethodDescriptor getGetClusterInfoMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetClusterInfo",
requestType = io.temporal.api.workflowservice.v1.GetClusterInfoRequest.class,
responseType = io.temporal.api.workflowservice.v1.GetClusterInfoResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetClusterInfoMethod() {
io.grpc.MethodDescriptor getGetClusterInfoMethod;
if ((getGetClusterInfoMethod = WorkflowServiceGrpc.getGetClusterInfoMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getGetClusterInfoMethod = WorkflowServiceGrpc.getGetClusterInfoMethod) == null) {
WorkflowServiceGrpc.getGetClusterInfoMethod = getGetClusterInfoMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClusterInfo"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetClusterInfoRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetClusterInfoResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("GetClusterInfo"))
.build();
}
}
}
return getGetClusterInfoMethod;
}
private static volatile io.grpc.MethodDescriptor getGetSystemInfoMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetSystemInfo",
requestType = io.temporal.api.workflowservice.v1.GetSystemInfoRequest.class,
responseType = io.temporal.api.workflowservice.v1.GetSystemInfoResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetSystemInfoMethod() {
io.grpc.MethodDescriptor getGetSystemInfoMethod;
if ((getGetSystemInfoMethod = WorkflowServiceGrpc.getGetSystemInfoMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getGetSystemInfoMethod = WorkflowServiceGrpc.getGetSystemInfoMethod) == null) {
WorkflowServiceGrpc.getGetSystemInfoMethod = getGetSystemInfoMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSystemInfo"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetSystemInfoRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetSystemInfoResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("GetSystemInfo"))
.build();
}
}
}
return getGetSystemInfoMethod;
}
private static volatile io.grpc.MethodDescriptor getListTaskQueuePartitionsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListTaskQueuePartitions",
requestType = io.temporal.api.workflowservice.v1.ListTaskQueuePartitionsRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListTaskQueuePartitionsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListTaskQueuePartitionsMethod() {
io.grpc.MethodDescriptor getListTaskQueuePartitionsMethod;
if ((getListTaskQueuePartitionsMethod = WorkflowServiceGrpc.getListTaskQueuePartitionsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListTaskQueuePartitionsMethod = WorkflowServiceGrpc.getListTaskQueuePartitionsMethod) == null) {
WorkflowServiceGrpc.getListTaskQueuePartitionsMethod = getListTaskQueuePartitionsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListTaskQueuePartitions"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListTaskQueuePartitionsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListTaskQueuePartitionsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListTaskQueuePartitions"))
.build();
}
}
}
return getListTaskQueuePartitionsMethod;
}
private static volatile io.grpc.MethodDescriptor getCreateScheduleMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "CreateSchedule",
requestType = io.temporal.api.workflowservice.v1.CreateScheduleRequest.class,
responseType = io.temporal.api.workflowservice.v1.CreateScheduleResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getCreateScheduleMethod() {
io.grpc.MethodDescriptor getCreateScheduleMethod;
if ((getCreateScheduleMethod = WorkflowServiceGrpc.getCreateScheduleMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getCreateScheduleMethod = WorkflowServiceGrpc.getCreateScheduleMethod) == null) {
WorkflowServiceGrpc.getCreateScheduleMethod = getCreateScheduleMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateSchedule"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.CreateScheduleRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.CreateScheduleResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("CreateSchedule"))
.build();
}
}
}
return getCreateScheduleMethod;
}
private static volatile io.grpc.MethodDescriptor getDescribeScheduleMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DescribeSchedule",
requestType = io.temporal.api.workflowservice.v1.DescribeScheduleRequest.class,
responseType = io.temporal.api.workflowservice.v1.DescribeScheduleResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDescribeScheduleMethod() {
io.grpc.MethodDescriptor getDescribeScheduleMethod;
if ((getDescribeScheduleMethod = WorkflowServiceGrpc.getDescribeScheduleMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDescribeScheduleMethod = WorkflowServiceGrpc.getDescribeScheduleMethod) == null) {
WorkflowServiceGrpc.getDescribeScheduleMethod = getDescribeScheduleMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DescribeSchedule"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeScheduleRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeScheduleResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DescribeSchedule"))
.build();
}
}
}
return getDescribeScheduleMethod;
}
private static volatile io.grpc.MethodDescriptor getUpdateScheduleMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "UpdateSchedule",
requestType = io.temporal.api.workflowservice.v1.UpdateScheduleRequest.class,
responseType = io.temporal.api.workflowservice.v1.UpdateScheduleResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getUpdateScheduleMethod() {
io.grpc.MethodDescriptor getUpdateScheduleMethod;
if ((getUpdateScheduleMethod = WorkflowServiceGrpc.getUpdateScheduleMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getUpdateScheduleMethod = WorkflowServiceGrpc.getUpdateScheduleMethod) == null) {
WorkflowServiceGrpc.getUpdateScheduleMethod = getUpdateScheduleMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateSchedule"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateScheduleRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateScheduleResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("UpdateSchedule"))
.build();
}
}
}
return getUpdateScheduleMethod;
}
private static volatile io.grpc.MethodDescriptor getPatchScheduleMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "PatchSchedule",
requestType = io.temporal.api.workflowservice.v1.PatchScheduleRequest.class,
responseType = io.temporal.api.workflowservice.v1.PatchScheduleResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getPatchScheduleMethod() {
io.grpc.MethodDescriptor getPatchScheduleMethod;
if ((getPatchScheduleMethod = WorkflowServiceGrpc.getPatchScheduleMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getPatchScheduleMethod = WorkflowServiceGrpc.getPatchScheduleMethod) == null) {
WorkflowServiceGrpc.getPatchScheduleMethod = getPatchScheduleMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchSchedule"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PatchScheduleRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PatchScheduleResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("PatchSchedule"))
.build();
}
}
}
return getPatchScheduleMethod;
}
private static volatile io.grpc.MethodDescriptor getListScheduleMatchingTimesMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListScheduleMatchingTimes",
requestType = io.temporal.api.workflowservice.v1.ListScheduleMatchingTimesRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListScheduleMatchingTimesResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListScheduleMatchingTimesMethod() {
io.grpc.MethodDescriptor getListScheduleMatchingTimesMethod;
if ((getListScheduleMatchingTimesMethod = WorkflowServiceGrpc.getListScheduleMatchingTimesMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListScheduleMatchingTimesMethod = WorkflowServiceGrpc.getListScheduleMatchingTimesMethod) == null) {
WorkflowServiceGrpc.getListScheduleMatchingTimesMethod = getListScheduleMatchingTimesMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListScheduleMatchingTimes"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListScheduleMatchingTimesRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListScheduleMatchingTimesResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListScheduleMatchingTimes"))
.build();
}
}
}
return getListScheduleMatchingTimesMethod;
}
private static volatile io.grpc.MethodDescriptor getDeleteScheduleMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DeleteSchedule",
requestType = io.temporal.api.workflowservice.v1.DeleteScheduleRequest.class,
responseType = io.temporal.api.workflowservice.v1.DeleteScheduleResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDeleteScheduleMethod() {
io.grpc.MethodDescriptor getDeleteScheduleMethod;
if ((getDeleteScheduleMethod = WorkflowServiceGrpc.getDeleteScheduleMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDeleteScheduleMethod = WorkflowServiceGrpc.getDeleteScheduleMethod) == null) {
WorkflowServiceGrpc.getDeleteScheduleMethod = getDeleteScheduleMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteSchedule"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DeleteScheduleRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DeleteScheduleResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DeleteSchedule"))
.build();
}
}
}
return getDeleteScheduleMethod;
}
private static volatile io.grpc.MethodDescriptor getListSchedulesMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListSchedules",
requestType = io.temporal.api.workflowservice.v1.ListSchedulesRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListSchedulesResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListSchedulesMethod() {
io.grpc.MethodDescriptor getListSchedulesMethod;
if ((getListSchedulesMethod = WorkflowServiceGrpc.getListSchedulesMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListSchedulesMethod = WorkflowServiceGrpc.getListSchedulesMethod) == null) {
WorkflowServiceGrpc.getListSchedulesMethod = getListSchedulesMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListSchedules"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListSchedulesRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListSchedulesResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListSchedules"))
.build();
}
}
}
return getListSchedulesMethod;
}
private static volatile io.grpc.MethodDescriptor getUpdateWorkerBuildIdCompatibilityMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "UpdateWorkerBuildIdCompatibility",
requestType = io.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest.class,
responseType = io.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getUpdateWorkerBuildIdCompatibilityMethod() {
io.grpc.MethodDescriptor getUpdateWorkerBuildIdCompatibilityMethod;
if ((getUpdateWorkerBuildIdCompatibilityMethod = WorkflowServiceGrpc.getUpdateWorkerBuildIdCompatibilityMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getUpdateWorkerBuildIdCompatibilityMethod = WorkflowServiceGrpc.getUpdateWorkerBuildIdCompatibilityMethod) == null) {
WorkflowServiceGrpc.getUpdateWorkerBuildIdCompatibilityMethod = getUpdateWorkerBuildIdCompatibilityMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateWorkerBuildIdCompatibility"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("UpdateWorkerBuildIdCompatibility"))
.build();
}
}
}
return getUpdateWorkerBuildIdCompatibilityMethod;
}
private static volatile io.grpc.MethodDescriptor getGetWorkerBuildIdCompatibilityMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetWorkerBuildIdCompatibility",
requestType = io.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityRequest.class,
responseType = io.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetWorkerBuildIdCompatibilityMethod() {
io.grpc.MethodDescriptor getGetWorkerBuildIdCompatibilityMethod;
if ((getGetWorkerBuildIdCompatibilityMethod = WorkflowServiceGrpc.getGetWorkerBuildIdCompatibilityMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getGetWorkerBuildIdCompatibilityMethod = WorkflowServiceGrpc.getGetWorkerBuildIdCompatibilityMethod) == null) {
WorkflowServiceGrpc.getGetWorkerBuildIdCompatibilityMethod = getGetWorkerBuildIdCompatibilityMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetWorkerBuildIdCompatibility"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("GetWorkerBuildIdCompatibility"))
.build();
}
}
}
return getGetWorkerBuildIdCompatibilityMethod;
}
private static volatile io.grpc.MethodDescriptor getGetWorkerTaskReachabilityMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetWorkerTaskReachability",
requestType = io.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityRequest.class,
responseType = io.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetWorkerTaskReachabilityMethod() {
io.grpc.MethodDescriptor getGetWorkerTaskReachabilityMethod;
if ((getGetWorkerTaskReachabilityMethod = WorkflowServiceGrpc.getGetWorkerTaskReachabilityMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getGetWorkerTaskReachabilityMethod = WorkflowServiceGrpc.getGetWorkerTaskReachabilityMethod) == null) {
WorkflowServiceGrpc.getGetWorkerTaskReachabilityMethod = getGetWorkerTaskReachabilityMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetWorkerTaskReachability"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("GetWorkerTaskReachability"))
.build();
}
}
}
return getGetWorkerTaskReachabilityMethod;
}
private static volatile io.grpc.MethodDescriptor getUpdateWorkflowExecutionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "UpdateWorkflowExecution",
requestType = io.temporal.api.workflowservice.v1.UpdateWorkflowExecutionRequest.class,
responseType = io.temporal.api.workflowservice.v1.UpdateWorkflowExecutionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getUpdateWorkflowExecutionMethod() {
io.grpc.MethodDescriptor getUpdateWorkflowExecutionMethod;
if ((getUpdateWorkflowExecutionMethod = WorkflowServiceGrpc.getUpdateWorkflowExecutionMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getUpdateWorkflowExecutionMethod = WorkflowServiceGrpc.getUpdateWorkflowExecutionMethod) == null) {
WorkflowServiceGrpc.getUpdateWorkflowExecutionMethod = getUpdateWorkflowExecutionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateWorkflowExecution"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateWorkflowExecutionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.UpdateWorkflowExecutionResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("UpdateWorkflowExecution"))
.build();
}
}
}
return getUpdateWorkflowExecutionMethod;
}
private static volatile io.grpc.MethodDescriptor getPollWorkflowExecutionUpdateMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "PollWorkflowExecutionUpdate",
requestType = io.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateRequest.class,
responseType = io.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getPollWorkflowExecutionUpdateMethod() {
io.grpc.MethodDescriptor getPollWorkflowExecutionUpdateMethod;
if ((getPollWorkflowExecutionUpdateMethod = WorkflowServiceGrpc.getPollWorkflowExecutionUpdateMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getPollWorkflowExecutionUpdateMethod = WorkflowServiceGrpc.getPollWorkflowExecutionUpdateMethod) == null) {
WorkflowServiceGrpc.getPollWorkflowExecutionUpdateMethod = getPollWorkflowExecutionUpdateMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "PollWorkflowExecutionUpdate"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("PollWorkflowExecutionUpdate"))
.build();
}
}
}
return getPollWorkflowExecutionUpdateMethod;
}
private static volatile io.grpc.MethodDescriptor getStartBatchOperationMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "StartBatchOperation",
requestType = io.temporal.api.workflowservice.v1.StartBatchOperationRequest.class,
responseType = io.temporal.api.workflowservice.v1.StartBatchOperationResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getStartBatchOperationMethod() {
io.grpc.MethodDescriptor getStartBatchOperationMethod;
if ((getStartBatchOperationMethod = WorkflowServiceGrpc.getStartBatchOperationMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getStartBatchOperationMethod = WorkflowServiceGrpc.getStartBatchOperationMethod) == null) {
WorkflowServiceGrpc.getStartBatchOperationMethod = getStartBatchOperationMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "StartBatchOperation"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.StartBatchOperationRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.StartBatchOperationResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("StartBatchOperation"))
.build();
}
}
}
return getStartBatchOperationMethod;
}
private static volatile io.grpc.MethodDescriptor getStopBatchOperationMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "StopBatchOperation",
requestType = io.temporal.api.workflowservice.v1.StopBatchOperationRequest.class,
responseType = io.temporal.api.workflowservice.v1.StopBatchOperationResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getStopBatchOperationMethod() {
io.grpc.MethodDescriptor getStopBatchOperationMethod;
if ((getStopBatchOperationMethod = WorkflowServiceGrpc.getStopBatchOperationMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getStopBatchOperationMethod = WorkflowServiceGrpc.getStopBatchOperationMethod) == null) {
WorkflowServiceGrpc.getStopBatchOperationMethod = getStopBatchOperationMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "StopBatchOperation"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.StopBatchOperationRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.StopBatchOperationResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("StopBatchOperation"))
.build();
}
}
}
return getStopBatchOperationMethod;
}
private static volatile io.grpc.MethodDescriptor getDescribeBatchOperationMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DescribeBatchOperation",
requestType = io.temporal.api.workflowservice.v1.DescribeBatchOperationRequest.class,
responseType = io.temporal.api.workflowservice.v1.DescribeBatchOperationResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDescribeBatchOperationMethod() {
io.grpc.MethodDescriptor getDescribeBatchOperationMethod;
if ((getDescribeBatchOperationMethod = WorkflowServiceGrpc.getDescribeBatchOperationMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getDescribeBatchOperationMethod = WorkflowServiceGrpc.getDescribeBatchOperationMethod) == null) {
WorkflowServiceGrpc.getDescribeBatchOperationMethod = getDescribeBatchOperationMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DescribeBatchOperation"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeBatchOperationRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.DescribeBatchOperationResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("DescribeBatchOperation"))
.build();
}
}
}
return getDescribeBatchOperationMethod;
}
private static volatile io.grpc.MethodDescriptor getListBatchOperationsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ListBatchOperations",
requestType = io.temporal.api.workflowservice.v1.ListBatchOperationsRequest.class,
responseType = io.temporal.api.workflowservice.v1.ListBatchOperationsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getListBatchOperationsMethod() {
io.grpc.MethodDescriptor getListBatchOperationsMethod;
if ((getListBatchOperationsMethod = WorkflowServiceGrpc.getListBatchOperationsMethod) == null) {
synchronized (WorkflowServiceGrpc.class) {
if ((getListBatchOperationsMethod = WorkflowServiceGrpc.getListBatchOperationsMethod) == null) {
WorkflowServiceGrpc.getListBatchOperationsMethod = getListBatchOperationsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListBatchOperations"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListBatchOperationsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
io.temporal.api.workflowservice.v1.ListBatchOperationsResponse.getDefaultInstance()))
.setSchemaDescriptor(new WorkflowServiceMethodDescriptorSupplier("ListBatchOperations"))
.build();
}
}
}
return getListBatchOperationsMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static WorkflowServiceStub newStub(io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public WorkflowServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new WorkflowServiceStub(channel, callOptions);
}
};
return WorkflowServiceStub.newStub(factory, channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static WorkflowServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public WorkflowServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new WorkflowServiceBlockingStub(channel, callOptions);
}
};
return WorkflowServiceBlockingStub.newStub(factory, channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static WorkflowServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public WorkflowServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new WorkflowServiceFutureStub(channel, callOptions);
}
};
return WorkflowServiceFutureStub.newStub(factory, channel);
}
/**
*
* 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.
*
*/
public static abstract class WorkflowServiceImplBase implements io.grpc.BindableService {
/**
*
* 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.
*
*/
public void registerNamespace(io.temporal.api.workflowservice.v1.RegisterNamespaceRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getRegisterNamespaceMethod(), responseObserver);
}
/**
*
* DescribeNamespace returns the information and configuration for a registered namespace.
*
*/
public void describeNamespace(io.temporal.api.workflowservice.v1.DescribeNamespaceRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getDescribeNamespaceMethod(), responseObserver);
}
/**
*
* ListNamespaces returns the information and configuration for all namespaces.
*
*/
public void listNamespaces(io.temporal.api.workflowservice.v1.ListNamespacesRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getListNamespacesMethod(), responseObserver);
}
/**
*
* UpdateNamespace is used to update the information and configuration of a registered
* namespace.
* (-- api-linter: core::0134::method-signature=disabled
* aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)
* (-- api-linter: core::0134::response-message-name=disabled
* aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)
*
*/
public void updateNamespace(io.temporal.api.workflowservice.v1.UpdateNamespaceRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getUpdateNamespaceMethod(), responseObserver);
}
/**
*
* 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.
*
*/
public void deprecateNamespace(io.temporal.api.workflowservice.v1.DeprecateNamespaceRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getDeprecateNamespaceMethod(), responseObserver);
}
/**
*
* 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.
*
*/
public void startWorkflowExecution(io.temporal.api.workflowservice.v1.StartWorkflowExecutionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getStartWorkflowExecutionMethod(), responseObserver);
}
/**
*
* GetWorkflowExecutionHistory returns the history of specified workflow execution. Fails with
* `NotFound` if the specified workflow execution is unknown to the service.
*
*/
public void getWorkflowExecutionHistory(io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getGetWorkflowExecutionHistoryMethod(), responseObserver);
}
/**
*
* 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 void getWorkflowExecutionHistoryReverse(io.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getGetWorkflowExecutionHistoryReverseMethod(), responseObserver);
}
/**
*
* 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.
*
*/
public void pollWorkflowTaskQueue(io.temporal.api.workflowservice.v1.PollWorkflowTaskQueueRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getPollWorkflowTaskQueueMethod(), responseObserver);
}
/**
*
* 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).
*
*/
public void respondWorkflowTaskCompleted(io.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getRespondWorkflowTaskCompletedMethod(), responseObserver);
}
/**
*
* 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.
*
*/
public void respondWorkflowTaskFailed(io.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getRespondWorkflowTaskFailedMethod(), responseObserver);
}
/**
*
* 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.
*
*/
public void pollActivityTaskQueue(io.temporal.api.workflowservice.v1.PollActivityTaskQueueRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getPollActivityTaskQueueMethod(), responseObserver);
}
/**
*
* 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.
*
*/
public void recordActivityTaskHeartbeat(io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getRecordActivityTaskHeartbeatMethod(), responseObserver);
}
/**
*
* 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. --)
*
*/
public void recordActivityTaskHeartbeatById(io.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getRecordActivityTaskHeartbeatByIdMethod(), responseObserver);
}
/**
*
* 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.
*
*/
public void respondActivityTaskCompleted(io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getRespondActivityTaskCompletedMethod(), responseObserver);
}
/**
*
* 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. --)
*
*/
public void respondActivityTaskCompletedById(io.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getRespondActivityTaskCompletedByIdMethod(), responseObserver);
}
/**
* 