/*
* Copyright 2018-2023 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.lightsail;
import static java.util.concurrent.Executors.newFixedThreadPool;
import javax.annotation.Generated;
import com.amazonaws.services.lightsail.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import java.util.concurrent.ExecutorService;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
/**
* Client for accessing Amazon Lightsail 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.
*
*
* Amazon Lightsail is the easiest way to get started with Amazon Web Services (Amazon Web Services) for developers who
* need to build websites or web applications. It includes everything you need to launch your project quickly -
* instances (virtual private servers), container services, storage buckets, managed databases, SSD-based block storage,
* static IP addresses, load balancers, content delivery network (CDN) distributions, DNS management of registered
* domains, and resource snapshots (backups) - for a low, predictable monthly price.
*
*
* You can manage your Lightsail resources using the Lightsail console, Lightsail API, Command Line Interface (CLI), or
* SDKs. For more information about Lightsail concepts and tasks, see the Amazon Lightsail Developer Guide.
*
*
* This API Reference provides detailed information about the actions, data types, parameters, and errors of the
* Lightsail service. For more information about the supported Amazon Web Services Regions, endpoints, and service
* quotas of the Lightsail service, see Amazon
* Lightsail Endpoints and Quotas in the Amazon Web Services General Reference.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonLightsailAsyncClient extends AmazonLightsailClient implements AmazonLightsailAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail. A credentials provider chain
* will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonLightsailAsyncClient() {
this(DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail. A credentials provider chain
* will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon Lightsail (ex: proxy
* settings, retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonLightsailAsyncClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified AWS
* account credentials.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonLightsailAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified AWS
* account credentials and executor service. Default client settings will be used.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonLightsailAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonLightsailAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified AWS
* account credentials, executor service, and client configuration options.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonLightsailAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonLightsailAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonLightsailAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified AWS
* account credentials provider. Default client settings will be used.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonLightsailAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the provided AWS account
* credentials provider and client configuration options.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonLightsailAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonLightsailAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified AWS
* account credentials provider and executor service. Default client settings will be used.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonLightsailAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonLightsailAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified AWS
* account credentials provider, executor service, and client configuration options.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonLightsailAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonLightsailAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonLightsailAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonLightsailAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
public static AmazonLightsailAsyncClientBuilder asyncBuilder() {
return AmazonLightsailAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonLightsailAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Lightsail using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AmazonLightsailAsyncClient(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 allocateStaticIpAsync(AllocateStaticIpRequest request) {
return allocateStaticIpAsync(request, null);
}
@Override
public java.util.concurrent.Future allocateStaticIpAsync(final AllocateStaticIpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AllocateStaticIpRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AllocateStaticIpResult call() throws Exception {
AllocateStaticIpResult result = null;
try {
result = executeAllocateStaticIp(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 attachCertificateToDistributionAsync(
AttachCertificateToDistributionRequest request) {
return attachCertificateToDistributionAsync(request, null);
}
@Override
public java.util.concurrent.Future attachCertificateToDistributionAsync(
final AttachCertificateToDistributionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachCertificateToDistributionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachCertificateToDistributionResult call() throws Exception {
AttachCertificateToDistributionResult result = null;
try {
result = executeAttachCertificateToDistribution(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 attachDiskAsync(AttachDiskRequest request) {
return attachDiskAsync(request, null);
}
@Override
public java.util.concurrent.Future attachDiskAsync(final AttachDiskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachDiskRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachDiskResult call() throws Exception {
AttachDiskResult result = null;
try {
result = executeAttachDisk(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 attachInstancesToLoadBalancerAsync(AttachInstancesToLoadBalancerRequest request) {
return attachInstancesToLoadBalancerAsync(request, null);
}
@Override
public java.util.concurrent.Future attachInstancesToLoadBalancerAsync(
final AttachInstancesToLoadBalancerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachInstancesToLoadBalancerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachInstancesToLoadBalancerResult call() throws Exception {
AttachInstancesToLoadBalancerResult result = null;
try {
result = executeAttachInstancesToLoadBalancer(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 attachLoadBalancerTlsCertificateAsync(
AttachLoadBalancerTlsCertificateRequest request) {
return attachLoadBalancerTlsCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future attachLoadBalancerTlsCertificateAsync(
final AttachLoadBalancerTlsCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachLoadBalancerTlsCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachLoadBalancerTlsCertificateResult call() throws Exception {
AttachLoadBalancerTlsCertificateResult result = null;
try {
result = executeAttachLoadBalancerTlsCertificate(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 attachStaticIpAsync(AttachStaticIpRequest request) {
return attachStaticIpAsync(request, null);
}
@Override
public java.util.concurrent.Future attachStaticIpAsync(final AttachStaticIpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachStaticIpRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachStaticIpResult call() throws Exception {
AttachStaticIpResult result = null;
try {
result = executeAttachStaticIp(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 closeInstancePublicPortsAsync(CloseInstancePublicPortsRequest request) {
return closeInstancePublicPortsAsync(request, null);
}
@Override
public java.util.concurrent.Future closeInstancePublicPortsAsync(final CloseInstancePublicPortsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CloseInstancePublicPortsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CloseInstancePublicPortsResult call() throws Exception {
CloseInstancePublicPortsResult result = null;
try {
result = executeCloseInstancePublicPorts(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 copySnapshotAsync(CopySnapshotRequest request) {
return copySnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future copySnapshotAsync(final CopySnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CopySnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CopySnapshotResult call() throws Exception {
CopySnapshotResult result = null;
try {
result = executeCopySnapshot(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 createBucketAsync(CreateBucketRequest request) {
return createBucketAsync(request, null);
}
@Override
public java.util.concurrent.Future createBucketAsync(final CreateBucketRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateBucketRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateBucketResult call() throws Exception {
CreateBucketResult result = null;
try {
result = executeCreateBucket(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 createBucketAccessKeyAsync(CreateBucketAccessKeyRequest request) {
return createBucketAccessKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future createBucketAccessKeyAsync(final CreateBucketAccessKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateBucketAccessKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateBucketAccessKeyResult call() throws Exception {
CreateBucketAccessKeyResult result = null;
try {
result = executeCreateBucketAccessKey(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 createCertificateAsync(CreateCertificateRequest request) {
return createCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future createCertificateAsync(final CreateCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCertificateResult call() throws Exception {
CreateCertificateResult result = null;
try {
result = executeCreateCertificate(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 createCloudFormationStackAsync(CreateCloudFormationStackRequest request) {
return createCloudFormationStackAsync(request, null);
}
@Override
public java.util.concurrent.Future createCloudFormationStackAsync(final CreateCloudFormationStackRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCloudFormationStackRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCloudFormationStackResult call() throws Exception {
CreateCloudFormationStackResult result = null;
try {
result = executeCreateCloudFormationStack(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 createContactMethodAsync(CreateContactMethodRequest request) {
return createContactMethodAsync(request, null);
}
@Override
public java.util.concurrent.Future createContactMethodAsync(final CreateContactMethodRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateContactMethodRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateContactMethodResult call() throws Exception {
CreateContactMethodResult result = null;
try {
result = executeCreateContactMethod(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 createContainerServiceAsync(CreateContainerServiceRequest request) {
return createContainerServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future createContainerServiceAsync(final CreateContainerServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateContainerServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateContainerServiceResult call() throws Exception {
CreateContainerServiceResult result = null;
try {
result = executeCreateContainerService(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 createContainerServiceDeploymentAsync(
CreateContainerServiceDeploymentRequest request) {
return createContainerServiceDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future createContainerServiceDeploymentAsync(
final CreateContainerServiceDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateContainerServiceDeploymentRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateContainerServiceDeploymentResult call() throws Exception {
CreateContainerServiceDeploymentResult result = null;
try {
result = executeCreateContainerServiceDeployment(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 createContainerServiceRegistryLoginAsync(
CreateContainerServiceRegistryLoginRequest request) {
return createContainerServiceRegistryLoginAsync(request, null);
}
@Override
public java.util.concurrent.Future createContainerServiceRegistryLoginAsync(
final CreateContainerServiceRegistryLoginRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateContainerServiceRegistryLoginRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateContainerServiceRegistryLoginResult call() throws Exception {
CreateContainerServiceRegistryLoginResult result = null;
try {
result = executeCreateContainerServiceRegistryLogin(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 createDiskAsync(CreateDiskRequest request) {
return createDiskAsync(request, null);
}
@Override
public java.util.concurrent.Future createDiskAsync(final CreateDiskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDiskRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDiskResult call() throws Exception {
CreateDiskResult result = null;
try {
result = executeCreateDisk(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 createDiskFromSnapshotAsync(CreateDiskFromSnapshotRequest request) {
return createDiskFromSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createDiskFromSnapshotAsync(final CreateDiskFromSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDiskFromSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDiskFromSnapshotResult call() throws Exception {
CreateDiskFromSnapshotResult result = null;
try {
result = executeCreateDiskFromSnapshot(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 createDiskSnapshotAsync(CreateDiskSnapshotRequest request) {
return createDiskSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createDiskSnapshotAsync(final CreateDiskSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDiskSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDiskSnapshotResult call() throws Exception {
CreateDiskSnapshotResult result = null;
try {
result = executeCreateDiskSnapshot(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 createDistributionAsync(CreateDistributionRequest request) {
return createDistributionAsync(request, null);
}
@Override
public java.util.concurrent.Future createDistributionAsync(final CreateDistributionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDistributionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDistributionResult call() throws Exception {
CreateDistributionResult result = null;
try {
result = executeCreateDistribution(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 createDomainAsync(CreateDomainRequest request) {
return createDomainAsync(request, null);
}
@Override
public java.util.concurrent.Future createDomainAsync(final CreateDomainRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDomainRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDomainResult call() throws Exception {
CreateDomainResult result = null;
try {
result = executeCreateDomain(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 createDomainEntryAsync(CreateDomainEntryRequest request) {
return createDomainEntryAsync(request, null);
}
@Override
public java.util.concurrent.Future createDomainEntryAsync(final CreateDomainEntryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDomainEntryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDomainEntryResult call() throws Exception {
CreateDomainEntryResult result = null;
try {
result = executeCreateDomainEntry(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 createGUISessionAccessDetailsAsync(CreateGUISessionAccessDetailsRequest request) {
return createGUISessionAccessDetailsAsync(request, null);
}
@Override
public java.util.concurrent.Future createGUISessionAccessDetailsAsync(
final CreateGUISessionAccessDetailsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateGUISessionAccessDetailsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateGUISessionAccessDetailsResult call() throws Exception {
CreateGUISessionAccessDetailsResult result = null;
try {
result = executeCreateGUISessionAccessDetails(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 createInstanceSnapshotAsync(CreateInstanceSnapshotRequest request) {
return createInstanceSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createInstanceSnapshotAsync(final CreateInstanceSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateInstanceSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateInstanceSnapshotResult call() throws Exception {
CreateInstanceSnapshotResult result = null;
try {
result = executeCreateInstanceSnapshot(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 createInstancesAsync(CreateInstancesRequest request) {
return createInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future createInstancesAsync(final CreateInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateInstancesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateInstancesResult call() throws Exception {
CreateInstancesResult result = null;
try {
result = executeCreateInstances(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 createInstancesFromSnapshotAsync(CreateInstancesFromSnapshotRequest request) {
return createInstancesFromSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createInstancesFromSnapshotAsync(final CreateInstancesFromSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateInstancesFromSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateInstancesFromSnapshotResult call() throws Exception {
CreateInstancesFromSnapshotResult result = null;
try {
result = executeCreateInstancesFromSnapshot(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 createKeyPairAsync(CreateKeyPairRequest request) {
return createKeyPairAsync(request, null);
}
@Override
public java.util.concurrent.Future createKeyPairAsync(final CreateKeyPairRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateKeyPairRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateKeyPairResult call() throws Exception {
CreateKeyPairResult result = null;
try {
result = executeCreateKeyPair(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 createLoadBalancerAsync(CreateLoadBalancerRequest request) {
return createLoadBalancerAsync(request, null);
}
@Override
public java.util.concurrent.Future createLoadBalancerAsync(final CreateLoadBalancerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateLoadBalancerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateLoadBalancerResult call() throws Exception {
CreateLoadBalancerResult result = null;
try {
result = executeCreateLoadBalancer(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 createLoadBalancerTlsCertificateAsync(
CreateLoadBalancerTlsCertificateRequest request) {
return createLoadBalancerTlsCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future createLoadBalancerTlsCertificateAsync(
final CreateLoadBalancerTlsCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateLoadBalancerTlsCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateLoadBalancerTlsCertificateResult call() throws Exception {
CreateLoadBalancerTlsCertificateResult result = null;
try {
result = executeCreateLoadBalancerTlsCertificate(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 createRelationalDatabaseAsync(CreateRelationalDatabaseRequest request) {
return createRelationalDatabaseAsync(request, null);
}
@Override
public java.util.concurrent.Future createRelationalDatabaseAsync(final CreateRelationalDatabaseRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateRelationalDatabaseRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRelationalDatabaseResult call() throws Exception {
CreateRelationalDatabaseResult result = null;
try {
result = executeCreateRelationalDatabase(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 createRelationalDatabaseFromSnapshotAsync(
CreateRelationalDatabaseFromSnapshotRequest request) {
return createRelationalDatabaseFromSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createRelationalDatabaseFromSnapshotAsync(
final CreateRelationalDatabaseFromSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateRelationalDatabaseFromSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRelationalDatabaseFromSnapshotResult call() throws Exception {
CreateRelationalDatabaseFromSnapshotResult result = null;
try {
result = executeCreateRelationalDatabaseFromSnapshot(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 createRelationalDatabaseSnapshotAsync(
CreateRelationalDatabaseSnapshotRequest request) {
return createRelationalDatabaseSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createRelationalDatabaseSnapshotAsync(
final CreateRelationalDatabaseSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateRelationalDatabaseSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRelationalDatabaseSnapshotResult call() throws Exception {
CreateRelationalDatabaseSnapshotResult result = null;
try {
result = executeCreateRelationalDatabaseSnapshot(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 deleteAlarmAsync(DeleteAlarmRequest request) {
return deleteAlarmAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAlarmAsync(final DeleteAlarmRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAlarmRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAlarmResult call() throws Exception {
DeleteAlarmResult result = null;
try {
result = executeDeleteAlarm(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 deleteAutoSnapshotAsync(DeleteAutoSnapshotRequest request) {
return deleteAutoSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAutoSnapshotAsync(final DeleteAutoSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAutoSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAutoSnapshotResult call() throws Exception {
DeleteAutoSnapshotResult result = null;
try {
result = executeDeleteAutoSnapshot(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 deleteBucketAsync(DeleteBucketRequest request) {
return deleteBucketAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteBucketAsync(final DeleteBucketRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteBucketRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteBucketResult call() throws Exception {
DeleteBucketResult result = null;
try {
result = executeDeleteBucket(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 deleteBucketAccessKeyAsync(DeleteBucketAccessKeyRequest request) {
return deleteBucketAccessKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteBucketAccessKeyAsync(final DeleteBucketAccessKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteBucketAccessKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteBucketAccessKeyResult call() throws Exception {
DeleteBucketAccessKeyResult result = null;
try {
result = executeDeleteBucketAccessKey(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 deleteCertificateAsync(DeleteCertificateRequest request) {
return deleteCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCertificateAsync(final DeleteCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCertificateResult call() throws Exception {
DeleteCertificateResult result = null;
try {
result = executeDeleteCertificate(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 deleteContactMethodAsync(DeleteContactMethodRequest request) {
return deleteContactMethodAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteContactMethodAsync(final DeleteContactMethodRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteContactMethodRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteContactMethodResult call() throws Exception {
DeleteContactMethodResult result = null;
try {
result = executeDeleteContactMethod(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 deleteContainerImageAsync(DeleteContainerImageRequest request) {
return deleteContainerImageAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteContainerImageAsync(final DeleteContainerImageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteContainerImageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteContainerImageResult call() throws Exception {
DeleteContainerImageResult result = null;
try {
result = executeDeleteContainerImage(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 deleteContainerServiceAsync(DeleteContainerServiceRequest request) {
return deleteContainerServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteContainerServiceAsync(final DeleteContainerServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteContainerServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteContainerServiceResult call() throws Exception {
DeleteContainerServiceResult result = null;
try {
result = executeDeleteContainerService(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 deleteDiskAsync(DeleteDiskRequest request) {
return deleteDiskAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDiskAsync(final DeleteDiskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDiskRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDiskResult call() throws Exception {
DeleteDiskResult result = null;
try {
result = executeDeleteDisk(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 deleteDiskSnapshotAsync(DeleteDiskSnapshotRequest request) {
return deleteDiskSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDiskSnapshotAsync(final DeleteDiskSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDiskSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDiskSnapshotResult call() throws Exception {
DeleteDiskSnapshotResult result = null;
try {
result = executeDeleteDiskSnapshot(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 deleteDistributionAsync(DeleteDistributionRequest request) {
return deleteDistributionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDistributionAsync(final DeleteDistributionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDistributionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDistributionResult call() throws Exception {
DeleteDistributionResult result = null;
try {
result = executeDeleteDistribution(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 deleteDomainAsync(DeleteDomainRequest request) {
return deleteDomainAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDomainAsync(final DeleteDomainRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDomainRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDomainResult call() throws Exception {
DeleteDomainResult result = null;
try {
result = executeDeleteDomain(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 deleteDomainEntryAsync(DeleteDomainEntryRequest request) {
return deleteDomainEntryAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDomainEntryAsync(final DeleteDomainEntryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDomainEntryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDomainEntryResult call() throws Exception {
DeleteDomainEntryResult result = null;
try {
result = executeDeleteDomainEntry(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 deleteInstanceAsync(DeleteInstanceRequest request) {
return deleteInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteInstanceAsync(final DeleteInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteInstanceResult call() throws Exception {
DeleteInstanceResult result = null;
try {
result = executeDeleteInstance(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 deleteInstanceSnapshotAsync(DeleteInstanceSnapshotRequest request) {
return deleteInstanceSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteInstanceSnapshotAsync(final DeleteInstanceSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteInstanceSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteInstanceSnapshotResult call() throws Exception {
DeleteInstanceSnapshotResult result = null;
try {
result = executeDeleteInstanceSnapshot(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 deleteKeyPairAsync(DeleteKeyPairRequest request) {
return deleteKeyPairAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteKeyPairAsync(final DeleteKeyPairRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteKeyPairRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteKeyPairResult call() throws Exception {
DeleteKeyPairResult result = null;
try {
result = executeDeleteKeyPair(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 deleteKnownHostKeysAsync(DeleteKnownHostKeysRequest request) {
return deleteKnownHostKeysAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteKnownHostKeysAsync(final DeleteKnownHostKeysRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteKnownHostKeysRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteKnownHostKeysResult call() throws Exception {
DeleteKnownHostKeysResult result = null;
try {
result = executeDeleteKnownHostKeys(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 deleteLoadBalancerAsync(DeleteLoadBalancerRequest request) {
return deleteLoadBalancerAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteLoadBalancerAsync(final DeleteLoadBalancerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteLoadBalancerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteLoadBalancerResult call() throws Exception {
DeleteLoadBalancerResult result = null;
try {
result = executeDeleteLoadBalancer(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 deleteLoadBalancerTlsCertificateAsync(
DeleteLoadBalancerTlsCertificateRequest request) {
return deleteLoadBalancerTlsCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteLoadBalancerTlsCertificateAsync(
final DeleteLoadBalancerTlsCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteLoadBalancerTlsCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteLoadBalancerTlsCertificateResult call() throws Exception {
DeleteLoadBalancerTlsCertificateResult result = null;
try {
result = executeDeleteLoadBalancerTlsCertificate(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 deleteRelationalDatabaseAsync(DeleteRelationalDatabaseRequest request) {
return deleteRelationalDatabaseAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRelationalDatabaseAsync(final DeleteRelationalDatabaseRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteRelationalDatabaseRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRelationalDatabaseResult call() throws Exception {
DeleteRelationalDatabaseResult result = null;
try {
result = executeDeleteRelationalDatabase(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 deleteRelationalDatabaseSnapshotAsync(
DeleteRelationalDatabaseSnapshotRequest request) {
return deleteRelationalDatabaseSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRelationalDatabaseSnapshotAsync(
final DeleteRelationalDatabaseSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteRelationalDatabaseSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRelationalDatabaseSnapshotResult call() throws Exception {
DeleteRelationalDatabaseSnapshotResult result = null;
try {
result = executeDeleteRelationalDatabaseSnapshot(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 detachCertificateFromDistributionAsync(
DetachCertificateFromDistributionRequest request) {
return detachCertificateFromDistributionAsync(request, null);
}
@Override
public java.util.concurrent.Future detachCertificateFromDistributionAsync(
final DetachCertificateFromDistributionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DetachCertificateFromDistributionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachCertificateFromDistributionResult call() throws Exception {
DetachCertificateFromDistributionResult result = null;
try {
result = executeDetachCertificateFromDistribution(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 detachDiskAsync(DetachDiskRequest request) {
return detachDiskAsync(request, null);
}
@Override
public java.util.concurrent.Future detachDiskAsync(final DetachDiskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DetachDiskRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachDiskResult call() throws Exception {
DetachDiskResult result = null;
try {
result = executeDetachDisk(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 detachInstancesFromLoadBalancerAsync(
DetachInstancesFromLoadBalancerRequest request) {
return detachInstancesFromLoadBalancerAsync(request, null);
}
@Override
public java.util.concurrent.Future detachInstancesFromLoadBalancerAsync(
final DetachInstancesFromLoadBalancerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DetachInstancesFromLoadBalancerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachInstancesFromLoadBalancerResult call() throws Exception {
DetachInstancesFromLoadBalancerResult result = null;
try {
result = executeDetachInstancesFromLoadBalancer(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 detachStaticIpAsync(DetachStaticIpRequest request) {
return detachStaticIpAsync(request, null);
}
@Override
public java.util.concurrent.Future detachStaticIpAsync(final DetachStaticIpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DetachStaticIpRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachStaticIpResult call() throws Exception {
DetachStaticIpResult result = null;
try {
result = executeDetachStaticIp(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 disableAddOnAsync(DisableAddOnRequest request) {
return disableAddOnAsync(request, null);
}
@Override
public java.util.concurrent.Future disableAddOnAsync(final DisableAddOnRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DisableAddOnRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisableAddOnResult call() throws Exception {
DisableAddOnResult result = null;
try {
result = executeDisableAddOn(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 downloadDefaultKeyPairAsync(DownloadDefaultKeyPairRequest request) {
return downloadDefaultKeyPairAsync(request, null);
}
@Override
public java.util.concurrent.Future downloadDefaultKeyPairAsync(final DownloadDefaultKeyPairRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DownloadDefaultKeyPairRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DownloadDefaultKeyPairResult call() throws Exception {
DownloadDefaultKeyPairResult result = null;
try {
result = executeDownloadDefaultKeyPair(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 enableAddOnAsync(EnableAddOnRequest request) {
return enableAddOnAsync(request, null);
}
@Override
public java.util.concurrent.Future enableAddOnAsync(final EnableAddOnRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final EnableAddOnRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public EnableAddOnResult call() throws Exception {
EnableAddOnResult result = null;
try {
result = executeEnableAddOn(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 exportSnapshotAsync(ExportSnapshotRequest request) {
return exportSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future exportSnapshotAsync(final ExportSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ExportSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ExportSnapshotResult call() throws Exception {
ExportSnapshotResult result = null;
try {
result = executeExportSnapshot(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 getActiveNamesAsync(GetActiveNamesRequest request) {
return getActiveNamesAsync(request, null);
}
@Override
public java.util.concurrent.Future getActiveNamesAsync(final GetActiveNamesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetActiveNamesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetActiveNamesResult call() throws Exception {
GetActiveNamesResult result = null;
try {
result = executeGetActiveNames(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 getAlarmsAsync(GetAlarmsRequest request) {
return getAlarmsAsync(request, null);
}
@Override
public java.util.concurrent.Future getAlarmsAsync(final GetAlarmsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAlarmsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable