com.amazonaws.services.route53.AmazonRoute53AsyncClient Maven / Gradle / Ivy
/*
* Copyright 2019-2024 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 static java.util.concurrent.Executors.newFixedThreadPool;
import javax.annotation.Generated;
import com.amazonaws.services.route53.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import java.util.concurrent.ExecutorService;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
/**
* Client for accessing 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.
*
*
* Amazon Route 53 is a highly available and scalable Domain Name System (DNS) web service.
*
*
* You can use Route 53 to:
*
*
* -
*
* Register domain names.
*
*
* For more information, see How domain
* registration works.
*
*
* -
*
* Route internet traffic to the resources for your domain
*
*
* For more information, see How internet traffic is
* routed to your website or web application.
*
*
* -
*
* Check the health of your resources.
*
*
* For more information, see How Route 53 checks the
* health of your resources.
*
*
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
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)
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonRoute53AsyncClient() {
this(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)
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonRoute53AsyncClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, 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)
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonRoute53AsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, 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.
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRoute53AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonRoute53AsyncClient(AWSCredentials awsCredentials, 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.
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRoute53AsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonRoute53AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonRoute53AsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, 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)
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonRoute53AsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, 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)
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRoute53AsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonRoute53AsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, 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.
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRoute53AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonRoute53AsyncClient(AWSCredentialsProvider awsCredentialsProvider, 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.
* @deprecated use {@link AmazonRoute53AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRoute53AsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonRoute53AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonRoute53AsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
public static AmazonRoute53AsyncClientBuilder asyncBuilder() {
return AmazonRoute53AsyncClientBuilder.standard();
}
/**
* 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) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Route 53 using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AmazonRoute53AsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
super(asyncClientParams, endpointDiscoveryEnabled);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async requests.
*
* @return The executor service used by this client to execute async requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future activateKeySigningKeyAsync(ActivateKeySigningKeyRequest request) {
return activateKeySigningKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future activateKeySigningKeyAsync(final ActivateKeySigningKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ActivateKeySigningKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ActivateKeySigningKeyResult call() throws Exception {
ActivateKeySigningKeyResult result = null;
try {
result = executeActivateKeySigningKey(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future associateVPCWithHostedZoneAsync(AssociateVPCWithHostedZoneRequest request) {
return associateVPCWithHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future associateVPCWithHostedZoneAsync(final AssociateVPCWithHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AssociateVPCWithHostedZoneRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AssociateVPCWithHostedZoneResult call() throws Exception {
AssociateVPCWithHostedZoneResult result = null;
try {
result = executeAssociateVPCWithHostedZone(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future changeCidrCollectionAsync(ChangeCidrCollectionRequest request) {
return changeCidrCollectionAsync(request, null);
}
@Override
public java.util.concurrent.Future changeCidrCollectionAsync(final ChangeCidrCollectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ChangeCidrCollectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangeCidrCollectionResult call() throws Exception {
ChangeCidrCollectionResult result = null;
try {
result = executeChangeCidrCollection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future changeResourceRecordSetsAsync(ChangeResourceRecordSetsRequest request) {
return changeResourceRecordSetsAsync(request, null);
}
@Override
public java.util.concurrent.Future changeResourceRecordSetsAsync(final ChangeResourceRecordSetsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ChangeResourceRecordSetsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangeResourceRecordSetsResult call() throws Exception {
ChangeResourceRecordSetsResult result = null;
try {
result = executeChangeResourceRecordSets(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future changeTagsForResourceAsync(ChangeTagsForResourceRequest request) {
return changeTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future changeTagsForResourceAsync(final ChangeTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ChangeTagsForResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangeTagsForResourceResult call() throws Exception {
ChangeTagsForResourceResult result = null;
try {
result = executeChangeTagsForResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createCidrCollectionAsync(CreateCidrCollectionRequest request) {
return createCidrCollectionAsync(request, null);
}
@Override
public java.util.concurrent.Future createCidrCollectionAsync(final CreateCidrCollectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCidrCollectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCidrCollectionResult call() throws Exception {
CreateCidrCollectionResult result = null;
try {
result = executeCreateCidrCollection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createHealthCheckAsync(CreateHealthCheckRequest request) {
return createHealthCheckAsync(request, null);
}
@Override
public java.util.concurrent.Future createHealthCheckAsync(final CreateHealthCheckRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateHealthCheckRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateHealthCheckResult call() throws Exception {
CreateHealthCheckResult result = null;
try {
result = executeCreateHealthCheck(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createHostedZoneAsync(CreateHostedZoneRequest request) {
return createHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future createHostedZoneAsync(final CreateHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateHostedZoneRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateHostedZoneResult call() throws Exception {
CreateHostedZoneResult result = null;
try {
result = executeCreateHostedZone(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createKeySigningKeyAsync(CreateKeySigningKeyRequest request) {
return createKeySigningKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future createKeySigningKeyAsync(final CreateKeySigningKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateKeySigningKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateKeySigningKeyResult call() throws Exception {
CreateKeySigningKeyResult result = null;
try {
result = executeCreateKeySigningKey(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createQueryLoggingConfigAsync(CreateQueryLoggingConfigRequest request) {
return createQueryLoggingConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future createQueryLoggingConfigAsync(final CreateQueryLoggingConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateQueryLoggingConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateQueryLoggingConfigResult call() throws Exception {
CreateQueryLoggingConfigResult result = null;
try {
result = executeCreateQueryLoggingConfig(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createReusableDelegationSetAsync(CreateReusableDelegationSetRequest request) {
return createReusableDelegationSetAsync(request, null);
}
@Override
public java.util.concurrent.Future createReusableDelegationSetAsync(final CreateReusableDelegationSetRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateReusableDelegationSetRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateReusableDelegationSetResult call() throws Exception {
CreateReusableDelegationSetResult result = null;
try {
result = executeCreateReusableDelegationSet(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createTrafficPolicyAsync(CreateTrafficPolicyRequest request) {
return createTrafficPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future createTrafficPolicyAsync(final CreateTrafficPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateTrafficPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTrafficPolicyResult call() throws Exception {
CreateTrafficPolicyResult result = null;
try {
result = executeCreateTrafficPolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createTrafficPolicyInstanceAsync(CreateTrafficPolicyInstanceRequest request) {
return createTrafficPolicyInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future createTrafficPolicyInstanceAsync(final CreateTrafficPolicyInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateTrafficPolicyInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTrafficPolicyInstanceResult call() throws Exception {
CreateTrafficPolicyInstanceResult result = null;
try {
result = executeCreateTrafficPolicyInstance(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createTrafficPolicyVersionAsync(CreateTrafficPolicyVersionRequest request) {
return createTrafficPolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createTrafficPolicyVersionAsync(final CreateTrafficPolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateTrafficPolicyVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTrafficPolicyVersionResult call() throws Exception {
CreateTrafficPolicyVersionResult result = null;
try {
result = executeCreateTrafficPolicyVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createVPCAssociationAuthorizationAsync(
CreateVPCAssociationAuthorizationRequest request) {
return createVPCAssociationAuthorizationAsync(request, null);
}
@Override
public java.util.concurrent.Future createVPCAssociationAuthorizationAsync(
final CreateVPCAssociationAuthorizationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateVPCAssociationAuthorizationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateVPCAssociationAuthorizationResult call() throws Exception {
CreateVPCAssociationAuthorizationResult result = null;
try {
result = executeCreateVPCAssociationAuthorization(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deactivateKeySigningKeyAsync(DeactivateKeySigningKeyRequest request) {
return deactivateKeySigningKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future deactivateKeySigningKeyAsync(final DeactivateKeySigningKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeactivateKeySigningKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeactivateKeySigningKeyResult call() throws Exception {
DeactivateKeySigningKeyResult result = null;
try {
result = executeDeactivateKeySigningKey(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteCidrCollectionAsync(DeleteCidrCollectionRequest request) {
return deleteCidrCollectionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCidrCollectionAsync(final DeleteCidrCollectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCidrCollectionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCidrCollectionResult call() throws Exception {
DeleteCidrCollectionResult result = null;
try {
result = executeDeleteCidrCollection(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteHealthCheckAsync(DeleteHealthCheckRequest request) {
return deleteHealthCheckAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteHealthCheckAsync(final DeleteHealthCheckRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteHealthCheckRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteHealthCheckResult call() throws Exception {
DeleteHealthCheckResult result = null;
try {
result = executeDeleteHealthCheck(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteHostedZoneAsync(DeleteHostedZoneRequest request) {
return deleteHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteHostedZoneAsync(final DeleteHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteHostedZoneRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteHostedZoneResult call() throws Exception {
DeleteHostedZoneResult result = null;
try {
result = executeDeleteHostedZone(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteKeySigningKeyAsync(DeleteKeySigningKeyRequest request) {
return deleteKeySigningKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteKeySigningKeyAsync(final DeleteKeySigningKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteKeySigningKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteKeySigningKeyResult call() throws Exception {
DeleteKeySigningKeyResult result = null;
try {
result = executeDeleteKeySigningKey(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteQueryLoggingConfigAsync(DeleteQueryLoggingConfigRequest request) {
return deleteQueryLoggingConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteQueryLoggingConfigAsync(final DeleteQueryLoggingConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteQueryLoggingConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteQueryLoggingConfigResult call() throws Exception {
DeleteQueryLoggingConfigResult result = null;
try {
result = executeDeleteQueryLoggingConfig(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteReusableDelegationSetAsync(DeleteReusableDelegationSetRequest request) {
return deleteReusableDelegationSetAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteReusableDelegationSetAsync(final DeleteReusableDelegationSetRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteReusableDelegationSetRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteReusableDelegationSetResult call() throws Exception {
DeleteReusableDelegationSetResult result = null;
try {
result = executeDeleteReusableDelegationSet(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteTrafficPolicyAsync(DeleteTrafficPolicyRequest request) {
return deleteTrafficPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTrafficPolicyAsync(final DeleteTrafficPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteTrafficPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTrafficPolicyResult call() throws Exception {
DeleteTrafficPolicyResult result = null;
try {
result = executeDeleteTrafficPolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteTrafficPolicyInstanceAsync(DeleteTrafficPolicyInstanceRequest request) {
return deleteTrafficPolicyInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTrafficPolicyInstanceAsync(final DeleteTrafficPolicyInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteTrafficPolicyInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTrafficPolicyInstanceResult call() throws Exception {
DeleteTrafficPolicyInstanceResult result = null;
try {
result = executeDeleteTrafficPolicyInstance(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteVPCAssociationAuthorizationAsync(
DeleteVPCAssociationAuthorizationRequest request) {
return deleteVPCAssociationAuthorizationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteVPCAssociationAuthorizationAsync(
final DeleteVPCAssociationAuthorizationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteVPCAssociationAuthorizationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteVPCAssociationAuthorizationResult call() throws Exception {
DeleteVPCAssociationAuthorizationResult result = null;
try {
result = executeDeleteVPCAssociationAuthorization(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future disableHostedZoneDNSSECAsync(DisableHostedZoneDNSSECRequest request) {
return disableHostedZoneDNSSECAsync(request, null);
}
@Override
public java.util.concurrent.Future disableHostedZoneDNSSECAsync(final DisableHostedZoneDNSSECRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DisableHostedZoneDNSSECRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisableHostedZoneDNSSECResult call() throws Exception {
DisableHostedZoneDNSSECResult result = null;
try {
result = executeDisableHostedZoneDNSSEC(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future disassociateVPCFromHostedZoneAsync(DisassociateVPCFromHostedZoneRequest request) {
return disassociateVPCFromHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future disassociateVPCFromHostedZoneAsync(
final DisassociateVPCFromHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DisassociateVPCFromHostedZoneRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisassociateVPCFromHostedZoneResult call() throws Exception {
DisassociateVPCFromHostedZoneResult result = null;
try {
result = executeDisassociateVPCFromHostedZone(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future enableHostedZoneDNSSECAsync(EnableHostedZoneDNSSECRequest request) {
return enableHostedZoneDNSSECAsync(request, null);
}
@Override
public java.util.concurrent.Future enableHostedZoneDNSSECAsync(final EnableHostedZoneDNSSECRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final EnableHostedZoneDNSSECRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public EnableHostedZoneDNSSECResult call() throws Exception {
EnableHostedZoneDNSSECResult result = null;
try {
result = executeEnableHostedZoneDNSSEC(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getAccountLimitAsync(GetAccountLimitRequest request) {
return getAccountLimitAsync(request, null);
}
@Override
public java.util.concurrent.Future getAccountLimitAsync(final GetAccountLimitRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAccountLimitRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountLimitResult call() throws Exception {
GetAccountLimitResult result = null;
try {
result = executeGetAccountLimit(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getChangeAsync(GetChangeRequest request) {
return getChangeAsync(request, null);
}
@Override
public java.util.concurrent.Future getChangeAsync(final GetChangeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetChangeRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetChangeResult call() throws Exception {
GetChangeResult result = null;
try {
result = executeGetChange(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCheckerIpRangesAsync(GetCheckerIpRangesRequest request) {
return getCheckerIpRangesAsync(request, null);
}
@Override
public java.util.concurrent.Future getCheckerIpRangesAsync(final GetCheckerIpRangesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCheckerIpRangesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCheckerIpRangesResult call() throws Exception {
GetCheckerIpRangesResult result = null;
try {
result = executeGetCheckerIpRanges(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
public java.util.concurrent.Future getCheckerIpRangesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getCheckerIpRangesAsync(new GetCheckerIpRangesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getDNSSECAsync(GetDNSSECRequest request) {
return getDNSSECAsync(request, null);
}
@Override
public java.util.concurrent.Future getDNSSECAsync(final GetDNSSECRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetDNSSECRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetDNSSECResult call() throws Exception {
GetDNSSECResult result = null;
try {
result = executeGetDNSSEC(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getGeoLocationAsync(GetGeoLocationRequest request) {
return getGeoLocationAsync(request, null);
}
@Override
public java.util.concurrent.Future getGeoLocationAsync(final GetGeoLocationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetGeoLocationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetGeoLocationResult call() throws Exception {
GetGeoLocationResult result = null;
try {
result = executeGetGeoLocation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
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) {
final GetHealthCheckRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckResult call() throws Exception {
GetHealthCheckResult result = null;
try {
result = executeGetHealthCheck(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getHealthCheckCountAsync(GetHealthCheckCountRequest request) {
return getHealthCheckCountAsync(request, null);
}
@Override
public java.util.concurrent.Future getHealthCheckCountAsync(final GetHealthCheckCountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetHealthCheckCountRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckCountResult call() throws Exception {
GetHealthCheckCountResult result = null;
try {
result = executeGetHealthCheckCount(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
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) {
final GetHealthCheckLastFailureReasonRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckLastFailureReasonResult call() throws Exception {
GetHealthCheckLastFailureReasonResult result = null;
try {
result = executeGetHealthCheckLastFailureReason(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getHealthCheckStatusAsync(GetHealthCheckStatusRequest request) {
return getHealthCheckStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future getHealthCheckStatusAsync(final GetHealthCheckStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetHealthCheckStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHealthCheckStatusResult call() throws Exception {
GetHealthCheckStatusResult result = null;
try {
result = executeGetHealthCheckStatus(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getHostedZoneAsync(GetHostedZoneRequest request) {
return getHostedZoneAsync(request, null);
}
@Override
public java.util.concurrent.Future getHostedZoneAsync(final GetHostedZoneRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetHostedZoneRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHostedZoneResult call() throws Exception {
GetHostedZoneResult result = null;
try {
result = executeGetHostedZone(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getHostedZoneCountAsync(GetHostedZoneCountRequest request) {
return getHostedZoneCountAsync(request, null);
}
@Override
public java.util.concurrent.Future getHostedZoneCountAsync(final GetHostedZoneCountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetHostedZoneCountRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHostedZoneCountResult call() throws Exception {
GetHostedZoneCountResult result = null;
try {
result = executeGetHostedZoneCount(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
public java.util.concurrent.Future getHostedZoneCountAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getHostedZoneCountAsync(new GetHostedZoneCountRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getHostedZoneLimitAsync(GetHostedZoneLimitRequest request) {
return getHostedZoneLimitAsync(request, null);
}
@Override
public java.util.concurrent.Future getHostedZoneLimitAsync(final GetHostedZoneLimitRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetHostedZoneLimitRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetHostedZoneLimitResult call() throws Exception {
GetHostedZoneLimitResult result = null;
try {
result = executeGetHostedZoneLimit(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getQueryLoggingConfigAsync(GetQueryLoggingConfigRequest request) {
return getQueryLoggingConfigAsync(request, null);
}
@Override
public java.util.concurrent.Future getQueryLoggingConfigAsync(final GetQueryLoggingConfigRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetQueryLoggingConfigRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetQueryLoggingConfigResult call() throws Exception {
GetQueryLoggingConfigResult result = null;
try {
result = executeGetQueryLoggingConfig(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getReusableDelegationSetAsync(GetReusableDelegationSetRequest request) {
return getReusableDelegationSetAsync(request, null);
}
@Override
public java.util.concurrent.Future getReusableDelegationSetAsync(final GetReusableDelegationSetRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetReusableDelegationSetRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetReusableDelegationSetResult call() throws Exception {
GetReusableDelegationSetResult result = null;
try {
result = executeGetReusableDelegationSet(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getReusableDelegationSetLimitAsync(GetReusableDelegationSetLimitRequest request) {
return getReusableDelegationSetLimitAsync(request, null);
}
@Override
public java.util.concurrent.Future getReusableDelegationSetLimitAsync(
final GetReusableDelegationSetLimitRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetReusableDelegationSetLimitRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetReusableDelegationSetLimitResult call() throws Exception {
GetReusableDelegationSetLimitResult result = null;
try {
result = executeGetReusableDelegationSetLimit(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getTrafficPolicyAsync(GetTrafficPolicyRequest request) {
return getTrafficPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getTrafficPolicyAsync(final GetTrafficPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetTrafficPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTrafficPolicyResult call() throws Exception {
GetTrafficPolicyResult result = null;
try {
result = executeGetTrafficPolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceAsync(GetTrafficPolicyInstanceRequest request) {
return getTrafficPolicyInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceAsync(final GetTrafficPolicyInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetTrafficPolicyInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTrafficPolicyInstanceResult call() throws Exception {
GetTrafficPolicyInstanceResult result = null;
try {
result = executeGetTrafficPolicyInstance(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceCountAsync(GetTrafficPolicyInstanceCountRequest request) {
return getTrafficPolicyInstanceCountAsync(request, null);
}
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceCountAsync(
final GetTrafficPolicyInstanceCountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetTrafficPolicyInstanceCountRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTrafficPolicyInstanceCountResult call() throws Exception {
GetTrafficPolicyInstanceCountResult result = null;
try {
result = executeGetTrafficPolicyInstanceCount(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
public java.util.concurrent.Future getTrafficPolicyInstanceCountAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getTrafficPolicyInstanceCountAsync(new GetTrafficPolicyInstanceCountRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listCidrBlocksAsync(ListCidrBlocksRequest request) {
return listCidrBlocksAsync(request, null);
}
@Override
public java.util.concurrent.Future listCidrBlocksAsync(final ListCidrBlocksRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCidrBlocksRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCidrBlocksResult call() throws Exception {
ListCidrBlocksResult result = null;
try {
result = executeListCidrBlocks(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCidrCollectionsAsync(ListCidrCollectionsRequest request) {
return listCidrCollectionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCidrCollectionsAsync(final ListCidrCollectionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCidrCollectionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCidrCollectionsResult call() throws Exception {
ListCidrCollectionsResult result = null;
try {
result = executeListCidrCollections(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCidrLocationsAsync(ListCidrLocationsRequest request) {
return listCidrLocationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCidrLocationsAsync(final ListCidrLocationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCidrLocationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCidrLocationsResult call() throws Exception {
ListCidrLocationsResult result = null;
try {
result = executeListCidrLocations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listGeoLocationsAsync(ListGeoLocationsRequest request) {
return listGeoLocationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listGeoLocationsAsync(final ListGeoLocationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListGeoLocationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListGeoLocationsResult call() throws Exception {
ListGeoLocationsResult result = null;
try {
result = executeListGeoLocations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
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) {
final ListHealthChecksRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListHealthChecksResult call() throws Exception {
ListHealthChecksResult result = null;
try {
result = executeListHealthChecks(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
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) {
final ListHostedZonesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListHostedZonesResult call() throws Exception {
ListHostedZonesResult result = null;
try {
result = executeListHostedZones(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
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) {
final ListHostedZonesByNameRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListHostedZonesByNameResult call() throws Exception {
ListHostedZonesByNameResult result = null;
try {
result = executeListHostedZonesByName(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, 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)
*/
@Override
public java.util.concurrent.Future listHostedZonesByNameAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listHostedZonesByNameAsync(new ListHostedZonesByNameRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listHostedZonesByVPCAsync(ListHostedZonesByVPCRequest request) {
return listHostedZonesByVPCAsync(request, null);
}
@Override
public java.util.concurrent.Future listHostedZonesByVPCAsync(final ListHostedZonesByVPCRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListHostedZonesByVPCRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListHostedZonesByVPCResult call() throws Exception {
ListHostedZonesByVPCResult result = null;
try {
result = executeListHostedZonesByVPC(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listQueryLoggingConfigsAsync(ListQueryLoggingConfigsRequest request) {
return listQueryLoggingConfigsAsync(request, null);
}
@Override
public java.util.concurrent.Future listQueryLoggingConfigsAsync(final ListQueryLoggingConfigsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListQueryLoggingConfigsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListQueryLoggingConfigsResult call() throws Exception {
ListQueryLoggingConfigsResult result = null;
try {
result = executeListQueryLoggingConfigs(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listResourceRecordSetsAsync(ListResourceRecordSetsRequest request) {
return listResourceRecordSetsAsync(request, null);
}
@Override
public java.util.concurrent.Future