com.amazonaws.services.proton.AWSProtonAsyncClient Maven / Gradle / Ivy
/*
* Copyright 2019-2024 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 Proton Service API Reference. It provides descriptions, syntax and usage examples for each of the actions and data types for the Proton service.
*
*
* The documentation for each action shows the Query API request parameters and the XML response.
*
*
* Alternatively, you can use the Amazon Web Services CLI to access an API. For more information, see the Amazon Web Services Command Line
* Interface User Guide.
*
*
* The 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 Proton deploys and manages, they need permissions
* to use all of the listed API operations.
*
*
* When developers select a specific infrastructure and tooling set, Proton deploys their applications. To monitor their
* applications that are running on 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 Proton, see the 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 Amazon Web
* Services 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
*
*
*
*
* Idempotent create APIs
*
*
* Given a request action that has succeeded:
*
*
* If you retry the request with an API from this group, and the original resource hasn't been modified, the
* retry succeeds without performing any further actions other than returning the original resource detail data in the
* response.
*
*
* If the original resource has been modified, the retry throws a ConflictException.
*
*
* If you retry with different input parameters, the retry throws a ValidationException with an
* IdempotentParameterMismatch error.
*
*
* Idempotent create APIs:
*
*
* -
*
* CreateEnvironmentTemplate
*
*
* -
*
* CreateServiceTemplate
*
*
* -
*
* CreateEnvironment
*
*
* -
*
* CreateService
*
*
*
*
* Idempotent delete APIs
*
*
* Given a request action that has succeeded:
*
*
* When you retry the request with an API from this group and the resource was deleted, its metadata is returned in the
* response.
*
*
* If you retry and the resource doesn't exist, the response is empty.
*
*
* In both cases, the retry succeeds.
*
*
* Idempotent delete APIs:
*
*
* -
*
* DeleteEnvironmentTemplate
*
*
* -
*
* DeleteEnvironmentTemplateVersion
*
*
* -
*
* DeleteServiceTemplate
*
*
* -
*
* DeleteServiceTemplateVersion
*
*
* -
*
* DeleteEnvironmentAccountConnection
*
*
*
*
* Asynchronous idempotent delete APIs
*
*
* Given a request action that has succeeded:
*
*
* If you retry the request with an API from this group, if the original request delete operation status is
* DELETE_IN_PROGRESS, the retry returns the resource detail data in the response without performing any
* further actions.
*
*
* If the original request delete operation is complete, a retry returns an empty response.
*
*
* Asynchronous idempotent delete APIs:
*
*
* -
*
* DeleteEnvironment
*
*
* -
*
* DeleteService
*
*
*
*/
@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 cancelComponentDeploymentAsync(CancelComponentDeploymentRequest request) {
return cancelComponentDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelComponentDeploymentAsync(final CancelComponentDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelComponentDeploymentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelComponentDeploymentResult call() throws Exception {
CancelComponentDeploymentResult result = null;
try {
result = executeCancelComponentDeployment(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 createComponentAsync(CreateComponentRequest request) {
return createComponentAsync(request, null);
}
@Override
public java.util.concurrent.Future createComponentAsync(final CreateComponentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateComponentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateComponentResult call() throws Exception {
CreateComponentResult result = null;
try {
result = executeCreateComponent(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 createRepositoryAsync(CreateRepositoryRequest request) {
return createRepositoryAsync(request, null);
}
@Override
public java.util.concurrent.Future createRepositoryAsync(final CreateRepositoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateRepositoryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRepositoryResult call() throws Exception {
CreateRepositoryResult result = null;
try {
result = executeCreateRepository(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 createServiceInstanceAsync(CreateServiceInstanceRequest request) {
return createServiceInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceInstanceAsync(final CreateServiceInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceInstanceResult call() throws Exception {
CreateServiceInstanceResult result = null;
try {
result = executeCreateServiceInstance(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 createServiceSyncConfigAsync(CreateServiceSyncConfigRequest request) {
return createServiceSyncConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceSyncConfigAsync(final CreateServiceSyncConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceSyncConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceSyncConfigResult call() throws Exception {
CreateServiceSyncConfigResult result = null;
try {
result = executeCreateServiceSyncConfig(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 createTemplateSyncConfigAsync(CreateTemplateSyncConfigRequest request) {
return createTemplateSyncConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future createTemplateSyncConfigAsync(final CreateTemplateSyncConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateTemplateSyncConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTemplateSyncConfigResult call() throws Exception {
CreateTemplateSyncConfigResult result = null;
try {
result = executeCreateTemplateSyncConfig(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 deleteComponentAsync(DeleteComponentRequest request) {
return deleteComponentAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteComponentAsync(final DeleteComponentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteComponentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteComponentResult call() throws Exception {
DeleteComponentResult result = null;
try {
result = executeDeleteComponent(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 deleteDeploymentAsync(DeleteDeploymentRequest request) {
return deleteDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDeploymentAsync(final DeleteDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDeploymentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDeploymentResult call() throws Exception {
DeleteDeploymentResult result = null;
try {
result = executeDeleteDeployment(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 deleteRepositoryAsync(DeleteRepositoryRequest request) {
return deleteRepositoryAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRepositoryAsync(final DeleteRepositoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteRepositoryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRepositoryResult call() throws Exception {
DeleteRepositoryResult result = null;
try {
result = executeDeleteRepository(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 deleteServiceSyncConfigAsync(DeleteServiceSyncConfigRequest request) {
return deleteServiceSyncConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServiceSyncConfigAsync(final DeleteServiceSyncConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServiceSyncConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServiceSyncConfigResult call() throws Exception {
DeleteServiceSyncConfigResult result = null;
try {
result = executeDeleteServiceSyncConfig(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 deleteTemplateSyncConfigAsync(DeleteTemplateSyncConfigRequest request) {
return deleteTemplateSyncConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTemplateSyncConfigAsync(final DeleteTemplateSyncConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteTemplateSyncConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTemplateSyncConfigResult call() throws Exception {
DeleteTemplateSyncConfigResult result = null;
try {
result = executeDeleteTemplateSyncConfig(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 getComponentAsync(GetComponentRequest request) {
return getComponentAsync(request, null);
}
@Override
public java.util.concurrent.Future getComponentAsync(final GetComponentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetComponentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetComponentResult call() throws Exception {
GetComponentResult result = null;
try {
result = executeGetComponent(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 getDeploymentAsync(GetDeploymentRequest request) {
return getDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future getDeploymentAsync(final GetDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetDeploymentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetDeploymentResult call() throws Exception {
GetDeploymentResult result = null;
try {
result = executeGetDeployment(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 getRepositoryAsync(GetRepositoryRequest request) {
return getRepositoryAsync(request, null);
}
@Override
public java.util.concurrent.Future getRepositoryAsync(final GetRepositoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetRepositoryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetRepositoryResult call() throws Exception {
GetRepositoryResult result = null;
try {
result = executeGetRepository(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 getRepositorySyncStatusAsync(GetRepositorySyncStatusRequest request) {
return getRepositorySyncStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future getRepositorySyncStatusAsync(final GetRepositorySyncStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetRepositorySyncStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetRepositorySyncStatusResult call() throws Exception {
GetRepositorySyncStatusResult result = null;
try {
result = executeGetRepositorySyncStatus(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 getResourcesSummaryAsync(GetResourcesSummaryRequest request) {
return getResourcesSummaryAsync(request, null);
}
@Override
public java.util.concurrent.Future getResourcesSummaryAsync(final GetResourcesSummaryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetResourcesSummaryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetResourcesSummaryResult call() throws Exception {
GetResourcesSummaryResult result = null;
try {
result = executeGetResourcesSummary(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 getServiceInstanceSyncStatusAsync(GetServiceInstanceSyncStatusRequest request) {
return getServiceInstanceSyncStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceInstanceSyncStatusAsync(final GetServiceInstanceSyncStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceInstanceSyncStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceInstanceSyncStatusResult call() throws Exception {
GetServiceInstanceSyncStatusResult result = null;
try {
result = executeGetServiceInstanceSyncStatus(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 getServiceSyncBlockerSummaryAsync(GetServiceSyncBlockerSummaryRequest request) {
return getServiceSyncBlockerSummaryAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceSyncBlockerSummaryAsync(final GetServiceSyncBlockerSummaryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceSyncBlockerSummaryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceSyncBlockerSummaryResult call() throws Exception {
GetServiceSyncBlockerSummaryResult result = null;
try {
result = executeGetServiceSyncBlockerSummary(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 getServiceSyncConfigAsync(GetServiceSyncConfigRequest request) {
return getServiceSyncConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceSyncConfigAsync(final GetServiceSyncConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceSyncConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceSyncConfigResult call() throws Exception {
GetServiceSyncConfigResult result = null;
try {
result = executeGetServiceSyncConfig(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 getTemplateSyncConfigAsync(GetTemplateSyncConfigRequest request) {
return getTemplateSyncConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future getTemplateSyncConfigAsync(final GetTemplateSyncConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetTemplateSyncConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTemplateSyncConfigResult call() throws Exception {
GetTemplateSyncConfigResult result = null;
try {
result = executeGetTemplateSyncConfig(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 getTemplateSyncStatusAsync(GetTemplateSyncStatusRequest request) {
return getTemplateSyncStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future getTemplateSyncStatusAsync(final GetTemplateSyncStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetTemplateSyncStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTemplateSyncStatusResult call() throws Exception {
GetTemplateSyncStatusResult result = null;
try {
result = executeGetTemplateSyncStatus(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 listComponentOutputsAsync(ListComponentOutputsRequest request) {
return listComponentOutputsAsync(request, null);
}
@Override
public java.util.concurrent.Future listComponentOutputsAsync(final ListComponentOutputsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListComponentOutputsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListComponentOutputsResult call() throws Exception {
ListComponentOutputsResult result = null;
try {
result = executeListComponentOutputs(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 listComponentProvisionedResourcesAsync(
ListComponentProvisionedResourcesRequest request) {
return listComponentProvisionedResourcesAsync(request, null);
}
@Override
public java.util.concurrent.Future listComponentProvisionedResourcesAsync(
final ListComponentProvisionedResourcesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListComponentProvisionedResourcesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListComponentProvisionedResourcesResult call() throws Exception {
ListComponentProvisionedResourcesResult result = null;
try {
result = executeListComponentProvisionedResources(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 listComponentsAsync(ListComponentsRequest request) {
return listComponentsAsync(request, null);
}
@Override
public java.util.concurrent.Future listComponentsAsync(final ListComponentsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListComponentsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListComponentsResult call() throws Exception {
ListComponentsResult result = null;
try {
result = executeListComponents(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 listDeploymentsAsync(ListDeploymentsRequest request) {
return listDeploymentsAsync(request, null);
}
@Override
public java.util.concurrent.Future listDeploymentsAsync(final ListDeploymentsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListDeploymentsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListDeploymentsResult call() throws Exception {
ListDeploymentsResult result = null;
try {
result = executeListDeployments(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 listEnvironmentOutputsAsync(ListEnvironmentOutputsRequest request) {
return listEnvironmentOutputsAsync(request, null);
}
@Override
public java.util.concurrent.Future listEnvironmentOutputsAsync(final ListEnvironmentOutputsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListEnvironmentOutputsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListEnvironmentOutputsResult call() throws Exception {
ListEnvironmentOutputsResult result = null;
try {
result = executeListEnvironmentOutputs(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 listEnvironmentProvisionedResourcesAsync(
ListEnvironmentProvisionedResourcesRequest request) {
return listEnvironmentProvisionedResourcesAsync(request, null);
}
@Override
public java.util.concurrent.Future listEnvironmentProvisionedResourcesAsync(
final ListEnvironmentProvisionedResourcesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListEnvironmentProvisionedResourcesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListEnvironmentProvisionedResourcesResult call() throws Exception {
ListEnvironmentProvisionedResourcesResult result = null;
try {
result = executeListEnvironmentProvisionedResources(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 listRepositoriesAsync(ListRepositoriesRequest request) {
return listRepositoriesAsync(request, null);
}
@Override
public java.util.concurrent.Future listRepositoriesAsync(final ListRepositoriesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListRepositoriesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListRepositoriesResult call() throws Exception {
ListRepositoriesResult result = null;
try {
result = executeListRepositories(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 listRepositorySyncDefinitionsAsync(ListRepositorySyncDefinitionsRequest request) {
return listRepositorySyncDefinitionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listRepositorySyncDefinitionsAsync(
final ListRepositorySyncDefinitionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListRepositorySyncDefinitionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListRepositorySyncDefinitionsResult call() throws Exception {
ListRepositorySyncDefinitionsResult result = null;
try {
result = executeListRepositorySyncDefinitions(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 listServiceInstanceOutputsAsync(ListServiceInstanceOutputsRequest request) {
return listServiceInstanceOutputsAsync(request, null);
}
@Override
public java.util.concurrent.Future listServiceInstanceOutputsAsync(final ListServiceInstanceOutputsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListServiceInstanceOutputsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListServiceInstanceOutputsResult call() throws Exception {
ListServiceInstanceOutputsResult result = null;
try {
result = executeListServiceInstanceOutputs(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 listServiceInstanceProvisionedResourcesAsync(
ListServiceInstanceProvisionedResourcesRequest request) {
return listServiceInstanceProvisionedResourcesAsync(request, null);
}
@Override
public java.util.concurrent.Future listServiceInstanceProvisionedResourcesAsync(
final ListServiceInstanceProvisionedResourcesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListServiceInstanceProvisionedResourcesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListServiceInstanceProvisionedResourcesResult call() throws Exception {
ListServiceInstanceProvisionedResourcesResult result = null;
try {
result = executeListServiceInstanceProvisionedResources(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