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(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* 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(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain(),
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();
}
}