com.amazonaws.services.rds.AmazonRDSClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-osgi Show documentation
/*
* Copyright 2011-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not
* use this file except in compliance with the License. A copy of the License is
* located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.amazonaws.services.rds;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import java.util.Map.Entry;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.rds.model.*;
import com.amazonaws.services.rds.model.transform.*;
/**
* Client for accessing Amazon RDS. All service calls made using this client are
* blocking, and will not return until the service call completes.
*
* Amazon Relational Database Service
*
*
*
* 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, resizeable 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 MySQL, MariaDB,
* PostgreSQL, Microsoft SQL Server, Oracle, or Amazon Aurora database server.
* These capabilities mean that the code, applications, and tools you already
* use today with your existing 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.
*
*
* This interface reference for Amazon RDS contains documentation for a
* programming or command line interface you can use to manage Amazon RDS. Note
* that Amazon RDS is asynchronous, which means that some interfaces might
* require techniques such as polling or callback functions to determine when a
* command has been applied. In this reference, the parameter descriptions
* indicate whether a command is applied immediately, on the next instance
* reboot, or during the maintenance window. The reference structure is as
* follows, and we list following some related topics from the user guide.
*
*
* Amazon RDS API Reference
*
*
* -
*
* For the alphabetical list of API actions, see API Actions.
*
*
* -
*
* For the alphabetical list of data types, see Data Types.
*
*
* -
*
* For a list of common query parameters, see Common Parameters.
*
*
* -
*
* For descriptions of the error codes, see Common Errors.
*
*
*
*
* Amazon RDS User Guide
*
*
* -
*
* For a summary of the Amazon RDS interfaces, see Available RDS Interfaces.
*
*
* -
*
* For more information about how to use the Query API, see Using the Query API.
*
*
*
*/
@ThreadSafe
public class AmazonRDSClient extends AmazonWebServiceClient implements
AmazonRDS {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonRDS.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "rds";
/**
* Client configuration factory providing ClientConfigurations tailored to
* this client
*/
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
/**
* List of exception unmarshallers for all modeled exceptions
*/
protected final List> exceptionUnmarshallers = new ArrayList>();
/**
* Constructs a new client to invoke service methods on Amazon RDS. 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 AmazonRDSClient() {
this(new DefaultAWSCredentialsProviderChain(), configFactory
.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon RDS. 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 Amazon RDS (ex: proxy settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonRDSClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on Amazon RDS using the
* specified AWS account credentials.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
*/
public AmazonRDSClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon RDS using the
* specified AWS account credentials and client configuration options.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to Amazon RDS (ex: proxy settings, retry counts, etc.).
*/
public AmazonRDSClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(
awsCredentials);
init();
}
/**
* Constructs a new client to invoke service methods on Amazon RDS using the
* specified AWS account credentials provider.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
*/
public AmazonRDSClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon RDS using the
* specified AWS account credentials provider and client configuration
* options.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to Amazon RDS (ex: proxy settings, retry counts, etc.).
*/
public AmazonRDSClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on Amazon RDS using the
* specified AWS account credentials provider, client configuration options,
* and request metric collector.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to Amazon RDS (ex: proxy settings, retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
*/
public AmazonRDSClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
/**
* Constructs a new client to invoke service methods on Amazon RDS using the
* specified parameters.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonRDSClient(AwsSyncClientParams clientParams) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
init();
}
private void init() {
exceptionUnmarshallers
.add(new OptionGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new OptionGroupQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSnapshotNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SubscriptionCategoryNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidRestoreExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBInstanceAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSnapshotAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers.add(new SNSInvalidTopicExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBParameterGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBInstanceStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBLogFileNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidOptionGroupStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBSubnetGroupStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSecurityGroupNotSupportedExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InsufficientDBClusterCapacityExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBSubnetStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSubnetGroupNotAllowedExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CertificateNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBSecurityGroupStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSubnetQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBSnapshotStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSecurityGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReservedDBInstanceNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSubnetGroupQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers.add(new ResourceNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new StorageTypeNotSupportedExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InsufficientDBInstanceCapacityExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBUpgradeDependencyFailureExceptionUnmarshaller());
exceptionUnmarshallers
.add(new KMSKeyNotAccessibleExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SubscriptionNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBClusterQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InsufficientStorageClusterCapacityExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SubnetAlreadyInUseExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ProvisionedIopsNotAvailableInAZExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBClusterSnapshotAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReservedDBInstanceAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidEventSubscriptionStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new PointInTimeRestoreNotEnabledExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBParameterGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidSubnetExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSubnetGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SNSNoAuthorizationExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSubnetGroupDoesNotCoverEnoughAZsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBClusterSnapshotNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSubnetGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new AuthorizationQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InstanceQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBClusterParameterGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSecurityGroupQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SnapshotQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBInstanceNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SharedSnapshotQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReservedDBInstanceQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBClusterStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBClusterAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidVPCNetworkStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SNSTopicArnNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBSubnetGroupExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SubscriptionAlreadyExistExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBParameterGroupQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBClusterNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new OptionGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBClusterSnapshotStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new DBSecurityGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers.add(new SourceNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReservedDBInstancesOfferingNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidDBParameterGroupStateExceptionUnmarshaller());
exceptionUnmarshallers.add(new DomainNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new EventSubscriptionQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new AuthorizationAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new StorageQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new AuthorizationNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new StandardErrorUnmarshaller(
com.amazonaws.services.rds.model.AmazonRDSException.class));
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("rds.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s
.addAll(chainFactory
.newRequestHandlerChain("/com/amazonaws/services/rds/request.handlers"));
requestHandler2s
.addAll(chainFactory
.newRequestHandler2Chain("/com/amazonaws/services/rds/request.handler2s"));
}
/**
*
* Adds a source identifier to an existing RDS event notification
* subscription.
*
*
* @param addSourceIdentifierToSubscriptionRequest
* @return Result of the AddSourceIdentifierToSubscription operation
* returned by the service.
* @throws SubscriptionNotFoundException
* The subscription name does not exist.
* @throws SourceNotFoundException
* The requested source could not be found.
* @sample AmazonRDS.AddSourceIdentifierToSubscription
*/
@Override
public EventSubscription addSourceIdentifierToSubscription(
AddSourceIdentifierToSubscriptionRequest addSourceIdentifierToSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(addSourceIdentifierToSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddSourceIdentifierToSubscriptionRequestMarshaller()
.marshall(super
.beforeMarshalling(addSourceIdentifierToSubscriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new EventSubscriptionStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds metadata tags to an Amazon RDS resource. These tags can also be used
* with cost allocation reporting to track cost associated with Amazon RDS
* resources, or used in a Condition statement in an IAM policy for Amazon
* RDS.
*
*
* For an overview on tagging Amazon RDS resources, see Tagging Amazon RDS Resources.
*
*
* @param addTagsToResourceRequest
* @return Result of the AddTagsToResource operation returned by the
* service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB
* snapshot.
* @sample AmazonRDS.AddTagsToResource
*/
@Override
public AddTagsToResourceResult addTagsToResource(
AddTagsToResourceRequest addTagsToResourceRequest) {
ExecutionContext executionContext = createExecutionContext(addTagsToResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddTagsToResourceRequestMarshaller()
.marshall(super
.beforeMarshalling(addTagsToResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new AddTagsToResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Applies a pending maintenance action to a resource (for example, to a DB
* instance).
*
*
* @param applyPendingMaintenanceActionRequest
* @return Result of the ApplyPendingMaintenanceAction operation returned by
* the service.
* @throws ResourceNotFoundException
* The specified resource ID was not found.
* @sample AmazonRDS.ApplyPendingMaintenanceAction
*/
@Override
public ResourcePendingMaintenanceActions applyPendingMaintenanceAction(
ApplyPendingMaintenanceActionRequest applyPendingMaintenanceActionRequest) {
ExecutionContext executionContext = createExecutionContext(applyPendingMaintenanceActionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ApplyPendingMaintenanceActionRequestMarshaller()
.marshall(super
.beforeMarshalling(applyPendingMaintenanceActionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ResourcePendingMaintenanceActionsStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enables ingress to a DBSecurityGroup using one of two forms of
* authorization. First, EC2 or VPC security groups can be added to the
* DBSecurityGroup if the application using the database is running on EC2
* or VPC 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, EC2SecurityGroupId for VPC, or
* (EC2SecurityGroupOwnerId and either EC2SecurityGroupName or
* EC2SecurityGroupId for non-VPC).
*
*
*
* You cannot authorize ingress from an EC2 security group in one region to
* an Amazon RDS DB instance in another. You cannot authorize ingress from a
* VPC security group in one VPC to an Amazon RDS DB instance in another.
*
*
*
* For an overview of CIDR ranges, go to the Wikipedia Tutorial.
*
*
* @param authorizeDBSecurityGroupIngressRequest
* @return Result of the AuthorizeDBSecurityGroupIngress operation returned
* by the service.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName does not refer to an existing DB
* security group.
* @throws InvalidDBSecurityGroupStateException
* The state of the DB security group does not allow deletion.
* @throws AuthorizationAlreadyExistsException
* The specified CIDRIP or EC2 security group is already authorized
* for the specified DB security group.
* @throws AuthorizationQuotaExceededException
* DB security group authorization quota has been reached.
* @sample AmazonRDS.AuthorizeDBSecurityGroupIngress
*/
@Override
public DBSecurityGroup authorizeDBSecurityGroupIngress(
AuthorizeDBSecurityGroupIngressRequest authorizeDBSecurityGroupIngressRequest) {
ExecutionContext executionContext = createExecutionContext(authorizeDBSecurityGroupIngressRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AuthorizeDBSecurityGroupIngressRequestMarshaller()
.marshall(super
.beforeMarshalling(authorizeDBSecurityGroupIngressRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies the specified DB cluster parameter group.
*
*
* @param copyDBClusterParameterGroupRequest
* @return Result of the CopyDBClusterParameterGroup operation returned by
* the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonRDS.CopyDBClusterParameterGroup
*/
@Override
public DBClusterParameterGroup copyDBClusterParameterGroup(
CopyDBClusterParameterGroupRequest copyDBClusterParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(copyDBClusterParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyDBClusterParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(copyDBClusterParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterParameterGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a snapshot of a DB cluster. For more information on Amazon
* Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param copyDBClusterSnapshotRequest
* @return Result of the CopyDBClusterSnapshot operation returned by the
* service.
* @throws DBClusterSnapshotAlreadyExistsException
* User already has a DB cluster snapshot with the given identifier.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @sample AmazonRDS.CopyDBClusterSnapshot
*/
@Override
public DBClusterSnapshot copyDBClusterSnapshot(
CopyDBClusterSnapshotRequest copyDBClusterSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(copyDBClusterSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyDBClusterSnapshotRequestMarshaller()
.marshall(super
.beforeMarshalling(copyDBClusterSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterSnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies the specified DB parameter group.
*
*
* @param copyDBParameterGroupRequest
* @return Result of the CopyDBParameterGroup operation returned by the
* service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* parameter groups.
* @sample AmazonRDS.CopyDBParameterGroup
*/
@Override
public DBParameterGroup copyDBParameterGroup(
CopyDBParameterGroupRequest copyDBParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(copyDBParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyDBParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(copyDBParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBParameterGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies the specified DB snapshot. The source DB snapshot must be in the
* "available" state.
*
*
* If you are copying from a shared manual DB snapshot, the
* SourceDBSnapshotIdentifier must be the ARN of the shared DB
* snapshot.
*
*
* @param copyDBSnapshotRequest
* @return Result of the CopyDBSnapshot operation returned by the service.
* @throws DBSnapshotAlreadyExistsException
* DBSnapshotIdentifier is already used by an existing
* snapshot.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB
* snapshot.
* @throws InvalidDBSnapshotStateException
* The state of the DB snapshot does not allow deletion.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* snapshots.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @sample AmazonRDS.CopyDBSnapshot
*/
@Override
public DBSnapshot copyDBSnapshot(CopyDBSnapshotRequest copyDBSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(copyDBSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyDBSnapshotRequestMarshaller().marshall(super
.beforeMarshalling(copyDBSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBSnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies the specified option group.
*
*
* @param copyOptionGroupRequest
* @return Result of the CopyOptionGroup operation returned by the service.
* @throws OptionGroupAlreadyExistsException
* The option group you are trying to create already exists.
* @throws OptionGroupNotFoundException
* The specified option group could not be found.
* @throws OptionGroupQuotaExceededException
* The quota of 20 option groups was exceeded for this AWS account.
* @sample AmazonRDS.CopyOptionGroup
*/
@Override
public OptionGroup copyOptionGroup(
CopyOptionGroupRequest copyOptionGroupRequest) {
ExecutionContext executionContext = createExecutionContext(copyOptionGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyOptionGroupRequestMarshaller().marshall(super
.beforeMarshalling(copyOptionGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new OptionGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new Amazon Aurora DB cluster.
*
*
* You can use the ReplicationSourceIdentifier parameter to
* create the DB cluster as a Read Replica of another DB cluster.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param createDBClusterRequest
* @return Result of the CreateDBCluster operation returned by the service.
* @throws DBClusterAlreadyExistsException
* User already has a DB cluster with the given identifier.
* @throws InsufficientStorageClusterCapacityException
* There is insufficient storage available for the current action.
* You may be able to resolve this error by updating your subnet
* group to use different Availability Zones that have more storage
* available.
* @throws DBClusterQuotaExceededException
* User attempted to create a new DB cluster and the user has
* already reached the maximum allowed DB cluster quota.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of
* storage available across all DB instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet
* group.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBSubnetGroupStateException
* The DB subnet group cannot be deleted because it is in use.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were
* requested that are not all in a common VPC.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName does not refer to an existing
* DB Cluster parameter group.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB
* cluster.
* @sample AmazonRDS.CreateDBCluster
*/
@Override
public DBCluster createDBCluster(
CreateDBClusterRequest createDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(createDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBClusterRequestMarshaller().marshall(super
.beforeMarshalling(createDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new DB cluster parameter group.
*
*
* Parameters in a DB cluster parameter group apply to all of the instances
* in a DB cluster.
*
*
* A DB cluster parameter group is initially created with the default
* parameters for the database engine used by instances in the DB cluster.
* To provide custom values for any of the parameters, you must modify the
* group after creating it using ModifyDBClusterParameterGroup. Once
* you've created a DB cluster parameter group, you need to associate it
* with your DB cluster using ModifyDBCluster. When you associate a
* new DB cluster parameter group with a running DB cluster, you need to
* reboot the DB instances in the DB cluster without failover for the new DB
* cluster parameter group and associated settings to take effect.
*
*
*
* After you create a DB cluster parameter group, you should wait at least 5
* minutes before creating your first DB cluster that uses that DB cluster
* parameter group as the default parameter group. This allows Amazon RDS to
* fully complete the create action before the DB cluster parameter group is
* used as the default for a new DB cluster. This is especially important
* for parameters that are critical when creating the default database for a
* DB cluster, such as the character set for the default database defined by
* the character_set_database parameter. You can use the
* Parameter Groups option of the Amazon RDS console or the
* DescribeDBClusterParameters command to verify that your DB cluster
* parameter group has been created or modified.
*
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param createDBClusterParameterGroupRequest
* @return Result of the CreateDBClusterParameterGroup operation returned by
* the service.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonRDS.CreateDBClusterParameterGroup
*/
@Override
public DBClusterParameterGroup createDBClusterParameterGroup(
CreateDBClusterParameterGroupRequest createDBClusterParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createDBClusterParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBClusterParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBClusterParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterParameterGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a snapshot of a DB cluster. For more information on Amazon
* Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param createDBClusterSnapshotRequest
* @return Result of the CreateDBClusterSnapshot operation returned by the
* service.
* @throws DBClusterSnapshotAlreadyExistsException
* User already has a DB cluster snapshot with the given identifier.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB
* cluster.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* snapshots.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @sample AmazonRDS.CreateDBClusterSnapshot
*/
@Override
public DBClusterSnapshot createDBClusterSnapshot(
CreateDBClusterSnapshotRequest createDBClusterSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(createDBClusterSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBClusterSnapshotRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBClusterSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterSnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new DB instance.
*
*
* @param createDBInstanceRequest
* @return Result of the CreateDBInstance operation returned by the service.
* @throws DBInstanceAlreadyExistsException
* User already has a DB instance with the given identifier.
* @throws InsufficientDBInstanceCapacityException
* Specified DB instance class is not available in the specified
* Availability Zone.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName does not refer to an existing DB
* security group.
* @throws InstanceQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* instances.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of
* storage available across all DB instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet
* group.
* @throws DBSubnetGroupDoesNotCoverEnoughAZsException
* Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were
* requested that are not all in a common VPC.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* @throws ProvisionedIopsNotAvailableInAZException
* Provisioned IOPS not available in the specified Availability
* Zone.
* @throws OptionGroupNotFoundException
* The specified option group could not be found.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB
* cluster.
* @throws StorageTypeNotSupportedException
* StorageType specified cannot be associated with the DB
* Instance.
* @throws AuthorizationNotFoundException
* Specified CIDRIP or EC2 security group is not authorized for the
* specified DB security group.
*
* RDS may not also be authorized via IAM to perform necessary
* actions on your behalf.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @throws DomainNotFoundException
* Domain does not refer to an existing Active Directory
* Domain.
* @sample AmazonRDS.CreateDBInstance
*/
@Override
public DBInstance createDBInstance(
CreateDBInstanceRequest createDBInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(createDBInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBInstanceRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBInstanceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBInstanceStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a DB instance for a DB instance running MySQL, MariaDB, or
* PostgreSQL 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.
*
*
*
* The source DB instance must have backup retention enabled.
*
*
*
* @param createDBInstanceReadReplicaRequest
* @return Result of the CreateDBInstanceReadReplica operation returned by
* the service.
* @throws DBInstanceAlreadyExistsException
* User already has a DB instance with the given identifier.
* @throws InsufficientDBInstanceCapacityException
* Specified DB instance class is not available in the specified
* Availability Zone.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName does not refer to an existing DB
* security group.
* @throws InstanceQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* instances.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of
* storage available across all DB instances.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet
* group.
* @throws DBSubnetGroupDoesNotCoverEnoughAZsException
* Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were
* requested that are not all in a common VPC.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* @throws ProvisionedIopsNotAvailableInAZException
* Provisioned IOPS not available in the specified Availability
* Zone.
* @throws OptionGroupNotFoundException
* The specified option group could not be found.
* @throws DBSubnetGroupNotAllowedException
* Indicates that the DBSubnetGroup should not be specified while
* creating read replicas that lie in the same region as the source
* instance.
* @throws InvalidDBSubnetGroupException
* Indicates the DBSubnetGroup does not belong to the same VPC as
* that of an existing cross region read replica of the same source
* instance.
* @throws StorageTypeNotSupportedException
* StorageType specified cannot be associated with the DB
* Instance.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @sample AmazonRDS.CreateDBInstanceReadReplica
*/
@Override
public DBInstance createDBInstanceReadReplica(
CreateDBInstanceReadReplicaRequest createDBInstanceReadReplicaRequest) {
ExecutionContext executionContext = createExecutionContext(createDBInstanceReadReplicaRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBInstanceReadReplicaRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBInstanceReadReplicaRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBInstanceStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new DB parameter group.
*
*
* A DB parameter group is initially created with the default parameters for
* the database engine used by the DB instance. To provide custom values for
* any of the parameters, you must modify the group after creating it using
* ModifyDBParameterGroup. Once you've created a DB parameter group,
* you need to associate it with your DB instance using
* ModifyDBInstance. When you associate a new DB parameter group with
* a running DB instance, you need to reboot the DB instance without
* failover for the new DB parameter group and associated settings to take
* effect.
*
*
*
* After you create a DB parameter group, you should wait at least 5 minutes
* before creating your first DB instance that uses that DB parameter group
* as the default parameter group. This allows Amazon RDS to fully complete
* the create action before the parameter group is used as the default for a
* new DB instance. This is especially important for parameters that are
* critical when creating the default database for a DB instance, such as
* the character set for the default database defined by the
* character_set_database parameter. You can use the
* Parameter Groups option of the Amazon RDS console or the
* DescribeDBParameters command to verify that your DB parameter
* group has been created or modified.
*
*
*
* @param createDBParameterGroupRequest
* @return Result of the CreateDBParameterGroup operation returned by the
* service.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonRDS.CreateDBParameterGroup
*/
@Override
public DBParameterGroup createDBParameterGroup(
CreateDBParameterGroupRequest createDBParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createDBParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBParameterGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new DB security group. DB security groups control access to a
* DB instance.
*
*
* @param createDBSecurityGroupRequest
* @return Result of the CreateDBSecurityGroup operation returned by the
* service.
* @throws DBSecurityGroupAlreadyExistsException
* A DB security group with the name specified in
* DBSecurityGroupName already exists.
* @throws DBSecurityGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* security groups.
* @throws DBSecurityGroupNotSupportedException
* A DB security group is not allowed for this action.
* @sample AmazonRDS.CreateDBSecurityGroup
*/
@Override
public DBSecurityGroup createDBSecurityGroup(
CreateDBSecurityGroupRequest createDBSecurityGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createDBSecurityGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBSecurityGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBSecurityGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a DBSnapshot. The source DBInstance must be in "available" state.
*
*
* @param createDBSnapshotRequest
* @return Result of the CreateDBSnapshot operation returned by the service.
* @throws DBSnapshotAlreadyExistsException
* DBSnapshotIdentifier is already used by an existing
* snapshot.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* snapshots.
* @sample AmazonRDS.CreateDBSnapshot
*/
@Override
public DBSnapshot createDBSnapshot(
CreateDBSnapshotRequest createDBSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(createDBSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBSnapshotRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBSnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new DB subnet group. DB subnet groups must contain at least one
* subnet in at least two AZs in the region.
*
*
* @param createDBSubnetGroupRequest
* @return Result of the CreateDBSubnetGroup operation returned by the
* service.
* @throws DBSubnetGroupAlreadyExistsException
* DBSubnetGroupName is already used by an existing DB subnet
* group.
* @throws DBSubnetGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* subnet groups.
* @throws DBSubnetQuotaExceededException
* Request would result in user exceeding the allowed number of
* subnets in a DB subnet groups.
* @throws DBSubnetGroupDoesNotCoverEnoughAZsException
* Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were
* requested that are not all in a common VPC.
* @sample AmazonRDS.CreateDBSubnetGroup
*/
@Override
public DBSubnetGroup createDBSubnetGroup(
CreateDBSubnetGroupRequest createDBSubnetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createDBSubnetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBSubnetGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createDBSubnetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBSubnetGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an RDS event notification subscription. This action requires a
* topic ARN (Amazon Resource Name) created by either the RDS console, the
* SNS console, or the SNS API. To obtain an ARN with SNS, you must create a
* topic in Amazon SNS and subscribe to the topic. The ARN is displayed in
* the SNS console.
*
*
* You can specify the type of source (SourceType) you want to be notified
* of, provide a list of RDS sources (SourceIds) that triggers the events,
* and provide a list of event categories (EventCategories) for events you
* want to be notified of. For example, you can specify SourceType =
* db-instance, SourceIds = mydbinstance1, mydbinstance2 and EventCategories
* = Availability, Backup.
*
*
* If you specify both the SourceType and SourceIds, such as SourceType =
* db-instance and SourceIdentifier = myDBInstance1, you will be notified of
* all the db-instance events for the specified source. If you specify a
* SourceType but do not specify a SourceIdentifier, you will receive notice
* of the events for that source type for all your RDS sources. If you do
* not specify either the SourceType nor the SourceIdentifier, you will be
* notified of events generated from all RDS sources belonging to your
* customer account.
*
*
* @param createEventSubscriptionRequest
* @return Result of the CreateEventSubscription operation returned by the
* service.
* @throws EventSubscriptionQuotaExceededException
* You have reached the maximum number of event subscriptions.
* @throws SubscriptionAlreadyExistException
* The supplied subscription name already exists.
* @throws SNSInvalidTopicException
* SNS has responded that there is a problem with the SND topic
* specified.
* @throws SNSNoAuthorizationException
* You do not have permission to publish to the SNS topic ARN.
* @throws SNSTopicArnNotFoundException
* The SNS topic ARN does not exist.
* @throws SubscriptionCategoryNotFoundException
* The supplied category does not exist.
* @throws SourceNotFoundException
* The requested source could not be found.
* @sample AmazonRDS.CreateEventSubscription
*/
@Override
public EventSubscription createEventSubscription(
CreateEventSubscriptionRequest createEventSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(createEventSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateEventSubscriptionRequestMarshaller()
.marshall(super
.beforeMarshalling(createEventSubscriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new EventSubscriptionStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new option group. You can create up to 20 option groups.
*
*
* @param createOptionGroupRequest
* @return Result of the CreateOptionGroup operation returned by the
* service.
* @throws OptionGroupAlreadyExistsException
* The option group you are trying to create already exists.
* @throws OptionGroupQuotaExceededException
* The quota of 20 option groups was exceeded for this AWS account.
* @sample AmazonRDS.CreateOptionGroup
*/
@Override
public OptionGroup createOptionGroup(
CreateOptionGroupRequest createOptionGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createOptionGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateOptionGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createOptionGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new OptionGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteDBCluster action deletes a previously provisioned DB cluster.
* When you delete a DB cluster, all automated backups for that DB cluster
* are deleted and cannot be recovered. Manual DB cluster snapshots of the
* specified DB cluster are not deleted.
*
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param deleteDBClusterRequest
* @return Result of the DeleteDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB
* cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws DBClusterSnapshotAlreadyExistsException
* User already has a DB cluster snapshot with the given identifier.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* snapshots.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @sample AmazonRDS.DeleteDBCluster
*/
@Override
public DBCluster deleteDBCluster(
DeleteDBClusterRequest deleteDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBClusterRequestMarshaller().marshall(super
.beforeMarshalling(deleteDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a specified DB cluster parameter group. The DB cluster parameter
* group to be deleted cannot be associated with any DB clusters.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param deleteDBClusterParameterGroupRequest
* @return Result of the DeleteDBClusterParameterGroup operation returned by
* the service.
* @throws InvalidDBParameterGroupStateException
* The DB parameter group cannot be deleted because it is in use.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @sample AmazonRDS.DeleteDBClusterParameterGroup
*/
@Override
public DeleteDBClusterParameterGroupResult deleteDBClusterParameterGroup(
DeleteDBClusterParameterGroupRequest deleteDBClusterParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBClusterParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBClusterParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteDBClusterParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteDBClusterParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a DB cluster snapshot. If the snapshot is being copied, the copy
* operation is terminated.
*
*
*
* The DB cluster snapshot must be in the available state to be
* deleted.
*
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param deleteDBClusterSnapshotRequest
* @return Result of the DeleteDBClusterSnapshot operation returned by the
* service.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* @sample AmazonRDS.DeleteDBClusterSnapshot
*/
@Override
public DBClusterSnapshot deleteDBClusterSnapshot(
DeleteDBClusterSnapshotRequest deleteDBClusterSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBClusterSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBClusterSnapshotRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteDBClusterSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterSnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteDBInstance action deletes a previously provisioned DB instance.
* When you delete a DB instance, all automated backups for that instance
* are deleted and cannot be recovered. Manual DB snapshots of the DB
* instance to be deleted by DeleteDBInstance are not deleted.
*
*
* If you request a final DB snapshot the status of the Amazon RDS DB
* instance is deleting until the DB snapshot is created. The
* API action DescribeDBInstance is used to monitor the status
* of this operation. The action cannot be canceled or reverted once
* submitted.
*
*
* Note that when a DB instance is in a failure state and has a status of
* failed, incompatible-restore, or
* incompatible-network, you can only delete it when the
* SkipFinalSnapshot parameter is set to true.
*
*
* If the specified DB instance is part of an Amazon Aurora DB cluster, you
* cannot delete the DB instance if the following are true:
*
*
* -
*
* The DB cluster is a Read Replica of another Amazon Aurora DB cluster.
*
*
* -
*
* The DB instance is the only instance in the DB cluster.
*
*
*
*
* To delete a DB instance in this case, first call the
* PromoteReadReplicaDBCluster API action to promote the DB cluster
* so it's no longer a Read Replica. After the promotion completes, then
* call the DeleteDBInstance API action to delete the final
* instance in the DB cluster.
*
*
* @param deleteDBInstanceRequest
* @return Result of the DeleteDBInstance operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBSnapshotAlreadyExistsException
* DBSnapshotIdentifier is already used by an existing
* snapshot.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB
* snapshots.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @sample AmazonRDS.DeleteDBInstance
*/
@Override
public DBInstance deleteDBInstance(
DeleteDBInstanceRequest deleteDBInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBInstanceRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteDBInstanceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBInstanceStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a specified DBParameterGroup. The DBParameterGroup to be deleted
* cannot be associated with any DB instances.
*
*
* @param deleteDBParameterGroupRequest
* @return Result of the DeleteDBParameterGroup operation returned by the
* service.
* @throws InvalidDBParameterGroupStateException
* The DB parameter group cannot be deleted because it is in use.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @sample AmazonRDS.DeleteDBParameterGroup
*/
@Override
public DeleteDBParameterGroupResult deleteDBParameterGroup(
DeleteDBParameterGroupRequest deleteDBParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteDBParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteDBParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a DB security group.
*
*
*
* The specified DB security group must not be associated with any DB
* instances.
*
*
*
* @param deleteDBSecurityGroupRequest
* @return Result of the DeleteDBSecurityGroup operation returned by the
* service.
* @throws InvalidDBSecurityGroupStateException
* The state of the DB security group does not allow deletion.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName does not refer to an existing DB
* security group.
* @sample AmazonRDS.DeleteDBSecurityGroup
*/
@Override
public DeleteDBSecurityGroupResult deleteDBSecurityGroup(
DeleteDBSecurityGroupRequest deleteDBSecurityGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBSecurityGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBSecurityGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteDBSecurityGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteDBSecurityGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a DBSnapshot. If the snapshot is being copied, the copy operation
* is terminated.
*
*
*
* The DBSnapshot must be in the available state to be deleted.
*
*
*
* @param deleteDBSnapshotRequest
* @return Result of the DeleteDBSnapshot operation returned by the service.
* @throws InvalidDBSnapshotStateException
* The state of the DB snapshot does not allow deletion.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB
* snapshot.
* @sample AmazonRDS.DeleteDBSnapshot
*/
@Override
public DBSnapshot deleteDBSnapshot(
DeleteDBSnapshotRequest deleteDBSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBSnapshotRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteDBSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBSnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a DB subnet group.
*
*
*
* The specified database subnet group must not be associated with any DB
* instances.
*
*
*
* @param deleteDBSubnetGroupRequest
* @return Result of the DeleteDBSubnetGroup operation returned by the
* service.
* @throws InvalidDBSubnetGroupStateException
* The DB subnet group cannot be deleted because it is in use.
* @throws InvalidDBSubnetStateException
* The DB subnet is not in the available state.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet
* group.
* @sample AmazonRDS.DeleteDBSubnetGroup
*/
@Override
public DeleteDBSubnetGroupResult deleteDBSubnetGroup(
DeleteDBSubnetGroupRequest deleteDBSubnetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBSubnetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBSubnetGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteDBSubnetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteDBSubnetGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an RDS event notification subscription.
*
*
* @param deleteEventSubscriptionRequest
* @return Result of the DeleteEventSubscription operation returned by the
* service.
* @throws SubscriptionNotFoundException
* The subscription name does not exist.
* @throws InvalidEventSubscriptionStateException
* This error can occur if someone else is modifying a subscription.
* You should retry the action.
* @sample AmazonRDS.DeleteEventSubscription
*/
@Override
public EventSubscription deleteEventSubscription(
DeleteEventSubscriptionRequest deleteEventSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteEventSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteEventSubscriptionRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteEventSubscriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new EventSubscriptionStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an existing option group.
*
*
* @param deleteOptionGroupRequest
* @return Result of the DeleteOptionGroup operation returned by the
* service.
* @throws OptionGroupNotFoundException
* The specified option group could not be found.
* @throws InvalidOptionGroupStateException
* The option group is not in the available state.
* @sample AmazonRDS.DeleteOptionGroup
*/
@Override
public DeleteOptionGroupResult deleteOptionGroup(
DeleteOptionGroupRequest deleteOptionGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteOptionGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteOptionGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteOptionGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteOptionGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all of the attributes for a customer account. The attributes
* include Amazon RDS quotas for the account, such as the number of DB
* instances allowed. The description for a quota includes the quota name,
* current usage toward that quota, and the quota's maximum value.
*
*
* This command does not take any parameters.
*
*
* @param describeAccountAttributesRequest
* @return Result of the DescribeAccountAttributes operation returned by the
* service.
* @sample AmazonRDS.DescribeAccountAttributes
*/
@Override
public DescribeAccountAttributesResult describeAccountAttributes(
DescribeAccountAttributesRequest describeAccountAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(describeAccountAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAccountAttributesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeAccountAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeAccountAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeAccountAttributesResult describeAccountAttributes() {
return describeAccountAttributes(new DescribeAccountAttributesRequest());
}
/**
*
* Lists the set of CA certificates provided by Amazon RDS for this AWS
* account.
*
*
* @param describeCertificatesRequest
* @return Result of the DescribeCertificates operation returned by the
* service.
* @throws CertificateNotFoundException
* CertificateIdentifier does not refer to an existing
* certificate.
* @sample AmazonRDS.DescribeCertificates
*/
@Override
public DescribeCertificatesResult describeCertificates(
DescribeCertificatesRequest describeCertificatesRequest) {
ExecutionContext executionContext = createExecutionContext(describeCertificatesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCertificatesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeCertificatesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCertificatesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeCertificatesResult describeCertificates() {
return describeCertificates(new DescribeCertificatesRequest());
}
/**
*
* Returns a list of DBClusterParameterGroup descriptions. If a
* DBClusterParameterGroupName parameter is specified, the list
* will contain only the description of the specified DB cluster parameter
* group.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param describeDBClusterParameterGroupsRequest
* @return Result of the DescribeDBClusterParameterGroups operation returned
* by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @sample AmazonRDS.DescribeDBClusterParameterGroups
*/
@Override
public DescribeDBClusterParameterGroupsResult describeDBClusterParameterGroups(
DescribeDBClusterParameterGroupsRequest describeDBClusterParameterGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterParameterGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterParameterGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBClusterParameterGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterParameterGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBClusterParameterGroupsResult describeDBClusterParameterGroups() {
return describeDBClusterParameterGroups(new DescribeDBClusterParameterGroupsRequest());
}
/**
*
* Returns the detailed parameter list for a particular DB cluster parameter
* group.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param describeDBClusterParametersRequest
* @return Result of the DescribeDBClusterParameters operation returned by
* the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @sample AmazonRDS.DescribeDBClusterParameters
*/
@Override
public DescribeDBClusterParametersResult describeDBClusterParameters(
DescribeDBClusterParametersRequest describeDBClusterParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterParametersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBClusterParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterParametersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of DB cluster snapshot attribute names and values for a
* manual DB cluster snapshot.
*
*
* When sharing snapshots with other AWS accounts,
* DescribeDBClusterSnapshotAttributes returns the
* restore attribute and a list of IDs for the AWS accounts
* that are authorized to copy or restore the manual DB cluster snapshot. If
* all is included in the list of values for the
* restore attribute, then the manual DB cluster snapshot is
* public and can be copied or restored by all AWS accounts.
*
*
* To add or remove access for an AWS account to copy or restore a manual DB
* cluster snapshot, or to make the manual DB cluster snapshot public or
* private, use the ModifyDBClusterSnapshotAttribute API action.
*
*
* @param describeDBClusterSnapshotAttributesRequest
* @return Result of the DescribeDBClusterSnapshotAttributes operation
* returned by the service.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* @sample AmazonRDS.DescribeDBClusterSnapshotAttributes
*/
@Override
public DBClusterSnapshotAttributesResult describeDBClusterSnapshotAttributes(
DescribeDBClusterSnapshotAttributesRequest describeDBClusterSnapshotAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterSnapshotAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterSnapshotAttributesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBClusterSnapshotAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterSnapshotAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about DB cluster snapshots. This API action supports
* pagination.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param describeDBClusterSnapshotsRequest
* @return Result of the DescribeDBClusterSnapshots operation returned by
* the service.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* @sample AmazonRDS.DescribeDBClusterSnapshots
*/
@Override
public DescribeDBClusterSnapshotsResult describeDBClusterSnapshots(
DescribeDBClusterSnapshotsRequest describeDBClusterSnapshotsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterSnapshotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterSnapshotsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBClusterSnapshotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterSnapshotsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBClusterSnapshotsResult describeDBClusterSnapshots() {
return describeDBClusterSnapshots(new DescribeDBClusterSnapshotsRequest());
}
/**
*
* Returns information about provisioned Aurora DB clusters. This API
* supports pagination.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param describeDBClustersRequest
* @return Result of the DescribeDBClusters operation returned by the
* service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB
* cluster.
* @sample AmazonRDS.DescribeDBClusters
*/
@Override
public DescribeDBClustersResult describeDBClusters(
DescribeDBClustersRequest describeDBClustersRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClustersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClustersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBClustersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClustersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBClustersResult describeDBClusters() {
return describeDBClusters(new DescribeDBClustersRequest());
}
/**
*
* Returns a list of the available DB engines.
*
*
* @param describeDBEngineVersionsRequest
* @return Result of the DescribeDBEngineVersions operation returned by the
* service.
* @sample AmazonRDS.DescribeDBEngineVersions
*/
@Override
public DescribeDBEngineVersionsResult describeDBEngineVersions(
DescribeDBEngineVersionsRequest describeDBEngineVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBEngineVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBEngineVersionsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBEngineVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBEngineVersionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBEngineVersionsResult describeDBEngineVersions() {
return describeDBEngineVersions(new DescribeDBEngineVersionsRequest());
}
/**
*
* Returns information about provisioned RDS instances. This API supports
* pagination.
*
*
* @param describeDBInstancesRequest
* @return Result of the DescribeDBInstances operation returned by the
* service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @sample AmazonRDS.DescribeDBInstances
*/
@Override
public DescribeDBInstancesResult describeDBInstances(
DescribeDBInstancesRequest describeDBInstancesRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBInstancesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBInstancesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBInstancesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBInstancesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBInstancesResult describeDBInstances() {
return describeDBInstances(new DescribeDBInstancesRequest());
}
/**
*
* Returns a list of DB log files for the DB instance.
*
*
* @param describeDBLogFilesRequest
* @return Result of the DescribeDBLogFiles operation returned by the
* service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @sample AmazonRDS.DescribeDBLogFiles
*/
@Override
public DescribeDBLogFilesResult describeDBLogFiles(
DescribeDBLogFilesRequest describeDBLogFilesRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBLogFilesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBLogFilesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBLogFilesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBLogFilesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of DBParameterGroup descriptions. If a
* DBParameterGroupName is specified, the list will contain
* only the description of the specified DB parameter group.
*
*
* @param describeDBParameterGroupsRequest
* @return Result of the DescribeDBParameterGroups operation returned by the
* service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @sample AmazonRDS.DescribeDBParameterGroups
*/
@Override
public DescribeDBParameterGroupsResult describeDBParameterGroups(
DescribeDBParameterGroupsRequest describeDBParameterGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBParameterGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBParameterGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBParameterGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBParameterGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBParameterGroupsResult describeDBParameterGroups() {
return describeDBParameterGroups(new DescribeDBParameterGroupsRequest());
}
/**
*
* Returns the detailed parameter list for a particular DB parameter group.
*
*
* @param describeDBParametersRequest
* @return Result of the DescribeDBParameters operation returned by the
* service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB
* parameter group.
* @sample AmazonRDS.DescribeDBParameters
*/
@Override
public DescribeDBParametersResult describeDBParameters(
DescribeDBParametersRequest describeDBParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBParametersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBParametersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of DBSecurityGroup descriptions. If a
* DBSecurityGroupName is specified, the list will contain only
* the descriptions of the specified DB security group.
*
*
* @param describeDBSecurityGroupsRequest
* @return Result of the DescribeDBSecurityGroups operation returned by the
* service.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName does not refer to an existing DB
* security group.
* @sample AmazonRDS.DescribeDBSecurityGroups
*/
@Override
public DescribeDBSecurityGroupsResult describeDBSecurityGroups(
DescribeDBSecurityGroupsRequest describeDBSecurityGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBSecurityGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBSecurityGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBSecurityGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBSecurityGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBSecurityGroupsResult describeDBSecurityGroups() {
return describeDBSecurityGroups(new DescribeDBSecurityGroupsRequest());
}
/**
*
* Returns a list of DB snapshot attribute names and values for a manual DB
* snapshot.
*
*
* When sharing snapshots with other AWS accounts,
* DescribeDBSnapshotAttributes returns the
* restore attribute and a list of IDs for the AWS accounts
* that are authorized to copy or restore the manual DB snapshot. If
* all is included in the list of values for the
* restore attribute, then the manual DB snapshot is public and
* can be copied or restored by all AWS accounts.
*
*
* To add or remove access for an AWS account to copy or restore a manual DB
* snapshot, or to make the manual DB snapshot public or private, use the
* ModifyDBSnapshotAttribute API action.
*
*
* @param describeDBSnapshotAttributesRequest
* @return Result of the DescribeDBSnapshotAttributes operation returned by
* the service.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB
* snapshot.
* @sample AmazonRDS.DescribeDBSnapshotAttributes
*/
@Override
public DBSnapshotAttributesResult describeDBSnapshotAttributes(
DescribeDBSnapshotAttributesRequest describeDBSnapshotAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBSnapshotAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBSnapshotAttributesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBSnapshotAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBSnapshotAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DBSnapshotAttributesResult describeDBSnapshotAttributes() {
return describeDBSnapshotAttributes(new DescribeDBSnapshotAttributesRequest());
}
/**
*
* Returns information about DB snapshots. This API action supports
* pagination.
*
*
* @param describeDBSnapshotsRequest
* @return Result of the DescribeDBSnapshots operation returned by the
* service.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB
* snapshot.
* @sample AmazonRDS.DescribeDBSnapshots
*/
@Override
public DescribeDBSnapshotsResult describeDBSnapshots(
DescribeDBSnapshotsRequest describeDBSnapshotsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBSnapshotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBSnapshotsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBSnapshotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBSnapshotsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBSnapshotsResult describeDBSnapshots() {
return describeDBSnapshots(new DescribeDBSnapshotsRequest());
}
/**
*
* Returns a list of DBSubnetGroup descriptions. If a DBSubnetGroupName is
* specified, the list will contain only the descriptions of the specified
* DBSubnetGroup.
*
*
* For an overview of CIDR ranges, go to the Wikipedia Tutorial.
*
*
* @param describeDBSubnetGroupsRequest
* @return Result of the DescribeDBSubnetGroups operation returned by the
* service.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet
* group.
* @sample AmazonRDS.DescribeDBSubnetGroups
*/
@Override
public DescribeDBSubnetGroupsResult describeDBSubnetGroups(
DescribeDBSubnetGroupsRequest describeDBSubnetGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBSubnetGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBSubnetGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeDBSubnetGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBSubnetGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeDBSubnetGroupsResult describeDBSubnetGroups() {
return describeDBSubnetGroups(new DescribeDBSubnetGroupsRequest());
}
/**
*
* Returns the default engine and system parameter information for the
* cluster database engine.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param describeEngineDefaultClusterParametersRequest
* @return Result of the DescribeEngineDefaultClusterParameters operation
* returned by the service.
* @sample AmazonRDS.DescribeEngineDefaultClusterParameters
*/
@Override
public EngineDefaults describeEngineDefaultClusterParameters(
DescribeEngineDefaultClusterParametersRequest describeEngineDefaultClusterParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeEngineDefaultClusterParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEngineDefaultClusterParametersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeEngineDefaultClusterParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new EngineDefaultsStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the default engine and system parameter information for the
* specified database engine.
*
*
* @param describeEngineDefaultParametersRequest
* @return Result of the DescribeEngineDefaultParameters operation returned
* by the service.
* @sample AmazonRDS.DescribeEngineDefaultParameters
*/
@Override
public EngineDefaults describeEngineDefaultParameters(
DescribeEngineDefaultParametersRequest describeEngineDefaultParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeEngineDefaultParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEngineDefaultParametersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeEngineDefaultParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new EngineDefaultsStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Displays a list of categories for all event source types, or, if
* specified, for a specified source type. You can see a list of the event
* categories and source types in the
* Events topic in the Amazon RDS User Guide.
*
*
* @param describeEventCategoriesRequest
* @return Result of the DescribeEventCategories operation returned by the
* service.
* @sample AmazonRDS.DescribeEventCategories
*/
@Override
public DescribeEventCategoriesResult describeEventCategories(
DescribeEventCategoriesRequest describeEventCategoriesRequest) {
ExecutionContext executionContext = createExecutionContext(describeEventCategoriesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEventCategoriesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeEventCategoriesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeEventCategoriesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeEventCategoriesResult describeEventCategories() {
return describeEventCategories(new DescribeEventCategoriesRequest());
}
/**
*
* Lists all the subscription descriptions for a customer account. The
* description for a subscription includes SubscriptionName, SNSTopicARN,
* CustomerID, SourceType, SourceID, CreationTime, and Status.
*
*
* If you specify a SubscriptionName, lists the description for that
* subscription.
*
*
* @param describeEventSubscriptionsRequest
* @return Result of the DescribeEventSubscriptions operation returned by
* the service.
* @throws SubscriptionNotFoundException
* The subscription name does not exist.
* @sample AmazonRDS.DescribeEventSubscriptions
*/
@Override
public DescribeEventSubscriptionsResult describeEventSubscriptions(
DescribeEventSubscriptionsRequest describeEventSubscriptionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeEventSubscriptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEventSubscriptionsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeEventSubscriptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeEventSubscriptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeEventSubscriptionsResult describeEventSubscriptions() {
return describeEventSubscriptions(new DescribeEventSubscriptionsRequest());
}
/**
*
* Returns events related to DB instances, DB security groups, DB snapshots,
* and DB parameter groups for the past 14 days. Events specific to a
* particular DB instance, DB security group, database snapshot, or DB
* parameter group can be obtained by providing the name as a parameter. By
* default, the past hour of events are returned.
*
*
* @param describeEventsRequest
* @return Result of the DescribeEvents operation returned by the service.
* @sample AmazonRDS.DescribeEvents
*/
@Override
public DescribeEventsResult describeEvents(
DescribeEventsRequest describeEventsRequest) {
ExecutionContext executionContext = createExecutionContext(describeEventsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEventsRequestMarshaller().marshall(super
.beforeMarshalling(describeEventsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeEventsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeEventsResult describeEvents() {
return describeEvents(new DescribeEventsRequest());
}
/**
*
* Describes all available options.
*
*
* @param describeOptionGroupOptionsRequest
* @return Result of the DescribeOptionGroupOptions operation returned by
* the service.
* @sample AmazonRDS.DescribeOptionGroupOptions
*/
@Override
public DescribeOptionGroupOptionsResult describeOptionGroupOptions(
DescribeOptionGroupOptionsRequest describeOptionGroupOptionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeOptionGroupOptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeOptionGroupOptionsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeOptionGroupOptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeOptionGroupOptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the available option groups.
*
*
* @param describeOptionGroupsRequest
* @return Result of the DescribeOptionGroups operation returned by the
* service.
* @throws OptionGroupNotFoundException
* The specified option group could not be found.
* @sample AmazonRDS.DescribeOptionGroups
*/
@Override
public DescribeOptionGroupsResult describeOptionGroups(
DescribeOptionGroupsRequest describeOptionGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeOptionGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeOptionGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeOptionGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeOptionGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeOptionGroupsResult describeOptionGroups() {
return describeOptionGroups(new DescribeOptionGroupsRequest());
}
/**
*
* Returns a list of orderable DB instance options for the specified engine.
*
*
* @param describeOrderableDBInstanceOptionsRequest
* @return Result of the DescribeOrderableDBInstanceOptions operation
* returned by the service.
* @sample AmazonRDS.DescribeOrderableDBInstanceOptions
*/
@Override
public DescribeOrderableDBInstanceOptionsResult describeOrderableDBInstanceOptions(
DescribeOrderableDBInstanceOptionsRequest describeOrderableDBInstanceOptionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeOrderableDBInstanceOptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeOrderableDBInstanceOptionsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeOrderableDBInstanceOptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeOrderableDBInstanceOptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of resources (for example, DB instances) that have at
* least one pending maintenance action.
*
*
* @param describePendingMaintenanceActionsRequest
* @return Result of the DescribePendingMaintenanceActions operation
* returned by the service.
* @throws ResourceNotFoundException
* The specified resource ID was not found.
* @sample AmazonRDS.DescribePendingMaintenanceActions
*/
@Override
public DescribePendingMaintenanceActionsResult describePendingMaintenanceActions(
DescribePendingMaintenanceActionsRequest describePendingMaintenanceActionsRequest) {
ExecutionContext executionContext = createExecutionContext(describePendingMaintenanceActionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribePendingMaintenanceActionsRequestMarshaller()
.marshall(super
.beforeMarshalling(describePendingMaintenanceActionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribePendingMaintenanceActionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribePendingMaintenanceActionsResult describePendingMaintenanceActions() {
return describePendingMaintenanceActions(new DescribePendingMaintenanceActionsRequest());
}
/**
*
* Returns information about reserved DB instances for this account, or
* about a specified reserved DB instance.
*
*
* @param describeReservedDBInstancesRequest
* @return Result of the DescribeReservedDBInstances operation returned by
* the service.
* @throws ReservedDBInstanceNotFoundException
* The specified reserved DB Instance not found.
* @sample AmazonRDS.DescribeReservedDBInstances
*/
@Override
public DescribeReservedDBInstancesResult describeReservedDBInstances(
DescribeReservedDBInstancesRequest describeReservedDBInstancesRequest) {
ExecutionContext executionContext = createExecutionContext(describeReservedDBInstancesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeReservedDBInstancesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeReservedDBInstancesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeReservedDBInstancesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeReservedDBInstancesResult describeReservedDBInstances() {
return describeReservedDBInstances(new DescribeReservedDBInstancesRequest());
}
/**
*
* Lists available reserved DB instance offerings.
*
*
* @param describeReservedDBInstancesOfferingsRequest
* @return Result of the DescribeReservedDBInstancesOfferings operation
* returned by the service.
* @throws ReservedDBInstancesOfferingNotFoundException
* Specified offering does not exist.
* @sample AmazonRDS.DescribeReservedDBInstancesOfferings
*/
@Override
public DescribeReservedDBInstancesOfferingsResult describeReservedDBInstancesOfferings(
DescribeReservedDBInstancesOfferingsRequest describeReservedDBInstancesOfferingsRequest) {
ExecutionContext executionContext = createExecutionContext(describeReservedDBInstancesOfferingsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeReservedDBInstancesOfferingsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeReservedDBInstancesOfferingsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeReservedDBInstancesOfferingsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeReservedDBInstancesOfferingsResult describeReservedDBInstancesOfferings() {
return describeReservedDBInstancesOfferings(new DescribeReservedDBInstancesOfferingsRequest());
}
/**
*
* Downloads all or a portion of the specified log file, up to 1 MB in size.
*
*
* @param downloadDBLogFilePortionRequest
* @return Result of the DownloadDBLogFilePortion operation returned by the
* service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @throws DBLogFileNotFoundException
* LogFileName does not refer to an existing DB log file.
* @sample AmazonRDS.DownloadDBLogFilePortion
*/
@Override
public DownloadDBLogFilePortionResult downloadDBLogFilePortion(
DownloadDBLogFilePortionRequest downloadDBLogFilePortionRequest) {
ExecutionContext executionContext = createExecutionContext(downloadDBLogFilePortionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DownloadDBLogFilePortionRequestMarshaller()
.marshall(super
.beforeMarshalling(downloadDBLogFilePortionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DownloadDBLogFilePortionResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Forces a failover for a DB cluster.
*
*
* A failover for a DB cluster promotes one of the read-only instances in
* the DB cluster to the master DB instance (the cluster writer) and deletes
* the current primary instance.
*
*
* Amazon Aurora will automatically fail over to a read-only instance, if
* one exists, when the primary instance fails. You can force a failover
* when you want to simulate a failure of a DB instance for testing. Because
* each instance in a DB cluster has its own endpoint address, you will need
* to clean up and re-establish any existing connections that use those
* endpoint addresses when the failover is complete.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param failoverDBClusterRequest
* @return Result of the FailoverDBCluster operation returned by the
* service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB
* cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @sample AmazonRDS.FailoverDBCluster
*/
@Override
public DBCluster failoverDBCluster(
FailoverDBClusterRequest failoverDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(failoverDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new FailoverDBClusterRequestMarshaller()
.marshall(super
.beforeMarshalling(failoverDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DBCluster failoverDBCluster() {
return failoverDBCluster(new FailoverDBClusterRequest());
}
/**
*
* Lists all tags on an Amazon RDS resource.
*
*
* For an overview on tagging an Amazon RDS resource, see Tagging Amazon RDS Resources.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the
* service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB
* instance.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB
* snapshot.
* @sample AmazonRDS.ListTagsForResource
*/
@Override
public ListTagsForResourceResult listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestMarshaller()
.marshall(super
.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListTagsForResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modify a setting for an Amazon Aurora DB cluster. You can change one or
* more database configuration parameters by specifying these parameters and
* the new values in the request. For more information on Amazon Aurora, see
* Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
* @param modifyDBClusterRequest
* @return Result of the ModifyDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB
* cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of
* storage available across all DB instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet
* group.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* @throws InvalidDBSubnetGroupStateException
* The DB subnet group cannot be deleted because it is in use.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were
* requested that are not all in a common VPC.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName does not refer to an existing
* DB Cluster parameter group.
* @throws InvalidDBSecurityGroupStateException
* The state of the DB security group does not allow deletion.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBClusterAlreadyExistsException
* User already has a DB cluster with the given identifier.
* @sample AmazonRDS.ModifyDBCluster
*/
@Override
public DBCluster modifyDBCluster(
ModifyDBClusterRequest modifyDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBClusterRequestMarshaller().marshall(super
.beforeMarshalling(modifyDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the parameters of a DB cluster parameter group. 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.
*
*
* For more information on Amazon Aurora, see Aurora on Amazon RDS in the Amazon RDS User Guide.
*
*
*
* Changes to dynamic parameters are applied immediately. Changes to static
* parameters require a reboot without failover to the DB cluster associated
* with the parameter group before the change can take effect.
*
*
*
* After you create a DB cluster parameter group, you should wait at least 5
* minutes before creating your first DB cluster that uses that DB cluster
* parameter group as the default parameter group. This allows Amazon RDS to
* fully complete the create action before the parameter group is used as
* the default for a new DB cluster. This is especially important for
* parameters that are critical when creating the default database for a DB
* cluster, such as the character set for the default database defined by
* the