com.amazonaws.services.rds.AmazonRDSAsyncClient Maven / Gradle / Ivy
/*
* Copyright 2010-2011 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.rds;
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.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.services.rds.model.*;
/**
* Client for accessing AmazonRDS. All calls made
* using this client are non-blocking and will immediately return a Java Future.
* Callers must use the Future object to determine when the service call has actually
* completed.
*
* Amazon Relational Database Service (Amazon RDS) is a web service that
* makes it easier to set up, operate, and scale a relational database in
* the cloud. It provides cost-efficient, resizable capacity for an
* industry-standard relational database and manages common database
* administration tasks, freeing up developers to focus on what makes
* their applications and businesses unique.
*
*
* Amazon RDS gives you access to the capabilities of a familiar MySQL
* database server. This means the code, applications, and tools you
* already use today with your existing MySQL databases work with Amazon
* RDS without modification. Amazon RDS automatically backs up your
* database and maintains the database software that powers your DB
* Instance. Amazon RDS is flexible: you can scale your database
* instance's compute resources and storage capacity to meet your
* application's demand. As with all Amazon Web Services, there are no
* up-front investments, and you pay only for the resources you use.
*
*/
public class AmazonRDSAsyncClient extends AmazonRDSClient
implements AmazonRDSAsync {
/**
* Executor service for executing asynchronous requests.
*/
private ExecutorService executorService;
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRDS using the specified AWS account credentials.
* Default client settings will be used, and a default cached 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 AmazonRDSAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, Executors.newCachedThreadPool());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRDS 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 AmazonRDSAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
super(awsCredentials);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonRDS 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 AmazonRDSAsyncClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, 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;
}
/**
*
* This API deletes a particular DBParameterGroup. The DBParameterGroup
* cannot be associated with any RDS instances to be deleted.
*
*
* @param deleteDBParameterGroupRequest Container for the necessary
* parameters to execute the DeleteDBParameterGroup operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* DeleteDBParameterGroup service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteDBParameterGroupAsync(final DeleteDBParameterGroupRequest deleteDBParameterGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public Void call() throws Exception {
deleteDBParameterGroup(deleteDBParameterGroupRequest);
return null;
}
});
}
/**
*
* This API is used to delete a DBSnapshot. The DBSnapshot must be in
* the "available" state to be deleted.
*
*
* @param deleteDBSnapshotRequest Container for the necessary parameters
* to execute the DeleteDBSnapshot operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DeleteDBSnapshot service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteDBSnapshotAsync(final DeleteDBSnapshotRequest deleteDBSnapshotRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBSnapshot call() throws Exception {
return deleteDBSnapshot(deleteDBSnapshotRequest);
}
});
}
/**
*
* This API modifies the parameters of a DBParameterGroup. To modify
* more than one parameter submit a list of the following: ParameterName,
* ParameterValue, and ApplyMethod. A maximum of 20 parameters can be
* modified in a single request.
*
*
* @param modifyDBParameterGroupRequest Container for the necessary
* parameters to execute the ModifyDBParameterGroup operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* ModifyDBParameterGroup service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future modifyDBParameterGroupAsync(final ModifyDBParameterGroupRequest modifyDBParameterGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ModifyDBParameterGroupResult call() throws Exception {
return modifyDBParameterGroup(modifyDBParameterGroupRequest);
}
});
}
/**
*
* This API revokes ingress from a DBSecurityGroup for previously
* authorized IP ranges or EC2 Security Groups. Required parameters for
* this API are one of CIDRIP or (EC2SecurityGroupName AND
* EC2SecurityGroupOwnerId).
*
*
* @param revokeDBSecurityGroupIngressRequest Container for the necessary
* parameters to execute the RevokeDBSecurityGroupIngress operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* RevokeDBSecurityGroupIngress service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future revokeDBSecurityGroupIngressAsync(final RevokeDBSecurityGroupIngressRequest revokeDBSecurityGroupIngressRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBSecurityGroup call() throws Exception {
return revokeDBSecurityGroupIngress(revokeDBSecurityGroupIngressRequest);
}
});
}
/**
*
* This API returns the detailed parameter list for a particular
* DBParameterGroup.
*
*
* @param describeDBParametersRequest Container for the necessary
* parameters to execute the DescribeDBParameters operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeDBParameters service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeDBParametersAsync(final DescribeDBParametersRequest describeDBParametersRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeDBParametersResult call() throws Exception {
return describeDBParameters(describeDBParametersRequest);
}
});
}
/**
*
* This API returns events related to DB Instances, DB Security Groups,
* DB Snapshots and DB Parameter Groups for the past 14 das. Events
* specific to a particular DB Instance, database security group,
* database snapshot or database parameter group can be obtained by
* providing the name as a parameter. By default, the past hour of events
* are returned.
*
*
* @param describeEventsRequest Container for the necessary parameters to
* execute the DescribeEvents operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeEvents service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeEventsAsync(final DescribeEventsRequest describeEventsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeEventsResult call() throws Exception {
return describeEvents(describeEventsRequest);
}
});
}
/**
*
* This API creates a new database security group. Database Security
* groups control access to a database instance.
*
*
* @param createDBSecurityGroupRequest Container for the necessary
* parameters to execute the CreateDBSecurityGroup operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* CreateDBSecurityGroup service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createDBSecurityGroupAsync(final CreateDBSecurityGroupRequest createDBSecurityGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBSecurityGroup call() throws Exception {
return createDBSecurityGroup(createDBSecurityGroupRequest);
}
});
}
/**
*
* This API is used to retrieve information about provisioned RDS
* instances. DescribeDBInstances supports pagination.
*
*
* @param describeDBInstancesRequest Container for the necessary
* parameters to execute the DescribeDBInstances operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeDBInstances service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeDBInstancesAsync(final DescribeDBInstancesRequest describeDBInstancesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeDBInstancesResult call() throws Exception {
return describeDBInstances(describeDBInstancesRequest);
}
});
}
/**
*
* This API returns a list of DBParameterGroup descriptions. If a
* DBParameterGroupName is specified, the list will contain only the
* descriptions of the specified DBParameterGroup.
*
*
* @param describeDBParameterGroupsRequest Container for the necessary
* parameters to execute the DescribeDBParameterGroups operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeDBParameterGroups service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeDBParameterGroupsAsync(final DescribeDBParameterGroupsRequest describeDBParameterGroupsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeDBParameterGroupsResult call() throws Exception {
return describeDBParameterGroups(describeDBParameterGroupsRequest);
}
});
}
/**
*
* This API is used to create a DBSnapshot. The source DBInstance must
* be in "available" state.
*
*
* @param createDBSnapshotRequest Container for the necessary parameters
* to execute the CreateDBSnapshot operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* CreateDBSnapshot service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createDBSnapshotAsync(final CreateDBSnapshotRequest createDBSnapshotRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBSnapshot call() throws Exception {
return createDBSnapshot(createDBSnapshotRequest);
}
});
}
/**
*
* Returns a list of the available DB engines.
*
*
* @param describeDBEngineVersionsRequest Container for the necessary
* parameters to execute the DescribeDBEngineVersions operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeDBEngineVersions service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeDBEngineVersionsAsync(final DescribeDBEngineVersionsRequest describeDBEngineVersionsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeDBEngineVersionsResult call() throws Exception {
return describeDBEngineVersions(describeDBEngineVersionsRequest);
}
});
}
/**
*
* The RebootDBInstance API reboots a previously provisioned RDS
* instance. This API results in the application of modified
* DBParameterGroup parameters with ApplyStatus of pending-reboot to the
* RDS instance. This action is taken as soon as possible, and results in
* a momentary outage to the RDS instance during which the RDS instance
* status is set to rebooting. A DBInstance event is created when the
* reboot is completed.
*
*
* @param rebootDBInstanceRequest Container for the necessary parameters
* to execute the RebootDBInstance operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* RebootDBInstance service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future rebootDBInstanceAsync(final RebootDBInstanceRequest rebootDBInstanceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBInstance call() throws Exception {
return rebootDBInstance(rebootDBInstanceRequest);
}
});
}
/**
*
* This API allows for ingress to a DBSecurityGroup using one of two
* forms of authorization. First, EC2 Security Groups can be added to the
* DBSecurityGroup if the application using the database is running on
* EC2 instances. Second, IP ranges are available if the application
* accessing your database is running on the Internet. Required
* parameters for this API are one of CIDR range or (EC2SecurityGroupName
* AND EC2SecurityGroupOwnerId).
*
*
* @param authorizeDBSecurityGroupIngressRequest Container for the
* necessary parameters to execute the AuthorizeDBSecurityGroupIngress
* operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* AuthorizeDBSecurityGroupIngress service method, as returned by
* AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future authorizeDBSecurityGroupIngressAsync(final AuthorizeDBSecurityGroupIngressRequest authorizeDBSecurityGroupIngressRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBSecurityGroup call() throws Exception {
return authorizeDBSecurityGroupIngress(authorizeDBSecurityGroupIngressRequest);
}
});
}
/**
*
* This API creates a new RDS instance from a point-in-time system
* snapshot. The target database is created from the source database
* restore point with the same configuration as the original source
* database, except that the new RDS instance is created with the default
* security group.
*
*
* @param restoreDBInstanceToPointInTimeRequest Container for the
* necessary parameters to execute the RestoreDBInstanceToPointInTime
* operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* RestoreDBInstanceToPointInTime service method, as returned by
* AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future restoreDBInstanceToPointInTimeAsync(final RestoreDBInstanceToPointInTimeRequest restoreDBInstanceToPointInTimeRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBInstance call() throws Exception {
return restoreDBInstanceToPointInTime(restoreDBInstanceToPointInTimeRequest);
}
});
}
/**
*
* This API is used to retrieve information about DBSnapshots. This API
* supports pagination.
*
*
* @param describeDBSnapshotsRequest Container for the necessary
* parameters to execute the DescribeDBSnapshots operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeDBSnapshots service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeDBSnapshotsAsync(final DescribeDBSnapshotsRequest describeDBSnapshotsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeDBSnapshotsResult call() throws Exception {
return describeDBSnapshots(describeDBSnapshotsRequest);
}
});
}
/**
*
* Lists available reserved DB Instance offerings.
*
*
* @param describeReservedDBInstancesOfferingsRequest Container for the
* necessary parameters to execute the
* DescribeReservedDBInstancesOfferings operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeReservedDBInstancesOfferings service method, as returned by
* AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeReservedDBInstancesOfferingsAsync(final DescribeReservedDBInstancesOfferingsRequest describeReservedDBInstancesOfferingsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeReservedDBInstancesOfferingsResult call() throws Exception {
return describeReservedDBInstancesOfferings(describeReservedDBInstancesOfferingsRequest);
}
});
}
/**
*
* This API returns the default engine and system parameter information
* for the specified database engine.
*
*
* @param describeEngineDefaultParametersRequest Container for the
* necessary parameters to execute the DescribeEngineDefaultParameters
* operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeEngineDefaultParameters service method, as returned by
* AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeEngineDefaultParametersAsync(final DescribeEngineDefaultParametersRequest describeEngineDefaultParametersRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public EngineDefaults call() throws Exception {
return describeEngineDefaultParameters(describeEngineDefaultParametersRequest);
}
});
}
/**
*
* The DeleteDBInstance API deletes a previously provisioned RDS
* instance. A successful response from the web service indicates the
* request was received correctly. If a final DBSnapshot is requested the
* status of the RDS instance will be "deleting" until the DBSnapshot is
* created. DescribeDBInstance is used to monitor the status of this
* operation. This cannot be canceled or reverted once submitted.
*
*
* @param deleteDBInstanceRequest Container for the necessary parameters
* to execute the DeleteDBInstance operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* DeleteDBInstance service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteDBInstanceAsync(final DeleteDBInstanceRequest deleteDBInstanceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBInstance call() throws Exception {
return deleteDBInstance(deleteDBInstanceRequest);
}
});
}
/**
*
* This API returns a list of DBSecurityGroup descriptions. If a
* DBSecurityGroupName is specified, the list will contain only the
* descriptions of the specified DBSecurityGroup.
*
*
* @param describeDBSecurityGroupsRequest Container for the necessary
* parameters to execute the DescribeDBSecurityGroups operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeDBSecurityGroups service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeDBSecurityGroupsAsync(final DescribeDBSecurityGroupsRequest describeDBSecurityGroupsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeDBSecurityGroupsResult call() throws Exception {
return describeDBSecurityGroups(describeDBSecurityGroupsRequest);
}
});
}
/**
*
* This API creates a new DB instance.
*
*
* @param createDBInstanceRequest Container for the necessary parameters
* to execute the CreateDBInstance operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* CreateDBInstance service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createDBInstanceAsync(final CreateDBInstanceRequest createDBInstanceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBInstance call() throws Exception {
return createDBInstance(createDBInstanceRequest);
}
});
}
/**
*
* This API modifies the parameters of a DBParameterGroup to the
* engine/system default value. To reset specific parameters submit a
* list of the following: ParameterName and ApplyMethod. To reset the
* entire DBParameterGroup specify the DBParameterGroup name and
* ResetAllParameters parameters. When resetting the entire group,
* dynamic parameters are updated immediately and static parameters are
* set to pending-reboot to take effect on the next MySQL reboot or
* RebootDBInstance request.
*
*
* @param resetDBParameterGroupRequest Container for the necessary
* parameters to execute the ResetDBParameterGroup operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* ResetDBParameterGroup service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future resetDBParameterGroupAsync(final ResetDBParameterGroupRequest resetDBParameterGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ResetDBParameterGroupResult call() throws Exception {
return resetDBParameterGroup(resetDBParameterGroupRequest);
}
});
}
/**
*
* This API is used to change RDS Instance settings. Users call the
* ModifyDBInstance API to change one or more database configuration
* parameters by specifying these parameters and the new values in the
* request.
*
*
* @param modifyDBInstanceRequest Container for the necessary parameters
* to execute the ModifyDBInstance operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* ModifyDBInstance service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future modifyDBInstanceAsync(final ModifyDBInstanceRequest modifyDBInstanceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBInstance call() throws Exception {
return modifyDBInstance(modifyDBInstanceRequest);
}
});
}
/**
*
* This API creates a new DB Instance to an arbitrary point-in-time.
* Users can restore to any point in time before the latestRestorableTime
* for up to backupRetentionPeriod days. The target database is created
* from the source database with the same configuration as the original
* database except that the DB instance is created with the default DB
* security group.
*
*
* @param restoreDBInstanceFromDBSnapshotRequest Container for the
* necessary parameters to execute the RestoreDBInstanceFromDBSnapshot
* operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* RestoreDBInstanceFromDBSnapshot service method, as returned by
* AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future restoreDBInstanceFromDBSnapshotAsync(final RestoreDBInstanceFromDBSnapshotRequest restoreDBInstanceFromDBSnapshotRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBInstance call() throws Exception {
return restoreDBInstanceFromDBSnapshot(restoreDBInstanceFromDBSnapshotRequest);
}
});
}
/**
*
* Returns information about reserved DB Instances for this account, or
* about a specified reserved DB Instance.
*
*
* @param describeReservedDBInstancesRequest Container for the necessary
* parameters to execute the DescribeReservedDBInstances operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* DescribeReservedDBInstances service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeReservedDBInstancesAsync(final DescribeReservedDBInstancesRequest describeReservedDBInstancesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeReservedDBInstancesResult call() throws Exception {
return describeReservedDBInstances(describeReservedDBInstancesRequest);
}
});
}
/**
*
* This API creates a new database parameter group.
*
*
* @param createDBParameterGroupRequest Container for the necessary
* parameters to execute the CreateDBParameterGroup operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* CreateDBParameterGroup service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createDBParameterGroupAsync(final CreateDBParameterGroupRequest createDBParameterGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBParameterGroup call() throws Exception {
return createDBParameterGroup(createDBParameterGroupRequest);
}
});
}
/**
*
* This API deletes a database security group. Database security group
* must not be associated with any RDS Instances.
*
*
* @param deleteDBSecurityGroupRequest Container for the necessary
* parameters to execute the DeleteDBSecurityGroup operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* DeleteDBSecurityGroup service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteDBSecurityGroupAsync(final DeleteDBSecurityGroupRequest deleteDBSecurityGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public Void call() throws Exception {
deleteDBSecurityGroup(deleteDBSecurityGroupRequest);
return null;
}
});
}
/**
*
* Creates a DB Instance that acts as a Read Replica of a source DB
* Instance.
*
*
* All Read Replica DB Instances are created as Single-AZ deployments
* with backups disabled. All other DB Instance attributes (including DB
* Security Groups and DB Parameter Groups) are inherited from the source
* DB Instance, except as specified below.
*
*
* IMPORTANT: The source DB Instance must have backup retention
* enabled.
*
*
* @param createDBInstanceReadReplicaRequest Container for the necessary
* parameters to execute the CreateDBInstanceReadReplica operation on
* AmazonRDS.
*
* @return A Java Future object containing the response from the
* CreateDBInstanceReadReplica service method, as returned by AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createDBInstanceReadReplicaAsync(final CreateDBInstanceReadReplicaRequest createDBInstanceReadReplicaRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DBInstance call() throws Exception {
return createDBInstanceReadReplica(createDBInstanceReadReplicaRequest);
}
});
}
/**
*
* Purchases a reserved DB Instance offering.
*
*
* @param purchaseReservedDBInstancesOfferingRequest Container for the
* necessary parameters to execute the
* PurchaseReservedDBInstancesOffering operation on AmazonRDS.
*
* @return A Java Future object containing the response from the
* PurchaseReservedDBInstancesOffering service method, as returned by
* AmazonRDS.
*
* @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 AmazonRDS indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future purchaseReservedDBInstancesOfferingAsync(final PurchaseReservedDBInstancesOfferingRequest purchaseReservedDBInstancesOfferingRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ReservedDBInstance call() throws Exception {
return purchaseReservedDBInstancesOffering(purchaseReservedDBInstancesOfferingRequest);
}
});
}
}