com.amazonaws.services.route53.AmazonRoute53AsyncClient Maven / Gradle / Ivy
/*
* Copyright 2010-2014 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 java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.handlers.AsyncHandler;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.route53.model.*;
/**
* Asynchronous client for accessing AmazonRoute53.
* All asynchronous calls made using this client are non-blocking. Callers could either
* process the result and handle the exceptions in the worker thread by providing a callback handler
* when making the call, or use the returned Future object to check the result of the call in the calling thread.
*
*/
public class AmazonRoute53AsyncClient extends AmazonRoute53Client
implements AmazonRoute53Async {
/**
* Executor service for executing asynchronous requests.
*/
private ExecutorService executorService;
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53. 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
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonRoute53AsyncClient() {
this(new DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53. 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
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonRoute53
* (ex: proxy settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonRoute53AsyncClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53 using the specified AWS account credentials.
* Default client settings will be used, and a fixed size thread pool will be
* created for executing the asynchronous tasks.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
*/
public AmazonRoute53AsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53 using the specified AWS account credentials
* and executor service. Default client settings will be used.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentials awsCredentials, ExecutorService executorService) {
super(awsCredentials);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53 using the specified AWS account credentials,
* executor service, and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53 using the specified AWS account credentials provider.
* Default client settings will be used, and a fixed size thread pool will be
* created for executing the asynchronous tasks.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
*/
public AmazonRoute53AsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53 using the specified AWS account credentials provider
* and executor service. Default client settings will be used.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, new ClientConfiguration(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53 using the specified AWS account credentials
* provider and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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).
*/
public AmazonRoute53AsyncClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRoute53 using the specified AWS account credentials
* provider, executor service, and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Returns the executor service used by this async client to execute
* requests.
*
* @return The executor service used by this async client to execute
* requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
/**
* 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 getExecutorService().shutdown() followed by
* getExecutorService().awaitTermination() prior to calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
/**
*
* To retrieve the delegation set for a hosted zone, send a
* GET request to the 2013-04-01/hostedzone/hosted
* zone ID resource. The delegation set is the four Route 53 name
* servers that were assigned to the hosted zone when you created it.
*
*
* @param getHostedZoneRequest Container for the necessary parameters to
* execute the GetHostedZone operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* GetHostedZone service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getHostedZoneAsync(final GetHostedZoneRequest getHostedZoneRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetHostedZoneResult call() throws Exception {
return getHostedZone(getHostedZoneRequest);
}
});
}
/**
*
* To retrieve the delegation set for a hosted zone, send a
* GET request to the 2013-04-01/hostedzone/hosted
* zone ID resource. The delegation set is the four Route 53 name
* servers that were assigned to the hosted zone when you created it.
*
*
* @param getHostedZoneRequest Container for the necessary parameters to
* execute the GetHostedZone operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetHostedZone service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getHostedZoneAsync(
final GetHostedZoneRequest getHostedZoneRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetHostedZoneResult call() throws Exception {
GetHostedZoneResult result;
try {
result = getHostedZone(getHostedZoneRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getHostedZoneRequest, result);
return result;
}
});
}
/**
*
* This action returns the current status of a change batch request. The
* status is one of the following values:
*
*
* - PENDING indicates that the changes in this request
* have not replicated to all Route 53 DNS servers. This is the initial
* status of all change batch requests.
*
*
* - INSYNC indicates that the changes have replicated to
* all Amazon Route 53 DNS servers.
*
*
* @param getChangeRequest Container for the necessary parameters to
* execute the GetChange operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* GetChange service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getChangeAsync(final GetChangeRequest getChangeRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetChangeResult call() throws Exception {
return getChange(getChangeRequest);
}
});
}
/**
*
* This action returns the current status of a change batch request. The
* status is one of the following values:
*
*
* - PENDING indicates that the changes in this request
* have not replicated to all Route 53 DNS servers. This is the initial
* status of all change batch requests.
*
*
* - INSYNC indicates that the changes have replicated to
* all Amazon Route 53 DNS servers.
*
*
* @param getChangeRequest Container for the necessary parameters to
* execute the GetChange operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetChange service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getChangeAsync(
final GetChangeRequest getChangeRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetChangeResult call() throws Exception {
GetChangeResult result;
try {
result = getChange(getChangeRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getChangeRequest, result);
return result;
}
});
}
/**
*
* To retrieve a list of your hosted zones, send a GET
* request to the 2013-04-01/hostedzone resource. The
* response to this request includes a HostedZones element
* with zero, one, or multiple HostedZone child elements. By
* default, the list of hosted zones is displayed on a single page. You
* can control the length of the page that is displayed by using the
* MaxItems parameter. You can use the Marker
* parameter to control the hosted zone that the list begins with.
*
*
* NOTE: Amazon Route 53 returns a maximum of 100 items. If you
* set MaxItems to a value greater than 100, Amazon Route 53 returns only
* the first 100.
*
*
* @param listHostedZonesRequest Container for the necessary parameters
* to execute the ListHostedZones operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ListHostedZones service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listHostedZonesAsync(final ListHostedZonesRequest listHostedZonesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListHostedZonesResult call() throws Exception {
return listHostedZones(listHostedZonesRequest);
}
});
}
/**
*
* To retrieve a list of your hosted zones, send a GET
* request to the 2013-04-01/hostedzone resource. The
* response to this request includes a HostedZones element
* with zero, one, or multiple HostedZone child elements. By
* default, the list of hosted zones is displayed on a single page. You
* can control the length of the page that is displayed by using the
* MaxItems parameter. You can use the Marker
* parameter to control the hosted zone that the list begins with.
*
*
* NOTE: Amazon Route 53 returns a maximum of 100 items. If you
* set MaxItems to a value greater than 100, Amazon Route 53 returns only
* the first 100.
*
*
* @param listHostedZonesRequest Container for the necessary parameters
* to execute the ListHostedZones operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListHostedZones service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listHostedZonesAsync(
final ListHostedZonesRequest listHostedZonesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListHostedZonesResult call() throws Exception {
ListHostedZonesResult result;
try {
result = listHostedZones(listHostedZonesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listHostedZonesRequest, result);
return result;
}
});
}
/**
*
* This action updates an existing health check.
*
*
* To update a health check, send a POST request to the
* 2013-05-27/healthcheck/health check ID resource. The
* request body must include an XML document with an
* UpdateHealthCheckRequest element. The response returns an
* UpdateHealthCheckResponse element, which contains
* metadata about the health check.
*
*
* @param updateHealthCheckRequest Container for the necessary parameters
* to execute the UpdateHealthCheck operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* UpdateHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateHealthCheckAsync(final UpdateHealthCheckRequest updateHealthCheckRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateHealthCheckResult call() throws Exception {
return updateHealthCheck(updateHealthCheckRequest);
}
});
}
/**
*
* This action updates an existing health check.
*
*
* To update a health check, send a POST request to the
* 2013-05-27/healthcheck/health check ID resource. The
* request body must include an XML document with an
* UpdateHealthCheckRequest element. The response returns an
* UpdateHealthCheckResponse element, which contains
* metadata about the health check.
*
*
* @param updateHealthCheckRequest Container for the necessary parameters
* to execute the UpdateHealthCheck operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateHealthCheckAsync(
final UpdateHealthCheckRequest updateHealthCheckRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateHealthCheckResult call() throws Exception {
UpdateHealthCheckResult result;
try {
result = updateHealthCheck(updateHealthCheckRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateHealthCheckRequest, result);
return result;
}
});
}
/**
*
* To retrieve a single geo location, send a GET request to
* the 2013-04-01/geolocation resource with one of these
* options: continentcode | countrycode | countrycode and
* subdivisioncode.
*
*
* @param getGeoLocationRequest Container for the necessary parameters to
* execute the GetGeoLocation operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* GetGeoLocation service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getGeoLocationAsync(final GetGeoLocationRequest getGeoLocationRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetGeoLocationResult call() throws Exception {
return getGeoLocation(getGeoLocationRequest);
}
});
}
/**
*
* To retrieve a single geo location, send a GET request to
* the 2013-04-01/geolocation resource with one of these
* options: continentcode | countrycode | countrycode and
* subdivisioncode.
*
*
* @param getGeoLocationRequest Container for the necessary parameters to
* execute the GetGeoLocation operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetGeoLocation service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getGeoLocationAsync(
final GetGeoLocationRequest getGeoLocationRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetGeoLocationResult call() throws Exception {
GetGeoLocationResult result;
try {
result = getGeoLocation(getGeoLocationRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getGeoLocationRequest, result);
return result;
}
});
}
/**
*
* @param listTagsForResourcesRequest Container for the necessary
* parameters to execute the ListTagsForResources operation on
* AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ListTagsForResources service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listTagsForResourcesAsync(final ListTagsForResourcesRequest listTagsForResourcesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListTagsForResourcesResult call() throws Exception {
return listTagsForResources(listTagsForResourcesRequest);
}
});
}
/**
*
* @param listTagsForResourcesRequest Container for the necessary
* parameters to execute the ListTagsForResources operation on
* AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListTagsForResources service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listTagsForResourcesAsync(
final ListTagsForResourcesRequest listTagsForResourcesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListTagsForResourcesResult call() throws Exception {
ListTagsForResourcesResult result;
try {
result = listTagsForResources(listTagsForResourcesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listTagsForResourcesRequest, result);
return result;
}
});
}
/**
*
* This action deletes a health check. To delete a health check, send a
* DELETE request to the 2013-04-01/healthcheck/health
* check ID resource.
*
*
* IMPORTANT: You can delete a health check only if there are no
* resource record sets associated with this health check. If resource
* record sets are associated with this health check, you must
* disassociate them before you can delete your health check. If you try
* to delete a health check that is associated with resource record sets,
* Route 53 will deny your request with a HealthCheckInUse error. For
* information about disassociating the records from your health check,
* see ChangeResourceRecordSets.
*
*
* @param deleteHealthCheckRequest Container for the necessary parameters
* to execute the DeleteHealthCheck operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* DeleteHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteHealthCheckAsync(final DeleteHealthCheckRequest deleteHealthCheckRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteHealthCheckResult call() throws Exception {
return deleteHealthCheck(deleteHealthCheckRequest);
}
});
}
/**
*
* This action deletes a health check. To delete a health check, send a
* DELETE request to the 2013-04-01/healthcheck/health
* check ID resource.
*
*
* IMPORTANT: You can delete a health check only if there are no
* resource record sets associated with this health check. If resource
* record sets are associated with this health check, you must
* disassociate them before you can delete your health check. If you try
* to delete a health check that is associated with resource record sets,
* Route 53 will deny your request with a HealthCheckInUse error. For
* information about disassociating the records from your health check,
* see ChangeResourceRecordSets.
*
*
* @param deleteHealthCheckRequest Container for the necessary parameters
* to execute the DeleteHealthCheck operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteHealthCheckAsync(
final DeleteHealthCheckRequest deleteHealthCheckRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteHealthCheckResult call() throws Exception {
DeleteHealthCheckResult result;
try {
result = deleteHealthCheck(deleteHealthCheckRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteHealthCheckRequest, result);
return result;
}
});
}
/**
*
* Imagine all the resource record sets in a zone listed out in front of
* you. Imagine them sorted lexicographically first by DNS name (with the
* labels reversed, like "com.amazon.www" for example), and secondarily,
* lexicographically by record type. This operation retrieves at most
* MaxItems resource record sets from this list, in order, starting at a
* position specified by the Name and Type arguments:
*
*
*
* - If both Name and Type are omitted, this means start the results
* at the first RRSET in the HostedZone.
* - If Name is specified but Type is omitted, this means start the
* results at the first RRSET in the list whose name is greater than or
* equal to Name.
* - If both Name and Type are specified, this means start the results
* at the first RRSET in the list whose name is greater than or equal to
* Name and whose type is greater than or equal to Type.
* - It is an error to specify the Type but not the Name.
*
*
*
* Use ListResourceRecordSets to retrieve a single known record set by
* specifying the record set's name and type, and setting MaxItems = 1
*
*
* To retrieve all the records in a HostedZone, first pause any
* processes making calls to ChangeResourceRecordSets. Initially call
* ListResourceRecordSets without a Name and Type to get the first page
* of record sets. For subsequent calls, set Name and Type to the
* NextName and NextType values returned by the previous response.
*
*
* In the presence of concurrent ChangeResourceRecordSets calls, there
* is no consistency of results across calls to ListResourceRecordSets.
* The only way to get a consistent multi-page snapshot of all RRSETs in
* a zone is to stop making changes while pagination is in progress.
*
*
* However, the results from ListResourceRecordSets are consistent
* within a page. If MakeChange calls are taking place concurrently, the
* result of each one will either be completely visible in your results
* or not at all. You will not see partial changes, or changes that do
* not ultimately succeed. (This follows from the fact that MakeChange is
* atomic)
*
*
* The results from ListResourceRecordSets are strongly consistent with
* ChangeResourceRecordSets. To be precise, if a single process makes a
* call to ChangeResourceRecordSets and receives a successful response,
* the effects of that change will be visible in a subsequent call to
* ListResourceRecordSets by that process.
*
*
* @param listResourceRecordSetsRequest Container for the necessary
* parameters to execute the ListResourceRecordSets operation on
* AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ListResourceRecordSets service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listResourceRecordSetsAsync(final ListResourceRecordSetsRequest listResourceRecordSetsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListResourceRecordSetsResult call() throws Exception {
return listResourceRecordSets(listResourceRecordSetsRequest);
}
});
}
/**
*
* Imagine all the resource record sets in a zone listed out in front of
* you. Imagine them sorted lexicographically first by DNS name (with the
* labels reversed, like "com.amazon.www" for example), and secondarily,
* lexicographically by record type. This operation retrieves at most
* MaxItems resource record sets from this list, in order, starting at a
* position specified by the Name and Type arguments:
*
*
*
* - If both Name and Type are omitted, this means start the results
* at the first RRSET in the HostedZone.
* - If Name is specified but Type is omitted, this means start the
* results at the first RRSET in the list whose name is greater than or
* equal to Name.
* - If both Name and Type are specified, this means start the results
* at the first RRSET in the list whose name is greater than or equal to
* Name and whose type is greater than or equal to Type.
* - It is an error to specify the Type but not the Name.
*
*
*
* Use ListResourceRecordSets to retrieve a single known record set by
* specifying the record set's name and type, and setting MaxItems = 1
*
*
* To retrieve all the records in a HostedZone, first pause any
* processes making calls to ChangeResourceRecordSets. Initially call
* ListResourceRecordSets without a Name and Type to get the first page
* of record sets. For subsequent calls, set Name and Type to the
* NextName and NextType values returned by the previous response.
*
*
* In the presence of concurrent ChangeResourceRecordSets calls, there
* is no consistency of results across calls to ListResourceRecordSets.
* The only way to get a consistent multi-page snapshot of all RRSETs in
* a zone is to stop making changes while pagination is in progress.
*
*
* However, the results from ListResourceRecordSets are consistent
* within a page. If MakeChange calls are taking place concurrently, the
* result of each one will either be completely visible in your results
* or not at all. You will not see partial changes, or changes that do
* not ultimately succeed. (This follows from the fact that MakeChange is
* atomic)
*
*
* The results from ListResourceRecordSets are strongly consistent with
* ChangeResourceRecordSets. To be precise, if a single process makes a
* call to ChangeResourceRecordSets and receives a successful response,
* the effects of that change will be visible in a subsequent call to
* ListResourceRecordSets by that process.
*
*
* @param listResourceRecordSetsRequest Container for the necessary
* parameters to execute the ListResourceRecordSets operation on
* AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListResourceRecordSets service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listResourceRecordSetsAsync(
final ListResourceRecordSetsRequest listResourceRecordSetsRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListResourceRecordSetsResult call() throws Exception {
ListResourceRecordSetsResult result;
try {
result = listResourceRecordSets(listResourceRecordSetsRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listResourceRecordSetsRequest, result);
return result;
}
});
}
/**
*
* To retrieve the health check, send a GET request to the
* 2013-04-01/healthcheck/health check ID resource.
*
*
* @param getHealthCheckRequest Container for the necessary parameters to
* execute the GetHealthCheck operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* GetHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getHealthCheckAsync(final GetHealthCheckRequest getHealthCheckRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetHealthCheckResult call() throws Exception {
return getHealthCheck(getHealthCheckRequest);
}
});
}
/**
*
* To retrieve the health check, send a GET request to the
* 2013-04-01/healthcheck/health check ID resource.
*
*
* @param getHealthCheckRequest Container for the necessary parameters to
* execute the GetHealthCheck operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getHealthCheckAsync(
final GetHealthCheckRequest getHealthCheckRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetHealthCheckResult call() throws Exception {
GetHealthCheckResult result;
try {
result = getHealthCheck(getHealthCheckRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getHealthCheckRequest, result);
return result;
}
});
}
/**
*
* This action deletes a hosted zone. To delete a hosted zone, send a
* DELETE request to the 2013-04-01/hostedzone/hosted
* zone ID resource.
*
*
* For more information about deleting a hosted zone, see
* Deleting a Hosted Zone
* in the Amazon Route 53 Developer Guide .
*
*
* IMPORTANT: You can delete a hosted zone only if there are no
* resource record sets other than the default SOA record and NS resource
* record sets. If your hosted zone contains other resource record sets,
* you must delete them before you can delete your hosted zone. If you
* try to delete a hosted zone that contains other resource record sets,
* Route 53 will deny your request with a HostedZoneNotEmpty error. For
* information about deleting records from your hosted zone, see
* ChangeResourceRecordSets.
*
*
* @param deleteHostedZoneRequest Container for the necessary parameters
* to execute the DeleteHostedZone operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* DeleteHostedZone service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteHostedZoneAsync(final DeleteHostedZoneRequest deleteHostedZoneRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteHostedZoneResult call() throws Exception {
return deleteHostedZone(deleteHostedZoneRequest);
}
});
}
/**
*
* This action deletes a hosted zone. To delete a hosted zone, send a
* DELETE request to the 2013-04-01/hostedzone/hosted
* zone ID resource.
*
*
* For more information about deleting a hosted zone, see
* Deleting a Hosted Zone
* in the Amazon Route 53 Developer Guide .
*
*
* IMPORTANT: You can delete a hosted zone only if there are no
* resource record sets other than the default SOA record and NS resource
* record sets. If your hosted zone contains other resource record sets,
* you must delete them before you can delete your hosted zone. If you
* try to delete a hosted zone that contains other resource record sets,
* Route 53 will deny your request with a HostedZoneNotEmpty error. For
* information about deleting records from your hosted zone, see
* ChangeResourceRecordSets.
*
*
* @param deleteHostedZoneRequest Container for the necessary parameters
* to execute the DeleteHostedZone operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteHostedZone service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteHostedZoneAsync(
final DeleteHostedZoneRequest deleteHostedZoneRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteHostedZoneResult call() throws Exception {
DeleteHostedZoneResult result;
try {
result = deleteHostedZone(deleteHostedZoneRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteHostedZoneRequest, result);
return result;
}
});
}
/**
*
* To retrieve a list of the IP ranges used by Amazon Route 53 health
* checkers to check the health of your resources, send a
* GET request to the
* 2013-04-01/checkeripranges resource. You can use these IP
* addresses to configure router and firewall rules to allow health
* checkers to check the health of your resources.
*
*
* @param getCheckerIpRangesRequest Container for the necessary
* parameters to execute the GetCheckerIpRanges operation on
* AmazonRoute53.
*
* @return A Java Future object containing the response from the
* GetCheckerIpRanges service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getCheckerIpRangesAsync(final GetCheckerIpRangesRequest getCheckerIpRangesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetCheckerIpRangesResult call() throws Exception {
return getCheckerIpRanges(getCheckerIpRangesRequest);
}
});
}
/**
*
* To retrieve a list of the IP ranges used by Amazon Route 53 health
* checkers to check the health of your resources, send a
* GET request to the
* 2013-04-01/checkeripranges resource. You can use these IP
* addresses to configure router and firewall rules to allow health
* checkers to check the health of your resources.
*
*
* @param getCheckerIpRangesRequest Container for the necessary
* parameters to execute the GetCheckerIpRanges operation on
* AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetCheckerIpRanges service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getCheckerIpRangesAsync(
final GetCheckerIpRangesRequest getCheckerIpRangesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetCheckerIpRangesResult call() throws Exception {
GetCheckerIpRangesResult result;
try {
result = getCheckerIpRanges(getCheckerIpRangesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getCheckerIpRangesRequest, result);
return result;
}
});
}
/**
*
* This action creates a new hosted zone.
*
*
* To create a new hosted zone, send a POST request to the
* 2013-04-01/hostedzone resource. The request body must
* include an XML document with a CreateHostedZoneRequest
* element. The response returns the
* CreateHostedZoneResponse element that contains metadata
* about the hosted zone.
*
*
* Route 53 automatically creates a default SOA record and four NS
* records for the zone. The NS records in the hosted zone are the name
* servers you give your registrar to delegate your domain to. For more
* information about SOA and NS records, see
* NS and SOA Records that Route 53 Creates for a Hosted Zone
* in the Amazon Route 53 Developer Guide .
*
*
* When you create a zone, its initial status is PENDING .
* This means that it is not yet available on all DNS servers. The status
* of the zone changes to INSYNC when the NS and SOA records
* are available on all Route 53 DNS servers.
*
*
* @param createHostedZoneRequest Container for the necessary parameters
* to execute the CreateHostedZone operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* CreateHostedZone service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createHostedZoneAsync(final CreateHostedZoneRequest createHostedZoneRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateHostedZoneResult call() throws Exception {
return createHostedZone(createHostedZoneRequest);
}
});
}
/**
*
* This action creates a new hosted zone.
*
*
* To create a new hosted zone, send a POST request to the
* 2013-04-01/hostedzone resource. The request body must
* include an XML document with a CreateHostedZoneRequest
* element. The response returns the
* CreateHostedZoneResponse element that contains metadata
* about the hosted zone.
*
*
* Route 53 automatically creates a default SOA record and four NS
* records for the zone. The NS records in the hosted zone are the name
* servers you give your registrar to delegate your domain to. For more
* information about SOA and NS records, see
* NS and SOA Records that Route 53 Creates for a Hosted Zone
* in the Amazon Route 53 Developer Guide .
*
*
* When you create a zone, its initial status is PENDING .
* This means that it is not yet available on all DNS servers. The status
* of the zone changes to INSYNC when the NS and SOA records
* are available on all Route 53 DNS servers.
*
*
* @param createHostedZoneRequest Container for the necessary parameters
* to execute the CreateHostedZone operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateHostedZone service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createHostedZoneAsync(
final CreateHostedZoneRequest createHostedZoneRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateHostedZoneResult call() throws Exception {
CreateHostedZoneResult result;
try {
result = createHostedZone(createHostedZoneRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createHostedZoneRequest, result);
return result;
}
});
}
/**
*
* @param listTagsForResourceRequest Container for the necessary
* parameters to execute the ListTagsForResource operation on
* AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ListTagsForResource service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listTagsForResourceAsync(final ListTagsForResourceRequest listTagsForResourceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListTagsForResourceResult call() throws Exception {
return listTagsForResource(listTagsForResourceRequest);
}
});
}
/**
*
* @param listTagsForResourceRequest Container for the necessary
* parameters to execute the ListTagsForResource operation on
* AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListTagsForResource service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listTagsForResourceAsync(
final ListTagsForResourceRequest listTagsForResourceRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result;
try {
result = listTagsForResource(listTagsForResourceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listTagsForResourceRequest, result);
return result;
}
});
}
/**
*
* To retrieve a list of your health checks, send a GET
* request to the 2013-04-01/healthcheck resource. The
* response to this request includes a HealthChecks element
* with zero, one, or multiple HealthCheck child elements.
* By default, the list of health checks is displayed on a single page.
* You can control the length of the page that is displayed by using the
* MaxItems parameter. You can use the Marker
* parameter to control the health check that the list begins with.
*
*
* NOTE: Amazon Route 53 returns a maximum of 100 items. If you
* set MaxItems to a value greater than 100, Amazon Route 53 returns only
* the first 100.
*
*
* @param listHealthChecksRequest Container for the necessary parameters
* to execute the ListHealthChecks operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ListHealthChecks service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listHealthChecksAsync(final ListHealthChecksRequest listHealthChecksRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListHealthChecksResult call() throws Exception {
return listHealthChecks(listHealthChecksRequest);
}
});
}
/**
*
* To retrieve a list of your health checks, send a GET
* request to the 2013-04-01/healthcheck resource. The
* response to this request includes a HealthChecks element
* with zero, one, or multiple HealthCheck child elements.
* By default, the list of health checks is displayed on a single page.
* You can control the length of the page that is displayed by using the
* MaxItems parameter. You can use the Marker
* parameter to control the health check that the list begins with.
*
*
* NOTE: Amazon Route 53 returns a maximum of 100 items. If you
* set MaxItems to a value greater than 100, Amazon Route 53 returns only
* the first 100.
*
*
* @param listHealthChecksRequest Container for the necessary parameters
* to execute the ListHealthChecks operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListHealthChecks service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listHealthChecksAsync(
final ListHealthChecksRequest listHealthChecksRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListHealthChecksResult call() throws Exception {
ListHealthChecksResult result;
try {
result = listHealthChecks(listHealthChecksRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listHealthChecksRequest, result);
return result;
}
});
}
/**
*
* This action creates a new health check.
*
*
* To create a new health check, send a POST request to the
* 2013-04-01/healthcheck resource. The request body must
* include an XML document with a CreateHealthCheckRequest
* element. The response returns the
* CreateHealthCheckResponse element that contains metadata
* about the health check.
*
*
* @param createHealthCheckRequest Container for the necessary parameters
* to execute the CreateHealthCheck operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* CreateHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createHealthCheckAsync(final CreateHealthCheckRequest createHealthCheckRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateHealthCheckResult call() throws Exception {
return createHealthCheck(createHealthCheckRequest);
}
});
}
/**
*
* This action creates a new health check.
*
*
* To create a new health check, send a POST request to the
* 2013-04-01/healthcheck resource. The request body must
* include an XML document with a CreateHealthCheckRequest
* element. The response returns the
* CreateHealthCheckResponse element that contains metadata
* about the health check.
*
*
* @param createHealthCheckRequest Container for the necessary parameters
* to execute the CreateHealthCheck operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateHealthCheck service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createHealthCheckAsync(
final CreateHealthCheckRequest createHealthCheckRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateHealthCheckResult call() throws Exception {
CreateHealthCheckResult result;
try {
result = createHealthCheck(createHealthCheckRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createHealthCheckRequest, result);
return result;
}
});
}
/**
*
* Use this action to create or change your authoritative DNS
* information. To use this action, send a POST request to
* the 2013-04-01/hostedzone/hosted Zone ID/rrset resource.
* The request body must include an XML document with a
* ChangeResourceRecordSetsRequest element.
*
*
* Changes are a list of change items and are considered transactional.
* For more information on transactional changes, also known as change
* batches, see
* Creating, Changing, and Deleting Resource Record Sets Using the Route 53 API
* in the Amazon Route 53 Developer Guide .
*
*
* IMPORTANT:Due to the nature of transactional changes, you
* cannot delete the same resource record set more than once in a single
* change batch. If you attempt to delete the same change batch more than
* once, Route 53 returns an InvalidChangeBatch error.
*
*
* In response to a ChangeResourceRecordSets request, your
* DNS data is changed on all Route 53 DNS servers. Initially, the status
* of a change is PENDING . This means the change has not
* yet propagated to all the authoritative Route 53 DNS servers. When the
* change is propagated to all hosts, the change returns a status of
* INSYNC .
*
*
* Note the following limitations on a
* ChangeResourceRecordSets request:
*
*
* - A request cannot contain more than 100 Change elements.
*
*
* - A request cannot contain more than 1000 ResourceRecord elements.
*
*
* The sum of the number of characters (including spaces) in all
* Value elements in a request cannot exceed 32,000
* characters.
*
*
* @param changeResourceRecordSetsRequest Container for the necessary
* parameters to execute the ChangeResourceRecordSets operation on
* AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ChangeResourceRecordSets service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future changeResourceRecordSetsAsync(final ChangeResourceRecordSetsRequest changeResourceRecordSetsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ChangeResourceRecordSetsResult call() throws Exception {
return changeResourceRecordSets(changeResourceRecordSetsRequest);
}
});
}
/**
*
* Use this action to create or change your authoritative DNS
* information. To use this action, send a POST request to
* the 2013-04-01/hostedzone/hosted Zone ID/rrset resource.
* The request body must include an XML document with a
* ChangeResourceRecordSetsRequest element.
*
*
* Changes are a list of change items and are considered transactional.
* For more information on transactional changes, also known as change
* batches, see
* Creating, Changing, and Deleting Resource Record Sets Using the Route 53 API
* in the Amazon Route 53 Developer Guide .
*
*
* IMPORTANT:Due to the nature of transactional changes, you
* cannot delete the same resource record set more than once in a single
* change batch. If you attempt to delete the same change batch more than
* once, Route 53 returns an InvalidChangeBatch error.
*
*
* In response to a ChangeResourceRecordSets request, your
* DNS data is changed on all Route 53 DNS servers. Initially, the status
* of a change is PENDING . This means the change has not
* yet propagated to all the authoritative Route 53 DNS servers. When the
* change is propagated to all hosts, the change returns a status of
* INSYNC .
*
*
* Note the following limitations on a
* ChangeResourceRecordSets request:
*
*
* - A request cannot contain more than 100 Change elements.
*
*
* - A request cannot contain more than 1000 ResourceRecord elements.
*
*
* The sum of the number of characters (including spaces) in all
* Value elements in a request cannot exceed 32,000
* characters.
*
*
* @param changeResourceRecordSetsRequest Container for the necessary
* parameters to execute the ChangeResourceRecordSets operation on
* AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ChangeResourceRecordSets service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future changeResourceRecordSetsAsync(
final ChangeResourceRecordSetsRequest changeResourceRecordSetsRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ChangeResourceRecordSetsResult call() throws Exception {
ChangeResourceRecordSetsResult result;
try {
result = changeResourceRecordSets(changeResourceRecordSetsRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(changeResourceRecordSetsRequest, result);
return result;
}
});
}
/**
*
* To retrieve a list of supported geo locations, send a
* GET request to the 2013-04-01/geolocations
* resource. The response to this request includes a
* GeoLocationDetailsList element with zero, one, or
* multiple GeoLocationDetails child elements. The list is
* sorted by country code, and then subdivision code, followed by
* continents at the end of the list.
*
*
* By default, the list of geo locations is displayed on a single page.
* You can control the length of the page that is displayed by using the
* MaxItems parameter. If the list is truncated,
* IsTruncated will be set to true and a combination
* of NextContinentCode, NextCountryCode,
* NextSubdivisionCode will be populated. You can pass these as
* parameters to StartContinentCode, StartCountryCode,
* StartSubdivisionCode to control the geo location that the list
* begins with.
*
*
* @param listGeoLocationsRequest Container for the necessary parameters
* to execute the ListGeoLocations operation on AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ListGeoLocations service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listGeoLocationsAsync(final ListGeoLocationsRequest listGeoLocationsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListGeoLocationsResult call() throws Exception {
return listGeoLocations(listGeoLocationsRequest);
}
});
}
/**
*
* To retrieve a list of supported geo locations, send a
* GET request to the 2013-04-01/geolocations
* resource. The response to this request includes a
* GeoLocationDetailsList element with zero, one, or
* multiple GeoLocationDetails child elements. The list is
* sorted by country code, and then subdivision code, followed by
* continents at the end of the list.
*
*
* By default, the list of geo locations is displayed on a single page.
* You can control the length of the page that is displayed by using the
* MaxItems parameter. If the list is truncated,
* IsTruncated will be set to true and a combination
* of NextContinentCode, NextCountryCode,
* NextSubdivisionCode will be populated. You can pass these as
* parameters to StartContinentCode, StartCountryCode,
* StartSubdivisionCode to control the geo location that the list
* begins with.
*
*
* @param listGeoLocationsRequest Container for the necessary parameters
* to execute the ListGeoLocations operation on AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListGeoLocations service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listGeoLocationsAsync(
final ListGeoLocationsRequest listGeoLocationsRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListGeoLocationsResult call() throws Exception {
ListGeoLocationsResult result;
try {
result = listGeoLocations(listGeoLocationsRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listGeoLocationsRequest, result);
return result;
}
});
}
/**
*
* To retrieve a count of all your health checks, send a
* GET request to the
* 2013-04-01/healthcheckcount resource.
*
*
* @param getHealthCheckCountRequest Container for the necessary
* parameters to execute the GetHealthCheckCount operation on
* AmazonRoute53.
*
* @return A Java Future object containing the response from the
* GetHealthCheckCount service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getHealthCheckCountAsync(final GetHealthCheckCountRequest getHealthCheckCountRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetHealthCheckCountResult call() throws Exception {
return getHealthCheckCount(getHealthCheckCountRequest);
}
});
}
/**
*
* To retrieve a count of all your health checks, send a
* GET request to the
* 2013-04-01/healthcheckcount resource.
*
*
* @param getHealthCheckCountRequest Container for the necessary
* parameters to execute the GetHealthCheckCount operation on
* AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetHealthCheckCount service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getHealthCheckCountAsync(
final GetHealthCheckCountRequest getHealthCheckCountRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetHealthCheckCountResult call() throws Exception {
GetHealthCheckCountResult result;
try {
result = getHealthCheckCount(getHealthCheckCountRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getHealthCheckCountRequest, result);
return result;
}
});
}
/**
*
* @param changeTagsForResourceRequest Container for the necessary
* parameters to execute the ChangeTagsForResource operation on
* AmazonRoute53.
*
* @return A Java Future object containing the response from the
* ChangeTagsForResource service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future changeTagsForResourceAsync(final ChangeTagsForResourceRequest changeTagsForResourceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ChangeTagsForResourceResult call() throws Exception {
return changeTagsForResource(changeTagsForResourceRequest);
}
});
}
/**
*
* @param changeTagsForResourceRequest Container for the necessary
* parameters to execute the ChangeTagsForResource operation on
* AmazonRoute53.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ChangeTagsForResource service method, as returned by AmazonRoute53.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonRoute53 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future changeTagsForResourceAsync(
final ChangeTagsForResourceRequest changeTagsForResourceRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ChangeTagsForResourceResult call() throws Exception {
ChangeTagsForResourceResult result;
try {
result = changeTagsForResource(changeTagsForResourceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(changeTagsForResourceRequest, result);
return result;
}
});
}
}