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.
com.uber.cadence.internal.sync.TestActivityEnvironmentInternal Maven / Gradle / Ivy
/*
* Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Modifications copyright (C) 2017 Uber Technologies, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not
* use this file except in compliance with the License. A copy of the License is
* located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.uber.cadence.internal.sync;
import com.google.common.base.Defaults;
import com.uber.cadence.ActivityType;
import com.uber.cadence.BadRequestError;
import com.uber.cadence.CancellationAlreadyRequestedError;
import com.uber.cadence.DeprecateDomainRequest;
import com.uber.cadence.DescribeDomainRequest;
import com.uber.cadence.DescribeDomainResponse;
import com.uber.cadence.DescribeTaskListRequest;
import com.uber.cadence.DescribeTaskListResponse;
import com.uber.cadence.DescribeWorkflowExecutionRequest;
import com.uber.cadence.DescribeWorkflowExecutionResponse;
import com.uber.cadence.DomainAlreadyExistsError;
import com.uber.cadence.DomainNotActiveError;
import com.uber.cadence.EntityNotExistsError;
import com.uber.cadence.GetWorkflowExecutionHistoryRequest;
import com.uber.cadence.GetWorkflowExecutionHistoryResponse;
import com.uber.cadence.InternalServiceError;
import com.uber.cadence.LimitExceededError;
import com.uber.cadence.ListClosedWorkflowExecutionsRequest;
import com.uber.cadence.ListClosedWorkflowExecutionsResponse;
import com.uber.cadence.ListDomainsRequest;
import com.uber.cadence.ListDomainsResponse;
import com.uber.cadence.ListOpenWorkflowExecutionsRequest;
import com.uber.cadence.ListOpenWorkflowExecutionsResponse;
import com.uber.cadence.PollForActivityTaskRequest;
import com.uber.cadence.PollForActivityTaskResponse;
import com.uber.cadence.PollForDecisionTaskRequest;
import com.uber.cadence.PollForDecisionTaskResponse;
import com.uber.cadence.QueryFailedError;
import com.uber.cadence.QueryWorkflowRequest;
import com.uber.cadence.QueryWorkflowResponse;
import com.uber.cadence.RecordActivityTaskHeartbeatByIDRequest;
import com.uber.cadence.RecordActivityTaskHeartbeatRequest;
import com.uber.cadence.RecordActivityTaskHeartbeatResponse;
import com.uber.cadence.RegisterDomainRequest;
import com.uber.cadence.RequestCancelWorkflowExecutionRequest;
import com.uber.cadence.ResetStickyTaskListRequest;
import com.uber.cadence.ResetStickyTaskListResponse;
import com.uber.cadence.RespondActivityTaskCanceledByIDRequest;
import com.uber.cadence.RespondActivityTaskCanceledRequest;
import com.uber.cadence.RespondActivityTaskCompletedByIDRequest;
import com.uber.cadence.RespondActivityTaskCompletedRequest;
import com.uber.cadence.RespondActivityTaskFailedByIDRequest;
import com.uber.cadence.RespondActivityTaskFailedRequest;
import com.uber.cadence.RespondDecisionTaskCompletedRequest;
import com.uber.cadence.RespondDecisionTaskCompletedResponse;
import com.uber.cadence.RespondDecisionTaskFailedRequest;
import com.uber.cadence.RespondQueryTaskCompletedRequest;
import com.uber.cadence.ServiceBusyError;
import com.uber.cadence.SignalWithStartWorkflowExecutionRequest;
import com.uber.cadence.SignalWorkflowExecutionRequest;
import com.uber.cadence.StartWorkflowExecutionRequest;
import com.uber.cadence.StartWorkflowExecutionResponse;
import com.uber.cadence.TerminateWorkflowExecutionRequest;
import com.uber.cadence.UpdateDomainRequest;
import com.uber.cadence.UpdateDomainResponse;
import com.uber.cadence.WorkflowExecution;
import com.uber.cadence.WorkflowExecutionAlreadyStartedError;
import com.uber.cadence.activity.ActivityOptions;
import com.uber.cadence.activity.LocalActivityOptions;
import com.uber.cadence.internal.metrics.NoopScope;
import com.uber.cadence.internal.worker.ActivityTaskHandler;
import com.uber.cadence.internal.worker.ActivityTaskHandler.Result;
import com.uber.cadence.serviceclient.IWorkflowService;
import com.uber.cadence.testing.TestActivityEnvironment;
import com.uber.cadence.testing.TestEnvironmentOptions;
import com.uber.cadence.workflow.ActivityFailureException;
import com.uber.cadence.workflow.ChildWorkflowOptions;
import com.uber.cadence.workflow.ContinueAsNewOptions;
import com.uber.cadence.workflow.Functions.Func;
import com.uber.cadence.workflow.Functions.Func1;
import com.uber.cadence.workflow.Promise;
import com.uber.cadence.workflow.Workflow;
import com.uber.cadence.workflow.WorkflowInterceptor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Objects;
import java.util.Optional;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Supplier;
import org.apache.thrift.TException;
import org.apache.thrift.async.AsyncMethodCallback;
public final class TestActivityEnvironmentInternal implements TestActivityEnvironment {
private final POJOActivityTaskHandler activityTaskHandler;
private final TestEnvironmentOptions testEnvironmentOptions;
private final AtomicInteger idSequencer = new AtomicInteger();
private ClassConsumerPair activityHeartbetListener;
private static final ScheduledExecutorService heartbeatExecutor =
Executors.newScheduledThreadPool(20);
private IWorkflowService workflowService;
public TestActivityEnvironmentInternal(TestEnvironmentOptions options) {
if (options == null) {
this.testEnvironmentOptions = new TestEnvironmentOptions.Builder().build();
} else {
this.testEnvironmentOptions = options;
}
activityTaskHandler =
new POJOActivityTaskHandler(
new WorkflowServiceWrapper(workflowService),
testEnvironmentOptions.getDomain(),
testEnvironmentOptions.getDataConverter(),
heartbeatExecutor);
}
/**
* Register activity implementation objects with a worker. Overwrites previously registered
* objects. As activities are reentrant and stateless only one instance per activity type is
* registered.
*
* Implementations that share a worker must implement different interfaces as an activity type
* is identified by the activity interface, not by the implementation.
*
*
*/
@Override
public void registerActivitiesImplementations(Object... activityImplementations) {
activityTaskHandler.setActivitiesImplementation(activityImplementations);
}
/**
* Creates client stub to activities that implement given interface.
*
* @param activityInterface interface type implemented by activities
*/
@Override
public T newActivityStub(Class activityInterface) {
ActivityOptions options =
new ActivityOptions.Builder().setScheduleToCloseTimeout(Duration.ofDays(1)).build();
InvocationHandler invocationHandler =
ActivityInvocationHandler.newInstance(options, new TestActivityExecutor(workflowService));
invocationHandler = new DeterministicRunnerWrapper(invocationHandler);
return ActivityInvocationHandlerBase.newProxy(activityInterface, invocationHandler);
}
@Override
public void setActivityHeartbeatListener(Class detailsClass, Consumer listener) {
setActivityHeartbeatListener(detailsClass, detailsClass, listener);
}
@Override
@SuppressWarnings("unchecked")
public void setActivityHeartbeatListener(
Class detailsClass, Type detailsType, Consumer listener) {
activityHeartbetListener = new ClassConsumerPair(detailsClass, detailsType, listener);
}
@Override
public void setWorkflowService(IWorkflowService workflowService) {
IWorkflowService service = new WorkflowServiceWrapper(workflowService);
this.workflowService = service;
this.activityTaskHandler.setWorkflowService(service);
}
private class TestActivityExecutor implements WorkflowInterceptor {
@SuppressWarnings("UnusedVariable")
private final IWorkflowService workflowService;
TestActivityExecutor(IWorkflowService workflowService) {
this.workflowService = workflowService;
}
@Override
public Promise executeActivity(
String activityType,
Class resultClass,
Type resultType,
Object[] args,
ActivityOptions options) {
PollForActivityTaskResponse task = new PollForActivityTaskResponse();
task.setScheduleToCloseTimeoutSeconds((int) options.getScheduleToCloseTimeout().getSeconds());
task.setHeartbeatTimeoutSeconds((int) options.getHeartbeatTimeout().getSeconds());
task.setStartToCloseTimeoutSeconds((int) options.getStartToCloseTimeout().getSeconds());
task.setScheduledTimestamp(Duration.ofMillis(System.currentTimeMillis()).toNanos());
task.setStartedTimestamp(Duration.ofMillis(System.currentTimeMillis()).toNanos());
task.setInput(testEnvironmentOptions.getDataConverter().toData(args));
task.setTaskToken("test-task-token".getBytes(StandardCharsets.UTF_8));
task.setActivityId(String.valueOf(idSequencer.incrementAndGet()));
task.setWorkflowExecution(
new WorkflowExecution()
.setWorkflowId("test-workflow-id")
.setRunId(UUID.randomUUID().toString()));
task.setActivityType(new ActivityType().setName(activityType));
Result taskResult =
activityTaskHandler.handle(options.getTaskList(), task, NoopScope.getInstance());
return Workflow.newPromise(getReply(task, taskResult, resultClass, resultType));
}
@Override
public Promise executeLocalActivity(
String activityName,
Class resultClass,
Type resultType,
Object[] args,
LocalActivityOptions options) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public WorkflowResult executeChildWorkflow(
String workflowType,
Class resultClass,
Type resultType,
Object[] args,
ChildWorkflowOptions options) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public Random newRandom() {
throw new UnsupportedOperationException("not implemented");
}
@Override
public Promise signalExternalWorkflow(
WorkflowExecution execution, String signalName, Object[] args) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public Promise cancelWorkflow(WorkflowExecution execution) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public void sleep(Duration duration) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public boolean await(Duration timeout, String reason, Supplier unblockCondition) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public void await(String reason, Supplier unblockCondition) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public Promise newTimer(Duration duration) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public R sideEffect(Class resultClass, Type resultType, Func func) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public R mutableSideEffect(
String id, Class resultClass, Type resultType, BiPredicate updated, Func func) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public int getVersion(String changeID, int minSupported, int maxSupported) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public void continueAsNew(
Optional workflowType, Optional options, Object[] args) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public void registerQuery(String queryType, Type[] argTypes, Func1 callback) {
throw new UnsupportedOperationException("not implemented");
}
@Override
public UUID randomUUID() {
throw new UnsupportedOperationException("not implemented");
}
private T getReply(
PollForActivityTaskResponse task,
ActivityTaskHandler.Result response,
Class resultClass,
Type resultType) {
RespondActivityTaskCompletedRequest taskCompleted = response.getTaskCompleted();
if (taskCompleted != null) {
return testEnvironmentOptions
.getDataConverter()
.fromData(taskCompleted.getResult(), resultClass, resultType);
} else {
RespondActivityTaskFailedRequest taskFailed =
response.getTaskFailedResult().getTaskFailedRequest();
if (taskFailed != null) {
String causeClassName = taskFailed.getReason();
Class causeClass;
Exception cause;
try {
@SuppressWarnings("unchecked") // cc is just to have a place to put this annotation
Class cc =
(Class) Class.forName(causeClassName);
causeClass = cc;
cause =
testEnvironmentOptions
.getDataConverter()
.fromData(taskFailed.getDetails(), causeClass, causeClass);
} catch (Exception e) {
cause = e;
}
throw new ActivityFailureException(
0, task.getActivityType(), task.getActivityId(), cause);
} else {
RespondActivityTaskCanceledRequest taskCancelled = response.getTaskCancelled();
if (taskCancelled != null) {
throw new CancellationException(
new String(taskCancelled.getDetails(), StandardCharsets.UTF_8));
}
}
}
return Defaults.defaultValue(resultClass);
}
}
private static class ClassConsumerPair {
final Consumer consumer;
final Class valueClass;
final Type valueType;
ClassConsumerPair(Class valueClass, Type valueType, Consumer consumer) {
this.valueClass = Objects.requireNonNull(valueClass);
this.valueType = Objects.requireNonNull(valueType);
this.consumer = Objects.requireNonNull(consumer);
}
}
private class WorkflowServiceWrapper implements IWorkflowService {
private final IWorkflowService impl;
private WorkflowServiceWrapper(IWorkflowService impl) {
if (impl == null) {
// Create empty implementation that just ignores all requests.
this.impl =
(IWorkflowService)
Proxy.newProxyInstance(
WorkflowServiceWrapper.class.getClassLoader(),
new Class[] {IWorkflowService.class},
(proxy, method, args) -> {
// noop
return method.getReturnType().getDeclaredConstructor().newInstance();
});
} else {
this.impl = impl;
}
}
@Override
public RecordActivityTaskHeartbeatResponse RecordActivityTaskHeartbeat(
RecordActivityTaskHeartbeatRequest heartbeatRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
if (activityHeartbetListener != null) {
Object details =
testEnvironmentOptions
.getDataConverter()
.fromData(
heartbeatRequest.getDetails(),
activityHeartbetListener.valueClass,
activityHeartbetListener.valueType);
activityHeartbetListener.consumer.accept(details);
}
// TODO: Cancellation
return impl.RecordActivityTaskHeartbeat(heartbeatRequest);
}
@Override
public RecordActivityTaskHeartbeatResponse RecordActivityTaskHeartbeatByID(
RecordActivityTaskHeartbeatByIDRequest heartbeatRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, DomainNotActiveError,
LimitExceededError, ServiceBusyError, TException {
return impl.RecordActivityTaskHeartbeatByID(heartbeatRequest);
}
@Override
public void RespondActivityTaskCompleted(RespondActivityTaskCompletedRequest completeRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondActivityTaskCompleted(completeRequest);
}
@Override
public void RespondActivityTaskCompletedByID(
RespondActivityTaskCompletedByIDRequest completeRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondActivityTaskCompletedByID(completeRequest);
}
@Override
public void RespondActivityTaskFailed(RespondActivityTaskFailedRequest failRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondActivityTaskFailed(failRequest);
}
@Override
public void RespondActivityTaskFailedByID(RespondActivityTaskFailedByIDRequest failRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondActivityTaskFailedByID(failRequest);
}
@Override
public void RespondActivityTaskCanceled(RespondActivityTaskCanceledRequest canceledRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondActivityTaskCanceled(canceledRequest);
}
@Override
public void RespondActivityTaskCanceledByID(
RespondActivityTaskCanceledByIDRequest canceledRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondActivityTaskCanceledByID(canceledRequest);
}
@Override
public void RequestCancelWorkflowExecution(RequestCancelWorkflowExecutionRequest cancelRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError,
CancellationAlreadyRequestedError, ServiceBusyError, TException {
impl.RequestCancelWorkflowExecution(cancelRequest);
}
@Override
public void SignalWorkflowExecution(SignalWorkflowExecutionRequest signalRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, ServiceBusyError,
TException {
impl.SignalWorkflowExecution(signalRequest);
}
@Override
public StartWorkflowExecutionResponse SignalWithStartWorkflowExecution(
SignalWithStartWorkflowExecutionRequest signalWithStartRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, ServiceBusyError,
DomainNotActiveError, LimitExceededError, WorkflowExecutionAlreadyStartedError,
TException {
return impl.SignalWithStartWorkflowExecution(signalWithStartRequest);
}
@Override
public void TerminateWorkflowExecution(TerminateWorkflowExecutionRequest terminateRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, ServiceBusyError,
TException {
impl.TerminateWorkflowExecution(terminateRequest);
}
@Override
public ListOpenWorkflowExecutionsResponse ListOpenWorkflowExecutions(
ListOpenWorkflowExecutionsRequest listRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, ServiceBusyError,
TException {
return impl.ListOpenWorkflowExecutions(listRequest);
}
@Override
public ListClosedWorkflowExecutionsResponse ListClosedWorkflowExecutions(
ListClosedWorkflowExecutionsRequest listRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, ServiceBusyError,
TException {
return impl.ListClosedWorkflowExecutions(listRequest);
}
@Override
public void RespondQueryTaskCompleted(RespondQueryTaskCompletedRequest completeRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondQueryTaskCompleted(completeRequest);
}
@Override
public ResetStickyTaskListResponse ResetStickyTaskList(ResetStickyTaskListRequest resetRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, LimitExceededError,
ServiceBusyError, DomainNotActiveError, TException {
return impl.ResetStickyTaskList(resetRequest);
}
@Override
public QueryWorkflowResponse QueryWorkflow(QueryWorkflowRequest queryRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, QueryFailedError,
TException {
return impl.QueryWorkflow(queryRequest);
}
@Override
public DescribeWorkflowExecutionResponse DescribeWorkflowExecution(
DescribeWorkflowExecutionRequest describeRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
return impl.DescribeWorkflowExecution(describeRequest);
}
@Override
public DescribeTaskListResponse DescribeTaskList(DescribeTaskListRequest request)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
return impl.DescribeTaskList(request);
}
@Override
public void RegisterDomain(
RegisterDomainRequest registerRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RegisterDomain(registerRequest, resultHandler);
}
@Override
public void DescribeDomain(
DescribeDomainRequest describeRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.DescribeDomain(describeRequest, resultHandler);
}
@Override
public void ListDomains(ListDomainsRequest listRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.ListDomains(listRequest, resultHandler);
}
@Override
public void UpdateDomain(UpdateDomainRequest updateRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.UpdateDomain(updateRequest, resultHandler);
}
@Override
public void DeprecateDomain(
DeprecateDomainRequest deprecateRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.DeprecateDomain(deprecateRequest, resultHandler);
}
@Override
public void StartWorkflowExecution(
StartWorkflowExecutionRequest startRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.StartWorkflowExecution(startRequest, resultHandler);
}
@Override
public void GetWorkflowExecutionHistory(
GetWorkflowExecutionHistoryRequest getRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.GetWorkflowExecutionHistory(getRequest, resultHandler);
}
@Override
public void PollForDecisionTask(
PollForDecisionTaskRequest pollRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.PollForDecisionTask(pollRequest, resultHandler);
}
@Override
public void RespondDecisionTaskCompleted(
RespondDecisionTaskCompletedRequest completeRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondDecisionTaskCompleted(completeRequest, resultHandler);
}
@Override
public void RespondDecisionTaskFailed(
RespondDecisionTaskFailedRequest failedRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondDecisionTaskFailed(failedRequest, resultHandler);
}
@Override
public void PollForActivityTask(
PollForActivityTaskRequest pollRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.PollForActivityTask(pollRequest, resultHandler);
}
@Override
public void RecordActivityTaskHeartbeat(
RecordActivityTaskHeartbeatRequest heartbeatRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RecordActivityTaskHeartbeat(heartbeatRequest, resultHandler);
}
@Override
public void RecordActivityTaskHeartbeatByID(
RecordActivityTaskHeartbeatByIDRequest heartbeatRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RecordActivityTaskHeartbeatByID(heartbeatRequest, resultHandler);
}
@Override
public void RespondActivityTaskCompleted(
RespondActivityTaskCompletedRequest completeRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondActivityTaskCompleted(completeRequest, resultHandler);
}
@Override
public void RespondActivityTaskCompletedByID(
RespondActivityTaskCompletedByIDRequest completeRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondActivityTaskCompletedByID(completeRequest, resultHandler);
}
@Override
public void RespondActivityTaskFailed(
RespondActivityTaskFailedRequest failRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondActivityTaskFailed(failRequest, resultHandler);
}
@Override
public void RespondActivityTaskFailedByID(
RespondActivityTaskFailedByIDRequest failRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondActivityTaskFailedByID(failRequest, resultHandler);
}
@Override
public void RespondActivityTaskCanceled(
RespondActivityTaskCanceledRequest canceledRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondActivityTaskCanceled(canceledRequest, resultHandler);
}
@Override
public void RespondActivityTaskCanceledByID(
RespondActivityTaskCanceledByIDRequest canceledRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondActivityTaskCanceledByID(canceledRequest, resultHandler);
}
@Override
public void RequestCancelWorkflowExecution(
RequestCancelWorkflowExecutionRequest cancelRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RequestCancelWorkflowExecution(cancelRequest, resultHandler);
}
@Override
public void SignalWorkflowExecution(
SignalWorkflowExecutionRequest signalRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.SignalWorkflowExecution(signalRequest, resultHandler);
}
@Override
public void SignalWithStartWorkflowExecution(
SignalWithStartWorkflowExecutionRequest signalWithStartRequest,
AsyncMethodCallback resultHandler)
throws TException {
impl.SignalWithStartWorkflowExecution(signalWithStartRequest, resultHandler);
}
@Override
public void TerminateWorkflowExecution(
TerminateWorkflowExecutionRequest terminateRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.TerminateWorkflowExecution(terminateRequest, resultHandler);
}
@Override
public void ListOpenWorkflowExecutions(
ListOpenWorkflowExecutionsRequest listRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.ListOpenWorkflowExecutions(listRequest, resultHandler);
}
@Override
public void ListClosedWorkflowExecutions(
ListClosedWorkflowExecutionsRequest listRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.ListClosedWorkflowExecutions(listRequest, resultHandler);
}
@Override
public void RespondQueryTaskCompleted(
RespondQueryTaskCompletedRequest completeRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.RespondQueryTaskCompleted(completeRequest, resultHandler);
}
@Override
public void ResetStickyTaskList(
ResetStickyTaskListRequest resetRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.ResetStickyTaskList(resetRequest, resultHandler);
}
@Override
public void QueryWorkflow(QueryWorkflowRequest queryRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.QueryWorkflow(queryRequest, resultHandler);
}
@Override
public void DescribeWorkflowExecution(
DescribeWorkflowExecutionRequest describeRequest, AsyncMethodCallback resultHandler)
throws TException {
impl.DescribeWorkflowExecution(describeRequest, resultHandler);
}
@Override
public void DescribeTaskList(DescribeTaskListRequest request, AsyncMethodCallback resultHandler)
throws TException {
impl.DescribeTaskList(request, resultHandler);
}
@Override
public void RegisterDomain(RegisterDomainRequest registerRequest)
throws BadRequestError, InternalServiceError, DomainAlreadyExistsError, TException {
impl.RegisterDomain(registerRequest);
}
@Override
public DescribeDomainResponse DescribeDomain(DescribeDomainRequest describeRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
return impl.DescribeDomain(describeRequest);
}
@Override
public ListDomainsResponse ListDomains(ListDomainsRequest listRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, ServiceBusyError,
TException {
return impl.ListDomains(listRequest);
}
@Override
public UpdateDomainResponse UpdateDomain(UpdateDomainRequest updateRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
return impl.UpdateDomain(updateRequest);
}
@Override
public void DeprecateDomain(DeprecateDomainRequest deprecateRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.DeprecateDomain(deprecateRequest);
}
@Override
public StartWorkflowExecutionResponse StartWorkflowExecution(
StartWorkflowExecutionRequest startRequest)
throws BadRequestError, InternalServiceError, WorkflowExecutionAlreadyStartedError,
ServiceBusyError, TException {
return impl.StartWorkflowExecution(startRequest);
}
@Override
public GetWorkflowExecutionHistoryResponse GetWorkflowExecutionHistory(
GetWorkflowExecutionHistoryRequest getRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, ServiceBusyError,
TException {
return impl.GetWorkflowExecutionHistory(getRequest);
}
@Override
public PollForDecisionTaskResponse PollForDecisionTask(PollForDecisionTaskRequest pollRequest)
throws BadRequestError, InternalServiceError, ServiceBusyError, TException {
return impl.PollForDecisionTask(pollRequest);
}
@Override
public RespondDecisionTaskCompletedResponse RespondDecisionTaskCompleted(
RespondDecisionTaskCompletedRequest completeRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
return impl.RespondDecisionTaskCompleted(completeRequest);
}
@Override
public void RespondDecisionTaskFailed(RespondDecisionTaskFailedRequest failedRequest)
throws BadRequestError, InternalServiceError, EntityNotExistsError, TException {
impl.RespondDecisionTaskFailed(failedRequest);
}
@Override
public PollForActivityTaskResponse PollForActivityTask(PollForActivityTaskRequest pollRequest)
throws BadRequestError, InternalServiceError, ServiceBusyError, TException {
return impl.PollForActivityTask(pollRequest);
}
@Override
public void close() {
impl.close();
}
}
}
