com.amazonaws.services.proton.AWSProtonAsyncClient Maven / Gradle / Ivy
/*
* Copyright 2016-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* 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.amazonaws.services.proton;
import javax.annotation.Generated;
import com.amazonaws.services.proton.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing AWS Proton asynchronously. Each asynchronous method will return a Java Future object
* representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
*
* This is the AWS Proton Service API Reference. It provides descriptions, syntax and usage examples for each of the actions and data types for the AWS Proton
* service.
*
*
* The documentation for each action shows the Query API request parameters and the XML response.
*
*
* Alternatively, you can use the AWS CLI to access an API. For more information, see the AWS Command Line Interface User
* Guide.
*
*
* The AWS Proton service is a two-pronged automation framework. Administrators create service templates to provide
* standardized infrastructure and deployment tooling for serverless and container based applications. Developers, in
* turn, select from the available service templates to automate their application or service deployments.
*
*
* Because administrators define the infrastructure and tooling that AWS Proton deploys and manages, they need
* permissions to use all of the listed API operations.
*
*
* When developers select a specific infrastructure and tooling set, AWS Proton deploys their applications. To monitor
* their applications that are running on AWS Proton, developers need permissions to the service create,
* list, update and delete API operations and the service instance list and update
* API operations.
*
*
* To learn more about AWS Proton administration, see the AWS Proton Administration Guide.
*
*
* To learn more about deploying serverless and containerized applications on AWS Proton, see the AWS Proton User Guide.
*
*
* Ensuring Idempotency
*
*
* When you make a mutating API request, the request typically returns a result before the asynchronous workflows of the
* operation are complete. Operations might also time out or encounter other server issues before they're complete, even
* if the request already returned a result. This might make it difficult to determine whether the request succeeded.
* Moreover, you might need to retry the request multiple times to ensure that the operation completes successfully.
* However, if the original request and the subsequent retries are successful, the operation occurs multiple times. This
* means that you might create more resources than you intended.
*
*
* Idempotency ensures that an API request action completes no more than one time. With an idempotent request, if
* the original request action completes successfully, any subsequent retries complete successfully without performing
* any further actions. However, the result might contain updated information, such as the current creation status.
*
*
* The following lists of APIs are grouped according to methods that ensure idempotency.
*
*
* Idempotent create APIs with a client token
*
*
* The API actions in this list support idempotency with the use of a client token. The corresponding AWS CLI
* commands also support idempotency using a client token. A client token is a unique, case-sensitive string of up to 64
* ASCII characters. To make an idempotent API request using one of these actions, specify a client token in the
* request. We recommend that you don't reuse the same client token for other API requests. If you don’t provide
* a client token for these APIs, a default client token is automatically provided by SDKs.
*
*
* Given a request action that has succeeded:
*
*
* If you retry the request using the same client token and the same parameters, the retry succeeds without performing
* any further actions other than returning the original resource detail data in the response.
*
*
* If you retry the request using the same client token, but one or more of the parameters are different, the retry
* throws a ValidationException with an IdempotentParameterMismatch error.
*
*
* Client tokens expire eight hours after a request is made. If you retry the request with the expired token, a new
* resource is created.
*
*
* If the original resource is deleted and you retry the request, a new resource is created.
*
*
* Idempotent create APIs with a client token:
*
*
* -
*
* CreateEnvironmentTemplateVersion
*
*
* -
*
* CreateServiceTemplateVersion
*
*
* -
*
* CreateEnvironmentAccountConnection
*
*
*
*
*
* <p> <b>Idempotent delete APIs</b> </p> <p>Given a request action that has succeeded:</p> <p>When you retry the request with an API from this group and the resource was deleted, its metadata is returned in the response.</p> <p>If you retry and the resource doesn't exist, the response is empty.</p> <p>In both cases, the retry succeeds.</p> <p>Idempotent delete APIs:</p> <ul> <li> <p>DeleteEnvironmentTemplate</p> </li> <li> <p>DeleteEnvironmentTemplateVersion</p> </li> <li> <p>DeleteServiceTemplate</p> </li> <li> <p>DeleteServiceTemplateVersion</p> </li> <li> <p>DeleteEnvironmentAccountConnection</p> </li> </ul> <p> <b>Asynchronous idempotent delete APIs</b> </p> <p>Given a request action that has succeeded:</p> <p>If you retry the request with an API from this group, if the original request delete operation status is <code>DELETE_IN_PROGRESS</code>, the retry returns the resource detail data in the response without performing any further actions.</p> <p>If the original request delete operation is complete, a retry returns an empty response.</p> <p>Asynchronous idempotent delete APIs:</p> <ul> <li> <p>DeleteEnvironment</p> </li> <li> <p>DeleteService</p> </li> </ul>
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSProtonAsyncClient extends AWSProtonClient implements AWSProtonAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AWSProtonAsyncClientBuilder asyncBuilder() {
return AWSProtonAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS Proton using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSProtonAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS Proton using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSProtonAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
super(asyncClientParams, endpointDiscoveryEnabled);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async requests.
*
* @return The executor service used by this client to execute async requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future acceptEnvironmentAccountConnectionAsync(
AcceptEnvironmentAccountConnectionRequest request) {
return acceptEnvironmentAccountConnectionAsync(request, null);
}
@Override
public java.util.concurrent.Future acceptEnvironmentAccountConnectionAsync(
final AcceptEnvironmentAccountConnectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AcceptEnvironmentAccountConnectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AcceptEnvironmentAccountConnectionResult call() throws Exception {
AcceptEnvironmentAccountConnectionResult result = null;
try {
result = executeAcceptEnvironmentAccountConnection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelEnvironmentDeploymentAsync(CancelEnvironmentDeploymentRequest request) {
return cancelEnvironmentDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelEnvironmentDeploymentAsync(final CancelEnvironmentDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelEnvironmentDeploymentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelEnvironmentDeploymentResult call() throws Exception {
CancelEnvironmentDeploymentResult result = null;
try {
result = executeCancelEnvironmentDeployment(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelServiceInstanceDeploymentAsync(
CancelServiceInstanceDeploymentRequest request) {
return cancelServiceInstanceDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelServiceInstanceDeploymentAsync(
final CancelServiceInstanceDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelServiceInstanceDeploymentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelServiceInstanceDeploymentResult call() throws Exception {
CancelServiceInstanceDeploymentResult result = null;
try {
result = executeCancelServiceInstanceDeployment(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelServicePipelineDeploymentAsync(
CancelServicePipelineDeploymentRequest request) {
return cancelServicePipelineDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelServicePipelineDeploymentAsync(
final CancelServicePipelineDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelServicePipelineDeploymentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelServicePipelineDeploymentResult call() throws Exception {
CancelServicePipelineDeploymentResult result = null;
try {
result = executeCancelServicePipelineDeployment(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createEnvironmentAsync(CreateEnvironmentRequest request) {
return createEnvironmentAsync(request, null);
}
@Override
public java.util.concurrent.Future createEnvironmentAsync(final CreateEnvironmentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateEnvironmentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateEnvironmentResult call() throws Exception {
CreateEnvironmentResult result = null;
try {
result = executeCreateEnvironment(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createEnvironmentAccountConnectionAsync(
CreateEnvironmentAccountConnectionRequest request) {
return createEnvironmentAccountConnectionAsync(request, null);
}
@Override
public java.util.concurrent.Future createEnvironmentAccountConnectionAsync(
final CreateEnvironmentAccountConnectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateEnvironmentAccountConnectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateEnvironmentAccountConnectionResult call() throws Exception {
CreateEnvironmentAccountConnectionResult result = null;
try {
result = executeCreateEnvironmentAccountConnection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createEnvironmentTemplateAsync(CreateEnvironmentTemplateRequest request) {
return createEnvironmentTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future createEnvironmentTemplateAsync(final CreateEnvironmentTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateEnvironmentTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateEnvironmentTemplateResult call() throws Exception {
CreateEnvironmentTemplateResult result = null;
try {
result = executeCreateEnvironmentTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createEnvironmentTemplateVersionAsync(
CreateEnvironmentTemplateVersionRequest request) {
return createEnvironmentTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createEnvironmentTemplateVersionAsync(
final CreateEnvironmentTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateEnvironmentTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateEnvironmentTemplateVersionResult call() throws Exception {
CreateEnvironmentTemplateVersionResult result = null;
try {
result = executeCreateEnvironmentTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createServiceAsync(CreateServiceRequest request) {
return createServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceAsync(final CreateServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceResult call() throws Exception {
CreateServiceResult result = null;
try {
result = executeCreateService(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createServiceTemplateAsync(CreateServiceTemplateRequest request) {
return createServiceTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceTemplateAsync(final CreateServiceTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceTemplateResult call() throws Exception {
CreateServiceTemplateResult result = null;
try {
result = executeCreateServiceTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createServiceTemplateVersionAsync(CreateServiceTemplateVersionRequest request) {
return createServiceTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceTemplateVersionAsync(final CreateServiceTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceTemplateVersionResult call() throws Exception {
CreateServiceTemplateVersionResult result = null;
try {
result = executeCreateServiceTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteEnvironmentAsync(DeleteEnvironmentRequest request) {
return deleteEnvironmentAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteEnvironmentAsync(final DeleteEnvironmentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteEnvironmentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteEnvironmentResult call() throws Exception {
DeleteEnvironmentResult result = null;
try {
result = executeDeleteEnvironment(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteEnvironmentAccountConnectionAsync(
DeleteEnvironmentAccountConnectionRequest request) {
return deleteEnvironmentAccountConnectionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteEnvironmentAccountConnectionAsync(
final DeleteEnvironmentAccountConnectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteEnvironmentAccountConnectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteEnvironmentAccountConnectionResult call() throws Exception {
DeleteEnvironmentAccountConnectionResult result = null;
try {
result = executeDeleteEnvironmentAccountConnection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteEnvironmentTemplateAsync(DeleteEnvironmentTemplateRequest request) {
return deleteEnvironmentTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteEnvironmentTemplateAsync(final DeleteEnvironmentTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteEnvironmentTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteEnvironmentTemplateResult call() throws Exception {
DeleteEnvironmentTemplateResult result = null;
try {
result = executeDeleteEnvironmentTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteEnvironmentTemplateVersionAsync(
DeleteEnvironmentTemplateVersionRequest request) {
return deleteEnvironmentTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteEnvironmentTemplateVersionAsync(
final DeleteEnvironmentTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteEnvironmentTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteEnvironmentTemplateVersionResult call() throws Exception {
DeleteEnvironmentTemplateVersionResult result = null;
try {
result = executeDeleteEnvironmentTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteServiceAsync(DeleteServiceRequest request) {
return deleteServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServiceAsync(final DeleteServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServiceResult call() throws Exception {
DeleteServiceResult result = null;
try {
result = executeDeleteService(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteServiceTemplateAsync(DeleteServiceTemplateRequest request) {
return deleteServiceTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServiceTemplateAsync(final DeleteServiceTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServiceTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServiceTemplateResult call() throws Exception {
DeleteServiceTemplateResult result = null;
try {
result = executeDeleteServiceTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteServiceTemplateVersionAsync(DeleteServiceTemplateVersionRequest request) {
return deleteServiceTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServiceTemplateVersionAsync(final DeleteServiceTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServiceTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServiceTemplateVersionResult call() throws Exception {
DeleteServiceTemplateVersionResult result = null;
try {
result = executeDeleteServiceTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getAccountSettingsAsync(GetAccountSettingsRequest request) {
return getAccountSettingsAsync(request, null);
}
@Override
public java.util.concurrent.Future getAccountSettingsAsync(final GetAccountSettingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAccountSettingsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountSettingsResult call() throws Exception {
GetAccountSettingsResult result = null;
try {
result = executeGetAccountSettings(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getEnvironmentAsync(GetEnvironmentRequest request) {
return getEnvironmentAsync(request, null);
}
@Override
public java.util.concurrent.Future getEnvironmentAsync(final GetEnvironmentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetEnvironmentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetEnvironmentResult call() throws Exception {
GetEnvironmentResult result = null;
try {
result = executeGetEnvironment(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getEnvironmentAccountConnectionAsync(
GetEnvironmentAccountConnectionRequest request) {
return getEnvironmentAccountConnectionAsync(request, null);
}
@Override
public java.util.concurrent.Future getEnvironmentAccountConnectionAsync(
final GetEnvironmentAccountConnectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetEnvironmentAccountConnectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetEnvironmentAccountConnectionResult call() throws Exception {
GetEnvironmentAccountConnectionResult result = null;
try {
result = executeGetEnvironmentAccountConnection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getEnvironmentTemplateAsync(GetEnvironmentTemplateRequest request) {
return getEnvironmentTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future getEnvironmentTemplateAsync(final GetEnvironmentTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetEnvironmentTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetEnvironmentTemplateResult call() throws Exception {
GetEnvironmentTemplateResult result = null;
try {
result = executeGetEnvironmentTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getEnvironmentTemplateVersionAsync(GetEnvironmentTemplateVersionRequest request) {
return getEnvironmentTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future getEnvironmentTemplateVersionAsync(
final GetEnvironmentTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetEnvironmentTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetEnvironmentTemplateVersionResult call() throws Exception {
GetEnvironmentTemplateVersionResult result = null;
try {
result = executeGetEnvironmentTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getServiceAsync(GetServiceRequest request) {
return getServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceAsync(final GetServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceResult call() throws Exception {
GetServiceResult result = null;
try {
result = executeGetService(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getServiceInstanceAsync(GetServiceInstanceRequest request) {
return getServiceInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceInstanceAsync(final GetServiceInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceInstanceResult call() throws Exception {
GetServiceInstanceResult result = null;
try {
result = executeGetServiceInstance(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getServiceTemplateAsync(GetServiceTemplateRequest request) {
return getServiceTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceTemplateAsync(final GetServiceTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceTemplateResult call() throws Exception {
GetServiceTemplateResult result = null;
try {
result = executeGetServiceTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getServiceTemplateVersionAsync(GetServiceTemplateVersionRequest request) {
return getServiceTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceTemplateVersionAsync(final GetServiceTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceTemplateVersionResult call() throws Exception {
GetServiceTemplateVersionResult result = null;
try {
result = executeGetServiceTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listEnvironmentAccountConnectionsAsync(
ListEnvironmentAccountConnectionsRequest request) {
return listEnvironmentAccountConnectionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listEnvironmentAccountConnectionsAsync(
final ListEnvironmentAccountConnectionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListEnvironmentAccountConnectionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListEnvironmentAccountConnectionsResult call() throws Exception {
ListEnvironmentAccountConnectionsResult result = null;
try {
result = executeListEnvironmentAccountConnections(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listEnvironmentTemplateVersionsAsync(
ListEnvironmentTemplateVersionsRequest request) {
return listEnvironmentTemplateVersionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listEnvironmentTemplateVersionsAsync(
final ListEnvironmentTemplateVersionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListEnvironmentTemplateVersionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListEnvironmentTemplateVersionsResult call() throws Exception {
ListEnvironmentTemplateVersionsResult result = null;
try {
result = executeListEnvironmentTemplateVersions(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listEnvironmentTemplatesAsync(ListEnvironmentTemplatesRequest request) {
return listEnvironmentTemplatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listEnvironmentTemplatesAsync(final ListEnvironmentTemplatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListEnvironmentTemplatesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListEnvironmentTemplatesResult call() throws Exception {
ListEnvironmentTemplatesResult result = null;
try {
result = executeListEnvironmentTemplates(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listEnvironmentsAsync(ListEnvironmentsRequest request) {
return listEnvironmentsAsync(request, null);
}
@Override
public java.util.concurrent.Future listEnvironmentsAsync(final ListEnvironmentsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListEnvironmentsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListEnvironmentsResult call() throws Exception {
ListEnvironmentsResult result = null;
try {
result = executeListEnvironments(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listServiceInstancesAsync(ListServiceInstancesRequest request) {
return listServiceInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future listServiceInstancesAsync(final ListServiceInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListServiceInstancesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListServiceInstancesResult call() throws Exception {
ListServiceInstancesResult result = null;
try {
result = executeListServiceInstances(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listServiceTemplateVersionsAsync(ListServiceTemplateVersionsRequest request) {
return listServiceTemplateVersionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listServiceTemplateVersionsAsync(final ListServiceTemplateVersionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListServiceTemplateVersionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListServiceTemplateVersionsResult call() throws Exception {
ListServiceTemplateVersionsResult result = null;
try {
result = executeListServiceTemplateVersions(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listServiceTemplatesAsync(ListServiceTemplatesRequest request) {
return listServiceTemplatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listServiceTemplatesAsync(final ListServiceTemplatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListServiceTemplatesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListServiceTemplatesResult call() throws Exception {
ListServiceTemplatesResult result = null;
try {
result = executeListServiceTemplates(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listServicesAsync(ListServicesRequest request) {
return listServicesAsync(request, null);
}
@Override
public java.util.concurrent.Future listServicesAsync(final ListServicesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListServicesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListServicesResult call() throws Exception {
ListServicesResult result = null;
try {
result = executeListServices(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListTagsForResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result = null;
try {
result = executeListTagsForResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future rejectEnvironmentAccountConnectionAsync(
RejectEnvironmentAccountConnectionRequest request) {
return rejectEnvironmentAccountConnectionAsync(request, null);
}
@Override
public java.util.concurrent.Future rejectEnvironmentAccountConnectionAsync(
final RejectEnvironmentAccountConnectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RejectEnvironmentAccountConnectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RejectEnvironmentAccountConnectionResult call() throws Exception {
RejectEnvironmentAccountConnectionResult result = null;
try {
result = executeRejectEnvironmentAccountConnection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future tagResourceAsync(TagResourceRequest request) {
return tagResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future tagResourceAsync(final TagResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final TagResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public TagResourceResult call() throws Exception {
TagResourceResult result = null;
try {
result = executeTagResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future untagResourceAsync(UntagResourceRequest request) {
return untagResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future untagResourceAsync(final UntagResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UntagResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UntagResourceResult call() throws Exception {
UntagResourceResult result = null;
try {
result = executeUntagResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateAccountSettingsAsync(UpdateAccountSettingsRequest request) {
return updateAccountSettingsAsync(request, null);
}
@Override
public java.util.concurrent.Future updateAccountSettingsAsync(final UpdateAccountSettingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateAccountSettingsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateAccountSettingsResult call() throws Exception {
UpdateAccountSettingsResult result = null;
try {
result = executeUpdateAccountSettings(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateEnvironmentAsync(UpdateEnvironmentRequest request) {
return updateEnvironmentAsync(request, null);
}
@Override
public java.util.concurrent.Future updateEnvironmentAsync(final UpdateEnvironmentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateEnvironmentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateEnvironmentResult call() throws Exception {
UpdateEnvironmentResult result = null;
try {
result = executeUpdateEnvironment(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateEnvironmentAccountConnectionAsync(
UpdateEnvironmentAccountConnectionRequest request) {
return updateEnvironmentAccountConnectionAsync(request, null);
}
@Override
public java.util.concurrent.Future updateEnvironmentAccountConnectionAsync(
final UpdateEnvironmentAccountConnectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateEnvironmentAccountConnectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateEnvironmentAccountConnectionResult call() throws Exception {
UpdateEnvironmentAccountConnectionResult result = null;
try {
result = executeUpdateEnvironmentAccountConnection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateEnvironmentTemplateAsync(UpdateEnvironmentTemplateRequest request) {
return updateEnvironmentTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future updateEnvironmentTemplateAsync(final UpdateEnvironmentTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateEnvironmentTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateEnvironmentTemplateResult call() throws Exception {
UpdateEnvironmentTemplateResult result = null;
try {
result = executeUpdateEnvironmentTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateEnvironmentTemplateVersionAsync(
UpdateEnvironmentTemplateVersionRequest request) {
return updateEnvironmentTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future updateEnvironmentTemplateVersionAsync(
final UpdateEnvironmentTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateEnvironmentTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateEnvironmentTemplateVersionResult call() throws Exception {
UpdateEnvironmentTemplateVersionResult result = null;
try {
result = executeUpdateEnvironmentTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateServiceAsync(UpdateServiceRequest request) {
return updateServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future updateServiceAsync(final UpdateServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateServiceResult call() throws Exception {
UpdateServiceResult result = null;
try {
result = executeUpdateService(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateServiceInstanceAsync(UpdateServiceInstanceRequest request) {
return updateServiceInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future updateServiceInstanceAsync(final UpdateServiceInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateServiceInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateServiceInstanceResult call() throws Exception {
UpdateServiceInstanceResult result = null;
try {
result = executeUpdateServiceInstance(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateServicePipelineAsync(UpdateServicePipelineRequest request) {
return updateServicePipelineAsync(request, null);
}
@Override
public java.util.concurrent.Future updateServicePipelineAsync(final UpdateServicePipelineRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateServicePipelineRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateServicePipelineResult call() throws Exception {
UpdateServicePipelineResult result = null;
try {
result = executeUpdateServicePipeline(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateServiceTemplateAsync(UpdateServiceTemplateRequest request) {
return updateServiceTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future updateServiceTemplateAsync(final UpdateServiceTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateServiceTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateServiceTemplateResult call() throws Exception {
UpdateServiceTemplateResult result = null;
try {
result = executeUpdateServiceTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateServiceTemplateVersionAsync(UpdateServiceTemplateVersionRequest request) {
return updateServiceTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future updateServiceTemplateVersionAsync(final UpdateServiceTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateServiceTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateServiceTemplateVersionResult call() throws Exception {
UpdateServiceTemplateVersionResult result = null;
try {
result = executeUpdateServiceTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
* asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
* call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
* calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy