com.amazonaws.services.route53.AmazonRoute53AsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-route53 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.route53;
import com.amazonaws.services.route53.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing Route 53 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.
*/
@ThreadSafe
public class AmazonRoute53AsyncClient extends AmazonRoute53Client implements AmazonRoute53Async {
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 Route 53. 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 AmazonRoute53AsyncClient() {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on Route 53. 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 Route 53 (ex: proxy settings,
* retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AmazonRoute53AsyncClient(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 Route 53 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 AmazonRoute53AsyncClient(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 Route 53 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 AmazonRoute53AsyncClient(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 Route 53 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 AmazonRoute53AsyncClient(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 Route 53 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 AmazonRoute53AsyncClient(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 Route 53 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 AmazonRoute53AsyncClient(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 Route 53 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 AmazonRoute53AsyncClient(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 Route 53 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 AmazonRoute53AsyncClient(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 Route 53 using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonRoute53AsyncClient(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 associateVPCWithHostedZoneAsync(AssociateVPCWithHostedZoneRequest request) {
return associateVPCWithHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future associateVPCWithHostedZoneAsync(final AssociateVPCWithHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AssociateVPCWithHostedZoneResult call() throws Exception {
AssociateVPCWithHostedZoneResult result;
try {
result = associateVPCWithHostedZone(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 changeResourceRecordSetsAsync(ChangeResourceRecordSetsRequest request) {
return changeResourceRecordSetsAsync(request, null);
}
@Override
public java.util.concurrent.Future changeResourceRecordSetsAsync(final ChangeResourceRecordSetsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangeResourceRecordSetsResult call() throws Exception {
ChangeResourceRecordSetsResult result;
try {
result = changeResourceRecordSets(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 changeTagsForResourceAsync(ChangeTagsForResourceRequest request) {
return changeTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future changeTagsForResourceAsync(final ChangeTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangeTagsForResourceResult call() throws Exception {
ChangeTagsForResourceResult result;
try {
result = changeTagsForResource(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 createHealthCheckAsync(CreateHealthCheckRequest request) {
return createHealthCheckAsync(request, null);
}
@Override
public java.util.concurrent.Future createHealthCheckAsync(final CreateHealthCheckRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateHealthCheckResult call() throws Exception {
CreateHealthCheckResult result;
try {
result = createHealthCheck(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 createHostedZoneAsync(CreateHostedZoneRequest request) {
return createHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future createHostedZoneAsync(final CreateHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateHostedZoneResult call() throws Exception {
CreateHostedZoneResult result;
try {
result = createHostedZone(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 createReusableDelegationSetAsync(CreateReusableDelegationSetRequest request) {
return createReusableDelegationSetAsync(request, null);
}
@Override
public java.util.concurrent.Future createReusableDelegationSetAsync(final CreateReusableDelegationSetRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateReusableDelegationSetResult call() throws Exception {
CreateReusableDelegationSetResult result;
try {
result = createReusableDelegationSet(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 createTrafficPolicyAsync(CreateTrafficPolicyRequest request) {
return createTrafficPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future createTrafficPolicyAsync(final CreateTrafficPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTrafficPolicyResult call() throws Exception {
CreateTrafficPolicyResult result;
try {
result = createTrafficPolicy(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 createTrafficPolicyInstanceAsync(CreateTrafficPolicyInstanceRequest request) {
return createTrafficPolicyInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future createTrafficPolicyInstanceAsync(final CreateTrafficPolicyInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTrafficPolicyInstanceResult call() throws Exception {
CreateTrafficPolicyInstanceResult result;
try {
result = createTrafficPolicyInstance(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 createTrafficPolicyVersionAsync(CreateTrafficPolicyVersionRequest request) {
return createTrafficPolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createTrafficPolicyVersionAsync(final CreateTrafficPolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTrafficPolicyVersionResult call() throws Exception {
CreateTrafficPolicyVersionResult result;
try {
result = createTrafficPolicyVersion(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 deleteHealthCheckAsync(DeleteHealthCheckRequest request) {
return deleteHealthCheckAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteHealthCheckAsync(final DeleteHealthCheckRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteHealthCheckResult call() throws Exception {
DeleteHealthCheckResult result;
try {
result = deleteHealthCheck(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 deleteHostedZoneAsync(DeleteHostedZoneRequest request) {
return deleteHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteHostedZoneAsync(final DeleteHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteHostedZoneResult call() throws Exception {
DeleteHostedZoneResult result;
try {
result = deleteHostedZone(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 deleteReusableDelegationSetAsync(DeleteReusableDelegationSetRequest request) {
return deleteReusableDelegationSetAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteReusableDelegationSetAsync(final DeleteReusableDelegationSetRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteReusableDelegationSetResult call() throws Exception {
DeleteReusableDelegationSetResult result;
try {
result = deleteReusableDelegationSet(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 deleteTrafficPolicyAsync(DeleteTrafficPolicyRequest request) {
return deleteTrafficPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTrafficPolicyAsync(final DeleteTrafficPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTrafficPolicyResult call() throws Exception {
DeleteTrafficPolicyResult result;
try {
result = deleteTrafficPolicy(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 deleteTrafficPolicyInstanceAsync(DeleteTrafficPolicyInstanceRequest request) {
return deleteTrafficPolicyInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTrafficPolicyInstanceAsync(final DeleteTrafficPolicyInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTrafficPolicyInstanceResult call() throws Exception {
DeleteTrafficPolicyInstanceResult result;
try {
result = deleteTrafficPolicyInstance(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 disassociateVPCFromHostedZoneAsync(DisassociateVPCFromHostedZoneRequest request) {
return disassociateVPCFromHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future disassociateVPCFromHostedZoneAsync(
final DisassociateVPCFromHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisassociateVPCFromHostedZoneResult call() throws Exception {
DisassociateVPCFromHostedZoneResult result;
try {
result = disassociateVPCFromHostedZone(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 getChangeAsync(GetChangeRequest request) {
return getChangeAsync(request, null);
}
@Override
public java.util.concurrent.Future getChangeAsync(final GetChangeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetChangeResult call() throws Exception {
GetChangeResult result;
try {
result = getChange(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
@Deprecated
public java.util.concurrent.Future getChangeDetailsAsync(GetChangeDetailsRequest request) {
return getChangeDetailsAsync(request, null);
}
@Override
@Deprecated
public java.util.concurrent.Future getChangeDetailsAsync(final GetChangeDetailsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetChangeDetailsResult call() throws Exception {
GetChangeDetailsResult result;
try {
result = getChangeDetails(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 getCheckerIpRangesAsync(GetCheckerIpRangesRequest request) {
return getCheckerIpRangesAsync(request, null);
}
@Override
public java.util.concurrent.Future getCheckerIpRangesAsync(final GetCheckerIpRangesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCheckerIpRangesResult call() throws Exception {
GetCheckerIpRangesResult result;
try {
result = getCheckerIpRanges(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 GetCheckerIpRanges operation.
*
* @see #getCheckerIpRangesAsync(GetCheckerIpRangesRequest)
*/
@Override
public java.util.concurrent.Future getCheckerIpRangesAsync() {
return getCheckerIpRangesAsync(new GetCheckerIpRangesRequest());
}
/**
* Simplified method form for invoking the GetCheckerIpRanges operation with an AsyncHandler.
*
* @see #getCheckerIpRangesAsync(GetCheckerIpRangesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future getCheckerIpRangesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getCheckerIpRangesAsync(new GetCheckerIpRangesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getGeoLocationAsync(GetGeoLocationRequest request) {
return getGeoLocationAsync(request, null);
}
@Override
public java.util.concurrent.Future getGeoLocationAsync(final GetGeoLocationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetGeoLocationResult call() throws Exception {
GetGeoLocationResult result;
try {
result = getGeoLocation(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 GetGeoLocation operation.
*
* @see #getGeoLocationAsync(GetGeoLocationRequest)
*/
@Override
public java.util.concurrent.Future getGeoLocationAsync() {
return getGeoLocationAsync(new GetGeoLocationRequest());
}
/**
* Simplified method form for invoking the GetGeoLocation operation with an AsyncHandler.
*
* @see #getGeoLocationAsync(GetGeoLocationRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future getGeoLocationAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getGeoLocationAsync(new GetGeoLocationRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getHealthCheckAsync(GetHealthCheckRequest request) {
return getHealthCheckAsync(request, null);
}
@Override
public java.util.concurrent.Future getHealthCheckAsync(final GetHealthCheckRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckResult call() throws Exception {
GetHealthCheckResult result;
try {
result = getHealthCheck(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 getHealthCheckCountAsync(GetHealthCheckCountRequest request) {
return getHealthCheckCountAsync(request, null);
}
@Override
public java.util.concurrent.Future getHealthCheckCountAsync(final GetHealthCheckCountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckCountResult call() throws Exception {
GetHealthCheckCountResult result;
try {
result = getHealthCheckCount(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 GetHealthCheckCount operation.
*
* @see #getHealthCheckCountAsync(GetHealthCheckCountRequest)
*/
@Override
public java.util.concurrent.Future getHealthCheckCountAsync() {
return getHealthCheckCountAsync(new GetHealthCheckCountRequest());
}
/**
* Simplified method form for invoking the GetHealthCheckCount operation with an AsyncHandler.
*
* @see #getHealthCheckCountAsync(GetHealthCheckCountRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future getHealthCheckCountAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getHealthCheckCountAsync(new GetHealthCheckCountRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getHealthCheckLastFailureReasonAsync(
GetHealthCheckLastFailureReasonRequest request) {
return getHealthCheckLastFailureReasonAsync(request, null);
}
@Override
public java.util.concurrent.Future getHealthCheckLastFailureReasonAsync(
final GetHealthCheckLastFailureReasonRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckLastFailureReasonResult call() throws Exception {
GetHealthCheckLastFailureReasonResult result;
try {
result = getHealthCheckLastFailureReason(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 getHealthCheckStatusAsync(GetHealthCheckStatusRequest request) {
return getHealthCheckStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future getHealthCheckStatusAsync(final GetHealthCheckStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckStatusResult call() throws Exception {
GetHealthCheckStatusResult result;
try {
result = getHealthCheckStatus(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 getHostedZoneAsync(GetHostedZoneRequest request) {
return getHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future getHostedZoneAsync(final GetHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHostedZoneResult call() throws Exception {
GetHostedZoneResult result;
try {
result = getHostedZone(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 getHostedZoneCountAsync(GetHostedZoneCountRequest request) {
return getHostedZoneCountAsync(request, null);
}
@Override
public java.util.concurrent.Future getHostedZoneCountAsync(final GetHostedZoneCountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHostedZoneCountResult call() throws Exception {
GetHostedZoneCountResult result;
try {
result = getHostedZoneCount(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 GetHostedZoneCount operation.
*
* @see #getHostedZoneCountAsync(GetHostedZoneCountRequest)
*/
@Override
public java.util.concurrent.Future getHostedZoneCountAsync() {
return getHostedZoneCountAsync(new GetHostedZoneCountRequest());
}
/**
* Simplified method form for invoking the GetHostedZoneCount operation with an AsyncHandler.
*
* @see #getHostedZoneCountAsync(GetHostedZoneCountRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future getHostedZoneCountAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getHostedZoneCountAsync(new GetHostedZoneCountRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getReusableDelegationSetAsync(GetReusableDelegationSetRequest request) {
return getReusableDelegationSetAsync(request, null);
}
@Override
public java.util.concurrent.Future getReusableDelegationSetAsync(final GetReusableDelegationSetRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetReusableDelegationSetResult call() throws Exception {
GetReusableDelegationSetResult result;
try {
result = getReusableDelegationSet(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 getTrafficPolicyAsync(GetTrafficPolicyRequest request) {
return getTrafficPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getTrafficPolicyAsync(final GetTrafficPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTrafficPolicyResult call() throws Exception {
GetTrafficPolicyResult result;
try {
result = getTrafficPolicy(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 getTrafficPolicyInstanceAsync(GetTrafficPolicyInstanceRequest request) {
return getTrafficPolicyInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceAsync(final GetTrafficPolicyInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTrafficPolicyInstanceResult call() throws Exception {
GetTrafficPolicyInstanceResult result;
try {
result = getTrafficPolicyInstance(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 getTrafficPolicyInstanceCountAsync(GetTrafficPolicyInstanceCountRequest request) {
return getTrafficPolicyInstanceCountAsync(request, null);
}
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceCountAsync(
final GetTrafficPolicyInstanceCountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTrafficPolicyInstanceCountResult call() throws Exception {
GetTrafficPolicyInstanceCountResult result;
try {
result = getTrafficPolicyInstanceCount(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 GetTrafficPolicyInstanceCount operation.
*
* @see #getTrafficPolicyInstanceCountAsync(GetTrafficPolicyInstanceCountRequest)
*/
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceCountAsync() {
return getTrafficPolicyInstanceCountAsync(new GetTrafficPolicyInstanceCountRequest());
}
/**
* Simplified method form for invoking the GetTrafficPolicyInstanceCount operation with an AsyncHandler.
*
* @see #getTrafficPolicyInstanceCountAsync(GetTrafficPolicyInstanceCountRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future getTrafficPolicyInstanceCountAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getTrafficPolicyInstanceCountAsync(new GetTrafficPolicyInstanceCountRequest(), asyncHandler);
}
@Override
@Deprecated
public java.util.concurrent.Future listChangeBatchesByHostedZoneAsync(ListChangeBatchesByHostedZoneRequest request) {
return listChangeBatchesByHostedZoneAsync(request, null);
}
@Override
@Deprecated
public java.util.concurrent.Future listChangeBatchesByHostedZoneAsync(
final ListChangeBatchesByHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListChangeBatchesByHostedZoneResult call() throws Exception {
ListChangeBatchesByHostedZoneResult result;
try {
result = listChangeBatchesByHostedZone(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
@Deprecated
public java.util.concurrent.Future listChangeBatchesByRRSetAsync(ListChangeBatchesByRRSetRequest request) {
return listChangeBatchesByRRSetAsync(request, null);
}
@Override
@Deprecated
public java.util.concurrent.Future listChangeBatchesByRRSetAsync(final ListChangeBatchesByRRSetRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListChangeBatchesByRRSetResult call() throws Exception {
ListChangeBatchesByRRSetResult result;
try {
result = listChangeBatchesByRRSet(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 listGeoLocationsAsync(ListGeoLocationsRequest request) {
return listGeoLocationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listGeoLocationsAsync(final ListGeoLocationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListGeoLocationsResult call() throws Exception {
ListGeoLocationsResult result;
try {
result = listGeoLocations(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 ListGeoLocations operation.
*
* @see #listGeoLocationsAsync(ListGeoLocationsRequest)
*/
@Override
public java.util.concurrent.Future listGeoLocationsAsync() {
return listGeoLocationsAsync(new ListGeoLocationsRequest());
}
/**
* Simplified method form for invoking the ListGeoLocations operation with an AsyncHandler.
*
* @see #listGeoLocationsAsync(ListGeoLocationsRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listGeoLocationsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listGeoLocationsAsync(new ListGeoLocationsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listHealthChecksAsync(ListHealthChecksRequest request) {
return listHealthChecksAsync(request, null);
}
@Override
public java.util.concurrent.Future listHealthChecksAsync(final ListHealthChecksRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListHealthChecksResult call() throws Exception {
ListHealthChecksResult result;
try {
result = listHealthChecks(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 ListHealthChecks operation.
*
* @see #listHealthChecksAsync(ListHealthChecksRequest)
*/
@Override
public java.util.concurrent.Future listHealthChecksAsync() {
return listHealthChecksAsync(new ListHealthChecksRequest());
}
/**
* Simplified method form for invoking the ListHealthChecks operation with an AsyncHandler.
*
* @see #listHealthChecksAsync(ListHealthChecksRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listHealthChecksAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listHealthChecksAsync(new ListHealthChecksRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listHostedZonesAsync(ListHostedZonesRequest request) {
return listHostedZonesAsync(request, null);
}
@Override
public java.util.concurrent.Future listHostedZonesAsync(final ListHostedZonesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListHostedZonesResult call() throws Exception {
ListHostedZonesResult result;
try {
result = listHostedZones(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 ListHostedZones operation.
*
* @see #listHostedZonesAsync(ListHostedZonesRequest)
*/
@Override
public java.util.concurrent.Future listHostedZonesAsync() {
return listHostedZonesAsync(new ListHostedZonesRequest());
}
/**
* Simplified method form for invoking the ListHostedZones operation with an AsyncHandler.
*
* @see #listHostedZonesAsync(ListHostedZonesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listHostedZonesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listHostedZonesAsync(new ListHostedZonesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listHostedZonesByNameAsync(ListHostedZonesByNameRequest request) {
return listHostedZonesByNameAsync(request, null);
}
@Override
public java.util.concurrent.Future listHostedZonesByNameAsync(final ListHostedZonesByNameRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListHostedZonesByNameResult call() throws Exception {
ListHostedZonesByNameResult result;
try {
result = listHostedZonesByName(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 ListHostedZonesByName operation.
*
* @see #listHostedZonesByNameAsync(ListHostedZonesByNameRequest)
*/
@Override
public java.util.concurrent.Future listHostedZonesByNameAsync() {
return listHostedZonesByNameAsync(new ListHostedZonesByNameRequest());
}
/**
* Simplified method form for invoking the ListHostedZonesByName operation with an AsyncHandler.
*
* @see #listHostedZonesByNameAsync(ListHostedZonesByNameRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listHostedZonesByNameAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listHostedZonesByNameAsync(new ListHostedZonesByNameRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listResourceRecordSetsAsync(ListResourceRecordSetsRequest request) {
return listResourceRecordSetsAsync(request, null);
}
@Override
public java.util.concurrent.Future listResourceRecordSetsAsync(final ListResourceRecordSetsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListResourceRecordSetsResult call() throws Exception {
ListResourceRecordSetsResult result;
try {
result = listResourceRecordSets(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 listReusableDelegationSetsAsync(ListReusableDelegationSetsRequest request) {
return listReusableDelegationSetsAsync(request, null);
}
@Override
public java.util.concurrent.Future listReusableDelegationSetsAsync(final ListReusableDelegationSetsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListReusableDelegationSetsResult call() throws Exception {
ListReusableDelegationSetsResult result;
try {
result = listReusableDelegationSets(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 ListReusableDelegationSets operation.
*
* @see #listReusableDelegationSetsAsync(ListReusableDelegationSetsRequest)
*/
@Override
public java.util.concurrent.Future listReusableDelegationSetsAsync() {
return listReusableDelegationSetsAsync(new ListReusableDelegationSetsRequest());
}
/**
* Simplified method form for invoking the ListReusableDelegationSets operation with an AsyncHandler.
*
* @see #listReusableDelegationSetsAsync(ListReusableDelegationSetsRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listReusableDelegationSetsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listReusableDelegationSetsAsync(new ListReusableDelegationSetsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result;
try {
result = listTagsForResource(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 listTagsForResourcesAsync(ListTagsForResourcesRequest request) {
return listTagsForResourcesAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourcesAsync(final ListTagsForResourcesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourcesResult call() throws Exception {
ListTagsForResourcesResult result;
try {
result = listTagsForResources(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 listTrafficPoliciesAsync(ListTrafficPoliciesRequest request) {
return listTrafficPoliciesAsync(request, null);
}
@Override
public java.util.concurrent.Future listTrafficPoliciesAsync(final ListTrafficPoliciesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTrafficPoliciesResult call() throws Exception {
ListTrafficPoliciesResult result;
try {
result = listTrafficPolicies(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 ListTrafficPolicies operation.
*
* @see #listTrafficPoliciesAsync(ListTrafficPoliciesRequest)
*/
@Override
public java.util.concurrent.Future listTrafficPoliciesAsync() {
return listTrafficPoliciesAsync(new ListTrafficPoliciesRequest());
}
/**
* Simplified method form for invoking the ListTrafficPolicies operation with an AsyncHandler.
*
* @see #listTrafficPoliciesAsync(ListTrafficPoliciesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listTrafficPoliciesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listTrafficPoliciesAsync(new ListTrafficPoliciesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listTrafficPolicyInstancesAsync(ListTrafficPolicyInstancesRequest request) {
return listTrafficPolicyInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future listTrafficPolicyInstancesAsync(final ListTrafficPolicyInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTrafficPolicyInstancesResult call() throws Exception {
ListTrafficPolicyInstancesResult result;
try {
result = listTrafficPolicyInstances(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 ListTrafficPolicyInstances operation.
*
* @see #listTrafficPolicyInstancesAsync(ListTrafficPolicyInstancesRequest)
*/
@Override
public java.util.concurrent.Future listTrafficPolicyInstancesAsync() {
return listTrafficPolicyInstancesAsync(new ListTrafficPolicyInstancesRequest());
}
/**
* Simplified method form for invoking the ListTrafficPolicyInstances operation with an AsyncHandler.
*
* @see #listTrafficPolicyInstancesAsync(ListTrafficPolicyInstancesRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listTrafficPolicyInstancesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listTrafficPolicyInstancesAsync(new ListTrafficPolicyInstancesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listTrafficPolicyInstancesByHostedZoneAsync(
ListTrafficPolicyInstancesByHostedZoneRequest request) {
return listTrafficPolicyInstancesByHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future listTrafficPolicyInstancesByHostedZoneAsync(
final ListTrafficPolicyInstancesByHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTrafficPolicyInstancesByHostedZoneResult call() throws Exception {
ListTrafficPolicyInstancesByHostedZoneResult result;
try {
result = listTrafficPolicyInstancesByHostedZone(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 listTrafficPolicyInstancesByPolicyAsync(
ListTrafficPolicyInstancesByPolicyRequest request) {
return listTrafficPolicyInstancesByPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future listTrafficPolicyInstancesByPolicyAsync(
final ListTrafficPolicyInstancesByPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTrafficPolicyInstancesByPolicyResult call() throws Exception {
ListTrafficPolicyInstancesByPolicyResult result;
try {
result = listTrafficPolicyInstancesByPolicy(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 listTrafficPolicyVersionsAsync(ListTrafficPolicyVersionsRequest request) {
return listTrafficPolicyVersionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listTrafficPolicyVersionsAsync(final ListTrafficPolicyVersionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTrafficPolicyVersionsResult call() throws Exception {
ListTrafficPolicyVersionsResult result;
try {
result = listTrafficPolicyVersions(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 testDNSAnswerAsync(TestDNSAnswerRequest request) {
return testDNSAnswerAsync(request, null);
}
@Override
public java.util.concurrent.Future testDNSAnswerAsync(final TestDNSAnswerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public TestDNSAnswerResult call() throws Exception {
TestDNSAnswerResult result;
try {
result = testDNSAnswer(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 updateHealthCheckAsync(UpdateHealthCheckRequest request) {
return updateHealthCheckAsync(request, null);
}
@Override
public java.util.concurrent.Future updateHealthCheckAsync(final UpdateHealthCheckRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateHealthCheckResult call() throws Exception {
UpdateHealthCheckResult result;
try {
result = updateHealthCheck(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 updateHostedZoneCommentAsync(UpdateHostedZoneCommentRequest request) {
return updateHostedZoneCommentAsync(request, null);
}
@Override
public java.util.concurrent.Future updateHostedZoneCommentAsync(final UpdateHostedZoneCommentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateHostedZoneCommentResult call() throws Exception {
UpdateHostedZoneCommentResult result;
try {
result = updateHostedZoneComment(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 updateTrafficPolicyCommentAsync(UpdateTrafficPolicyCommentRequest request) {
return updateTrafficPolicyCommentAsync(request, null);
}
@Override
public java.util.concurrent.Future updateTrafficPolicyCommentAsync(final UpdateTrafficPolicyCommentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateTrafficPolicyCommentResult call() throws Exception {
UpdateTrafficPolicyCommentResult result;
try {
result = updateTrafficPolicyComment(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 updateTrafficPolicyInstanceAsync(UpdateTrafficPolicyInstanceRequest request) {
return updateTrafficPolicyInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future updateTrafficPolicyInstanceAsync(final UpdateTrafficPolicyInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateTrafficPolicyInstanceResult call() throws Exception {
UpdateTrafficPolicyInstanceResult result;
try {
result = updateTrafficPolicyInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
* asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
* call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
* calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
}