com.amazonaws.services.opsworks.AWSOpsWorksAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-opsworks Show documentation
/*
* Copyright 2010-2016 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.opsworks;
import com.amazonaws.services.opsworks.model.*;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing AWS OpsWorks 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.
*
* AWS OpsWorks
*
* Welcome to the AWS OpsWorks API Reference. This guide provides
* descriptions, syntax, and usage examples about AWS OpsWorks actions and data
* types, including common parameters and error codes.
*
*
* AWS OpsWorks is an application management service that provides an integrated
* experience for overseeing the complete application lifecycle. For information
* about this product, go to the AWS
* OpsWorks details page.
*
*
* SDKs and CLI
*
*
* The most common way to use the AWS OpsWorks API is by using the AWS Command
* Line Interface (CLI) or by using one of the AWS SDKs to implement
* applications in your preferred language. For more information, see:
*
*
* - AWS
* CLI
* - AWS SDK for Java
* - AWS SDK for .NET
* - AWS SDK for PHP 2
* - AWS
* SDK for Ruby
* - AWS SDK
* for Node.js
* - AWS SDK
* for Python(Boto)
*
*
* Endpoints
*
*
* AWS OpsWorks supports only one endpoint, opsworks.us-east-1.amazonaws.com
* (HTTPS), so you must connect to that endpoint. You can then use the API to
* direct AWS OpsWorks to create stacks in any AWS Region.
*
*
* Chef Versions
*
*
* When you call CreateStack, CloneStack, or UpdateStack we
* recommend you use the ConfigurationManager parameter to specify
* the Chef version. The recommended value for Linux stacks is currently 12 (the
* default is 11.4). Windows stacks use Chef 12.2. For more information, see Chef Versions.
*
* You can specify Chef 12, 11.10, or 11.4 for your Linux stack. We
* recommend migrating your existing Linux stacks to Chef 12 as soon as
* possible.
*/
@ThreadSafe
public class AWSOpsWorksAsyncClient extends AWSOpsWorksClient implements
AWSOpsWorksAsync {
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 AWS
* OpsWorks. 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)
*/
public AWSOpsWorksAsyncClient() {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks. 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 AWS OpsWorks (ex: proxy settings, retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.ClientConfiguration clientConfiguration) {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain(),
clientConfiguration, java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks 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)
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials) {
this(awsCredentials, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks 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.
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks 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.
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks 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)
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks 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)
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration,
java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks 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.
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* OpsWorks 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.
*/
public AWSOpsWorksAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* 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 java.util.concurrent.ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future assignInstanceAsync(
AssignInstanceRequest request) {
return assignInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future assignInstanceAsync(
final AssignInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AssignInstanceResult call() throws Exception {
AssignInstanceResult result;
try {
result = assignInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future assignVolumeAsync(
AssignVolumeRequest request) {
return assignVolumeAsync(request, null);
}
@Override
public java.util.concurrent.Future assignVolumeAsync(
final AssignVolumeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AssignVolumeResult call() throws Exception {
AssignVolumeResult result;
try {
result = assignVolume(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future associateElasticIpAsync(
AssociateElasticIpRequest request) {
return associateElasticIpAsync(request, null);
}
@Override
public java.util.concurrent.Future associateElasticIpAsync(
final AssociateElasticIpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AssociateElasticIpResult call() throws Exception {
AssociateElasticIpResult result;
try {
result = associateElasticIp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future attachElasticLoadBalancerAsync(
AttachElasticLoadBalancerRequest request) {
return attachElasticLoadBalancerAsync(request, null);
}
@Override
public java.util.concurrent.Future attachElasticLoadBalancerAsync(
final AttachElasticLoadBalancerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AttachElasticLoadBalancerResult call()
throws Exception {
AttachElasticLoadBalancerResult result;
try {
result = attachElasticLoadBalancer(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cloneStackAsync(
CloneStackRequest request) {
return cloneStackAsync(request, null);
}
@Override
public java.util.concurrent.Future cloneStackAsync(
final CloneStackRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CloneStackResult call() throws Exception {
CloneStackResult result;
try {
result = cloneStack(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createAppAsync(
CreateAppRequest request) {
return createAppAsync(request, null);
}
@Override
public java.util.concurrent.Future createAppAsync(
final CreateAppRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateAppResult call() throws Exception {
CreateAppResult result;
try {
result = createApp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDeploymentAsync(
CreateDeploymentRequest request) {
return createDeploymentAsync(request, null);
}
@Override
public java.util.concurrent.Future createDeploymentAsync(
final CreateDeploymentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateDeploymentResult call() throws Exception {
CreateDeploymentResult result;
try {
result = createDeployment(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createInstanceAsync(
CreateInstanceRequest request) {
return createInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future createInstanceAsync(
final CreateInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateInstanceResult call() throws Exception {
CreateInstanceResult result;
try {
result = createInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createLayerAsync(
CreateLayerRequest request) {
return createLayerAsync(request, null);
}
@Override
public java.util.concurrent.Future createLayerAsync(
final CreateLayerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateLayerResult call() throws Exception {
CreateLayerResult result;
try {
result = createLayer(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createStackAsync(
CreateStackRequest request) {
return createStackAsync(request, null);
}
@Override
public java.util.concurrent.Future createStackAsync(
final CreateStackRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateStackResult call() throws Exception {
CreateStackResult result;
try {
result = createStack(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserProfileAsync(
CreateUserProfileRequest request) {
return createUserProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserProfileAsync(
final CreateUserProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserProfileResult call() throws Exception {
CreateUserProfileResult result;
try {
result = createUserProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteAppAsync(
DeleteAppRequest request) {
return deleteAppAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAppAsync(
final DeleteAppRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAppResult call() throws Exception {
DeleteAppResult result;
try {
result = deleteApp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteInstanceResult call() throws Exception {
DeleteInstanceResult result;
try {
result = deleteInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteLayerAsync(
DeleteLayerRequest request) {
return deleteLayerAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteLayerAsync(
final DeleteLayerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteLayerResult call() throws Exception {
DeleteLayerResult result;
try {
result = deleteLayer(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteStackAsync(
DeleteStackRequest request) {
return deleteStackAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteStackAsync(
final DeleteStackRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteStackResult call() throws Exception {
DeleteStackResult result;
try {
result = deleteStack(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserProfileAsync(
DeleteUserProfileRequest request) {
return deleteUserProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserProfileAsync(
final DeleteUserProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserProfileResult call() throws Exception {
DeleteUserProfileResult result;
try {
result = deleteUserProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deregisterEcsClusterAsync(
DeregisterEcsClusterRequest request) {
return deregisterEcsClusterAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterEcsClusterAsync(
final DeregisterEcsClusterRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterEcsClusterResult call() throws Exception {
DeregisterEcsClusterResult result;
try {
result = deregisterEcsCluster(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deregisterElasticIpAsync(
DeregisterElasticIpRequest request) {
return deregisterElasticIpAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterElasticIpAsync(
final DeregisterElasticIpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterElasticIpResult call() throws Exception {
DeregisterElasticIpResult result;
try {
result = deregisterElasticIp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deregisterInstanceAsync(
DeregisterInstanceRequest request) {
return deregisterInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterInstanceAsync(
final DeregisterInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterInstanceResult call() throws Exception {
DeregisterInstanceResult result;
try {
result = deregisterInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deregisterRdsDbInstanceAsync(
DeregisterRdsDbInstanceRequest request) {
return deregisterRdsDbInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterRdsDbInstanceAsync(
final DeregisterRdsDbInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterRdsDbInstanceResult call()
throws Exception {
DeregisterRdsDbInstanceResult result;
try {
result = deregisterRdsDbInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deregisterVolumeAsync(
DeregisterVolumeRequest request) {
return deregisterVolumeAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterVolumeAsync(
final DeregisterVolumeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterVolumeResult call() throws Exception {
DeregisterVolumeResult result;
try {
result = deregisterVolume(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeAgentVersionsAsync(
DescribeAgentVersionsRequest request) {
return describeAgentVersionsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAgentVersionsAsync(
final DescribeAgentVersionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAgentVersionsResult call() throws Exception {
DescribeAgentVersionsResult result;
try {
result = describeAgentVersions(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeAppsAsync(
DescribeAppsRequest request) {
return describeAppsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAppsAsync(
final DescribeAppsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAppsResult call() throws Exception {
DescribeAppsResult result;
try {
result = describeApps(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeCommandsAsync(
DescribeCommandsRequest request) {
return describeCommandsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeCommandsAsync(
final DescribeCommandsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeCommandsResult call() throws Exception {
DescribeCommandsResult result;
try {
result = describeCommands(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeDeploymentsAsync(
DescribeDeploymentsRequest request) {
return describeDeploymentsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeDeploymentsAsync(
final DescribeDeploymentsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeDeploymentsResult call() throws Exception {
DescribeDeploymentsResult result;
try {
result = describeDeployments(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeEcsClustersAsync(
DescribeEcsClustersRequest request) {
return describeEcsClustersAsync(request, null);
}
@Override
public java.util.concurrent.Future describeEcsClustersAsync(
final DescribeEcsClustersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeEcsClustersResult call() throws Exception {
DescribeEcsClustersResult result;
try {
result = describeEcsClusters(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeElasticIpsAsync(
DescribeElasticIpsRequest request) {
return describeElasticIpsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeElasticIpsAsync(
final DescribeElasticIpsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeElasticIpsResult call() throws Exception {
DescribeElasticIpsResult result;
try {
result = describeElasticIps(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeElasticLoadBalancersAsync(
DescribeElasticLoadBalancersRequest request) {
return describeElasticLoadBalancersAsync(request, null);
}
@Override
public java.util.concurrent.Future describeElasticLoadBalancersAsync(
final DescribeElasticLoadBalancersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeElasticLoadBalancersResult call()
throws Exception {
DescribeElasticLoadBalancersResult result;
try {
result = describeElasticLoadBalancers(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeInstancesAsync(
DescribeInstancesRequest request) {
return describeInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeInstancesAsync(
final DescribeInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeInstancesResult call() throws Exception {
DescribeInstancesResult result;
try {
result = describeInstances(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeLayersAsync(
DescribeLayersRequest request) {
return describeLayersAsync(request, null);
}
@Override
public java.util.concurrent.Future describeLayersAsync(
final DescribeLayersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeLayersResult call() throws Exception {
DescribeLayersResult result;
try {
result = describeLayers(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeLoadBasedAutoScalingAsync(
DescribeLoadBasedAutoScalingRequest request) {
return describeLoadBasedAutoScalingAsync(request, null);
}
@Override
public java.util.concurrent.Future describeLoadBasedAutoScalingAsync(
final DescribeLoadBasedAutoScalingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeLoadBasedAutoScalingResult call()
throws Exception {
DescribeLoadBasedAutoScalingResult result;
try {
result = describeLoadBasedAutoScaling(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeMyUserProfileAsync(
DescribeMyUserProfileRequest request) {
return describeMyUserProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future describeMyUserProfileAsync(
final DescribeMyUserProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeMyUserProfileResult call() throws Exception {
DescribeMyUserProfileResult result;
try {
result = describeMyUserProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describePermissionsAsync(
DescribePermissionsRequest request) {
return describePermissionsAsync(request, null);
}
@Override
public java.util.concurrent.Future describePermissionsAsync(
final DescribePermissionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribePermissionsResult call() throws Exception {
DescribePermissionsResult result;
try {
result = describePermissions(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeRaidArraysAsync(
DescribeRaidArraysRequest request) {
return describeRaidArraysAsync(request, null);
}
@Override
public java.util.concurrent.Future describeRaidArraysAsync(
final DescribeRaidArraysRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeRaidArraysResult call() throws Exception {
DescribeRaidArraysResult result;
try {
result = describeRaidArrays(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeRdsDbInstancesAsync(
DescribeRdsDbInstancesRequest request) {
return describeRdsDbInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeRdsDbInstancesAsync(
final DescribeRdsDbInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeRdsDbInstancesResult call() throws Exception {
DescribeRdsDbInstancesResult result;
try {
result = describeRdsDbInstances(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeServiceErrorsAsync(
DescribeServiceErrorsRequest request) {
return describeServiceErrorsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeServiceErrorsAsync(
final DescribeServiceErrorsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeServiceErrorsResult call() throws Exception {
DescribeServiceErrorsResult result;
try {
result = describeServiceErrors(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeStackProvisioningParametersAsync(
DescribeStackProvisioningParametersRequest request) {
return describeStackProvisioningParametersAsync(request, null);
}
@Override
public java.util.concurrent.Future describeStackProvisioningParametersAsync(
final DescribeStackProvisioningParametersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeStackProvisioningParametersResult call()
throws Exception {
DescribeStackProvisioningParametersResult result;
try {
result = describeStackProvisioningParameters(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeStackSummaryAsync(
DescribeStackSummaryRequest request) {
return describeStackSummaryAsync(request, null);
}
@Override
public java.util.concurrent.Future describeStackSummaryAsync(
final DescribeStackSummaryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeStackSummaryResult call() throws Exception {
DescribeStackSummaryResult result;
try {
result = describeStackSummary(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeStacksAsync(
DescribeStacksRequest request) {
return describeStacksAsync(request, null);
}
@Override
public java.util.concurrent.Future describeStacksAsync(
final DescribeStacksRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeStacksResult call() throws Exception {
DescribeStacksResult result;
try {
result = describeStacks(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeTimeBasedAutoScalingAsync(
DescribeTimeBasedAutoScalingRequest request) {
return describeTimeBasedAutoScalingAsync(request, null);
}
@Override
public java.util.concurrent.Future describeTimeBasedAutoScalingAsync(
final DescribeTimeBasedAutoScalingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeTimeBasedAutoScalingResult call()
throws Exception {
DescribeTimeBasedAutoScalingResult result;
try {
result = describeTimeBasedAutoScaling(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserProfilesAsync(
DescribeUserProfilesRequest request) {
return describeUserProfilesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserProfilesAsync(
final DescribeUserProfilesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserProfilesResult call() throws Exception {
DescribeUserProfilesResult result;
try {
result = describeUserProfiles(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeVolumesAsync(
DescribeVolumesRequest request) {
return describeVolumesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeVolumesAsync(
final DescribeVolumesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeVolumesResult call() throws Exception {
DescribeVolumesResult result;
try {
result = describeVolumes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future detachElasticLoadBalancerAsync(
DetachElasticLoadBalancerRequest request) {
return detachElasticLoadBalancerAsync(request, null);
}
@Override
public java.util.concurrent.Future detachElasticLoadBalancerAsync(
final DetachElasticLoadBalancerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DetachElasticLoadBalancerResult call()
throws Exception {
DetachElasticLoadBalancerResult result;
try {
result = detachElasticLoadBalancer(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future disassociateElasticIpAsync(
DisassociateElasticIpRequest request) {
return disassociateElasticIpAsync(request, null);
}
@Override
public java.util.concurrent.Future disassociateElasticIpAsync(
final DisassociateElasticIpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DisassociateElasticIpResult call() throws Exception {
DisassociateElasticIpResult result;
try {
result = disassociateElasticIp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getHostnameSuggestionAsync(
GetHostnameSuggestionRequest request) {
return getHostnameSuggestionAsync(request, null);
}
@Override
public java.util.concurrent.Future getHostnameSuggestionAsync(
final GetHostnameSuggestionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public GetHostnameSuggestionResult call() throws Exception {
GetHostnameSuggestionResult result;
try {
result = getHostnameSuggestion(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future grantAccessAsync(
GrantAccessRequest request) {
return grantAccessAsync(request, null);
}
@Override
public java.util.concurrent.Future grantAccessAsync(
final GrantAccessRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public GrantAccessResult call() throws Exception {
GrantAccessResult result;
try {
result = grantAccess(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future rebootInstanceAsync(
RebootInstanceRequest request) {
return rebootInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future rebootInstanceAsync(
final RebootInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RebootInstanceResult call() throws Exception {
RebootInstanceResult result;
try {
result = rebootInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future registerEcsClusterAsync(
RegisterEcsClusterRequest request) {
return registerEcsClusterAsync(request, null);
}
@Override
public java.util.concurrent.Future registerEcsClusterAsync(
final RegisterEcsClusterRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RegisterEcsClusterResult call() throws Exception {
RegisterEcsClusterResult result;
try {
result = registerEcsCluster(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future registerElasticIpAsync(
RegisterElasticIpRequest request) {
return registerElasticIpAsync(request, null);
}
@Override
public java.util.concurrent.Future registerElasticIpAsync(
final RegisterElasticIpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RegisterElasticIpResult call() throws Exception {
RegisterElasticIpResult result;
try {
result = registerElasticIp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future registerInstanceAsync(
RegisterInstanceRequest request) {
return registerInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future registerInstanceAsync(
final RegisterInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RegisterInstanceResult call() throws Exception {
RegisterInstanceResult result;
try {
result = registerInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future registerRdsDbInstanceAsync(
RegisterRdsDbInstanceRequest request) {
return registerRdsDbInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future registerRdsDbInstanceAsync(
final RegisterRdsDbInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RegisterRdsDbInstanceResult call() throws Exception {
RegisterRdsDbInstanceResult result;
try {
result = registerRdsDbInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future registerVolumeAsync(
RegisterVolumeRequest request) {
return registerVolumeAsync(request, null);
}
@Override
public java.util.concurrent.Future registerVolumeAsync(
final RegisterVolumeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RegisterVolumeResult call() throws Exception {
RegisterVolumeResult result;
try {
result = registerVolume(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future setLoadBasedAutoScalingAsync(
SetLoadBasedAutoScalingRequest request) {
return setLoadBasedAutoScalingAsync(request, null);
}
@Override
public java.util.concurrent.Future setLoadBasedAutoScalingAsync(
final SetLoadBasedAutoScalingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public SetLoadBasedAutoScalingResult call()
throws Exception {
SetLoadBasedAutoScalingResult result;
try {
result = setLoadBasedAutoScaling(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future setPermissionAsync(
SetPermissionRequest request) {
return setPermissionAsync(request, null);
}
@Override
public java.util.concurrent.Future setPermissionAsync(
final SetPermissionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public SetPermissionResult call() throws Exception {
SetPermissionResult result;
try {
result = setPermission(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future setTimeBasedAutoScalingAsync(
SetTimeBasedAutoScalingRequest request) {
return setTimeBasedAutoScalingAsync(request, null);
}
@Override
public java.util.concurrent.Future setTimeBasedAutoScalingAsync(
final SetTimeBasedAutoScalingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public SetTimeBasedAutoScalingResult call()
throws Exception {
SetTimeBasedAutoScalingResult result;
try {
result = setTimeBasedAutoScaling(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future startInstanceAsync(
StartInstanceRequest request) {
return startInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future startInstanceAsync(
final StartInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public StartInstanceResult call() throws Exception {
StartInstanceResult result;
try {
result = startInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future startStackAsync(
StartStackRequest request) {
return startStackAsync(request, null);
}
@Override
public java.util.concurrent.Future startStackAsync(
final StartStackRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public StartStackResult call() throws Exception {
StartStackResult result;
try {
result = startStack(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future stopInstanceAsync(
StopInstanceRequest request) {
return stopInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future stopInstanceAsync(
final StopInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public StopInstanceResult call() throws Exception {
StopInstanceResult result;
try {
result = stopInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future stopStackAsync(
StopStackRequest request) {
return stopStackAsync(request, null);
}
@Override
public java.util.concurrent.Future stopStackAsync(
final StopStackRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public StopStackResult call() throws Exception {
StopStackResult result;
try {
result = stopStack(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future unassignInstanceAsync(
UnassignInstanceRequest request) {
return unassignInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future unassignInstanceAsync(
final UnassignInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UnassignInstanceResult call() throws Exception {
UnassignInstanceResult result;
try {
result = unassignInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future unassignVolumeAsync(
UnassignVolumeRequest request) {
return unassignVolumeAsync(request, null);
}
@Override
public java.util.concurrent.Future unassignVolumeAsync(
final UnassignVolumeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UnassignVolumeResult call() throws Exception {
UnassignVolumeResult result;
try {
result = unassignVolume(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateAppAsync(
UpdateAppRequest request) {
return updateAppAsync(request, null);
}
@Override
public java.util.concurrent.Future updateAppAsync(
final UpdateAppRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateAppResult call() throws Exception {
UpdateAppResult result;
try {
result = updateApp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future