com.amazonaws.services.autoscaling.AmazonAutoScalingAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-autoscaling Show documentation
/*
* Copyright 2011-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.autoscaling;
import com.amazonaws.services.autoscaling.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing Auto Scaling 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.
*
* Auto Scaling
*
* Auto Scaling is designed to automatically launch or terminate EC2 instances based on user-defined policies,
* schedules, and health checks. Use this service in conjunction with the Amazon CloudWatch and Elastic Load Balancing
* services.
*
*/
@ThreadSafe
public class AmazonAutoScalingAsyncClient extends AmazonAutoScalingClient implements AmazonAutoScalingAsync {
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 Auto Scaling. 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 AmazonAutoScalingAsyncClient() {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on Auto Scaling. 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 Auto Scaling (ex: proxy settings,
* retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AmazonAutoScalingAsyncClient(com.amazonaws.ClientConfiguration clientConfiguration) {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Auto Scaling 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 AmazonAutoScalingAsyncClient(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 Auto Scaling 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 AmazonAutoScalingAsyncClient(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 Auto Scaling 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 AmazonAutoScalingAsyncClient(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 Auto Scaling 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 AmazonAutoScalingAsyncClient(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 Auto Scaling 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 AmazonAutoScalingAsyncClient(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 Auto Scaling 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 AmazonAutoScalingAsyncClient(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 Auto Scaling 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 AmazonAutoScalingAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration, java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Auto Scaling using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonAutoScalingAsyncClient(AwsAsyncClientParams asyncClientParams) {
super(asyncClientParams);
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 java.util.concurrent.ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future attachInstancesAsync(AttachInstancesRequest request) {
return attachInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future attachInstancesAsync(final AttachInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachInstancesResult call() throws Exception {
AttachInstancesResult result;
try {
result = attachInstances(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 attachLoadBalancerTargetGroupsAsync(AttachLoadBalancerTargetGroupsRequest request) {
return attachLoadBalancerTargetGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future attachLoadBalancerTargetGroupsAsync(
final AttachLoadBalancerTargetGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachLoadBalancerTargetGroupsResult call() throws Exception {
AttachLoadBalancerTargetGroupsResult result;
try {
result = attachLoadBalancerTargetGroups(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 attachLoadBalancersAsync(AttachLoadBalancersRequest request) {
return attachLoadBalancersAsync(request, null);
}
@Override
public java.util.concurrent.Future attachLoadBalancersAsync(final AttachLoadBalancersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachLoadBalancersResult call() throws Exception {
AttachLoadBalancersResult result;
try {
result = attachLoadBalancers(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the AttachLoadBalancers operation.
*
* @see #attachLoadBalancersAsync(AttachLoadBalancersRequest)
*/
@Override
public java.util.concurrent.Future attachLoadBalancersAsync() {
return attachLoadBalancersAsync(new AttachLoadBalancersRequest());
}
/**
* Simplified method form for invoking the AttachLoadBalancers operation with an AsyncHandler.
*
* @see #attachLoadBalancersAsync(AttachLoadBalancersRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future attachLoadBalancersAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return attachLoadBalancersAsync(new AttachLoadBalancersRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future completeLifecycleActionAsync(CompleteLifecycleActionRequest request) {
return completeLifecycleActionAsync(request, null);
}
@Override
public java.util.concurrent.Future completeLifecycleActionAsync(final CompleteLifecycleActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CompleteLifecycleActionResult call() throws Exception {
CompleteLifecycleActionResult result;
try {
result = completeLifecycleAction(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 createAutoScalingGroupAsync(CreateAutoScalingGroupRequest request) {
return createAutoScalingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createAutoScalingGroupAsync(final CreateAutoScalingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAutoScalingGroupResult call() throws Exception {
CreateAutoScalingGroupResult result;
try {
result = createAutoScalingGroup(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 createLaunchConfigurationAsync(CreateLaunchConfigurationRequest request) {
return createLaunchConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future createLaunchConfigurationAsync(final CreateLaunchConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateLaunchConfigurationResult call() throws Exception {
CreateLaunchConfigurationResult result;
try {
result = createLaunchConfiguration(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 createOrUpdateTagsAsync(CreateOrUpdateTagsRequest request) {
return createOrUpdateTagsAsync(request, null);
}
@Override
public java.util.concurrent.Future createOrUpdateTagsAsync(final CreateOrUpdateTagsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateOrUpdateTagsResult call() throws Exception {
CreateOrUpdateTagsResult result;
try {
result = createOrUpdateTags(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 deleteAutoScalingGroupAsync(DeleteAutoScalingGroupRequest request) {
return deleteAutoScalingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAutoScalingGroupAsync(final DeleteAutoScalingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAutoScalingGroupResult call() throws Exception {
DeleteAutoScalingGroupResult result;
try {
result = deleteAutoScalingGroup(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 deleteLaunchConfigurationAsync(DeleteLaunchConfigurationRequest request) {
return deleteLaunchConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteLaunchConfigurationAsync(final DeleteLaunchConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteLaunchConfigurationResult call() throws Exception {
DeleteLaunchConfigurationResult result;
try {
result = deleteLaunchConfiguration(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 deleteLifecycleHookAsync(DeleteLifecycleHookRequest request) {
return deleteLifecycleHookAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteLifecycleHookAsync(final DeleteLifecycleHookRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteLifecycleHookResult call() throws Exception {
DeleteLifecycleHookResult result;
try {
result = deleteLifecycleHook(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 deleteNotificationConfigurationAsync(
DeleteNotificationConfigurationRequest request) {
return deleteNotificationConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteNotificationConfigurationAsync(
final DeleteNotificationConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteNotificationConfigurationResult call() throws Exception {
DeleteNotificationConfigurationResult result;
try {
result = deleteNotificationConfiguration(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 deletePolicyAsync(DeletePolicyRequest request) {
return deletePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePolicyAsync(final DeletePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePolicyResult call() throws Exception {
DeletePolicyResult result;
try {
result = deletePolicy(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 deleteScheduledActionAsync(DeleteScheduledActionRequest request) {
return deleteScheduledActionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteScheduledActionAsync(final DeleteScheduledActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteScheduledActionResult call() throws Exception {
DeleteScheduledActionResult result;
try {
result = deleteScheduledAction(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 deleteTagsAsync(DeleteTagsRequest request) {
return deleteTagsAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTagsAsync(final DeleteTagsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTagsResult call() throws Exception {
DeleteTagsResult result;
try {
result = deleteTags(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 describeAccountLimitsAsync(DescribeAccountLimitsRequest request) {
return describeAccountLimitsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAccountLimitsAsync(final DescribeAccountLimitsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAccountLimitsResult call() throws Exception {
DescribeAccountLimitsResult result;
try {
result = describeAccountLimits(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeAccountLimits operation.
*
* @see #describeAccountLimitsAsync(DescribeAccountLimitsRequest)
*/
@Override
public java.util.concurrent.Future describeAccountLimitsAsync() {
return describeAccountLimitsAsync(new DescribeAccountLimitsRequest());
}
/**
* Simplified method form for invoking the DescribeAccountLimits operation with an AsyncHandler.
*
* @see #describeAccountLimitsAsync(DescribeAccountLimitsRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeAccountLimitsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeAccountLimitsAsync(new DescribeAccountLimitsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeAdjustmentTypesAsync(DescribeAdjustmentTypesRequest request) {
return describeAdjustmentTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAdjustmentTypesAsync(final DescribeAdjustmentTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAdjustmentTypesResult call() throws Exception {
DescribeAdjustmentTypesResult result;
try {
result = describeAdjustmentTypes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeAdjustmentTypes operation.
*
* @see #describeAdjustmentTypesAsync(DescribeAdjustmentTypesRequest)
*/
@Override
public java.util.concurrent.Future describeAdjustmentTypesAsync() {
return describeAdjustmentTypesAsync(new DescribeAdjustmentTypesRequest());
}
/**
* Simplified method form for invoking the DescribeAdjustmentTypes operation with an AsyncHandler.
*
* @see #describeAdjustmentTypesAsync(DescribeAdjustmentTypesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeAdjustmentTypesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeAdjustmentTypesAsync(new DescribeAdjustmentTypesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeAutoScalingGroupsAsync(DescribeAutoScalingGroupsRequest request) {
return describeAutoScalingGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAutoScalingGroupsAsync(final DescribeAutoScalingGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAutoScalingGroupsResult call() throws Exception {
DescribeAutoScalingGroupsResult result;
try {
result = describeAutoScalingGroups(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeAutoScalingGroups operation.
*
* @see #describeAutoScalingGroupsAsync(DescribeAutoScalingGroupsRequest)
*/
@Override
public java.util.concurrent.Future describeAutoScalingGroupsAsync() {
return describeAutoScalingGroupsAsync(new DescribeAutoScalingGroupsRequest());
}
/**
* Simplified method form for invoking the DescribeAutoScalingGroups operation with an AsyncHandler.
*
* @see #describeAutoScalingGroupsAsync(DescribeAutoScalingGroupsRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeAutoScalingGroupsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeAutoScalingGroupsAsync(new DescribeAutoScalingGroupsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeAutoScalingInstancesAsync(DescribeAutoScalingInstancesRequest request) {
return describeAutoScalingInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAutoScalingInstancesAsync(final DescribeAutoScalingInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAutoScalingInstancesResult call() throws Exception {
DescribeAutoScalingInstancesResult result;
try {
result = describeAutoScalingInstances(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeAutoScalingInstances operation.
*
* @see #describeAutoScalingInstancesAsync(DescribeAutoScalingInstancesRequest)
*/
@Override
public java.util.concurrent.Future describeAutoScalingInstancesAsync() {
return describeAutoScalingInstancesAsync(new DescribeAutoScalingInstancesRequest());
}
/**
* Simplified method form for invoking the DescribeAutoScalingInstances operation with an AsyncHandler.
*
* @see #describeAutoScalingInstancesAsync(DescribeAutoScalingInstancesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeAutoScalingInstancesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeAutoScalingInstancesAsync(new DescribeAutoScalingInstancesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeAutoScalingNotificationTypesAsync(
DescribeAutoScalingNotificationTypesRequest request) {
return describeAutoScalingNotificationTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAutoScalingNotificationTypesAsync(
final DescribeAutoScalingNotificationTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAutoScalingNotificationTypesResult call() throws Exception {
DescribeAutoScalingNotificationTypesResult result;
try {
result = describeAutoScalingNotificationTypes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeAutoScalingNotificationTypes operation.
*
* @see #describeAutoScalingNotificationTypesAsync(DescribeAutoScalingNotificationTypesRequest)
*/
@Override
public java.util.concurrent.Future describeAutoScalingNotificationTypesAsync() {
return describeAutoScalingNotificationTypesAsync(new DescribeAutoScalingNotificationTypesRequest());
}
/**
* Simplified method form for invoking the DescribeAutoScalingNotificationTypes operation with an AsyncHandler.
*
* @see #describeAutoScalingNotificationTypesAsync(DescribeAutoScalingNotificationTypesRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeAutoScalingNotificationTypesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeAutoScalingNotificationTypesAsync(new DescribeAutoScalingNotificationTypesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeLaunchConfigurationsAsync(DescribeLaunchConfigurationsRequest request) {
return describeLaunchConfigurationsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeLaunchConfigurationsAsync(final DescribeLaunchConfigurationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeLaunchConfigurationsResult call() throws Exception {
DescribeLaunchConfigurationsResult result;
try {
result = describeLaunchConfigurations(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeLaunchConfigurations operation.
*
* @see #describeLaunchConfigurationsAsync(DescribeLaunchConfigurationsRequest)
*/
@Override
public java.util.concurrent.Future describeLaunchConfigurationsAsync() {
return describeLaunchConfigurationsAsync(new DescribeLaunchConfigurationsRequest());
}
/**
* Simplified method form for invoking the DescribeLaunchConfigurations operation with an AsyncHandler.
*
* @see #describeLaunchConfigurationsAsync(DescribeLaunchConfigurationsRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeLaunchConfigurationsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeLaunchConfigurationsAsync(new DescribeLaunchConfigurationsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeLifecycleHookTypesAsync(DescribeLifecycleHookTypesRequest request) {
return describeLifecycleHookTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeLifecycleHookTypesAsync(final DescribeLifecycleHookTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeLifecycleHookTypesResult call() throws Exception {
DescribeLifecycleHookTypesResult result;
try {
result = describeLifecycleHookTypes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeLifecycleHookTypes operation.
*
* @see #describeLifecycleHookTypesAsync(DescribeLifecycleHookTypesRequest)
*/
@Override
public java.util.concurrent.Future describeLifecycleHookTypesAsync() {
return describeLifecycleHookTypesAsync(new DescribeLifecycleHookTypesRequest());
}
/**
* Simplified method form for invoking the DescribeLifecycleHookTypes operation with an AsyncHandler.
*
* @see #describeLifecycleHookTypesAsync(DescribeLifecycleHookTypesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeLifecycleHookTypesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeLifecycleHookTypesAsync(new DescribeLifecycleHookTypesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeLifecycleHooksAsync(DescribeLifecycleHooksRequest request) {
return describeLifecycleHooksAsync(request, null);
}
@Override
public java.util.concurrent.Future describeLifecycleHooksAsync(final DescribeLifecycleHooksRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeLifecycleHooksResult call() throws Exception {
DescribeLifecycleHooksResult result;
try {
result = describeLifecycleHooks(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 describeLoadBalancerTargetGroupsAsync(
DescribeLoadBalancerTargetGroupsRequest request) {
return describeLoadBalancerTargetGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeLoadBalancerTargetGroupsAsync(
final DescribeLoadBalancerTargetGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeLoadBalancerTargetGroupsResult call() throws Exception {
DescribeLoadBalancerTargetGroupsResult result;
try {
result = describeLoadBalancerTargetGroups(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 describeLoadBalancersAsync(DescribeLoadBalancersRequest request) {
return describeLoadBalancersAsync(request, null);
}
@Override
public java.util.concurrent.Future describeLoadBalancersAsync(final DescribeLoadBalancersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeLoadBalancersResult call() throws Exception {
DescribeLoadBalancersResult result;
try {
result = describeLoadBalancers(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 describeMetricCollectionTypesAsync(DescribeMetricCollectionTypesRequest request) {
return describeMetricCollectionTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeMetricCollectionTypesAsync(
final DescribeMetricCollectionTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeMetricCollectionTypesResult call() throws Exception {
DescribeMetricCollectionTypesResult result;
try {
result = describeMetricCollectionTypes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeMetricCollectionTypes operation.
*
* @see #describeMetricCollectionTypesAsync(DescribeMetricCollectionTypesRequest)
*/
@Override
public java.util.concurrent.Future describeMetricCollectionTypesAsync() {
return describeMetricCollectionTypesAsync(new DescribeMetricCollectionTypesRequest());
}
/**
* Simplified method form for invoking the DescribeMetricCollectionTypes operation with an AsyncHandler.
*
* @see #describeMetricCollectionTypesAsync(DescribeMetricCollectionTypesRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeMetricCollectionTypesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeMetricCollectionTypesAsync(new DescribeMetricCollectionTypesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeNotificationConfigurationsAsync(
DescribeNotificationConfigurationsRequest request) {
return describeNotificationConfigurationsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeNotificationConfigurationsAsync(
final DescribeNotificationConfigurationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeNotificationConfigurationsResult call() throws Exception {
DescribeNotificationConfigurationsResult result;
try {
result = describeNotificationConfigurations(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeNotificationConfigurations operation.
*
* @see #describeNotificationConfigurationsAsync(DescribeNotificationConfigurationsRequest)
*/
@Override
public java.util.concurrent.Future describeNotificationConfigurationsAsync() {
return describeNotificationConfigurationsAsync(new DescribeNotificationConfigurationsRequest());
}
/**
* Simplified method form for invoking the DescribeNotificationConfigurations operation with an AsyncHandler.
*
* @see #describeNotificationConfigurationsAsync(DescribeNotificationConfigurationsRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeNotificationConfigurationsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeNotificationConfigurationsAsync(new DescribeNotificationConfigurationsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describePoliciesAsync(DescribePoliciesRequest request) {
return describePoliciesAsync(request, null);
}
@Override
public java.util.concurrent.Future describePoliciesAsync(final DescribePoliciesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribePoliciesResult call() throws Exception {
DescribePoliciesResult result;
try {
result = describePolicies(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribePolicies operation.
*
* @see #describePoliciesAsync(DescribePoliciesRequest)
*/
@Override
public java.util.concurrent.Future describePoliciesAsync() {
return describePoliciesAsync(new DescribePoliciesRequest());
}
/**
* Simplified method form for invoking the DescribePolicies operation with an AsyncHandler.
*
* @see #describePoliciesAsync(DescribePoliciesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describePoliciesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describePoliciesAsync(new DescribePoliciesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeScalingActivitiesAsync(DescribeScalingActivitiesRequest request) {
return describeScalingActivitiesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeScalingActivitiesAsync(final DescribeScalingActivitiesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeScalingActivitiesResult call() throws Exception {
DescribeScalingActivitiesResult result;
try {
result = describeScalingActivities(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeScalingActivities operation.
*
* @see #describeScalingActivitiesAsync(DescribeScalingActivitiesRequest)
*/
@Override
public java.util.concurrent.Future describeScalingActivitiesAsync() {
return describeScalingActivitiesAsync(new DescribeScalingActivitiesRequest());
}
/**
* Simplified method form for invoking the DescribeScalingActivities operation with an AsyncHandler.
*
* @see #describeScalingActivitiesAsync(DescribeScalingActivitiesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeScalingActivitiesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeScalingActivitiesAsync(new DescribeScalingActivitiesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeScalingProcessTypesAsync(DescribeScalingProcessTypesRequest request) {
return describeScalingProcessTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeScalingProcessTypesAsync(final DescribeScalingProcessTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeScalingProcessTypesResult call() throws Exception {
DescribeScalingProcessTypesResult result;
try {
result = describeScalingProcessTypes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeScalingProcessTypes operation.
*
* @see #describeScalingProcessTypesAsync(DescribeScalingProcessTypesRequest)
*/
@Override
public java.util.concurrent.Future describeScalingProcessTypesAsync() {
return describeScalingProcessTypesAsync(new DescribeScalingProcessTypesRequest());
}
/**
* Simplified method form for invoking the DescribeScalingProcessTypes operation with an AsyncHandler.
*
* @see #describeScalingProcessTypesAsync(DescribeScalingProcessTypesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeScalingProcessTypesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeScalingProcessTypesAsync(new DescribeScalingProcessTypesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeScheduledActionsAsync(DescribeScheduledActionsRequest request) {
return describeScheduledActionsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeScheduledActionsAsync(final DescribeScheduledActionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeScheduledActionsResult call() throws Exception {
DescribeScheduledActionsResult result;
try {
result = describeScheduledActions(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeScheduledActions operation.
*
* @see #describeScheduledActionsAsync(DescribeScheduledActionsRequest)
*/
@Override
public java.util.concurrent.Future describeScheduledActionsAsync() {
return describeScheduledActionsAsync(new DescribeScheduledActionsRequest());
}
/**
* Simplified method form for invoking the DescribeScheduledActions operation with an AsyncHandler.
*
* @see #describeScheduledActionsAsync(DescribeScheduledActionsRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeScheduledActionsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeScheduledActionsAsync(new DescribeScheduledActionsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeTagsAsync(DescribeTagsRequest request) {
return describeTagsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeTagsAsync(final DescribeTagsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeTagsResult call() throws Exception {
DescribeTagsResult result;
try {
result = describeTags(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeTags operation.
*
* @see #describeTagsAsync(DescribeTagsRequest)
*/
@Override
public java.util.concurrent.Future describeTagsAsync() {
return describeTagsAsync(new DescribeTagsRequest());
}
/**
* Simplified method form for invoking the DescribeTags operation with an AsyncHandler.
*
* @see #describeTagsAsync(DescribeTagsRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeTagsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeTagsAsync(new DescribeTagsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeTerminationPolicyTypesAsync(DescribeTerminationPolicyTypesRequest request) {
return describeTerminationPolicyTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeTerminationPolicyTypesAsync(
final DescribeTerminationPolicyTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeTerminationPolicyTypesResult call() throws Exception {
DescribeTerminationPolicyTypesResult result;
try {
result = describeTerminationPolicyTypes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeTerminationPolicyTypes operation.
*
* @see #describeTerminationPolicyTypesAsync(DescribeTerminationPolicyTypesRequest)
*/
@Override
public java.util.concurrent.Future describeTerminationPolicyTypesAsync() {
return describeTerminationPolicyTypesAsync(new DescribeTerminationPolicyTypesRequest());
}
/**
* Simplified method form for invoking the DescribeTerminationPolicyTypes operation with an AsyncHandler.
*
* @see #describeTerminationPolicyTypesAsync(DescribeTerminationPolicyTypesRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeTerminationPolicyTypesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeTerminationPolicyTypesAsync(new DescribeTerminationPolicyTypesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future detachInstancesAsync(DetachInstancesRequest request) {
return detachInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future detachInstancesAsync(final DetachInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachInstancesResult call() throws Exception {
DetachInstancesResult result;
try {
result = detachInstances(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 detachLoadBalancerTargetGroupsAsync(DetachLoadBalancerTargetGroupsRequest request) {
return detachLoadBalancerTargetGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future detachLoadBalancerTargetGroupsAsync(
final DetachLoadBalancerTargetGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachLoadBalancerTargetGroupsResult call() throws Exception {
DetachLoadBalancerTargetGroupsResult result;
try {
result = detachLoadBalancerTargetGroups(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 detachLoadBalancersAsync(DetachLoadBalancersRequest request) {
return detachLoadBalancersAsync(request, null);
}
@Override
public java.util.concurrent.Future detachLoadBalancersAsync(final DetachLoadBalancersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachLoadBalancersResult call() throws Exception {
DetachLoadBalancersResult result;
try {
result = detachLoadBalancers(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DetachLoadBalancers operation.
*
* @see #detachLoadBalancersAsync(DetachLoadBalancersRequest)
*/
@Override
public java.util.concurrent.Future detachLoadBalancersAsync() {
return detachLoadBalancersAsync(new DetachLoadBalancersRequest());
}
/**
* Simplified method form for invoking the DetachLoadBalancers operation with an AsyncHandler.
*
* @see #detachLoadBalancersAsync(DetachLoadBalancersRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future detachLoadBalancersAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return detachLoadBalancersAsync(new DetachLoadBalancersRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future disableMetricsCollectionAsync(DisableMetricsCollectionRequest request) {
return disableMetricsCollectionAsync(request, null);
}
@Override
public java.util.concurrent.Future disableMetricsCollectionAsync(final DisableMetricsCollectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisableMetricsCollectionResult call() throws Exception {
DisableMetricsCollectionResult result;
try {
result = disableMetricsCollection(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 enableMetricsCollectionAsync(EnableMetricsCollectionRequest request) {
return enableMetricsCollectionAsync(request, null);
}
@Override
public java.util.concurrent.Future enableMetricsCollectionAsync(final EnableMetricsCollectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public EnableMetricsCollectionResult call() throws Exception {
EnableMetricsCollectionResult result;
try {
result = enableMetricsCollection(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 enterStandbyAsync(EnterStandbyRequest request) {
return enterStandbyAsync(request, null);
}
@Override
public java.util.concurrent.Future enterStandbyAsync(final EnterStandbyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public EnterStandbyResult call() throws Exception {
EnterStandbyResult result;
try {
result = enterStandby(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 executePolicyAsync(ExecutePolicyRequest request) {
return executePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future executePolicyAsync(final ExecutePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ExecutePolicyResult call() throws Exception {
ExecutePolicyResult result;
try {
result = executePolicy(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 exitStandbyAsync(ExitStandbyRequest request) {
return exitStandbyAsync(request, null);
}
@Override
public java.util.concurrent.Future exitStandbyAsync(final ExitStandbyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ExitStandbyResult call() throws Exception {
ExitStandbyResult result;
try {
result = exitStandby(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 putLifecycleHookAsync(PutLifecycleHookRequest request) {
return putLifecycleHookAsync(request, null);
}
@Override
public java.util.concurrent.Future putLifecycleHookAsync(final PutLifecycleHookRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PutLifecycleHookResult call() throws Exception {
PutLifecycleHookResult result;
try {
result = putLifecycleHook(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 putNotificationConfigurationAsync(PutNotificationConfigurationRequest request) {
return putNotificationConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future putNotificationConfigurationAsync(final PutNotificationConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PutNotificationConfigurationResult call() throws Exception {
PutNotificationConfigurationResult result;
try {
result = putNotificationConfiguration(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 putScalingPolicyAsync(PutScalingPolicyRequest request) {
return putScalingPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future putScalingPolicyAsync(final PutScalingPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PutScalingPolicyResult call() throws Exception {
PutScalingPolicyResult result;
try {
result = putScalingPolicy(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 putScheduledUpdateGroupActionAsync(PutScheduledUpdateGroupActionRequest request) {
return putScheduledUpdateGroupActionAsync(request, null);
}
@Override
public java.util.concurrent.Future putScheduledUpdateGroupActionAsync(
final PutScheduledUpdateGroupActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PutScheduledUpdateGroupActionResult call() throws Exception {
PutScheduledUpdateGroupActionResult result;
try {
result = putScheduledUpdateGroupAction(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 recordLifecycleActionHeartbeatAsync(RecordLifecycleActionHeartbeatRequest request) {
return recordLifecycleActionHeartbeatAsync(request, null);
}
@Override
public java.util.concurrent.Future recordLifecycleActionHeartbeatAsync(
final RecordLifecycleActionHeartbeatRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RecordLifecycleActionHeartbeatResult call() throws Exception {
RecordLifecycleActionHeartbeatResult result;
try {
result = recordLifecycleActionHeartbeat(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 resumeProcessesAsync(ResumeProcessesRequest request) {
return resumeProcessesAsync(request, null);
}
@Override
public java.util.concurrent.Future resumeProcessesAsync(final ResumeProcessesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ResumeProcessesResult call() throws Exception {
ResumeProcessesResult result;
try {
result = resumeProcesses(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 setDesiredCapacityAsync(SetDesiredCapacityRequest request) {
return setDesiredCapacityAsync(request, null);
}
@Override
public java.util.concurrent.Future setDesiredCapacityAsync(final SetDesiredCapacityRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public SetDesiredCapacityResult call() throws Exception {
SetDesiredCapacityResult result;
try {
result = setDesiredCapacity(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 setInstanceHealthAsync(SetInstanceHealthRequest request) {
return setInstanceHealthAsync(request, null);
}
@Override
public java.util.concurrent.Future setInstanceHealthAsync(final SetInstanceHealthRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public SetInstanceHealthResult call() throws Exception {
SetInstanceHealthResult result;
try {
result = setInstanceHealth(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 setInstanceProtectionAsync(SetInstanceProtectionRequest request) {
return setInstanceProtectionAsync(request, null);
}
@Override
public java.util.concurrent.Future setInstanceProtectionAsync(final SetInstanceProtectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public SetInstanceProtectionResult call() throws Exception {
SetInstanceProtectionResult result;
try {
result = setInstanceProtection(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 suspendProcessesAsync(SuspendProcessesRequest request) {
return suspendProcessesAsync(request, null);
}
@Override
public java.util.concurrent.Future