com.amazonaws.services.databasemigrationservice.AWSDatabaseMigrationServiceAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-dms Show documentation
/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights
* Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.amazonaws.services.databasemigrationservice;
import com.amazonaws.services.databasemigrationservice.model.*;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing AWS Database Migration Service 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.
*
* AWS Database Migration Service
*
* AWS Database Migration Service (AWS DMS) can migrate your data to and from
* the most widely used commercial and open-source databases such as Oracle,
* PostgreSQL, Microsoft SQL Server, MariaDB, Amazon Aurora, and MySQL. The
* service supports homogeneous migrations such as Oracle to Oracle, as well as
* heterogeneous migrations between different database platforms, such as Oracle
* to MySQL or SQL Server to PostgreSQL.
*
*/
@ThreadSafe
public class AWSDatabaseMigrationServiceAsyncClient extends
AWSDatabaseMigrationServiceClient implements
AWSDatabaseMigrationServiceAsync {
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 AWS
* Database Migration Service. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials)
* shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* 50 threads (to match the default maximum number of concurrent connections
* to the service).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSDatabaseMigrationServiceAsyncClient() {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service. 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 AWS Database Migration Service (ex: proxy settings,
* retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.ClientConfiguration clientConfiguration) {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain(),
clientConfiguration, java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service using the specified AWS account credentials.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* 50 threads (to match the default maximum number of concurrent connections
* to the service).
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials) {
this(awsCredentials, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service using the specified AWS account credentials
* and executor service. Default client settings will be used.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service using the specified AWS account credentials,
* executor service, and client configuration options.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings,
* etc).
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service using the specified AWS account credentials
* provider. Default client settings will be used.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* 50 threads (to match the default maximum number of concurrent connections
* to the service).
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service using the provided AWS account credentials
* provider and client configuration options.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* a number of threads equal to the maximum number of concurrent connections
* configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings,
* etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration,
java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service using the specified AWS account credentials
* provider and executor service. Default client settings will be used.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS
* Database Migration Service using the specified AWS account credentials
* provider, executor service, and client configuration options.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings,
* etc).
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSDatabaseMigrationServiceAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Returns the executor service used by this client to execute async
* requests.
*
* @return The executor service used by this client to execute async
* requests.
*/
public java.util.concurrent.ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future addTagsToResourceAsync(
AddTagsToResourceRequest request) {
return addTagsToResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future addTagsToResourceAsync(
final AddTagsToResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AddTagsToResourceResult call() throws Exception {
AddTagsToResourceResult result;
try {
result = addTagsToResource(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createEndpointAsync(
CreateEndpointRequest request) {
return createEndpointAsync(request, null);
}
@Override
public java.util.concurrent.Future createEndpointAsync(
final CreateEndpointRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateEndpointResult call() throws Exception {
CreateEndpointResult result;
try {
result = createEndpoint(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createReplicationInstanceAsync(
CreateReplicationInstanceRequest request) {
return createReplicationInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future createReplicationInstanceAsync(
final CreateReplicationInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateReplicationInstanceResult call()
throws Exception {
CreateReplicationInstanceResult result;
try {
result = createReplicationInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createReplicationSubnetGroupAsync(
CreateReplicationSubnetGroupRequest request) {
return createReplicationSubnetGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createReplicationSubnetGroupAsync(
final CreateReplicationSubnetGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateReplicationSubnetGroupResult call()
throws Exception {
CreateReplicationSubnetGroupResult result;
try {
result = createReplicationSubnetGroup(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createReplicationTaskAsync(
CreateReplicationTaskRequest request) {
return createReplicationTaskAsync(request, null);
}
@Override
public java.util.concurrent.Future createReplicationTaskAsync(
final CreateReplicationTaskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateReplicationTaskResult call() throws Exception {
CreateReplicationTaskResult result;
try {
result = createReplicationTask(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteEndpointAsync(
DeleteEndpointRequest request) {
return deleteEndpointAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteEndpointAsync(
final DeleteEndpointRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteEndpointResult call() throws Exception {
DeleteEndpointResult result;
try {
result = deleteEndpoint(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteReplicationInstanceAsync(
DeleteReplicationInstanceRequest request) {
return deleteReplicationInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteReplicationInstanceAsync(
final DeleteReplicationInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteReplicationInstanceResult call()
throws Exception {
DeleteReplicationInstanceResult result;
try {
result = deleteReplicationInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteReplicationSubnetGroupAsync(
DeleteReplicationSubnetGroupRequest request) {
return deleteReplicationSubnetGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteReplicationSubnetGroupAsync(
final DeleteReplicationSubnetGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteReplicationSubnetGroupResult call()
throws Exception {
DeleteReplicationSubnetGroupResult result;
try {
result = deleteReplicationSubnetGroup(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteReplicationTaskAsync(
DeleteReplicationTaskRequest request) {
return deleteReplicationTaskAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteReplicationTaskAsync(
final DeleteReplicationTaskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteReplicationTaskResult call() throws Exception {
DeleteReplicationTaskResult result;
try {
result = deleteReplicationTask(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeAccountAttributesAsync(
DescribeAccountAttributesRequest request) {
return describeAccountAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAccountAttributesAsync(
final DescribeAccountAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAccountAttributesResult call()
throws Exception {
DescribeAccountAttributesResult result;
try {
result = describeAccountAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeConnectionsAsync(
DescribeConnectionsRequest request) {
return describeConnectionsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeConnectionsAsync(
final DescribeConnectionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeConnectionsResult call() throws Exception {
DescribeConnectionsResult result;
try {
result = describeConnections(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeEndpointTypesAsync(
DescribeEndpointTypesRequest request) {
return describeEndpointTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeEndpointTypesAsync(
final DescribeEndpointTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeEndpointTypesResult call() throws Exception {
DescribeEndpointTypesResult result;
try {
result = describeEndpointTypes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeEndpointsAsync(
DescribeEndpointsRequest request) {
return describeEndpointsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeEndpointsAsync(
final DescribeEndpointsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeEndpointsResult call() throws Exception {
DescribeEndpointsResult result;
try {
result = describeEndpoints(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeOrderableReplicationInstancesAsync(
DescribeOrderableReplicationInstancesRequest request) {
return describeOrderableReplicationInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeOrderableReplicationInstancesAsync(
final DescribeOrderableReplicationInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeOrderableReplicationInstancesResult call()
throws Exception {
DescribeOrderableReplicationInstancesResult result;
try {
result = describeOrderableReplicationInstances(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeRefreshSchemasStatusAsync(
DescribeRefreshSchemasStatusRequest request) {
return describeRefreshSchemasStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future describeRefreshSchemasStatusAsync(
final DescribeRefreshSchemasStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeRefreshSchemasStatusResult call()
throws Exception {
DescribeRefreshSchemasStatusResult result;
try {
result = describeRefreshSchemasStatus(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeReplicationInstancesAsync(
DescribeReplicationInstancesRequest request) {
return describeReplicationInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeReplicationInstancesAsync(
final DescribeReplicationInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeReplicationInstancesResult call()
throws Exception {
DescribeReplicationInstancesResult result;
try {
result = describeReplicationInstances(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeReplicationSubnetGroupsAsync(
DescribeReplicationSubnetGroupsRequest request) {
return describeReplicationSubnetGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeReplicationSubnetGroupsAsync(
final DescribeReplicationSubnetGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeReplicationSubnetGroupsResult call()
throws Exception {
DescribeReplicationSubnetGroupsResult result;
try {
result = describeReplicationSubnetGroups(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeReplicationTasksAsync(
DescribeReplicationTasksRequest request) {
return describeReplicationTasksAsync(request, null);
}
@Override
public java.util.concurrent.Future describeReplicationTasksAsync(
final DescribeReplicationTasksRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeReplicationTasksResult call()
throws Exception {
DescribeReplicationTasksResult result;
try {
result = describeReplicationTasks(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeSchemasAsync(
DescribeSchemasRequest request) {
return describeSchemasAsync(request, null);
}
@Override
public java.util.concurrent.Future describeSchemasAsync(
final DescribeSchemasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeSchemasResult call() throws Exception {
DescribeSchemasResult result;
try {
result = describeSchemas(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeTableStatisticsAsync(
DescribeTableStatisticsRequest request) {
return describeTableStatisticsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeTableStatisticsAsync(
final DescribeTableStatisticsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeTableStatisticsResult call()
throws Exception {
DescribeTableStatisticsResult result;
try {
result = describeTableStatistics(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(
ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(
final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result;
try {
result = listTagsForResource(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future modifyEndpointAsync(
ModifyEndpointRequest request) {
return modifyEndpointAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyEndpointAsync(
final ModifyEndpointRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ModifyEndpointResult call() throws Exception {
ModifyEndpointResult result;
try {
result = modifyEndpoint(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future modifyReplicationInstanceAsync(
ModifyReplicationInstanceRequest request) {
return modifyReplicationInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyReplicationInstanceAsync(
final ModifyReplicationInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ModifyReplicationInstanceResult call()
throws Exception {
ModifyReplicationInstanceResult result;
try {
result = modifyReplicationInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future modifyReplicationSubnetGroupAsync(
ModifyReplicationSubnetGroupRequest request) {
return modifyReplicationSubnetGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyReplicationSubnetGroupAsync(
final ModifyReplicationSubnetGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ModifyReplicationSubnetGroupResult call()
throws Exception {
ModifyReplicationSubnetGroupResult result;
try {
result = modifyReplicationSubnetGroup(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future refreshSchemasAsync(
RefreshSchemasRequest request) {
return refreshSchemasAsync(request, null);
}
@Override
public java.util.concurrent.Future refreshSchemasAsync(
final RefreshSchemasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RefreshSchemasResult call() throws Exception {
RefreshSchemasResult result;
try {
result = refreshSchemas(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future removeTagsFromResourceAsync(
RemoveTagsFromResourceRequest request) {
return removeTagsFromResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future removeTagsFromResourceAsync(
final RemoveTagsFromResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RemoveTagsFromResourceResult call() throws Exception {
RemoveTagsFromResourceResult result;
try {
result = removeTagsFromResource(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future startReplicationTaskAsync(
StartReplicationTaskRequest request) {
return startReplicationTaskAsync(request, null);
}
@Override
public java.util.concurrent.Future startReplicationTaskAsync(
final StartReplicationTaskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public StartReplicationTaskResult call() throws Exception {
StartReplicationTaskResult result;
try {
result = startReplicationTask(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future stopReplicationTaskAsync(
StopReplicationTaskRequest request) {
return stopReplicationTaskAsync(request, null);
}
@Override
public java.util.concurrent.Future stopReplicationTaskAsync(
final StopReplicationTaskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public StopReplicationTaskResult call() throws Exception {
StopReplicationTaskResult result;
try {
result = stopReplicationTask(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future testConnectionAsync(
TestConnectionRequest request) {
return testConnectionAsync(request, null);
}
@Override
public java.util.concurrent.Future testConnectionAsync(
final TestConnectionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public TestConnectionResult call() throws Exception {
TestConnectionResult result;
try {
result = testConnection(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Shuts down the client, releasing all managed resources. This includes
* forcibly terminating all pending asynchronous service calls. Clients who
* wish to give pending asynchronous service calls time to complete should
* call {@code getExecutorService().shutdown()} followed by
* {@code getExecutorService().awaitTermination()} prior to calling this
* method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
}