com.amazonaws.services.rds.AmazonRDSClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-rds Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.rds;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
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.client.builder.AdvancedConfig;
import com.amazonaws.services.rds.AmazonRDSClientBuilder;
import com.amazonaws.services.rds.waiters.AmazonRDSWaiters;
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, Db2,
* 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
* DB 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. 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
@Generated("com.amazonaws:aws-java-sdk-code-generator")
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";
private volatile AmazonRDSWaiters waiters;
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
/**
* Map of exception unmarshallers for all modeled exceptions
*/
private final Map> exceptionUnmarshallersMap = new HashMap>();
/**
* List of exception unmarshallers for all modeled exceptions Even though this exceptionUnmarshallers is not used in
* Clients, this is not removed since this was directly used by Client extended classes. Using this list can cause
* performance impact.
*/
protected final List> exceptionUnmarshallers = new ArrayList>();
protected Unmarshaller defaultUnmarshaller;
/**
* 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
* @deprecated use {@link AmazonRDSClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonRDSClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), 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
* @deprecated use {@link AmazonRDSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonRDSClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), 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.
* @deprecated use {@link AmazonRDSClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AmazonRDSClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
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.).
* @deprecated use {@link AmazonRDSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRDSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonRDSClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
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.
* @deprecated use {@link AmazonRDSClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
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.).
* @deprecated use {@link AmazonRDSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRDSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
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
* @deprecated use {@link AmazonRDSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRDSClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonRDSClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AmazonRDSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AmazonRDSClientBuilder builder() {
return AmazonRDSClientBuilder.standard();
}
/**
* 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) {
this(clientParams, false);
}
/**
* 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, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
if (exceptionUnmarshallersMap.get("InvalidBlueGreenDeploymentStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidBlueGreenDeploymentStateFault", new InvalidBlueGreenDeploymentStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidBlueGreenDeploymentStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("IamRoleNotFound") == null) {
exceptionUnmarshallersMap.put("IamRoleNotFound", new IamRoleNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new IamRoleNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterRoleNotFound") == null) {
exceptionUnmarshallersMap.put("DBClusterRoleNotFound", new DBClusterRoleNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterRoleNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ExportTaskNotFound") == null) {
exceptionUnmarshallersMap.put("ExportTaskNotFound", new ExportTaskNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ExportTaskNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("IntegrationNotFoundFault") == null) {
exceptionUnmarshallersMap.put("IntegrationNotFoundFault", new IntegrationNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new IntegrationNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidRestoreFault") == null) {
exceptionUnmarshallersMap.put("InvalidRestoreFault", new InvalidRestoreExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidRestoreExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidExportOnly") == null) {
exceptionUnmarshallersMap.put("InvalidExportOnly", new InvalidExportOnlyExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidExportOnlyExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBInstanceAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBInstanceAlreadyExists", new DBInstanceAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBInstanceAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSnapshotAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBSnapshotAlreadyExists", new DBSnapshotAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSnapshotAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBParameterGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBParameterGroupAlreadyExists", new DBParameterGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBParameterGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterBacktrackNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBClusterBacktrackNotFoundFault", new DBClusterBacktrackNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterBacktrackNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBLogFileNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBLogFileNotFoundFault", new DBLogFileNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBLogFileNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidOptionGroupStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidOptionGroupStateFault", new InvalidOptionGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidOptionGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSecurityGroupNotSupported") == null) {
exceptionUnmarshallersMap.put("DBSecurityGroupNotSupported", new DBSecurityGroupNotSupportedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSecurityGroupNotSupportedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBSubnetStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBSubnetStateFault", new InvalidDBSubnetStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBSubnetStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBSecurityGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidDBSecurityGroupState", new InvalidDBSecurityGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBSecurityGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSubnetQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("DBSubnetQuotaExceededFault", new DBSubnetQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("BackupPolicyNotFoundFault") == null) {
exceptionUnmarshallersMap.put("BackupPolicyNotFoundFault", new BackupPolicyNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new BackupPolicyNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSecurityGroupNotFound") == null) {
exceptionUnmarshallersMap.put("DBSecurityGroupNotFound", new DBSecurityGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSecurityGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("BlueGreenDeploymentAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("BlueGreenDeploymentAlreadyExistsFault", new BlueGreenDeploymentAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new BlueGreenDeploymentAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CustomDBEngineVersionNotFoundFault") == null) {
exceptionUnmarshallersMap.put("CustomDBEngineVersionNotFoundFault", new CustomDBEngineVersionNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CustomDBEngineVersionNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("IntegrationConflictOperationFault") == null) {
exceptionUnmarshallersMap.put("IntegrationConflictOperationFault", new IntegrationConflictOperationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new IntegrationConflictOperationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InsufficientDBInstanceCapacity") == null) {
exceptionUnmarshallersMap.put("InsufficientDBInstanceCapacity", new InsufficientDBInstanceCapacityExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InsufficientDBInstanceCapacityExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBUpgradeDependencyFailure") == null) {
exceptionUnmarshallersMap.put("DBUpgradeDependencyFailure", new DBUpgradeDependencyFailureExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBUpgradeDependencyFailureExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("StorageTypeNotAvailableFault") == null) {
exceptionUnmarshallersMap.put("StorageTypeNotAvailableFault", new StorageTypeNotAvailableExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new StorageTypeNotAvailableExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterEndpointNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBClusterEndpointNotFoundFault", new DBClusterEndpointNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterEndpointNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InsufficientStorageClusterCapacity") == null) {
exceptionUnmarshallersMap.put("InsufficientStorageClusterCapacity", new InsufficientStorageClusterCapacityExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InsufficientStorageClusterCapacityExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ProvisionedIopsNotAvailableInAZFault") == null) {
exceptionUnmarshallersMap.put("ProvisionedIopsNotAvailableInAZFault", new ProvisionedIopsNotAvailableInAZExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ProvisionedIopsNotAvailableInAZExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBClusterAutomatedBackupStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBClusterAutomatedBackupStateFault", new InvalidDBClusterAutomatedBackupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBClusterAutomatedBackupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedDBInstanceAlreadyExists") == null) {
exceptionUnmarshallersMap.put("ReservedDBInstanceAlreadyExists", new ReservedDBInstanceAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedDBInstanceAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("PointInTimeRestoreNotEnabled") == null) {
exceptionUnmarshallersMap.put("PointInTimeRestoreNotEnabled", new PointInTimeRestoreNotEnabledExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new PointInTimeRestoreNotEnabledExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBParameterGroupNotFound") == null) {
exceptionUnmarshallersMap.put("DBParameterGroupNotFound", new DBParameterGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBParameterGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterAutomatedBackupQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("DBClusterAutomatedBackupQuotaExceededFault", new DBClusterAutomatedBackupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterAutomatedBackupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBShardGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBShardGroupAlreadyExists", new DBShardGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBShardGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBInstanceAutomatedBackupState") == null) {
exceptionUnmarshallersMap.put("InvalidDBInstanceAutomatedBackupState", new InvalidDBInstanceAutomatedBackupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBInstanceAutomatedBackupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CustomAvailabilityZoneNotFound") == null) {
exceptionUnmarshallersMap.put("CustomAvailabilityZoneNotFound", new CustomAvailabilityZoneNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CustomAvailabilityZoneNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CustomDBEngineVersionAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("CustomDBEngineVersionAlreadyExistsFault", new CustomDBEngineVersionAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CustomDBEngineVersionAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSubnetGroupDoesNotCoverEnoughAZs") == null) {
exceptionUnmarshallersMap.put("DBSubnetGroupDoesNotCoverEnoughAZs", new DBSubnetGroupDoesNotCoverEnoughAZsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetGroupDoesNotCoverEnoughAZsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSubnetGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBSubnetGroupNotFoundFault", new DBSubnetGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBProxyNotFoundFault", new DBProxyNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("MaxDBShardGroupLimitReached") == null) {
exceptionUnmarshallersMap.put("MaxDBShardGroupLimitReached", new MaxDBShardGroupLimitReachedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new MaxDBShardGroupLimitReachedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterEndpointQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("DBClusterEndpointQuotaExceededFault", new DBClusterEndpointQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterEndpointQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("NetworkTypeNotSupported") == null) {
exceptionUnmarshallersMap.put("NetworkTypeNotSupported", new NetworkTypeNotSupportedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new NetworkTypeNotSupportedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AuthorizationQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("AuthorizationQuotaExceeded", new AuthorizationQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AuthorizationQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InstanceQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("InstanceQuotaExceeded", new InstanceQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InstanceQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("QuotaExceeded.DBSecurityGroup") == null) {
exceptionUnmarshallersMap.put("QuotaExceeded.DBSecurityGroup", new DBSecurityGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSecurityGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBInstanceAutomatedBackupQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("DBInstanceAutomatedBackupQuotaExceeded", new DBInstanceAutomatedBackupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBInstanceAutomatedBackupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SnapshotQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("SnapshotQuotaExceeded", new SnapshotQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SnapshotQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("GlobalClusterQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("GlobalClusterQuotaExceededFault", new GlobalClusterQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new GlobalClusterQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBInstanceNotFound") == null) {
exceptionUnmarshallersMap.put("DBInstanceNotFound", new DBInstanceNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBInstanceNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TenantDatabaseQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("TenantDatabaseQuotaExceeded", new TenantDatabaseQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TenantDatabaseQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("DBProxyAlreadyExistsFault", new DBProxyAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyTargetAlreadyRegisteredFault") == null) {
exceptionUnmarshallersMap.put("DBProxyTargetAlreadyRegisteredFault", new DBProxyTargetAlreadyRegisteredExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyTargetAlreadyRegisteredExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("BlueGreenDeploymentNotFoundFault") == null) {
exceptionUnmarshallersMap.put("BlueGreenDeploymentNotFoundFault", new BlueGreenDeploymentNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new BlueGreenDeploymentNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SharedSnapshotQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("SharedSnapshotQuotaExceeded", new SharedSnapshotQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SharedSnapshotQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBInstanceRoleQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("DBInstanceRoleQuotaExceeded", new DBInstanceRoleQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBInstanceRoleQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBInstanceAutomatedBackupNotFound") == null) {
exceptionUnmarshallersMap.put("DBInstanceAutomatedBackupNotFound", new DBInstanceAutomatedBackupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBInstanceAutomatedBackupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedDBInstanceQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("ReservedDBInstanceQuotaExceeded", new ReservedDBInstanceQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedDBInstanceQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SourceDatabaseNotSupportedFault") == null) {
exceptionUnmarshallersMap.put("SourceDatabaseNotSupportedFault", new SourceDatabaseNotSupportedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SourceDatabaseNotSupportedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBInstanceRoleNotFound") == null) {
exceptionUnmarshallersMap.put("DBInstanceRoleNotFound", new DBInstanceRoleNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBInstanceRoleNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidVPCNetworkStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidVPCNetworkStateFault", new InvalidVPCNetworkStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidVPCNetworkStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterAutomatedBackupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBClusterAutomatedBackupNotFoundFault", new DBClusterAutomatedBackupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterAutomatedBackupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SNSTopicArnNotFound") == null) {
exceptionUnmarshallersMap.put("SNSTopicArnNotFound", new SNSTopicArnNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SNSTopicArnNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidResourceStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidResourceStateFault", new InvalidResourceStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidResourceStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBSubnetGroupFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBSubnetGroupFault", new InvalidDBSubnetGroupExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBSubnetGroupExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSnapshotTenantDatabaseNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBSnapshotTenantDatabaseNotFoundFault", new DBSnapshotTenantDatabaseNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSnapshotTenantDatabaseNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("OptionGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("OptionGroupNotFoundFault", new OptionGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new OptionGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("UnsupportedDBEngineVersion") == null) {
exceptionUnmarshallersMap.put("UnsupportedDBEngineVersion", new UnsupportedDBEngineVersionExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UnsupportedDBEngineVersionExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBClusterSnapshotStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBClusterSnapshotStateFault", new InvalidDBClusterSnapshotStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBClusterSnapshotStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedDBInstancesOfferingNotFound") == null) {
exceptionUnmarshallersMap.put("ReservedDBInstancesOfferingNotFound", new ReservedDBInstancesOfferingNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedDBInstancesOfferingNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBParameterGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidDBParameterGroupState", new InvalidDBParameterGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBParameterGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DomainNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DomainNotFoundFault", new DomainNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DomainNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("StorageQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("StorageQuotaExceeded", new StorageQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new StorageQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidCustomDBEngineVersionStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidCustomDBEngineVersionStateFault", new InvalidCustomDBEngineVersionStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidCustomDBEngineVersionStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyEndpointAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("DBProxyEndpointAlreadyExistsFault", new DBProxyEndpointAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyEndpointAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AuthorizationNotFound") == null) {
exceptionUnmarshallersMap.put("AuthorizationNotFound", new AuthorizationNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AuthorizationNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("OptionGroupAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("OptionGroupAlreadyExistsFault", new OptionGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new OptionGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("OptionGroupQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("OptionGroupQuotaExceededFault", new OptionGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new OptionGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidExportSourceState") == null) {
exceptionUnmarshallersMap.put("InvalidExportSourceState", new InvalidExportSourceStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidExportSourceStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidMaxAcu") == null) {
exceptionUnmarshallersMap.put("InvalidMaxAcu", new InvalidMaxAcuExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidMaxAcuExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSnapshotNotFound") == null) {
exceptionUnmarshallersMap.put("DBSnapshotNotFound", new DBSnapshotNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSnapshotNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SubscriptionCategoryNotFound") == null) {
exceptionUnmarshallersMap.put("SubscriptionCategoryNotFound", new SubscriptionCategoryNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SubscriptionCategoryNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyTargetGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBProxyTargetGroupNotFoundFault", new DBProxyTargetGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyTargetGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBProxyEndpointStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBProxyEndpointStateFault", new InvalidDBProxyEndpointStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBProxyEndpointStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("Ec2ImagePropertiesNotSupportedFault") == null) {
exceptionUnmarshallersMap.put("Ec2ImagePropertiesNotSupportedFault", new Ec2ImagePropertiesNotSupportedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new Ec2ImagePropertiesNotSupportedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterRoleQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("DBClusterRoleQuotaExceeded", new DBClusterRoleQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterRoleQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("IntegrationQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("IntegrationQuotaExceededFault", new IntegrationQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new IntegrationQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SNSInvalidTopic") == null) {
exceptionUnmarshallersMap.put("SNSInvalidTopic", new SNSInvalidTopicExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SNSInvalidTopicExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBInstanceState") == null) {
exceptionUnmarshallersMap.put("InvalidDBInstanceState", new InvalidDBInstanceStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBInstanceStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBSubnetGroupStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBSubnetGroupStateFault", new InvalidDBSubnetGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBSubnetGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InsufficientDBClusterCapacityFault") == null) {
exceptionUnmarshallersMap.put("InsufficientDBClusterCapacityFault", new InsufficientDBClusterCapacityExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InsufficientDBClusterCapacityExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSubnetGroupNotAllowedFault") == null) {
exceptionUnmarshallersMap.put("DBSubnetGroupNotAllowedFault", new DBSubnetGroupNotAllowedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetGroupNotAllowedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CertificateNotFound") == null) {
exceptionUnmarshallersMap.put("CertificateNotFound", new CertificateNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CertificateNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBSnapshotState") == null) {
exceptionUnmarshallersMap.put("InvalidDBSnapshotState", new InvalidDBSnapshotStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBSnapshotStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidExportTaskStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidExportTaskStateFault", new InvalidExportTaskStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidExportTaskStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidS3BucketFault") == null) {
exceptionUnmarshallersMap.put("InvalidS3BucketFault", new InvalidS3BucketExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidS3BucketExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedDBInstanceNotFound") == null) {
exceptionUnmarshallersMap.put("ReservedDBInstanceNotFound", new ReservedDBInstanceNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedDBInstanceNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSubnetGroupQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("DBSubnetGroupQuotaExceeded", new DBSubnetGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ResourceNotFoundFault") == null) {
exceptionUnmarshallersMap.put("ResourceNotFoundFault", new ResourceNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ResourceNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("StorageTypeNotSupported") == null) {
exceptionUnmarshallersMap.put("StorageTypeNotSupported", new StorageTypeNotSupportedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new StorageTypeNotSupportedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("KMSKeyNotAccessibleFault") == null) {
exceptionUnmarshallersMap.put("KMSKeyNotAccessibleFault", new KMSKeyNotAccessibleExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new KMSKeyNotAccessibleExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SubscriptionNotFound") == null) {
exceptionUnmarshallersMap.put("SubscriptionNotFound", new SubscriptionNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SubscriptionNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("DBClusterQuotaExceededFault", new DBClusterQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBClusterCapacityFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBClusterCapacityFault", new InvalidDBClusterCapacityExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBClusterCapacityExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SubnetAlreadyInUse") == null) {
exceptionUnmarshallersMap.put("SubnetAlreadyInUse", new SubnetAlreadyInUseExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SubnetAlreadyInUseExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterSnapshotAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("DBClusterSnapshotAlreadyExistsFault", new DBClusterSnapshotAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterSnapshotAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterRoleAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBClusterRoleAlreadyExists", new DBClusterRoleAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterRoleAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("GlobalClusterNotFoundFault") == null) {
exceptionUnmarshallersMap.put("GlobalClusterNotFoundFault", new GlobalClusterNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new GlobalClusterNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("IntegrationAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("IntegrationAlreadyExistsFault", new IntegrationAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new IntegrationAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidEventSubscriptionState") == null) {
exceptionUnmarshallersMap.put("InvalidEventSubscriptionState", new InvalidEventSubscriptionStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidEventSubscriptionStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InsufficientAvailableIPsInSubnetFault") == null) {
exceptionUnmarshallersMap.put("InsufficientAvailableIPsInSubnetFault", new InsufficientAvailableIPsInSubnetExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InsufficientAvailableIPsInSubnetExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidSubnet") == null) {
exceptionUnmarshallersMap.put("InvalidSubnet", new InvalidSubnetExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidSubnetExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSubnetGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBSubnetGroupAlreadyExists", new DBSubnetGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SNSNoAuthorization") == null) {
exceptionUnmarshallersMap.put("SNSNoAuthorization", new SNSNoAuthorizationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SNSNoAuthorizationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterSnapshotNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBClusterSnapshotNotFoundFault", new DBClusterSnapshotNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterSnapshotNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyEndpointQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("DBProxyEndpointQuotaExceededFault", new DBProxyEndpointQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyEndpointQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CustomDBEngineVersionQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("CustomDBEngineVersionQuotaExceededFault", new CustomDBEngineVersionQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CustomDBEngineVersionQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TenantDatabaseNotFound") == null) {
exceptionUnmarshallersMap.put("TenantDatabaseNotFound", new TenantDatabaseNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TenantDatabaseNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterParameterGroupNotFound") == null) {
exceptionUnmarshallersMap.put("DBClusterParameterGroupNotFound", new DBClusterParameterGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterParameterGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("DBProxyQuotaExceededFault", new DBProxyQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TenantDatabaseAlreadyExists") == null) {
exceptionUnmarshallersMap.put("TenantDatabaseAlreadyExists", new TenantDatabaseAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TenantDatabaseAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ExportTaskAlreadyExists") == null) {
exceptionUnmarshallersMap.put("ExportTaskAlreadyExists", new ExportTaskAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ExportTaskAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("GlobalClusterAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("GlobalClusterAlreadyExistsFault", new GlobalClusterAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new GlobalClusterAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBClusterEndpointStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBClusterEndpointStateFault", new InvalidDBClusterEndpointStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBClusterEndpointStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidGlobalClusterStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidGlobalClusterStateFault", new InvalidGlobalClusterStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidGlobalClusterStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBShardGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidDBShardGroupState", new InvalidDBShardGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBShardGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SourceClusterNotSupportedFault") == null) {
exceptionUnmarshallersMap.put("SourceClusterNotSupportedFault", new SourceClusterNotSupportedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SourceClusterNotSupportedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("IamRoleMissingPermissions") == null) {
exceptionUnmarshallersMap.put("IamRoleMissingPermissions", new IamRoleMissingPermissionsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new IamRoleMissingPermissionsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBClusterStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBClusterStateFault", new InvalidDBClusterStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBClusterStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("DBClusterAlreadyExistsFault", new DBClusterAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidIntegrationStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidIntegrationStateFault", new InvalidIntegrationStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidIntegrationStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBProxyStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBProxyStateFault", new InvalidDBProxyStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBProxyStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyTargetNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBProxyTargetNotFoundFault", new DBProxyTargetNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyTargetNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SubscriptionAlreadyExist") == null) {
exceptionUnmarshallersMap.put("SubscriptionAlreadyExist", new SubscriptionAlreadyExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SubscriptionAlreadyExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBClusterNotFoundFault", new DBClusterNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBParameterGroupQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("DBParameterGroupQuotaExceeded", new DBParameterGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBParameterGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBInstanceRoleAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBInstanceRoleAlreadyExists", new DBInstanceRoleAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBInstanceRoleAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBProxyEndpointNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBProxyEndpointNotFoundFault", new DBProxyEndpointNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBProxyEndpointNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSecurityGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBSecurityGroupAlreadyExists", new DBSecurityGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSecurityGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SourceNotFound") == null) {
exceptionUnmarshallersMap.put("SourceNotFound", new SourceNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SourceNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CreateCustomDBEngineVersionFault") == null) {
exceptionUnmarshallersMap.put("CreateCustomDBEngineVersionFault", new CreateCustomDBEngineVersionExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CreateCustomDBEngineVersionExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBShardGroupNotFound") == null) {
exceptionUnmarshallersMap.put("DBShardGroupNotFound", new DBShardGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBShardGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("EventSubscriptionQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("EventSubscriptionQuotaExceeded", new EventSubscriptionQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new EventSubscriptionQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AuthorizationAlreadyExists") == null) {
exceptionUnmarshallersMap.put("AuthorizationAlreadyExists", new AuthorizationAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AuthorizationAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterEndpointAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("DBClusterEndpointAlreadyExistsFault", new DBClusterEndpointAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterEndpointAlreadyExistsExceptionUnmarshaller());
defaultUnmarshaller = new StandardErrorUnmarshaller(com.amazonaws.services.rds.model.AmazonRDSException.class);
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"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Associates an Identity and Access Management (IAM) role with a DB cluster.
*
*
* @param addRoleToDBClusterRequest
* @return Result of the AddRoleToDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws DBClusterRoleAlreadyExistsException
* The specified IAM role Amazon Resource Name (ARN) is already associated with the specified DB cluster.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws DBClusterRoleQuotaExceededException
* You have exceeded the maximum number of IAM roles that can be associated with the specified DB cluster.
* @sample AmazonRDS.AddRoleToDBCluster
* @see AWS API
* Documentation
*/
@Override
public AddRoleToDBClusterResult addRoleToDBCluster(AddRoleToDBClusterRequest request) {
request = beforeClientExecution(request);
return executeAddRoleToDBCluster(request);
}
@SdkInternalApi
final AddRoleToDBClusterResult executeAddRoleToDBCluster(AddRoleToDBClusterRequest addRoleToDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(addRoleToDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddRoleToDBClusterRequestMarshaller().marshall(super.beforeMarshalling(addRoleToDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddRoleToDBCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new AddRoleToDBClusterResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates an Amazon Web Services Identity and Access Management (IAM) role with a DB instance.
*
*
*
* To add a role to a DB instance, the status of the DB instance must be available
.
*
*
*
* This command doesn't apply to RDS Custom.
*
*
* @param addRoleToDBInstanceRequest
* @return Result of the AddRoleToDBInstance operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws DBInstanceRoleAlreadyExistsException
* The specified RoleArn
or FeatureName
value is already associated with the DB
* instance.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @throws DBInstanceRoleQuotaExceededException
* You can't associate any more Amazon Web Services Identity and Access Management (IAM) roles with the DB
* instance because the quota has been reached.
* @sample AmazonRDS.AddRoleToDBInstance
* @see AWS API
* Documentation
*/
@Override
public AddRoleToDBInstanceResult addRoleToDBInstance(AddRoleToDBInstanceRequest request) {
request = beforeClientExecution(request);
return executeAddRoleToDBInstance(request);
}
@SdkInternalApi
final AddRoleToDBInstanceResult executeAddRoleToDBInstance(AddRoleToDBInstanceRequest addRoleToDBInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(addRoleToDBInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddRoleToDBInstanceRequestMarshaller().marshall(super.beforeMarshalling(addRoleToDBInstanceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddRoleToDBInstance");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new AddRoleToDBInstanceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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
* @see AWS API Documentation
*/
@Override
public EventSubscription addSourceIdentifierToSubscription(AddSourceIdentifierToSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeAddSourceIdentifierToSubscription(request);
}
@SdkInternalApi
final EventSubscription executeAddSourceIdentifierToSubscription(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddSourceIdentifierToSubscription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 your relational database resources, see Tagging Amazon RDS Resources
* or Tagging Amazon Aurora
* and Amazon RDS Resources.
*
*
* @param addTagsToResourceRequest
* @return Result of the AddTagsToResource operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier
doesn't refer to an existing DB snapshot.
* @throws DBProxyNotFoundException
* The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services account in the
* specified Amazon Web Services Region.
* @throws DBProxyTargetGroupNotFoundException
* The specified target group isn't available for a proxy owned by your Amazon Web Services account in the
* specified Amazon Web Services Region.
* @throws BlueGreenDeploymentNotFoundException
* BlueGreenDeploymentIdentifier
doesn't refer to an existing blue/green deployment.
* @throws IntegrationNotFoundException
* The specified integration could not be found.
* @throws TenantDatabaseNotFoundException
* The specified tenant database wasn't found in the DB instance.
* @throws DBSnapshotTenantDatabaseNotFoundException
* The specified snapshot tenant database wasn't found.
* @sample AmazonRDS.AddTagsToResource
* @see AWS API
* Documentation
*/
@Override
public AddTagsToResourceResult addTagsToResource(AddTagsToResourceRequest request) {
request = beforeClientExecution(request);
return executeAddTagsToResource(request);
}
@SdkInternalApi
final AddTagsToResourceResult executeAddTagsToResource(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddTagsToResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @sample AmazonRDS.ApplyPendingMaintenanceAction
* @see AWS API Documentation
*/
@Override
public ResourcePendingMaintenanceActions applyPendingMaintenanceAction(ApplyPendingMaintenanceActionRequest request) {
request = beforeClientExecution(request);
return executeApplyPendingMaintenanceAction(request);
}
@SdkInternalApi
final ResourcePendingMaintenanceActions executeApplyPendingMaintenanceAction(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ApplyPendingMaintenanceAction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 can't authorize ingress from an EC2 security group in one Amazon Web Services Region to an Amazon RDS DB
* instance in another. You can't 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.
*
*
*
* EC2-Classic was retired on August 15, 2022. If you haven't migrated from EC2-Classic to a VPC, we recommend that
* you migrate as soon as possible. For more information, see Migrate from EC2-Classic to a VPC
* in the Amazon EC2 User Guide, the blog EC2-Classic Networking is
* Retiring – Here’s How to Prepare, and Moving a DB instance not
* in a VPC into a VPC in the Amazon RDS User Guide.
*
*
*
* @param authorizeDBSecurityGroupIngressRequest
* @return Result of the AuthorizeDBSecurityGroupIngress operation returned by the service.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName
doesn't refer to an existing DB security group.
* @throws InvalidDBSecurityGroupStateException
* The state of the DB security group doesn't allow deletion.
* @throws AuthorizationAlreadyExistsException
* The specified CIDR IP range or Amazon EC2 security group is already authorized for the specified DB
* security group.
* @throws AuthorizationQuotaExceededException
* The DB security group authorization quota has been reached.
* @sample AmazonRDS.AuthorizeDBSecurityGroupIngress
* @see AWS API Documentation
*/
@Override
public DBSecurityGroup authorizeDBSecurityGroupIngress(AuthorizeDBSecurityGroupIngressRequest request) {
request = beforeClientExecution(request);
return executeAuthorizeDBSecurityGroupIngress(request);
}
@SdkInternalApi
final DBSecurityGroup executeAuthorizeDBSecurityGroupIngress(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AuthorizeDBSecurityGroupIngress");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new DBSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Backtracks a DB cluster to a specific time, without creating a new DB cluster.
*
*
* For more information on backtracking, see
* Backtracking an Aurora DB Cluster in the Amazon Aurora User Guide.
*
*
*
* This action applies only to Aurora MySQL DB clusters.
*
*
*
* @param backtrackDBClusterRequest
* @return Result of the BacktrackDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @sample AmazonRDS.BacktrackDBCluster
* @see AWS API
* Documentation
*/
@Override
public BacktrackDBClusterResult backtrackDBCluster(BacktrackDBClusterRequest request) {
request = beforeClientExecution(request);
return executeBacktrackDBCluster(request);
}
@SdkInternalApi
final BacktrackDBClusterResult executeBacktrackDBCluster(BacktrackDBClusterRequest backtrackDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(backtrackDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new BacktrackDBClusterRequestMarshaller().marshall(super.beforeMarshalling(backtrackDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "BacktrackDBCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new BacktrackDBClusterResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Cancels an export task in progress that is exporting a snapshot or cluster to Amazon S3. Any data that has
* already been written to the S3 bucket isn't removed.
*
*
* @param cancelExportTaskRequest
* @return Result of the CancelExportTask operation returned by the service.
* @throws ExportTaskNotFoundException
* The export task doesn't exist.
* @throws InvalidExportTaskStateException
* You can't cancel an export task that has completed.
* @sample AmazonRDS.CancelExportTask
* @see AWS API
* Documentation
*/
@Override
public CancelExportTaskResult cancelExportTask(CancelExportTaskRequest request) {
request = beforeClientExecution(request);
return executeCancelExportTask(request);
}
@SdkInternalApi
final CancelExportTaskResult executeCancelExportTask(CancelExportTaskRequest cancelExportTaskRequest) {
ExecutionContext executionContext = createExecutionContext(cancelExportTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelExportTaskRequestMarshaller().marshall(super.beforeMarshalling(cancelExportTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelExportTask");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CancelExportTaskResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies the specified DB cluster parameter group.
*
*
*
* You can't copy a default DB cluster parameter group. Instead, create a new custom DB cluster parameter group,
* which copies the default parameters and values for the specified DB cluster parameter group family.
*
*
*
* @param copyDBClusterParameterGroupRequest
* @return Result of the CopyDBClusterParameterGroup operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName
doesn't refer to an existing DB parameter group.
* @throws DBParameterGroupQuotaExceededException
* The request would result in the user exceeding the allowed number of DB parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonRDS.CopyDBClusterParameterGroup
* @see AWS API Documentation
*/
@Override
public DBClusterParameterGroup copyDBClusterParameterGroup(CopyDBClusterParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeCopyDBClusterParameterGroup(request);
}
@SdkInternalApi
final DBClusterParameterGroup executeCopyDBClusterParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyDBClusterParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterParameterGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies a snapshot of a DB cluster.
*
*
* To copy a DB cluster snapshot from a shared manual DB cluster snapshot,
* SourceDBClusterSnapshotIdentifier
must be the Amazon Resource Name (ARN) of the shared DB cluster
* snapshot.
*
*
* You can copy an encrypted DB cluster snapshot from another Amazon Web Services Region. In that case, the Amazon
* Web Services Region where you call the CopyDBClusterSnapshot
operation is the destination Amazon Web
* Services Region for the encrypted DB cluster snapshot to be copied to. To copy an encrypted DB cluster snapshot
* from another Amazon Web Services Region, you must provide the following values:
*
*
* -
*
* KmsKeyId
- The Amazon Web Services Key Management System (Amazon Web Services KMS) key identifier
* for the key to use to encrypt the copy of the DB cluster snapshot in the destination Amazon Web Services Region.
*
*
* -
*
* TargetDBClusterSnapshotIdentifier
- The identifier for the new copy of the DB cluster snapshot in
* the destination Amazon Web Services Region.
*
*
* -
*
* SourceDBClusterSnapshotIdentifier
- The DB cluster snapshot identifier for the encrypted DB cluster
* snapshot to be copied. This identifier must be in the ARN format for the source Amazon Web Services Region and is
* the same value as the SourceDBClusterSnapshotIdentifier
in the presigned URL.
*
*
*
*
* To cancel the copy operation once it is in progress, delete the target DB cluster snapshot identified by
* TargetDBClusterSnapshotIdentifier
while that DB cluster snapshot is in "copying" status.
*
*
* For more information on copying encrypted Amazon Aurora DB cluster snapshots from one Amazon Web Services Region
* to another, see
* Copying a Snapshot in the Amazon Aurora User Guide.
*
*
* For more information on Amazon Aurora DB clusters, see What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
* For more information on Multi-AZ DB clusters, see Multi-AZ DB
* cluster deployments in the Amazon RDS User Guide.
*
*
* @param copyDBClusterSnapshotRequest
* @return Result of the CopyDBClusterSnapshot operation returned by the service.
* @throws DBClusterSnapshotAlreadyExistsException
* The user already has a DB cluster snapshot with the given identifier.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier
doesn't refer to an existing DB cluster snapshot.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value isn't a valid DB cluster snapshot state.
* @throws SnapshotQuotaExceededException
* The request would result in the user exceeding the allowed number of DB snapshots.
* @throws KMSKeyNotAccessibleException
* An error occurred accessing an Amazon Web Services KMS key.
* @sample AmazonRDS.CopyDBClusterSnapshot
* @see AWS API
* Documentation
*/
@Override
public DBClusterSnapshot copyDBClusterSnapshot(CopyDBClusterSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCopyDBClusterSnapshot(request);
}
@SdkInternalApi
final DBClusterSnapshot executeCopyDBClusterSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyDBClusterSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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.
*
*
*
* You can't copy a default DB parameter group. Instead, create a new custom DB parameter group, which copies the
* default parameters and values for the specified DB parameter group family.
*
*
*
* @param copyDBParameterGroupRequest
* @return Result of the CopyDBParameterGroup operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName
doesn't refer to an existing DB parameter group.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @throws DBParameterGroupQuotaExceededException
* The request would result in the user exceeding the allowed number of DB parameter groups.
* @sample AmazonRDS.CopyDBParameterGroup
* @see AWS API
* Documentation
*/
@Override
public DBParameterGroup copyDBParameterGroup(CopyDBParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeCopyDBParameterGroup(request);
}
@SdkInternalApi
final DBParameterGroup executeCopyDBParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyDBParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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.
*
*
* You can copy a snapshot from one Amazon Web Services Region to another. In that case, the Amazon Web Services
* Region where you call the CopyDBSnapshot
operation is the destination Amazon Web Services Region for
* the DB snapshot copy.
*
*
* This command doesn't apply to RDS Custom.
*
*
* For more information about copying snapshots, see Copying
* a DB Snapshot in the Amazon RDS User Guide.
*
*
* @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
doesn't refer to an existing DB snapshot.
* @throws InvalidDBSnapshotStateException
* The state of the DB snapshot doesn't allow deletion.
* @throws SnapshotQuotaExceededException
* The request would result in the user exceeding the allowed number of DB snapshots.
* @throws KMSKeyNotAccessibleException
* An error occurred accessing an Amazon Web Services KMS key.
* @throws CustomAvailabilityZoneNotFoundException
* CustomAvailabilityZoneId
doesn't refer to an existing custom Availability Zone identifier.
* @sample AmazonRDS.CopyDBSnapshot
* @see AWS API
* Documentation
*/
@Override
public DBSnapshot copyDBSnapshot(CopyDBSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCopyDBSnapshot(request);
}
@SdkInternalApi
final DBSnapshot executeCopyDBSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyDBSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 Amazon Web Services account.
* @sample AmazonRDS.CopyOptionGroup
* @see AWS API
* Documentation
*/
@Override
public OptionGroup copyOptionGroup(CopyOptionGroupRequest request) {
request = beforeClientExecution(request);
return executeCopyOptionGroup(request);
}
@SdkInternalApi
final OptionGroup executeCopyOptionGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyOptionGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 blue/green deployment.
*
*
* A blue/green deployment creates a staging environment that copies the production environment. In a blue/green
* deployment, the blue environment is the current production environment. The green environment is the staging
* environment. The staging environment stays in sync with the current production environment using logical
* replication.
*
*
* You can make changes to the databases in the green environment without affecting production workloads. For
* example, you can upgrade the major or minor DB engine version, change database parameters, or make schema changes
* in the staging environment. You can thoroughly test changes in the green environment. When ready, you can switch
* over the environments to promote the green environment to be the new production environment. The switchover
* typically takes under a minute.
*
*
* For more information, see Using Amazon RDS
* Blue/Green Deployments for database updates in the Amazon RDS User Guide and Using Amazon RDS
* Blue/Green Deployments for database updates in the Amazon Aurora User Guide.
*
*
* @param createBlueGreenDeploymentRequest
* @return Result of the CreateBlueGreenDeployment operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws SourceDatabaseNotSupportedException
* The source DB instance isn't supported for a blue/green deployment.
* @throws SourceClusterNotSupportedException
* The source DB cluster isn't supported for a blue/green deployment.
* @throws BlueGreenDeploymentAlreadyExistsException
* A blue/green deployment with the specified name already exists.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName
doesn't refer to an existing DB parameter group.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName
doesn't refer to an existing DB cluster parameter group.
* @throws InstanceQuotaExceededException
* The request would result in the user exceeding the allowed number of DB instances.
* @throws DBClusterQuotaExceededException
* The user attempted to create a new DB cluster and the user has already reached the maximum allowed DB
* cluster quota.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @sample AmazonRDS.CreateBlueGreenDeployment
* @see AWS
* API Documentation
*/
@Override
public CreateBlueGreenDeploymentResult createBlueGreenDeployment(CreateBlueGreenDeploymentRequest request) {
request = beforeClientExecution(request);
return executeCreateBlueGreenDeployment(request);
}
@SdkInternalApi
final CreateBlueGreenDeploymentResult executeCreateBlueGreenDeployment(CreateBlueGreenDeploymentRequest createBlueGreenDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(createBlueGreenDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateBlueGreenDeploymentRequestMarshaller().marshall(super.beforeMarshalling(createBlueGreenDeploymentRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateBlueGreenDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateBlueGreenDeploymentResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a custom DB engine version (CEV).
*
*
* @param createCustomDBEngineVersionRequest
* @return Result of the CreateCustomDBEngineVersion operation returned by the service.
* @throws CustomDBEngineVersionAlreadyExistsException
* A CEV with the specified name already exists.
* @throws CustomDBEngineVersionQuotaExceededException
* You have exceeded your CEV quota.
* @throws Ec2ImagePropertiesNotSupportedException
* The AMI configuration prerequisite has not been met.
* @throws KMSKeyNotAccessibleException
* An error occurred accessing an Amazon Web Services KMS key.
* @throws CreateCustomDBEngineVersionException
* An error occurred while trying to create the CEV.
* @sample AmazonRDS.CreateCustomDBEngineVersion
* @see AWS API Documentation
*/
@Override
public CreateCustomDBEngineVersionResult createCustomDBEngineVersion(CreateCustomDBEngineVersionRequest request) {
request = beforeClientExecution(request);
return executeCreateCustomDBEngineVersion(request);
}
@SdkInternalApi
final CreateCustomDBEngineVersionResult executeCreateCustomDBEngineVersion(CreateCustomDBEngineVersionRequest createCustomDBEngineVersionRequest) {
ExecutionContext executionContext = createExecutionContext(createCustomDBEngineVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCustomDBEngineVersionRequestMarshaller().marshall(super.beforeMarshalling(createCustomDBEngineVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCustomDBEngineVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateCustomDBEngineVersionResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new Amazon Aurora DB cluster or Multi-AZ DB cluster.
*
*
* If you create an Aurora DB cluster, the request creates an empty cluster. You must explicitly create the writer
* instance for your DB cluster using the CreateDBInstance
* operation. If you create a Multi-AZ DB cluster, the request creates a writer and two reader DB instances for you,
* each in a different Availability Zone.
*
*
* You can use the ReplicationSourceIdentifier
parameter to create an Amazon Aurora DB cluster as a
* read replica of another DB cluster or Amazon RDS for MySQL or PostgreSQL DB instance. For more information about
* Amazon Aurora, see What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
* You can also use the ReplicationSourceIdentifier
parameter to create a Multi-AZ DB cluster read
* replica with an RDS for MySQL or PostgreSQL DB instance as the source. For more information about Multi-AZ DB
* clusters, see Multi-AZ DB
* cluster deployments in the Amazon RDS User Guide.
*
*
* @param createDBClusterRequest
* @return Result of the CreateDBCluster operation returned by the service.
* @throws DBClusterAlreadyExistsException
* The user already has a DB cluster with the given identifier.
* @throws InsufficientDBInstanceCapacityException
* The specified DB instance class isn't available in the specified Availability Zone.
* @throws InsufficientStorageClusterCapacityException
* There is insufficient storage available for the current action. You might be able to resolve this error
* by updating your subnet group to use different Availability Zones that have more storage available.
* @throws DBClusterQuotaExceededException
* The user attempted to create a new DB cluster and the user has already reached the maximum allowed DB
* cluster quota.
* @throws StorageQuotaExceededException
* The request would result in the user exceeding the allowed amount of storage available across all DB
* instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName
doesn't refer to an existing DB subnet group.
* @throws InvalidVPCNetworkStateException
* The DB subnet group doesn't cover all Availability Zones after it's created because of users' change.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws InvalidDBSubnetGroupException
* The DBSubnetGroup doesn't belong to the same VPC as that of an existing cross-region read replica of the
* same source instance.
* @throws InvalidDBSubnetGroupStateException
* The DB subnet group cannot be deleted because it's in use.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName
doesn't refer to an existing DB cluster parameter group.
* @throws KMSKeyNotAccessibleException
* An error occurred accessing an Amazon Web Services KMS key.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws DBSubnetGroupDoesNotCoverEnoughAZsException
* Subnets in the DB subnet group should cover at least two Availability Zones unless there is only one
* Availability Zone.
* @throws GlobalClusterNotFoundException
* The GlobalClusterIdentifier
doesn't refer to an existing global database cluster.
* @throws InvalidGlobalClusterStateException
* The global cluster is in an invalid state and can't perform the requested operation.
* @throws DomainNotFoundException
* Domain
doesn't refer to an existing Active Directory domain.
* @throws OptionGroupNotFoundException
* The specified option group could not be found.
* @sample AmazonRDS.CreateDBCluster
* @see AWS API
* Documentation
*/
@Override
public DBCluster createDBCluster(CreateDBClusterRequest request) {
request = beforeClientExecution(request);
return executeCreateDBCluster(request);
}
@SdkInternalApi
final DBCluster executeCreateDBCluster(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 custom endpoint and associates it with an Amazon Aurora DB cluster.
*
*
*
* This action applies only to Aurora DB clusters.
*
*
*
* @param createDBClusterEndpointRequest
* @return Result of the CreateDBClusterEndpoint operation returned by the service.
* @throws DBClusterEndpointQuotaExceededException
* The cluster already has the maximum number of custom endpoints.
* @throws DBClusterEndpointAlreadyExistsException
* The specified custom endpoint can't be created because it already exists.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @sample AmazonRDS.CreateDBClusterEndpoint
* @see AWS
* API Documentation
*/
@Override
public CreateDBClusterEndpointResult createDBClusterEndpoint(CreateDBClusterEndpointRequest request) {
request = beforeClientExecution(request);
return executeCreateDBClusterEndpoint(request);
}
@SdkInternalApi
final CreateDBClusterEndpointResult executeCreateDBClusterEndpoint(CreateDBClusterEndpointRequest createDBClusterEndpointRequest) {
ExecutionContext executionContext = createExecutionContext(createDBClusterEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBClusterEndpointRequestMarshaller().marshall(super.beforeMarshalling(createDBClusterEndpointRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBClusterEndpoint");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateDBClusterEndpointResultStaxUnmarshaller());
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 Aurora DB cluster, reboot the DB instances in
* the DB cluster without failover for the new DB cluster parameter group and associated settings to take effect.
*
*
* When you associate a new DB cluster parameter group with a running Multi-AZ DB cluster, reboot 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
* operation to verify that your DB cluster parameter group has been created or modified.
*
*
*
* For more information on Amazon Aurora, see What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
* For more information on Multi-AZ DB clusters, see Multi-AZ DB
* cluster deployments in the Amazon RDS User Guide.
*
*
* @param createDBClusterParameterGroupRequest
* @return Result of the CreateDBClusterParameterGroup operation returned by the service.
* @throws DBParameterGroupQuotaExceededException
* The request would result in the user exceeding the allowed number of DB parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonRDS.CreateDBClusterParameterGroup
* @see AWS API Documentation
*/
@Override
public DBClusterParameterGroup createDBClusterParameterGroup(CreateDBClusterParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateDBClusterParameterGroup(request);
}
@SdkInternalApi
final DBClusterParameterGroup executeCreateDBClusterParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBClusterParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
* For more information on Multi-AZ DB clusters, see Multi-AZ DB
* cluster deployments in the Amazon RDS User Guide.
*
*
* @param createDBClusterSnapshotRequest
* @return Result of the CreateDBClusterSnapshot operation returned by the service.
* @throws DBClusterSnapshotAlreadyExistsException
* The user already has a DB cluster snapshot with the given identifier.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws SnapshotQuotaExceededException
* The request would result in the user exceeding the allowed number of DB snapshots.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value isn't a valid DB cluster snapshot state.
* @sample AmazonRDS.CreateDBClusterSnapshot
* @see AWS
* API Documentation
*/
@Override
public DBClusterSnapshot createDBClusterSnapshot(CreateDBClusterSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCreateDBClusterSnapshot(request);
}
@SdkInternalApi
final DBClusterSnapshot executeCreateDBClusterSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBClusterSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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.
*
*
* The new DB instance can be an RDS DB instance, or it can be a DB instance in an Aurora DB cluster. For an Aurora
* DB cluster, you can call this operation multiple times to add more than one DB instance to the cluster.
*
*
* For more information about creating an RDS DB instance, see Creating an Amazon RDS
* DB instance in the Amazon RDS User Guide.
*
*
* For more information about creating a DB instance in an Aurora DB cluster, see Creating an
* Amazon Aurora DB cluster in the Amazon Aurora User Guide.
*
*
* @param createDBInstanceRequest
* @return Result of the CreateDBInstance operation returned by the service.
* @throws DBInstanceAlreadyExistsException
* The user already has a DB instance with the given identifier.
* @throws InsufficientDBInstanceCapacityException
* The specified DB instance class isn't available in the specified Availability Zone.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName
doesn't refer to an existing DB parameter group.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName
doesn't refer to an existing DB security group.
* @throws InstanceQuotaExceededException
* The request would result in the user exceeding the allowed number of DB instances.
* @throws StorageQuotaExceededException
* The request would result in the user exceeding the allowed amount of storage available across all DB
* instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName
doesn't 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 requested operation can't be performed while the cluster is in this state.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws InvalidVPCNetworkStateException
* The DB subnet group doesn't cover all Availability Zones after it's created because of 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
doesn't refer to an existing DB cluster.
* @throws StorageTypeNotSupportedException
* The specified StorageType
can't be associated with the DB instance.
* @throws AuthorizationNotFoundException
* The specified CIDR IP range or Amazon EC2 security group might not be authorized for the specified DB
* security group.
*
* Or, RDS might not be authorized to perform necessary actions using IAM on your behalf.
* @throws KMSKeyNotAccessibleException
* An error occurred accessing an Amazon Web Services KMS key.
* @throws DomainNotFoundException
* Domain
doesn't refer to an existing Active Directory domain.
* @throws BackupPolicyNotFoundException
* @throws NetworkTypeNotSupportedException
* The network type is invalid for the DB instance. Valid nework type values are IPV4
and
* DUAL
.
* @throws CertificateNotFoundException
* CertificateIdentifier
doesn't refer to an existing certificate.
* @throws TenantDatabaseQuotaExceededException
* You attempted to create more tenant databases than are permitted in your Amazon Web Services account.
* @sample AmazonRDS.CreateDBInstance
* @see AWS API
* Documentation
*/
@Override
public DBInstance createDBInstance(CreateDBInstanceRequest request) {
request = beforeClientExecution(request);
return executeCreateDBInstance(request);
}
@SdkInternalApi
final DBInstance executeCreateDBInstance(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBInstance");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 instance that acts as a read replica for an existing source DB instance or Multi-AZ DB cluster.
* You can create a read replica for a DB instance running Db2, MariaDB, MySQL, Oracle, PostgreSQL, or SQL Server.
* You can create a read replica for a Multi-AZ DB cluster running MySQL or PostgreSQL. For more information, see Working with read replicas
* and Migrating from a Multi-AZ DB cluster to a DB instance using a read replica in the Amazon RDS User
* Guide.
*
*
* Amazon Aurora doesn't support this operation. To create a DB instance for an Aurora DB cluster, use the
* CreateDBInstance
operation.
*
*
* All read replica DB instances are created with backups disabled. All other attributes (including DB security
* groups and DB parameter groups) are inherited from the source DB instance or cluster, except as specified.
*
*
*
* Your source DB instance or cluster must have backup retention enabled.
*
*
*
* @param createDBInstanceReadReplicaRequest
* @return Result of the CreateDBInstanceReadReplica operation returned by the service.
* @throws DBInstanceAlreadyExistsException
* The user already has a DB instance with the given identifier.
* @throws InsufficientDBInstanceCapacityException
* The specified DB instance class isn't available in the specified Availability Zone.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName
doesn't refer to an existing DB parameter group.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName
doesn't refer to an existing DB security group.
* @throws InstanceQuotaExceededException
* The request would result in the user exceeding the allowed number of DB instances.
* @throws StorageQuotaExceededException
* The request would result in the user exceeding the allowed amount of storage available across all DB
* instances.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName
doesn't 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
* The DB subnet group doesn't cover all Availability Zones after it's created because of 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
* The DBSubnetGroup shouldn't be specified while creating read replicas that lie in the same region as the
* source instance.
* @throws InvalidDBSubnetGroupException
* The DBSubnetGroup doesn't belong to the same VPC as that of an existing cross-region read replica of the
* same source instance.
* @throws StorageTypeNotSupportedException
* The specified StorageType
can't be associated with the DB instance.
* @throws KMSKeyNotAccessibleException
* An error occurred accessing an Amazon Web Services KMS key.
* @throws DomainNotFoundException
* Domain
doesn't refer to an existing Active Directory domain.
* @throws NetworkTypeNotSupportedException
* The network type is invalid for the DB instance. Valid nework type values are IPV4
and
* DUAL
.
* @throws TenantDatabaseQuotaExceededException
* You attempted to create more tenant databases than are permitted in your Amazon Web Services account.
* @throws CertificateNotFoundException
* CertificateIdentifier
doesn't refer to an existing certificate.
* @sample AmazonRDS.CreateDBInstanceReadReplica
* @see AWS API Documentation
*/
@Override
public DBInstance createDBInstanceReadReplica(CreateDBInstanceReadReplicaRequest request) {
request = beforeClientExecution(request);
return executeCreateDBInstanceReadReplica(request);
}
@SdkInternalApi
final DBInstance executeCreateDBInstanceReadReplica(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBInstanceReadReplica");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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.
*
*
* This command doesn't apply to RDS Custom.
*
*
*
* 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
* The request would result in the user exceeding the allowed number of DB parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonRDS.CreateDBParameterGroup
* @see AWS API
* Documentation
*/
@Override
public DBParameterGroup createDBParameterGroup(CreateDBParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateDBParameterGroup(request);
}
@SdkInternalApi
final DBParameterGroup executeCreateDBParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 proxy.
*
*
* @param createDBProxyRequest
* @return Result of the CreateDBProxy operation returned by the service.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws DBProxyAlreadyExistsException
* The specified proxy name must be unique for all proxies owned by your Amazon Web Services account in the
* specified Amazon Web Services Region.
* @throws DBProxyQuotaExceededException
* Your Amazon Web Services account already has the maximum number of proxies in the specified Amazon Web
* Services Region.
* @sample AmazonRDS.CreateDBProxy
* @see AWS API
* Documentation
*/
@Override
public CreateDBProxyResult createDBProxy(CreateDBProxyRequest request) {
request = beforeClientExecution(request);
return executeCreateDBProxy(request);
}
@SdkInternalApi
final CreateDBProxyResult executeCreateDBProxy(CreateDBProxyRequest createDBProxyRequest) {
ExecutionContext executionContext = createExecutionContext(createDBProxyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBProxyRequestMarshaller().marshall(super.beforeMarshalling(createDBProxyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBProxy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CreateDBProxyResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a DBProxyEndpoint
. Only applies to proxies that are associated with Aurora DB clusters. You
* can use DB proxy endpoints to specify read/write or read-only access to the DB cluster. You can also use DB proxy
* endpoints to access a DB proxy through a different VPC than the proxy's default VPC.
*
*
* @param createDBProxyEndpointRequest
* @return Result of the CreateDBProxyEndpoint operation returned by the service.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws DBProxyNotFoundException
* The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services account in the
* specified Amazon Web Services Region.
* @throws DBProxyEndpointAlreadyExistsException
* The specified DB proxy endpoint name must be unique for all DB proxy endpoints owned by your Amazon Web
* Services account in the specified Amazon Web Services Region.
* @throws DBProxyEndpointQuotaExceededException
* The DB proxy already has the maximum number of endpoints.
* @throws InvalidDBProxyStateException
* The requested operation can't be performed while the proxy is in this state.
* @sample AmazonRDS.CreateDBProxyEndpoint
* @see AWS API
* Documentation
*/
@Override
public CreateDBProxyEndpointResult createDBProxyEndpoint(CreateDBProxyEndpointRequest request) {
request = beforeClientExecution(request);
return executeCreateDBProxyEndpoint(request);
}
@SdkInternalApi
final CreateDBProxyEndpointResult executeCreateDBProxyEndpoint(CreateDBProxyEndpointRequest createDBProxyEndpointRequest) {
ExecutionContext executionContext = createExecutionContext(createDBProxyEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBProxyEndpointRequestMarshaller().marshall(super.beforeMarshalling(createDBProxyEndpointRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBProxyEndpoint");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateDBProxyEndpointResultStaxUnmarshaller());
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.
*
*
* A DB security group controls access to EC2-Classic DB instances that are not in a VPC.
*
*
*
* EC2-Classic was retired on August 15, 2022. If you haven't migrated from EC2-Classic to a VPC, we recommend that
* you migrate as soon as possible. For more information, see Migrate from EC2-Classic to a VPC
* in the Amazon EC2 User Guide, the blog EC2-Classic Networking is
* Retiring – Here’s How to Prepare, and Moving a DB instance not
* in a VPC into a VPC in the Amazon RDS User Guide.
*
*
*
* @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
* The request would result in the user exceeding the allowed number of DB security groups.
* @throws DBSecurityGroupNotSupportedException
* A DB security group isn't allowed for this action.
* @sample AmazonRDS.CreateDBSecurityGroup
* @see AWS API
* Documentation
*/
@Override
public DBSecurityGroup createDBSecurityGroup(CreateDBSecurityGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateDBSecurityGroup(request);
}
@SdkInternalApi
final DBSecurityGroup executeCreateDBSecurityGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBSecurityGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 new DB shard group for Aurora Limitless Database. You must enable Aurora Limitless Database to create a
* DB shard group.
*
*
* Valid for: Aurora DB clusters only
*
*
* @param createDBShardGroupRequest
* @return Result of the CreateDBShardGroup operation returned by the service.
* @throws DBShardGroupAlreadyExistsException
* The specified DB shard group name must be unique in your Amazon Web Services account in the specified
* Amazon Web Services Region.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws MaxDBShardGroupLimitReachedException
* The maximum number of DB shard groups for your Amazon Web Services account in the specified Amazon Web
* Services Region has been reached.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws InvalidMaxAcuException
* The maximum capacity of the DB shard group must be 48-7168 Aurora capacity units (ACUs).
* @throws UnsupportedDBEngineVersionException
* The specified DB engine version isn't supported for Aurora Limitless Database.
* @throws InvalidVPCNetworkStateException
* The DB subnet group doesn't cover all Availability Zones after it's created because of users' change.
* @sample AmazonRDS.CreateDBShardGroup
* @see AWS API
* Documentation
*/
@Override
public CreateDBShardGroupResult createDBShardGroup(CreateDBShardGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateDBShardGroup(request);
}
@SdkInternalApi
final CreateDBShardGroupResult executeCreateDBShardGroup(CreateDBShardGroupRequest createDBShardGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createDBShardGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDBShardGroupRequestMarshaller().marshall(super.beforeMarshalling(createDBShardGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBShardGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateDBShardGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a snapshot of a DB instance. The source DB instance must be in the available
or
* storage-optimization
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 DB instance isn't in a valid state.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws SnapshotQuotaExceededException
* The request would result in the user exceeding the allowed number of DB snapshots.
* @sample AmazonRDS.CreateDBSnapshot
* @see AWS API
* Documentation
*/
@Override
public DBSnapshot createDBSnapshot(CreateDBSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCreateDBSnapshot(request);
}
@SdkInternalApi
final DBSnapshot executeCreateDBSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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
* Amazon Web Services 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
* The request would result in the user exceeding the allowed number of DB subnet groups.
* @throws DBSubnetQuotaExceededException
* The request would result in the 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
* @see AWS API
* Documentation
*/
@Override
public DBSubnetGroup createDBSubnetGroup(CreateDBSubnetGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateDBSubnetGroup(request);
}
@SdkInternalApi
final DBSubnetGroup executeCreateDBSubnetGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDBSubnetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 operation requires a topic Amazon Resource Name (ARN)
* 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
) that you want to be notified of and provide a list
* of RDS sources (SourceIds
) that triggers the events. You can also provide a list of event categories
* (EventCategories
) for events that 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 SourceIds
= myDBInstance1
, you are notified of all the
* db-instance
events for the specified source. If you specify a SourceType
but do not
* specify SourceIds
, you receive notice of the events for that source type for all your RDS sources.
* If you don't specify either the SourceType or the SourceIds
, you are notified of events generated
* from all RDS sources belonging to your customer account.
*
*
* For more information about subscribing to an event for RDS DB engines, see Subscribing to Amazon
* RDS event notification in the Amazon RDS User Guide.
*
*
* For more information about subscribing to an event for Aurora DB engines, see Subscribing to
* Amazon RDS event notification in the Amazon Aurora User Guide.
*
*
* @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 SNS 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
* @see AWS
* API Documentation
*/
@Override
public EventSubscription createEventSubscription(CreateEventSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeCreateEventSubscription(request);
}
@SdkInternalApi
final EventSubscription executeCreateEventSubscription(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateEventSubscription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 an Aurora global database spread across multiple Amazon Web Services Regions. The global database
* contains a single primary cluster with read-write capability, and a read-only secondary cluster that receives
* data from the primary cluster through high-speed replication performed by the Aurora storage subsystem.
*
*
* You can create a global database that is initially empty, and then create the primary and secondary DB clusters
* in the global database. Or you can specify an existing Aurora cluster during the create operation, and this
* cluster becomes the primary cluster of the global database.
*
*
*
* This operation applies only to Aurora DB clusters.
*
*
*
* @param createGlobalClusterRequest
* @return Result of the CreateGlobalCluster operation returned by the service.
* @throws GlobalClusterAlreadyExistsException
* The GlobalClusterIdentifier
already exists. Choose a new global database identifier (unique
* name) to create a new global database cluster.
* @throws GlobalClusterQuotaExceededException
* The number of global database clusters for this account is already at the maximum allowed.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @sample AmazonRDS.CreateGlobalCluster
* @see AWS API
* Documentation
*/
@Override
public GlobalCluster createGlobalCluster(CreateGlobalClusterRequest request) {
request = beforeClientExecution(request);
return executeCreateGlobalCluster(request);
}
@SdkInternalApi
final GlobalCluster executeCreateGlobalCluster(CreateGlobalClusterRequest createGlobalClusterRequest) {
ExecutionContext executionContext = createExecutionContext(createGlobalClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateGlobalClusterRequestMarshaller().marshall(super.beforeMarshalling(createGlobalClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateGlobalCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new GlobalClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a zero-ETL integration with Amazon Redshift.
*
*
* @param createIntegrationRequest
* @return Result of the CreateIntegration operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws IntegrationAlreadyExistsException
* The integration you are trying to create already exists.
* @throws IntegrationQuotaExceededException
* You can't crate any more zero-ETL integrations because the quota has been reached.
* @throws KMSKeyNotAccessibleException
* An error occurred accessing an Amazon Web Services KMS key.
* @throws IntegrationConflictOperationException
* A conflicting conditional operation is currently in progress against this resource. Typically occurs when
* there are multiple requests being made to the same resource at the same time, and these requests conflict
* with each other.
* @sample AmazonRDS.CreateIntegration
* @see AWS API
* Documentation
*/
@Override
public CreateIntegrationResult createIntegration(CreateIntegrationRequest request) {
request = beforeClientExecution(request);
return executeCreateIntegration(request);
}
@SdkInternalApi
final CreateIntegrationResult executeCreateIntegration(CreateIntegrationRequest createIntegrationRequest) {
ExecutionContext executionContext = createExecutionContext(createIntegrationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateIntegrationRequestMarshaller().marshall(super.beforeMarshalling(createIntegrationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateIntegration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateIntegrationResultStaxUnmarshaller());
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.
*
*
* This command doesn't apply to RDS Custom.
*
*
* @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 Amazon Web Services account.
* @sample AmazonRDS.CreateOptionGroup
* @see AWS API
* Documentation
*/
@Override
public OptionGroup createOptionGroup(CreateOptionGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateOptionGroup(request);
}
@SdkInternalApi
final OptionGroup executeCreateOptionGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateOptionGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 tenant database in a DB instance that uses the multi-tenant configuration. Only RDS for Oracle
* container database (CDB) instances are supported.
*
*
* @param createTenantDatabaseRequest
* @return Result of the CreateTenantDatabase operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @throws TenantDatabaseAlreadyExistsException
* You attempted to either create a tenant database that already exists or modify a tenant database to use
* the name of an existing tenant database.
* @throws TenantDatabaseQuotaExceededException
* You attempted to create more tenant databases than are permitted in your Amazon Web Services account.
* @sample AmazonRDS.CreateTenantDatabase
* @see AWS API
* Documentation
*/
@Override
public TenantDatabase createTenantDatabase(CreateTenantDatabaseRequest request) {
request = beforeClientExecution(request);
return executeCreateTenantDatabase(request);
}
@SdkInternalApi
final TenantDatabase executeCreateTenantDatabase(CreateTenantDatabaseRequest createTenantDatabaseRequest) {
ExecutionContext executionContext = createExecutionContext(createTenantDatabaseRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTenantDatabaseRequestMarshaller().marshall(super.beforeMarshalling(createTenantDatabaseRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateTenantDatabase");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new TenantDatabaseStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a blue/green deployment.
*
*
* For more information, see Using Amazon RDS
* Blue/Green Deployments for database updates in the Amazon RDS User Guide and Using Amazon RDS
* Blue/Green Deployments for database updates in the Amazon Aurora User Guide.
*
*
* @param deleteBlueGreenDeploymentRequest
* @return Result of the DeleteBlueGreenDeployment operation returned by the service.
* @throws BlueGreenDeploymentNotFoundException
* BlueGreenDeploymentIdentifier
doesn't refer to an existing blue/green deployment.
* @throws InvalidBlueGreenDeploymentStateException
* The blue/green deployment can't be switched over or deleted because there is an invalid configuration in
* the green environment.
* @sample AmazonRDS.DeleteBlueGreenDeployment
* @see AWS
* API Documentation
*/
@Override
public DeleteBlueGreenDeploymentResult deleteBlueGreenDeployment(DeleteBlueGreenDeploymentRequest request) {
request = beforeClientExecution(request);
return executeDeleteBlueGreenDeployment(request);
}
@SdkInternalApi
final DeleteBlueGreenDeploymentResult executeDeleteBlueGreenDeployment(DeleteBlueGreenDeploymentRequest deleteBlueGreenDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(deleteBlueGreenDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteBlueGreenDeploymentRequestMarshaller().marshall(super.beforeMarshalling(deleteBlueGreenDeploymentRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteBlueGreenDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteBlueGreenDeploymentResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a custom engine version. To run this command, make sure you meet the following prerequisites:
*
*
* -
*
* The CEV must not be the default for RDS Custom. If it is, change the default before running this command.
*
*
* -
*
* The CEV must not be associated with an RDS Custom DB instance, RDS Custom instance snapshot, or automated backup
* of your RDS Custom instance.
*
*
*
*
* Typically, deletion takes a few minutes.
*
*
*
* The MediaImport service that imports files from Amazon S3 to create CEVs isn't integrated with Amazon Web
* Services CloudTrail. If you turn on data logging for Amazon RDS in CloudTrail, calls to the
* DeleteCustomDbEngineVersion
event aren't logged. However, you might see calls from the API gateway
* that accesses your Amazon S3 bucket. These calls originate from the MediaImport service for the
* DeleteCustomDbEngineVersion
event.
*
*
*
* For more information, see Deleting a
* CEV in the Amazon RDS User Guide.
*
*
* @param deleteCustomDBEngineVersionRequest
* @return Result of the DeleteCustomDBEngineVersion operation returned by the service.
* @throws CustomDBEngineVersionNotFoundException
* The specified CEV was not found.
* @throws InvalidCustomDBEngineVersionStateException
* You can't delete the CEV.
* @sample AmazonRDS.DeleteCustomDBEngineVersion
* @see AWS API Documentation
*/
@Override
public DeleteCustomDBEngineVersionResult deleteCustomDBEngineVersion(DeleteCustomDBEngineVersionRequest request) {
request = beforeClientExecution(request);
return executeDeleteCustomDBEngineVersion(request);
}
@SdkInternalApi
final DeleteCustomDBEngineVersionResult executeDeleteCustomDBEngineVersion(DeleteCustomDBEngineVersionRequest deleteCustomDBEngineVersionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCustomDBEngineVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCustomDBEngineVersionRequestMarshaller().marshall(super.beforeMarshalling(deleteCustomDBEngineVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCustomDBEngineVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCustomDBEngineVersionResultStaxUnmarshaller());
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 can't be recovered. Manual DB cluster snapshots of the
* specified DB cluster are not deleted.
*
*
* If you're deleting a Multi-AZ DB cluster with read replicas, all cluster members are terminated and read replicas
* are promoted to standalone instances.
*
*
* For more information on Amazon Aurora, see What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
* For more information on Multi-AZ DB clusters, see Multi-AZ DB
* cluster deployments in the Amazon RDS User Guide.
*
*
* @param deleteDBClusterRequest
* @return Result of the DeleteDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws DBClusterSnapshotAlreadyExistsException
* The user already has a DB cluster snapshot with the given identifier.
* @throws SnapshotQuotaExceededException
* The request would result in the user exceeding the allowed number of DB snapshots.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value isn't a valid DB cluster snapshot state.
* @throws DBClusterAutomatedBackupQuotaExceededException
* The quota for retained automated backups was exceeded. This prevents you from retaining any additional
* automated backups. The retained automated backups quota is the same as your DB cluster quota.
* @sample AmazonRDS.DeleteDBCluster
* @see AWS API
* Documentation
*/
@Override
public DBCluster deleteDBCluster(DeleteDBClusterRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBCluster(request);
}
@SdkInternalApi
final DBCluster executeDeleteDBCluster(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 automated backups using the DbClusterResourceId
value of the source DB cluster or the Amazon
* Resource Name (ARN) of the automated backups.
*
*
* @param deleteDBClusterAutomatedBackupRequest
* @return Result of the DeleteDBClusterAutomatedBackup operation returned by the service.
* @throws InvalidDBClusterAutomatedBackupStateException
* The automated backup is in an invalid state. For example, this automated backup is associated with an
* active cluster.
* @throws DBClusterAutomatedBackupNotFoundException
* No automated backup for this DB cluster was found.
* @sample AmazonRDS.DeleteDBClusterAutomatedBackup
* @see AWS API Documentation
*/
@Override
public DBClusterAutomatedBackup deleteDBClusterAutomatedBackup(DeleteDBClusterAutomatedBackupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBClusterAutomatedBackup(request);
}
@SdkInternalApi
final DBClusterAutomatedBackup executeDeleteDBClusterAutomatedBackup(DeleteDBClusterAutomatedBackupRequest deleteDBClusterAutomatedBackupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBClusterAutomatedBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBClusterAutomatedBackupRequestMarshaller().marshall(super.beforeMarshalling(deleteDBClusterAutomatedBackupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBClusterAutomatedBackup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterAutomatedBackupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a custom endpoint and removes it from an Amazon Aurora DB cluster.
*
*
*
* This action only applies to Aurora DB clusters.
*
*
*
* @param deleteDBClusterEndpointRequest
* @return Result of the DeleteDBClusterEndpoint operation returned by the service.
* @throws InvalidDBClusterEndpointStateException
* The requested operation can't be performed on the endpoint while the endpoint is in this state.
* @throws DBClusterEndpointNotFoundException
* The specified custom endpoint doesn't exist.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @sample AmazonRDS.DeleteDBClusterEndpoint
* @see AWS
* API Documentation
*/
@Override
public DeleteDBClusterEndpointResult deleteDBClusterEndpoint(DeleteDBClusterEndpointRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBClusterEndpoint(request);
}
@SdkInternalApi
final DeleteDBClusterEndpointResult executeDeleteDBClusterEndpoint(DeleteDBClusterEndpointRequest deleteDBClusterEndpointRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBClusterEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBClusterEndpointRequestMarshaller().marshall(super.beforeMarshalling(deleteDBClusterEndpointRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBClusterEndpoint");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteDBClusterEndpointResultStaxUnmarshaller());
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 can't be associated
* with any DB clusters.
*
*
* For more information on Amazon Aurora, see What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
* For more information on Multi-AZ DB clusters, see Multi-AZ DB
* cluster deployments in the Amazon RDS User Guide.
*
*
* @param deleteDBClusterParameterGroupRequest
* @return Result of the DeleteDBClusterParameterGroup operation returned by the service.
* @throws InvalidDBParameterGroupStateException
* The DB parameter group is in use or is in an invalid state. If you are attempting to delete the parameter
* group, you can't delete it when the parameter group is in this state.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName
doesn't refer to an existing DB parameter group.
* @sample AmazonRDS.DeleteDBClusterParameterGroup
* @see AWS API Documentation
*/
@Override
public DeleteDBClusterParameterGroupResult deleteDBClusterParameterGroup(DeleteDBClusterParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBClusterParameterGroup(request);
}
@SdkInternalApi
final DeleteDBClusterParameterGroupResult executeDeleteDBClusterParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBClusterParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
* For more information on Multi-AZ DB clusters, see Multi-AZ DB
* cluster deployments in the Amazon RDS User Guide.
*
*
* @param deleteDBClusterSnapshotRequest
* @return Result of the DeleteDBClusterSnapshot operation returned by the service.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value isn't a valid DB cluster snapshot state.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier
doesn't refer to an existing DB cluster snapshot.
* @sample AmazonRDS.DeleteDBClusterSnapshot
* @see AWS
* API Documentation
*/
@Override
public DBClusterSnapshot deleteDBClusterSnapshot(DeleteDBClusterSnapshotRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBClusterSnapshot(request);
}
@SdkInternalApi
final DBClusterSnapshot executeDeleteDBClusterSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBClusterSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new DBClusterSnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a previously provisioned DB instance. When you delete a DB instance, all automated backups for that
* instance are deleted and can't be recovered. However, manual DB snapshots of the DB instance aren't deleted.
*
*
* If you request a final DB snapshot, the status of the Amazon RDS DB instance is deleting
until the
* DB snapshot is created. This operation can't be canceled or reverted after it begins. To monitor the status of
* this operation, use DescribeDBInstance
.
*
*
* 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 you skip
* creation of the final snapshot with the SkipFinalSnapshot
parameter.
*
*
* If the specified DB instance is part of an Amazon Aurora DB cluster, you can't delete the DB instance if both of
* the following conditions 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 use the PromoteReadReplicaDBCluster
operation to promote
* the DB cluster so that it's no longer a read replica. After the promotion completes, use the
* DeleteDBInstance
operation to delete the final instance in the DB cluster.
*
*
*
* For RDS Custom DB instances, deleting the DB instance permanently deletes the EC2 instance and the associated EBS
* volumes. Make sure that you don't terminate or delete these resources before you delete the DB instance.
* Otherwise, deleting the DB instance and creation of the final snapshot might fail.
*
*
*
* @param deleteDBInstanceRequest
* @return Result of the DeleteDBInstance operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @throws DBSnapshotAlreadyExistsException
* DBSnapshotIdentifier
is already used by an existing snapshot.
* @throws SnapshotQuotaExceededException
* The request would result in the user exceeding the allowed number of DB snapshots.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @throws DBInstanceAutomatedBackupQuotaExceededException
* The quota for retained automated backups was exceeded. This prevents you from retaining any additional
* automated backups. The retained automated backups quota is the same as your DB instance quota.
* @sample AmazonRDS.DeleteDBInstance
* @see AWS API
* Documentation
*/
@Override
public DBInstance deleteDBInstance(DeleteDBInstanceRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBInstance(request);
}
@SdkInternalApi
final DBInstance executeDeleteDBInstance(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBInstance");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 automated backups using the DbiResourceId
value of the source DB instance or the Amazon
* Resource Name (ARN) of the automated backups.
*
*
* @param deleteDBInstanceAutomatedBackupRequest
* Parameter input for the DeleteDBInstanceAutomatedBackup
operation.
* @return Result of the DeleteDBInstanceAutomatedBackup operation returned by the service.
* @throws InvalidDBInstanceAutomatedBackupStateException
* The automated backup is in an invalid state. For example, this automated backup is associated with an
* active instance.
* @throws DBInstanceAutomatedBackupNotFoundException
* No automated backup for this DB instance was found.
* @sample AmazonRDS.DeleteDBInstanceAutomatedBackup
* @see AWS API Documentation
*/
@Override
public DBInstanceAutomatedBackup deleteDBInstanceAutomatedBackup(DeleteDBInstanceAutomatedBackupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBInstanceAutomatedBackup(request);
}
@SdkInternalApi
final DBInstanceAutomatedBackup executeDeleteDBInstanceAutomatedBackup(DeleteDBInstanceAutomatedBackupRequest deleteDBInstanceAutomatedBackupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBInstanceAutomatedBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBInstanceAutomatedBackupRequestMarshaller().marshall(super.beforeMarshalling(deleteDBInstanceAutomatedBackupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBInstanceAutomatedBackup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBInstanceAutomatedBackupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a specified DB parameter group. The DB parameter group to be deleted can't be associated with any DB
* instances.
*
*
* @param deleteDBParameterGroupRequest
* @return Result of the DeleteDBParameterGroup operation returned by the service.
* @throws InvalidDBParameterGroupStateException
* The DB parameter group is in use or is in an invalid state. If you are attempting to delete the parameter
* group, you can't delete it when the parameter group is in this state.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName
doesn't refer to an existing DB parameter group.
* @sample AmazonRDS.DeleteDBParameterGroup
* @see AWS API
* Documentation
*/
@Override
public DeleteDBParameterGroupResult deleteDBParameterGroup(DeleteDBParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBParameterGroup(request);
}
@SdkInternalApi
final DeleteDBParameterGroupResult executeDeleteDBParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 an existing DB proxy.
*
*
* @param deleteDBProxyRequest
* @return Result of the DeleteDBProxy operation returned by the service.
* @throws DBProxyNotFoundException
* The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services account in the
* specified Amazon Web Services Region.
* @throws InvalidDBProxyStateException
* The requested operation can't be performed while the proxy is in this state.
* @sample AmazonRDS.DeleteDBProxy
* @see AWS API
* Documentation
*/
@Override
public DeleteDBProxyResult deleteDBProxy(DeleteDBProxyRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBProxy(request);
}
@SdkInternalApi
final DeleteDBProxyResult executeDeleteDBProxy(DeleteDBProxyRequest deleteDBProxyRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBProxyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBProxyRequestMarshaller().marshall(super.beforeMarshalling(deleteDBProxyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBProxy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new DeleteDBProxyResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a DBProxyEndpoint
. Doing so removes the ability to access the DB proxy using the endpoint
* that you defined. The endpoint that you delete might have provided capabilities such as read/write or read-only
* operations, or using a different VPC than the DB proxy's default VPC.
*
*
* @param deleteDBProxyEndpointRequest
* @return Result of the DeleteDBProxyEndpoint operation returned by the service.
* @throws DBProxyEndpointNotFoundException
* The DB proxy endpoint doesn't exist.
* @throws InvalidDBProxyEndpointStateException
* You can't perform this operation while the DB proxy endpoint is in a particular state.
* @sample AmazonRDS.DeleteDBProxyEndpoint
* @see AWS API
* Documentation
*/
@Override
public DeleteDBProxyEndpointResult deleteDBProxyEndpoint(DeleteDBProxyEndpointRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBProxyEndpoint(request);
}
@SdkInternalApi
final DeleteDBProxyEndpointResult executeDeleteDBProxyEndpoint(DeleteDBProxyEndpointRequest deleteDBProxyEndpointRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBProxyEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBProxyEndpointRequestMarshaller().marshall(super.beforeMarshalling(deleteDBProxyEndpointRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBProxyEndpoint");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteDBProxyEndpointResultStaxUnmarshaller());
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.
*
*
*
* EC2-Classic was retired on August 15, 2022. If you haven't migrated from EC2-Classic to a VPC, we recommend that
* you migrate as soon as possible. For more information, see Migrate from EC2-Classic to a VPC
* in the Amazon EC2 User Guide, the blog EC2-Classic Networking is
* Retiring – Here’s How to Prepare, and Moving a DB instance not
* in a VPC into a VPC in the Amazon RDS User Guide.
*
*
*
* @param deleteDBSecurityGroupRequest
* @return Result of the DeleteDBSecurityGroup operation returned by the service.
* @throws InvalidDBSecurityGroupStateException
* The state of the DB security group doesn't allow deletion.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName
doesn't refer to an existing DB security group.
* @sample AmazonRDS.DeleteDBSecurityGroup
* @see AWS API
* Documentation
*/
@Override
public DeleteDBSecurityGroupResult deleteDBSecurityGroup(DeleteDBSecurityGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBSecurityGroup(request);
}
@SdkInternalApi
final DeleteDBSecurityGroupResult executeDeleteDBSecurityGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBSecurityGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 an Aurora Limitless Database DB shard group.
*
*
* @param deleteDBShardGroupRequest
* @return Result of the DeleteDBShardGroup operation returned by the service.
* @throws DBShardGroupNotFoundException
* The specified DB shard group name wasn't found.
* @throws InvalidDBShardGroupStateException
* The DB shard group must be in the available state.
* @throws InvalidDBClusterStateException
* The requested operation can't be performed while the cluster is in this state.
* @sample AmazonRDS.DeleteDBShardGroup
* @see AWS API
* Documentation
*/
@Override
public DeleteDBShardGroupResult deleteDBShardGroup(DeleteDBShardGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBShardGroup(request);
}
@SdkInternalApi
final DeleteDBShardGroupResult executeDeleteDBShardGroup(DeleteDBShardGroupRequest deleteDBShardGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDBShardGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDBShardGroupRequestMarshaller().marshall(super.beforeMarshalling(deleteDBShardGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBShardGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteDBShardGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a DB snapshot. If the snapshot is being copied, the copy operation is terminated.
*
*
*
* The DB snapshot 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 doesn't allow deletion.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier
doesn't refer to an existing DB snapshot.
* @sample AmazonRDS.DeleteDBSnapshot
* @see AWS API
* Documentation
*/
@Override
public DBSnapshot deleteDBSnapshot(DeleteDBSnapshotRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBSnapshot(request);
}
@SdkInternalApi
final DBSnapshot executeDeleteDBSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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's in use.
* @throws InvalidDBSubnetStateException
* The DB subnet isn't in the available state.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName
doesn't refer to an existing DB subnet group.
* @sample AmazonRDS.DeleteDBSubnetGroup
* @see AWS API
* Documentation
*/
@Override
public DeleteDBSubnetGroupResult deleteDBSubnetGroup(DeleteDBSubnetGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDBSubnetGroup(request);
}
@SdkInternalApi
final DeleteDBSubnetGroupResult executeDeleteDBSubnetGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDBSubnetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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
* @see AWS
* API Documentation
*/
@Override
public EventSubscription deleteEventSubscription(DeleteEventSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeDeleteEventSubscription(request);
}
@SdkInternalApi
final EventSubscription executeDeleteEventSubscription(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteEventSubscription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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 a global database cluster. The primary and secondary clusters must already be detached or destroyed
* first.
*
*
*
* This action only applies to Aurora DB clusters.
*
*
*
* @param deleteGlobalClusterRequest
* @return Result of the DeleteGlobalCluster operation returned by the service.
* @throws GlobalClusterNotFoundException
* The GlobalClusterIdentifier
doesn't refer to an existing global database cluster.
* @throws InvalidGlobalClusterStateException
* The global cluster is in an invalid state and can't perform the requested operation.
* @sample AmazonRDS.DeleteGlobalCluster
* @see AWS API
* Documentation
*/
@Override
public GlobalCluster deleteGlobalCluster(DeleteGlobalClusterRequest request) {
request = beforeClientExecution(request);
return executeDeleteGlobalCluster(request);
}
@SdkInternalApi
final GlobalCluster executeDeleteGlobalCluster(DeleteGlobalClusterRequest deleteGlobalClusterRequest) {
ExecutionContext executionContext = createExecutionContext(deleteGlobalClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteGlobalClusterRequestMarshaller().marshall(super.beforeMarshalling(deleteGlobalClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteGlobalCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new GlobalClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a zero-ETL integration with Amazon Redshift.
*
*
* @param deleteIntegrationRequest
* @return Result of the DeleteIntegration operation returned by the service.
* @throws IntegrationNotFoundException
* The specified integration could not be found.
* @throws IntegrationConflictOperationException
* A conflicting conditional operation is currently in progress against this resource. Typically occurs when
* there are multiple requests being made to the same resource at the same time, and these requests conflict
* with each other.
* @throws InvalidIntegrationStateException
* The integration is in an invalid state and can't perform the requested operation.
* @sample AmazonRDS.DeleteIntegration
* @see AWS API
* Documentation
*/
@Override
public DeleteIntegrationResult deleteIntegration(DeleteIntegrationRequest request) {
request = beforeClientExecution(request);
return executeDeleteIntegration(request);
}
@SdkInternalApi
final DeleteIntegrationResult executeDeleteIntegration(DeleteIntegrationRequest deleteIntegrationRequest) {
ExecutionContext executionContext = createExecutionContext(deleteIntegrationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteIntegrationRequestMarshaller().marshall(super.beforeMarshalling(deleteIntegrationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteIntegration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteIntegrationResultStaxUnmarshaller());
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 isn't in the available state.
* @sample AmazonRDS.DeleteOptionGroup
* @see AWS API
* Documentation
*/
@Override
public DeleteOptionGroupResult deleteOptionGroup(DeleteOptionGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteOptionGroup(request);
}
@SdkInternalApi
final DeleteOptionGroupResult executeDeleteOptionGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteOptionGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteOptionGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a tenant database from your DB instance. This command only applies to RDS for Oracle container database
* (CDB) instances.
*
*
* You can't delete a tenant database when it is the only tenant in the DB instance.
*
*
* @param deleteTenantDatabaseRequest
* @return Result of the DeleteTenantDatabase operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier
doesn't refer to an existing DB instance.
* @throws TenantDatabaseNotFoundException
* The specified tenant database wasn't found in the DB instance.
* @throws InvalidDBInstanceStateException
* The DB instance isn't in a valid state.
* @sample AmazonRDS.DeleteTenantDatabase
* @see AWS API
* Documentation
*/
@Override
public TenantDatabase deleteTenantDatabase(DeleteTenantDatabaseRequest request) {
request = beforeClientExecution(request);
return executeDeleteTenantDatabase(request);
}
@SdkInternalApi
final TenantDatabase executeDeleteTenantDatabase(DeleteTenantDatabaseRequest deleteTenantDatabaseRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTenantDatabaseRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTenantDatabaseRequestMarshaller().marshall(super.beforeMarshalling(deleteTenantDatabaseRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteTenantDatabase");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new TenantDatabaseStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Remove the association between one or more DBProxyTarget
data structures and a
* DBProxyTargetGroup
.
*
*
* @param deregisterDBProxyTargetsRequest
* @return Result of the DeregisterDBProxyTargets operation returned by the service.
* @throws DBProxyTargetNotFoundException
* The specified RDS DB instance or Aurora DB cluster isn't available for a proxy owned by your Amazon Web
* Services account in the specified Amazon Web Services Region.
* @throws DBProxyTargetGroupNotFoundException
* The specified target group isn't available for a proxy owned by your Amazon Web Services account in the
* specified Amazon Web Services Region.
* @throws DBProxyNotFoundException
* The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services account in the
* specified Amazon Web Services Region.
* @throws InvalidDBProxyStateException
* The requested operation can't be performed while the proxy is in this state.
* @sample AmazonRDS.DeregisterDBProxyTargets
* @see AWS
* API Documentation
*/
@Override
public DeregisterDBProxyTargetsResult deregisterDBProxyTargets(DeregisterDBProxyTargetsRequest request) {
request = beforeClientExecution(request);
return executeDeregisterDBProxyTargets(request);
}
@SdkInternalApi
final DeregisterDBProxyTargetsResult executeDeregisterDBProxyTargets(DeregisterDBProxyTargetsRequest deregisterDBProxyTargetsRequest) {
ExecutionContext executionContext = createExecutionContext(deregisterDBProxyTargetsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeregisterDBProxyTargetsRequestMarshaller().marshall(super.beforeMarshalling(deregisterDBProxyTargetsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeregisterDBProxyTargets");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeregisterDBProxyTargetsResultStaxUnmarshaller());
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 doesn't take any parameters.
*
*
* @param describeAccountAttributesRequest
* @return Result of the DescribeAccountAttributes operation returned by the service.
* @sample AmazonRDS.DescribeAccountAttributes
* @see AWS
* API Documentation
*/
@Override
public DescribeAccountAttributesResult describeAccountAttributes(DescribeAccountAttributesRequest request) {
request = beforeClientExecution(request);
return executeDescribeAccountAttributes(request);
}
@SdkInternalApi
final DescribeAccountAttributesResult executeDescribeAccountAttributes(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAccountAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Describes one or more blue/green deployments.
*
*
* For more information, see Using Amazon RDS
* Blue/Green Deployments for database updates in the Amazon RDS User Guide and Using Amazon RDS
* Blue/Green Deployments for database updates in the Amazon Aurora User Guide.
*
*
* @param describeBlueGreenDeploymentsRequest
* @return Result of the DescribeBlueGreenDeployments operation returned by the service.
* @throws BlueGreenDeploymentNotFoundException
* BlueGreenDeploymentIdentifier
doesn't refer to an existing blue/green deployment.
* @sample AmazonRDS.DescribeBlueGreenDeployments
* @see AWS API Documentation
*/
@Override
public DescribeBlueGreenDeploymentsResult describeBlueGreenDeployments(DescribeBlueGreenDeploymentsRequest request) {
request = beforeClientExecution(request);
return executeDescribeBlueGreenDeployments(request);
}
@SdkInternalApi
final DescribeBlueGreenDeploymentsResult executeDescribeBlueGreenDeployments(DescribeBlueGreenDeploymentsRequest describeBlueGreenDeploymentsRequest) {
ExecutionContext executionContext = createExecutionContext(describeBlueGreenDeploymentsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeBlueGreenDeploymentsRequestMarshaller().marshall(super.beforeMarshalling(describeBlueGreenDeploymentsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeBlueGreenDeployments");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeBlueGreenDeploymentsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the set of certificate authority (CA) certificates provided by Amazon RDS for this Amazon Web Services
* account.
*
*
* For more information, see Using SSL/TLS to encrypt a
* connection to a DB instance in the Amazon RDS User Guide and Using SSL/TLS to
* encrypt a connection to a DB cluster in the Amazon Aurora User Guide.
*
*
* @param describeCertificatesRequest
* @return Result of the DescribeCertificates operation returned by the service.
* @throws CertificateNotFoundException
* CertificateIdentifier
doesn't refer to an existing certificate.
* @sample AmazonRDS.DescribeCertificates
* @see AWS API
* Documentation
*/
@Override
public DescribeCertificatesResult describeCertificates(DescribeCertificatesRequest request) {
request = beforeClientExecution(request);
return executeDescribeCertificates(request);
}
@SdkInternalApi
final DescribeCertificatesResult executeDescribeCertificates(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCertificates");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Displays backups for both current and deleted DB clusters. For example, use this operation to find details about
* automated backups for previously deleted clusters. Current clusters are returned for both the
* DescribeDBClusterAutomatedBackups
and DescribeDBClusters
operations.
*
*
* All parameters are optional.
*
*
* @param describeDBClusterAutomatedBackupsRequest
* @return Result of the DescribeDBClusterAutomatedBackups operation returned by the service.
* @throws DBClusterAutomatedBackupNotFoundException
* No automated backup for this DB cluster was found.
* @sample AmazonRDS.DescribeDBClusterAutomatedBackups
* @see AWS API Documentation
*/
@Override
public DescribeDBClusterAutomatedBackupsResult describeDBClusterAutomatedBackups(DescribeDBClusterAutomatedBackupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusterAutomatedBackups(request);
}
@SdkInternalApi
final DescribeDBClusterAutomatedBackupsResult executeDescribeDBClusterAutomatedBackups(
DescribeDBClusterAutomatedBackupsRequest describeDBClusterAutomatedBackupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterAutomatedBackupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterAutomatedBackupsRequestMarshaller().marshall(super.beforeMarshalling(describeDBClusterAutomatedBackupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusterAutomatedBackups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterAutomatedBackupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about backtracks for a DB cluster.
*
*
* For more information on Amazon Aurora, see What is Amazon
* Aurora? in the Amazon Aurora User Guide.
*
*
*
* This action only applies to Aurora MySQL DB clusters.
*
*
*
* @param describeDBClusterBacktracksRequest
* @return Result of the DescribeDBClusterBacktracks operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @throws DBClusterBacktrackNotFoundException
* BacktrackIdentifier
doesn't refer to an existing backtrack.
* @sample AmazonRDS.DescribeDBClusterBacktracks
* @see AWS API Documentation
*/
@Override
public DescribeDBClusterBacktracksResult describeDBClusterBacktracks(DescribeDBClusterBacktracksRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusterBacktracks(request);
}
@SdkInternalApi
final DescribeDBClusterBacktracksResult executeDescribeDBClusterBacktracks(DescribeDBClusterBacktracksRequest describeDBClusterBacktracksRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterBacktracksRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterBacktracksRequestMarshaller().marshall(super.beforeMarshalling(describeDBClusterBacktracksRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusterBacktracks");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterBacktracksResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about endpoints for an Amazon Aurora DB cluster.
*
*
*
* This action only applies to Aurora DB clusters.
*
*
*
* @param describeDBClusterEndpointsRequest
* @return Result of the DescribeDBClusterEndpoints operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier
doesn't refer to an existing DB cluster.
* @sample AmazonRDS.DescribeDBClusterEndpoints
* @see AWS
* API Documentation
*/
@Override
public DescribeDBClusterEndpointsResult describeDBClusterEndpoints(DescribeDBClusterEndpointsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusterEndpoints(request);
}
@SdkInternalApi
final DescribeDBClusterEndpointsResult executeDescribeDBClusterEndpoints(DescribeDBClusterEndpointsRequest describeDBClusterEndpointsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterEndpointsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterEndpointsRequestMarshaller().marshall(super.beforeMarshalling(describeDBClusterEndpointsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "RDS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusterEndpoints");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterEndpointsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*