com.amazonaws.services.neptune.AmazonNeptuneClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-neptune 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.neptune;
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.neptune.AmazonNeptuneClientBuilder;
import com.amazonaws.services.neptune.waiters.AmazonNeptuneWaiters;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.neptune.model.*;
import com.amazonaws.services.neptune.model.transform.*;
/**
* Client for accessing Amazon Neptune. All service calls made using this client are blocking, and will not return until
* the service call completes.
*
* Amazon Neptune
*
* Amazon Neptune is a fast, reliable, fully-managed graph database service that makes it easy to build and run
* applications that work with highly connected datasets. The core of Amazon Neptune is a purpose-built,
* high-performance graph database engine optimized for storing billions of relationships and querying the graph with
* milliseconds latency. Amazon Neptune supports popular graph models Property Graph and W3C's RDF, and their respective
* query languages Apache TinkerPop Gremlin and SPARQL, allowing you to easily build queries that efficiently navigate
* highly connected datasets. Neptune powers graph use cases such as recommendation engines, fraud detection, knowledge
* graphs, drug discovery, and network security.
*
*
* This interface reference for Amazon Neptune contains documentation for a programming or command line interface you
* can use to manage Amazon Neptune. Note that Amazon Neptune 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.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonNeptuneClient extends AmazonWebServiceClient implements AmazonNeptune {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonNeptune.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "rds";
private volatile AmazonNeptuneWaiters 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;
public static AmazonNeptuneClientBuilder builder() {
return AmazonNeptuneClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon Neptune 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.
*/
AmazonNeptuneClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon Neptune 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.
*/
AmazonNeptuneClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
if (exceptionUnmarshallersMap.get("DBClusterRoleNotFound") == null) {
exceptionUnmarshallersMap.put("DBClusterRoleNotFound", new DBClusterRoleNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterRoleNotFoundExceptionUnmarshaller());
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("InvalidRestoreFault") == null) {
exceptionUnmarshallersMap.put("InvalidRestoreFault", new InvalidRestoreExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidRestoreExceptionUnmarshaller());
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("DBClusterRoleQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("DBClusterRoleQuotaExceeded", new DBClusterRoleQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterRoleQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SNSInvalidTopic") == null) {
exceptionUnmarshallersMap.put("SNSInvalidTopic", new SNSInvalidTopicExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SNSInvalidTopicExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBParameterGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("DBParameterGroupAlreadyExists", new DBParameterGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBParameterGroupAlreadyExistsExceptionUnmarshaller());
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("InvalidDBSubnetStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBSubnetStateFault", new InvalidDBSubnetStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBSubnetStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CertificateNotFound") == null) {
exceptionUnmarshallersMap.put("CertificateNotFound", new CertificateNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CertificateNotFoundExceptionUnmarshaller());
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("InvalidDBSnapshotState") == null) {
exceptionUnmarshallersMap.put("InvalidDBSnapshotState", new InvalidDBSnapshotStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBSnapshotStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSecurityGroupNotFound") == null) {
exceptionUnmarshallersMap.put("DBSecurityGroupNotFound", new DBSecurityGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSecurityGroupNotFoundExceptionUnmarshaller());
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("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("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("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("SubnetAlreadyInUse") == null) {
exceptionUnmarshallersMap.put("SubnetAlreadyInUse", new SubnetAlreadyInUseExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SubnetAlreadyInUseExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ProvisionedIopsNotAvailableInAZFault") == null) {
exceptionUnmarshallersMap.put("ProvisionedIopsNotAvailableInAZFault", new ProvisionedIopsNotAvailableInAZExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ProvisionedIopsNotAvailableInAZExceptionUnmarshaller());
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("InvalidEventSubscriptionState") == null) {
exceptionUnmarshallersMap.put("InvalidEventSubscriptionState", new InvalidEventSubscriptionStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidEventSubscriptionStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBParameterGroupNotFound") == null) {
exceptionUnmarshallersMap.put("DBParameterGroupNotFound", new DBParameterGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBParameterGroupNotFoundExceptionUnmarshaller());
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("DBSubnetGroupDoesNotCoverEnoughAZs") == null) {
exceptionUnmarshallersMap.put("DBSubnetGroupDoesNotCoverEnoughAZs", new DBSubnetGroupDoesNotCoverEnoughAZsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetGroupDoesNotCoverEnoughAZsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterSnapshotNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBClusterSnapshotNotFoundFault", new DBClusterSnapshotNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterSnapshotNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBSubnetGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("DBSubnetGroupNotFoundFault", new DBSubnetGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBSubnetGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterEndpointQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("DBClusterEndpointQuotaExceededFault", new DBClusterEndpointQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterEndpointQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InstanceQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("InstanceQuotaExceeded", new InstanceQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InstanceQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterParameterGroupNotFound") == null) {
exceptionUnmarshallersMap.put("DBClusterParameterGroupNotFound", new DBClusterParameterGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterParameterGroupNotFoundExceptionUnmarshaller());
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("GlobalClusterAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("GlobalClusterAlreadyExistsFault", new GlobalClusterAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new GlobalClusterAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SharedSnapshotQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("SharedSnapshotQuotaExceeded", new SharedSnapshotQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SharedSnapshotQuotaExceededExceptionUnmarshaller());
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("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("InvalidVPCNetworkStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidVPCNetworkStateFault", new InvalidVPCNetworkStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidVPCNetworkStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SNSTopicArnNotFound") == null) {
exceptionUnmarshallersMap.put("SNSTopicArnNotFound", new SNSTopicArnNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SNSTopicArnNotFoundExceptionUnmarshaller());
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("OptionGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("OptionGroupNotFoundFault", new OptionGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new OptionGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDBClusterSnapshotStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidDBClusterSnapshotStateFault", new InvalidDBClusterSnapshotStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDBClusterSnapshotStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SourceNotFound") == null) {
exceptionUnmarshallersMap.put("SourceNotFound", new SourceNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SourceNotFoundExceptionUnmarshaller());
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("EventSubscriptionQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("EventSubscriptionQuotaExceeded", new EventSubscriptionQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new EventSubscriptionQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("StorageQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("StorageQuotaExceeded", new StorageQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new StorageQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DBClusterEndpointAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("DBClusterEndpointAlreadyExistsFault", new DBClusterEndpointAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DBClusterEndpointAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AuthorizationNotFound") == null) {
exceptionUnmarshallersMap.put("AuthorizationNotFound", new AuthorizationNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AuthorizationNotFoundExceptionUnmarshaller());
defaultUnmarshaller = new StandardErrorUnmarshaller(com.amazonaws.services.neptune.model.AmazonNeptuneException.class);
exceptionUnmarshallers.add(new StandardErrorUnmarshaller(com.amazonaws.services.neptune.model.AmazonNeptuneException.class));
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("rds.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/neptune/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/neptune/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Associates an Identity and Access Management (IAM) role with an Neptune DB cluster.
*
*
* @param addRoleToDBClusterRequest
* @return Result of the AddRoleToDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not 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 DB cluster is not in a valid state.
* @throws DBClusterRoleQuotaExceededException
* You have exceeded the maximum number of IAM roles that can be associated with the specified DB cluster.
* @sample AmazonNeptune.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, "Neptune");
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);
}
}
/**
*
* Adds a source identifier to an existing event notification subscription.
*
*
* @param addSourceIdentifierToSubscriptionRequest
* @return Result of the AddSourceIdentifierToSubscription operation returned by the service.
* @throws SubscriptionNotFoundException
* The designated subscription could not be found.
* @throws SourceNotFoundException
* The source could not be found.
* @sample AmazonNeptune.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, "Neptune");
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 Neptune resource. These tags can also be used with cost allocation reporting to
* track cost associated with Amazon Neptune resources, or used in a Condition statement in an IAM policy for Amazon
* Neptune.
*
*
* @param addTagsToResourceRequest
* @return Result of the AddTagsToResource operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB snapshot.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.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, "Neptune");
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.
* @sample AmazonNeptune.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, "Neptune");
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);
}
}
/**
*
* Copies the specified DB cluster parameter group.
*
*
* @param copyDBClusterParameterGroupRequest
* @return Result of the CopyDBClusterParameterGroup operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonNeptune.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, "Neptune");
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.
*
*
* @param copyDBClusterSnapshotRequest
* @return Result of the CopyDBClusterSnapshot operation returned by the service.
* @throws DBClusterSnapshotAlreadyExistsException
* User already has a DB cluster snapshot with the given identifier.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing DB cluster snapshot.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB snapshots.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @sample AmazonNeptune.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, "Neptune");
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.
*
*
* @param copyDBParameterGroupRequest
* @return Result of the CopyDBParameterGroup operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB parameter groups.
* @sample AmazonNeptune.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, "Neptune");
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);
}
}
/**
*
* Creates a new Amazon Neptune DB cluster.
*
*
* You can use the ReplicationSourceIdentifier parameter to create the DB cluster as a Read Replica of
* another DB cluster or Amazon Neptune DB instance.
*
*
* Note that when you create a new cluster using CreateDBCluster directly, deletion protection is
* disabled by default (when you create a new production cluster in the console, deletion protection is enabled by
* default). You can only delete a DB cluster if its DeletionProtection field is set to
* false.
*
*
* @param createDBClusterRequest
* @return Result of the CreateDBCluster operation returned by the service.
* @throws DBClusterAlreadyExistsException
* User already has a DB cluster with the given identifier.
* @throws InsufficientStorageClusterCapacityException
* There is insufficient storage available for the current action. You may be able to resolve this error by
* updating your subnet group to use different Availability Zones that have more storage available.
* @throws DBClusterQuotaExceededException
* User attempted to create a new DB cluster and the user has already reached the maximum allowed DB cluster
* quota.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of storage available across all DB instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is created because users' change.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBSubnetGroupStateException
* The DB subnet group cannot be deleted because it is in use.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName does not refer to an existing DB Cluster parameter group.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not 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.
* @sample AmazonNeptune.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, "Neptune");
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 Neptune DB cluster.
*
*
* @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 cannot be created because it already exists.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @sample AmazonNeptune.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, "Neptune");
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 DB cluster, you need to reboot the DB instances in the DB cluster without failover
* for the new DB cluster parameter group and associated settings to take effect.
*
*
*
* After you create a DB cluster parameter group, you should wait at least 5 minutes before creating your first DB
* cluster that uses that DB cluster parameter group as the default parameter group. This allows Amazon Neptune 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 Neptune console or the DescribeDBClusterParameters
* command to verify that your DB cluster parameter group has been created or modified.
*
*
*
* @param createDBClusterParameterGroupRequest
* @return Result of the CreateDBClusterParameterGroup operation returned by the service.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonNeptune.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, "Neptune");
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.
*
*
* @param createDBClusterSnapshotRequest
* @return Result of the CreateDBClusterSnapshot operation returned by the service.
* @throws DBClusterSnapshotAlreadyExistsException
* User already has a DB cluster snapshot with the given identifier.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB snapshots.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @sample AmazonNeptune.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, "Neptune");
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.
*
*
* @param createDBInstanceRequest
* @return Result of the CreateDBInstance operation returned by the service.
* @throws DBInstanceAlreadyExistsException
* User already has a DB instance with the given identifier.
* @throws InsufficientDBInstanceCapacityException
* Specified DB instance class is not available in the specified Availability Zone.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName does not refer to an existing DB security group.
* @throws InstanceQuotaExceededException
* Request would result in user exceeding the allowed number of DB instances.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of storage available across all DB instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @throws DBSubnetGroupDoesNotCoverEnoughAZsException
* Subnets in the DB subnet group should cover at least two Availability Zones unless there is only one
* Availability Zone.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is created because users' change.
* @throws ProvisionedIopsNotAvailableInAZException
* Provisioned IOPS not available in the specified Availability Zone.
* @throws OptionGroupNotFoundException
* The designated option group could not be found.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws StorageTypeNotSupportedException
* StorageType specified cannot be associated with the DB Instance.
* @throws AuthorizationNotFoundException
* Specified CIDRIP or EC2 security group is not authorized for the specified DB security group.
*
* Neptune may not also be authorized via IAM to perform necessary actions on your behalf.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @throws DomainNotFoundException
* Domain does not refer to an existing Active Directory Domain.
* @sample AmazonNeptune.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, "Neptune");
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 parameter group.
*
*
* A DB parameter group is initially created with the default parameters for the database engine used by the DB
* instance. To provide custom values for any of the parameters, you must modify the group after creating it using
* ModifyDBParameterGroup. Once you've created a DB parameter group, you need to associate it with your DB
* instance using ModifyDBInstance. When you associate a new DB parameter group with a running DB instance,
* you need to reboot the DB instance without failover for the new DB parameter group and associated settings to
* take effect.
*
*
*
* After you create a DB parameter group, you should wait at least 5 minutes before creating your first DB instance
* that uses that DB parameter group as the default parameter group. This allows Amazon Neptune 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 Neptune console or the DescribeDBParameters command to
* verify that your DB parameter group has been created or modified.
*
*
*
* @param createDBParameterGroupRequest
* @return Result of the CreateDBParameterGroup operation returned by the service.
* @throws DBParameterGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB parameter groups.
* @throws DBParameterGroupAlreadyExistsException
* A DB parameter group with the same name exists.
* @sample AmazonNeptune.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, "Neptune");
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 subnet group. DB subnet groups must contain at least one subnet in at least two AZs in the
* Amazon Region.
*
*
* @param createDBSubnetGroupRequest
* @return Result of the CreateDBSubnetGroup operation returned by the service.
* @throws DBSubnetGroupAlreadyExistsException
* DBSubnetGroupName is already used by an existing DB subnet group.
* @throws DBSubnetGroupQuotaExceededException
* Request would result in user exceeding the allowed number of DB subnet groups.
* @throws DBSubnetQuotaExceededException
* Request would result in user exceeding the allowed number of subnets in a DB subnet groups.
* @throws DBSubnetGroupDoesNotCoverEnoughAZsException
* Subnets in the DB subnet group should cover at least two Availability Zones unless there is only one
* Availability Zone.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @sample AmazonNeptune.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, "Neptune");
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 event notification subscription. This action requires a topic ARN (Amazon Resource Name) created by
* either the Neptune console, the SNS console, or the SNS API. To obtain an ARN with SNS, you must create a topic
* in Amazon SNS and subscribe to the topic. The ARN is displayed in the SNS console.
*
*
* You can specify the type of source (SourceType) you want to be notified of, provide a list of Neptune sources
* (SourceIds) that triggers the events, and provide a list of event categories (EventCategories) for events you
* want to be notified of. For example, you can specify SourceType = db-instance, SourceIds = mydbinstance1,
* mydbinstance2 and EventCategories = Availability, Backup.
*
*
* If you specify both the SourceType and SourceIds, such as SourceType = db-instance and SourceIdentifier =
* myDBInstance1, you are notified of all the db-instance events for the specified source. If you specify a
* SourceType but do not specify a SourceIdentifier, you receive notice of the events for that source type for all
* your Neptune sources. If you do not specify either the SourceType nor the SourceIdentifier, you are notified of
* events generated from all Neptune sources belonging to your customer account.
*
*
* @param createEventSubscriptionRequest
* @return Result of the CreateEventSubscription operation returned by the service.
* @throws EventSubscriptionQuotaExceededException
* You have exceeded the number of events you can subscribe to.
* @throws SubscriptionAlreadyExistException
* This subscription already exists.
* @throws SNSInvalidTopicException
* The SNS topic is invalid.
* @throws SNSNoAuthorizationException
* There is no SNS authorization.
* @throws SNSTopicArnNotFoundException
* The ARN of the SNS topic could not be found.
* @throws SubscriptionCategoryNotFoundException
* The designated subscription category could not be found.
* @throws SourceNotFoundException
* The source could not be found.
* @sample AmazonNeptune.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, "Neptune");
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 a Neptune global database spread across multiple Amazon Regions. The global database contains a single
* primary cluster with read-write capability, and read-only secondary clusters that receive data from the primary
* cluster through high-speed replication performed by the Neptune storage subsystem.
*
*
* You can create a global database that is initially empty, and then add a primary cluster and secondary clusters
* to it, or you can specify an existing Neptune cluster during the create operation to become the primary cluster
* of the global database.
*
*
* @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 DB cluster is not in a valid state.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.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, "Neptune");
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);
}
}
/**
*
* 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.
*
*
* Note that the DB Cluster cannot be deleted if deletion protection is enabled. To delete it, you must first set
* its DeletionProtection field to False.
*
*
* @param deleteDBClusterRequest
* @return Result of the DeleteDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws DBClusterSnapshotAlreadyExistsException
* User already has a DB cluster snapshot with the given identifier.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB snapshots.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @sample AmazonNeptune.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, "Neptune");
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 a custom endpoint and removes it from an Amazon Neptune DB cluster.
*
*
* @param deleteDBClusterEndpointRequest
* @return Result of the DeleteDBClusterEndpoint operation returned by the service.
* @throws InvalidDBClusterEndpointStateException
* The requested operation cannot be performed on the endpoint while the endpoint is in this state.
* @throws DBClusterEndpointNotFoundException
* The specified custom endpoint doesn't exist.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @sample AmazonNeptune.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, "Neptune");
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.
*
*
* @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 cannot delete it when the parameter group is in this state.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.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, "Neptune");
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.
*
*
*
* @param deleteDBClusterSnapshotRequest
* @return Result of the DeleteDBClusterSnapshot operation returned by the service.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing DB cluster snapshot.
* @sample AmazonNeptune.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, "Neptune");
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);
}
}
/**
*
* The DeleteDBInstance action 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. Manual DB snapshots of the DB instance to
* be deleted by DeleteDBInstance are not deleted.
*
*
* If you request a final DB snapshot the status of the Amazon Neptune DB instance is deleting until
* the DB snapshot is created. The API action DescribeDBInstance is used to monitor the status of this
* operation. The action can't be canceled or reverted once submitted.
*
*
* Note that when a DB instance is in a failure state and has a status of failed,
* incompatible-restore, or incompatible-network, you can only delete it when the
* SkipFinalSnapshot parameter is set to true.
*
*
* You can't delete a DB instance if it is the only instance in the DB cluster, or if it has deletion protection
* enabled.
*
*
* @param deleteDBInstanceRequest
* @return Result of the DeleteDBInstance operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBSnapshotAlreadyExistsException
* DBSnapshotIdentifier is already used by an existing snapshot.
* @throws SnapshotQuotaExceededException
* Request would result in user exceeding the allowed number of DB snapshots.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @sample AmazonNeptune.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, "Neptune");
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 a specified DBParameterGroup. The DBParameterGroup 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 cannot delete it when the parameter group is in this state.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.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, "Neptune");
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 a DB subnet group.
*
*
*
* The specified database subnet group must not be associated with any DB instances.
*
*
*
* @param deleteDBSubnetGroupRequest
* @return Result of the DeleteDBSubnetGroup operation returned by the service.
* @throws InvalidDBSubnetGroupStateException
* The DB subnet group cannot be deleted because it is in use.
* @throws InvalidDBSubnetStateException
* The DB subnet is not in the available state.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @sample AmazonNeptune.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, "Neptune");
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 event notification subscription.
*
*
* @param deleteEventSubscriptionRequest
* @return Result of the DeleteEventSubscription operation returned by the service.
* @throws SubscriptionNotFoundException
* The designated subscription could not be found.
* @throws InvalidEventSubscriptionStateException
* The event subscription is in an invalid state.
* @sample AmazonNeptune.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, "Neptune");
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. The primary and all secondary clusters must already be detached or deleted first.
*
*
* @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 AmazonNeptune.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, "Neptune");
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);
}
}
/**
*
* Returns information about endpoints for an Amazon Neptune DB cluster.
*
*
*
* This operation can also return information for Amazon RDS clusters and Amazon DocDB clusters.
*
*
*
* @param describeDBClusterEndpointsRequest
* @return Result of the DescribeDBClusterEndpoints operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.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, "Neptune");
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);
}
}
/**
*
* Returns a list of DBClusterParameterGroup descriptions. If a
* DBClusterParameterGroupName parameter is specified, the list will contain only the description of
* the specified DB cluster parameter group.
*
*
* @param describeDBClusterParameterGroupsRequest
* @return Result of the DescribeDBClusterParameterGroups operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.DescribeDBClusterParameterGroups
* @see AWS API Documentation
*/
@Override
public DescribeDBClusterParameterGroupsResult describeDBClusterParameterGroups(DescribeDBClusterParameterGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusterParameterGroups(request);
}
@SdkInternalApi
final DescribeDBClusterParameterGroupsResult executeDescribeDBClusterParameterGroups(
DescribeDBClusterParameterGroupsRequest describeDBClusterParameterGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterParameterGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterParameterGroupsRequestMarshaller().marshall(super.beforeMarshalling(describeDBClusterParameterGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusterParameterGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterParameterGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the detailed parameter list for a particular DB cluster parameter group.
*
*
* @param describeDBClusterParametersRequest
* @return Result of the DescribeDBClusterParameters operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.DescribeDBClusterParameters
* @see AWS API Documentation
*/
@Override
public DescribeDBClusterParametersResult describeDBClusterParameters(DescribeDBClusterParametersRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusterParameters(request);
}
@SdkInternalApi
final DescribeDBClusterParametersResult executeDescribeDBClusterParameters(DescribeDBClusterParametersRequest describeDBClusterParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterParametersRequestMarshaller().marshall(super.beforeMarshalling(describeDBClusterParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusterParameters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterParametersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of DB cluster snapshot attribute names and values for a manual DB cluster snapshot.
*
*
* When sharing snapshots with other Amazon accounts, DescribeDBClusterSnapshotAttributes returns the
* restore attribute and a list of IDs for the Amazon accounts that are authorized to copy or restore
* the manual DB cluster snapshot. If all is included in the list of values for the
* restore attribute, then the manual DB cluster snapshot is public and can be copied or restored by
* all Amazon accounts.
*
*
* To add or remove access for an Amazon account to copy or restore a manual DB cluster snapshot, or to make the
* manual DB cluster snapshot public or private, use the ModifyDBClusterSnapshotAttribute API action.
*
*
* @param describeDBClusterSnapshotAttributesRequest
* @return Result of the DescribeDBClusterSnapshotAttributes operation returned by the service.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing DB cluster snapshot.
* @sample AmazonNeptune.DescribeDBClusterSnapshotAttributes
* @see AWS API Documentation
*/
@Override
public DBClusterSnapshotAttributesResult describeDBClusterSnapshotAttributes(DescribeDBClusterSnapshotAttributesRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusterSnapshotAttributes(request);
}
@SdkInternalApi
final DBClusterSnapshotAttributesResult executeDescribeDBClusterSnapshotAttributes(
DescribeDBClusterSnapshotAttributesRequest describeDBClusterSnapshotAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterSnapshotAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterSnapshotAttributesRequestMarshaller().marshall(super
.beforeMarshalling(describeDBClusterSnapshotAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusterSnapshotAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterSnapshotAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about DB cluster snapshots. This API action supports pagination.
*
*
* @param describeDBClusterSnapshotsRequest
* @return Result of the DescribeDBClusterSnapshots operation returned by the service.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing DB cluster snapshot.
* @sample AmazonNeptune.DescribeDBClusterSnapshots
* @see AWS API Documentation
*/
@Override
public DescribeDBClusterSnapshotsResult describeDBClusterSnapshots(DescribeDBClusterSnapshotsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusterSnapshots(request);
}
@SdkInternalApi
final DescribeDBClusterSnapshotsResult executeDescribeDBClusterSnapshots(DescribeDBClusterSnapshotsRequest describeDBClusterSnapshotsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClusterSnapshotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClusterSnapshotsRequestMarshaller().marshall(super.beforeMarshalling(describeDBClusterSnapshotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusterSnapshots");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClusterSnapshotsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about provisioned DB clusters, and supports pagination.
*
*
*
* This operation can also return information for Amazon RDS clusters and Amazon DocDB clusters.
*
*
*
* @param describeDBClustersRequest
* @return Result of the DescribeDBClusters operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.DescribeDBClusters
* @see AWS API
* Documentation
*/
@Override
public DescribeDBClustersResult describeDBClusters(DescribeDBClustersRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBClusters(request);
}
@SdkInternalApi
final DescribeDBClustersResult executeDescribeDBClusters(DescribeDBClustersRequest describeDBClustersRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBClustersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBClustersRequestMarshaller().marshall(super.beforeMarshalling(describeDBClustersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBClusters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBClustersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of the available DB engines.
*
*
* @param describeDBEngineVersionsRequest
* @return Result of the DescribeDBEngineVersions operation returned by the service.
* @sample AmazonNeptune.DescribeDBEngineVersions
* @see AWS API Documentation
*/
@Override
public DescribeDBEngineVersionsResult describeDBEngineVersions(DescribeDBEngineVersionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBEngineVersions(request);
}
@SdkInternalApi
final DescribeDBEngineVersionsResult executeDescribeDBEngineVersions(DescribeDBEngineVersionsRequest describeDBEngineVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBEngineVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBEngineVersionsRequestMarshaller().marshall(super.beforeMarshalling(describeDBEngineVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBEngineVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBEngineVersionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about provisioned instances, and supports pagination.
*
*
*
* This operation can also return information for Amazon RDS instances and Amazon DocDB instances.
*
*
*
* @param describeDBInstancesRequest
* @return Result of the DescribeDBInstances operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @sample AmazonNeptune.DescribeDBInstances
* @see AWS
* API Documentation
*/
@Override
public DescribeDBInstancesResult describeDBInstances(DescribeDBInstancesRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBInstances(request);
}
@SdkInternalApi
final DescribeDBInstancesResult executeDescribeDBInstances(DescribeDBInstancesRequest describeDBInstancesRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBInstancesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBInstancesRequestMarshaller().marshall(super.beforeMarshalling(describeDBInstancesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBInstances");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBInstancesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of DBParameterGroup descriptions. If a DBParameterGroupName is
* specified, the list will contain only the description of the specified DB parameter group.
*
*
* @param describeDBParameterGroupsRequest
* @return Result of the DescribeDBParameterGroups operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.DescribeDBParameterGroups
* @see AWS API Documentation
*/
@Override
public DescribeDBParameterGroupsResult describeDBParameterGroups(DescribeDBParameterGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBParameterGroups(request);
}
@SdkInternalApi
final DescribeDBParameterGroupsResult executeDescribeDBParameterGroups(DescribeDBParameterGroupsRequest describeDBParameterGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBParameterGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBParameterGroupsRequestMarshaller().marshall(super.beforeMarshalling(describeDBParameterGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBParameterGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBParameterGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the detailed parameter list for a particular DB parameter group.
*
*
* @param describeDBParametersRequest
* @return Result of the DescribeDBParameters operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.DescribeDBParameters
* @see AWS
* API Documentation
*/
@Override
public DescribeDBParametersResult describeDBParameters(DescribeDBParametersRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBParameters(request);
}
@SdkInternalApi
final DescribeDBParametersResult executeDescribeDBParameters(DescribeDBParametersRequest describeDBParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBParametersRequestMarshaller().marshall(super.beforeMarshalling(describeDBParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBParameters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBParametersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of DBSubnetGroup descriptions. If a DBSubnetGroupName is specified, the list will contain only the
* descriptions of the specified DBSubnetGroup.
*
*
* For an overview of CIDR ranges, go to the Wikipedia Tutorial.
*
*
* @param describeDBSubnetGroupsRequest
* @return Result of the DescribeDBSubnetGroups operation returned by the service.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @sample AmazonNeptune.DescribeDBSubnetGroups
* @see AWS
* API Documentation
*/
@Override
public DescribeDBSubnetGroupsResult describeDBSubnetGroups(DescribeDBSubnetGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDBSubnetGroups(request);
}
@SdkInternalApi
final DescribeDBSubnetGroupsResult executeDescribeDBSubnetGroups(DescribeDBSubnetGroupsRequest describeDBSubnetGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDBSubnetGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDBSubnetGroupsRequestMarshaller().marshall(super.beforeMarshalling(describeDBSubnetGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDBSubnetGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeDBSubnetGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the default engine and system parameter information for the cluster database engine.
*
*
* @param describeEngineDefaultClusterParametersRequest
* @return Result of the DescribeEngineDefaultClusterParameters operation returned by the service.
* @sample AmazonNeptune.DescribeEngineDefaultClusterParameters
* @see AWS API Documentation
*/
@Override
public EngineDefaults describeEngineDefaultClusterParameters(DescribeEngineDefaultClusterParametersRequest request) {
request = beforeClientExecution(request);
return executeDescribeEngineDefaultClusterParameters(request);
}
@SdkInternalApi
final EngineDefaults executeDescribeEngineDefaultClusterParameters(
DescribeEngineDefaultClusterParametersRequest describeEngineDefaultClusterParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeEngineDefaultClusterParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEngineDefaultClusterParametersRequestMarshaller().marshall(super
.beforeMarshalling(describeEngineDefaultClusterParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEngineDefaultClusterParameters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new EngineDefaultsStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the default engine and system parameter information for the specified database engine.
*
*
* @param describeEngineDefaultParametersRequest
* @return Result of the DescribeEngineDefaultParameters operation returned by the service.
* @sample AmazonNeptune.DescribeEngineDefaultParameters
* @see AWS API Documentation
*/
@Override
public EngineDefaults describeEngineDefaultParameters(DescribeEngineDefaultParametersRequest request) {
request = beforeClientExecution(request);
return executeDescribeEngineDefaultParameters(request);
}
@SdkInternalApi
final EngineDefaults executeDescribeEngineDefaultParameters(DescribeEngineDefaultParametersRequest describeEngineDefaultParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeEngineDefaultParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEngineDefaultParametersRequestMarshaller().marshall(super.beforeMarshalling(describeEngineDefaultParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEngineDefaultParameters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new EngineDefaultsStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Displays a list of categories for all event source types, or, if specified, for a specified source type.
*
*
* @param describeEventCategoriesRequest
* @return Result of the DescribeEventCategories operation returned by the service.
* @sample AmazonNeptune.DescribeEventCategories
* @see AWS API Documentation
*/
@Override
public DescribeEventCategoriesResult describeEventCategories(DescribeEventCategoriesRequest request) {
request = beforeClientExecution(request);
return executeDescribeEventCategories(request);
}
@SdkInternalApi
final DescribeEventCategoriesResult executeDescribeEventCategories(DescribeEventCategoriesRequest describeEventCategoriesRequest) {
ExecutionContext executionContext = createExecutionContext(describeEventCategoriesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEventCategoriesRequestMarshaller().marshall(super.beforeMarshalling(describeEventCategoriesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEventCategories");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeEventCategoriesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all the subscription descriptions for a customer account. The description for a subscription includes
* SubscriptionName, SNSTopicARN, CustomerID, SourceType, SourceID, CreationTime, and Status.
*
*
* If you specify a SubscriptionName, lists the description for that subscription.
*
*
* @param describeEventSubscriptionsRequest
* @return Result of the DescribeEventSubscriptions operation returned by the service.
* @throws SubscriptionNotFoundException
* The designated subscription could not be found.
* @sample AmazonNeptune.DescribeEventSubscriptions
* @see AWS API Documentation
*/
@Override
public DescribeEventSubscriptionsResult describeEventSubscriptions(DescribeEventSubscriptionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeEventSubscriptions(request);
}
@SdkInternalApi
final DescribeEventSubscriptionsResult executeDescribeEventSubscriptions(DescribeEventSubscriptionsRequest describeEventSubscriptionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeEventSubscriptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEventSubscriptionsRequestMarshaller().marshall(super.beforeMarshalling(describeEventSubscriptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEventSubscriptions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeEventSubscriptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns events related to DB instances, DB security groups, DB snapshots, and DB parameter groups for the past 14
* days. Events specific to a particular DB instance, DB security group, database snapshot, or DB parameter group
* can be obtained by providing the name as a parameter. By default, the past hour of events are returned.
*
*
* @param describeEventsRequest
* @return Result of the DescribeEvents operation returned by the service.
* @sample AmazonNeptune.DescribeEvents
* @see AWS API
* Documentation
*/
@Override
public DescribeEventsResult describeEvents(DescribeEventsRequest request) {
request = beforeClientExecution(request);
return executeDescribeEvents(request);
}
@SdkInternalApi
final DescribeEventsResult executeDescribeEvents(DescribeEventsRequest describeEventsRequest) {
ExecutionContext executionContext = createExecutionContext(describeEventsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEventsRequestMarshaller().marshall(super.beforeMarshalling(describeEventsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEvents");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeEventsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about Neptune global database clusters. This API supports pagination.
*
*
* @param describeGlobalClustersRequest
* @return Result of the DescribeGlobalClusters operation returned by the service.
* @throws GlobalClusterNotFoundException
* The GlobalClusterIdentifier doesn't refer to an existing global database cluster.
* @sample AmazonNeptune.DescribeGlobalClusters
* @see AWS
* API Documentation
*/
@Override
public DescribeGlobalClustersResult describeGlobalClusters(DescribeGlobalClustersRequest request) {
request = beforeClientExecution(request);
return executeDescribeGlobalClusters(request);
}
@SdkInternalApi
final DescribeGlobalClustersResult executeDescribeGlobalClusters(DescribeGlobalClustersRequest describeGlobalClustersRequest) {
ExecutionContext executionContext = createExecutionContext(describeGlobalClustersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeGlobalClustersRequestMarshaller().marshall(super.beforeMarshalling(describeGlobalClustersRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeGlobalClusters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeGlobalClustersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of orderable DB instance options for the specified engine.
*
*
* @param describeOrderableDBInstanceOptionsRequest
* @return Result of the DescribeOrderableDBInstanceOptions operation returned by the service.
* @sample AmazonNeptune.DescribeOrderableDBInstanceOptions
* @see AWS API Documentation
*/
@Override
public DescribeOrderableDBInstanceOptionsResult describeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeOrderableDBInstanceOptions(request);
}
@SdkInternalApi
final DescribeOrderableDBInstanceOptionsResult executeDescribeOrderableDBInstanceOptions(
DescribeOrderableDBInstanceOptionsRequest describeOrderableDBInstanceOptionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeOrderableDBInstanceOptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeOrderableDBInstanceOptionsRequestMarshaller()
.marshall(super.beforeMarshalling(describeOrderableDBInstanceOptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeOrderableDBInstanceOptions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeOrderableDBInstanceOptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of resources (for example, DB instances) that have at least one pending maintenance action.
*
*
* @param describePendingMaintenanceActionsRequest
* @return Result of the DescribePendingMaintenanceActions operation returned by the service.
* @throws ResourceNotFoundException
* The specified resource ID was not found.
* @sample AmazonNeptune.DescribePendingMaintenanceActions
* @see AWS API Documentation
*/
@Override
public DescribePendingMaintenanceActionsResult describePendingMaintenanceActions(DescribePendingMaintenanceActionsRequest request) {
request = beforeClientExecution(request);
return executeDescribePendingMaintenanceActions(request);
}
@SdkInternalApi
final DescribePendingMaintenanceActionsResult executeDescribePendingMaintenanceActions(
DescribePendingMaintenanceActionsRequest describePendingMaintenanceActionsRequest) {
ExecutionContext executionContext = createExecutionContext(describePendingMaintenanceActionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribePendingMaintenanceActionsRequestMarshaller().marshall(super.beforeMarshalling(describePendingMaintenanceActionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribePendingMaintenanceActions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribePendingMaintenanceActionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* You can call DescribeValidDBInstanceModifications to learn what modifications you can make to your DB
* instance. You can use this information when you call ModifyDBInstance.
*
*
* @param describeValidDBInstanceModificationsRequest
* @return Result of the DescribeValidDBInstanceModifications operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @sample AmazonNeptune.DescribeValidDBInstanceModifications
* @see AWS API Documentation
*/
@Override
public ValidDBInstanceModificationsMessage describeValidDBInstanceModifications(DescribeValidDBInstanceModificationsRequest request) {
request = beforeClientExecution(request);
return executeDescribeValidDBInstanceModifications(request);
}
@SdkInternalApi
final ValidDBInstanceModificationsMessage executeDescribeValidDBInstanceModifications(
DescribeValidDBInstanceModificationsRequest describeValidDBInstanceModificationsRequest) {
ExecutionContext executionContext = createExecutionContext(describeValidDBInstanceModificationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeValidDBInstanceModificationsRequestMarshaller().marshall(super
.beforeMarshalling(describeValidDBInstanceModificationsRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeValidDBInstanceModifications");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ValidDBInstanceModificationsMessageStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Forces a failover for a DB cluster.
*
*
* A failover for a DB cluster promotes one of the Read Replicas (read-only instances) in the DB cluster to be the
* primary instance (the cluster writer).
*
*
* Amazon Neptune will automatically fail over to a Read Replica, if one exists, when the primary instance fails.
* You can force a failover when you want to simulate a failure of a primary instance for testing. Because each
* instance in a DB cluster has its own endpoint address, you will need to clean up and re-establish any existing
* connections that use those endpoint addresses when the failover is complete.
*
*
* @param failoverDBClusterRequest
* @return Result of the FailoverDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @sample AmazonNeptune.FailoverDBCluster
* @see AWS API
* Documentation
*/
@Override
public DBCluster failoverDBCluster(FailoverDBClusterRequest request) {
request = beforeClientExecution(request);
return executeFailoverDBCluster(request);
}
@SdkInternalApi
final DBCluster executeFailoverDBCluster(FailoverDBClusterRequest failoverDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(failoverDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new FailoverDBClusterRequestMarshaller().marshall(super.beforeMarshalling(failoverDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "FailoverDBCluster");
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);
}
}
/**
*
* Initiates the failover process for a Neptune global database.
*
*
* A failover for a Neptune global database promotes one of secondary read-only DB clusters to be the primary DB
* cluster and demotes the primary DB cluster to being a secondary (read-only) DB cluster. In other words, the role
* of the current primary DB cluster and the selected target secondary DB cluster are switched. The selected
* secondary DB cluster assumes full read/write capabilities for the Neptune global database.
*
*
*
* This action applies only to Neptune global databases. This action is only intended for use on healthy
* Neptune global databases with healthy Neptune DB clusters and no region-wide outages, to test disaster recovery
* scenarios or to reconfigure the global database topology.
*
*
*
* @param failoverGlobalClusterRequest
* @return Result of the FailoverGlobalCluster 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.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.FailoverGlobalCluster
* @see AWS
* API Documentation
*/
@Override
public GlobalCluster failoverGlobalCluster(FailoverGlobalClusterRequest request) {
request = beforeClientExecution(request);
return executeFailoverGlobalCluster(request);
}
@SdkInternalApi
final GlobalCluster executeFailoverGlobalCluster(FailoverGlobalClusterRequest failoverGlobalClusterRequest) {
ExecutionContext executionContext = createExecutionContext(failoverGlobalClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new FailoverGlobalClusterRequestMarshaller().marshall(super.beforeMarshalling(failoverGlobalClusterRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "FailoverGlobalCluster");
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);
}
}
/**
*
* Lists all tags on an Amazon Neptune resource.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB snapshot.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.ListTagsForResource
* @see AWS
* API Documentation
*/
@Override
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {
request = beforeClientExecution(request);
return executeListTagsForResource(request);
}
@SdkInternalApi
final ListTagsForResourceResult executeListTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestMarshaller().marshall(super.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListTagsForResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modify a setting for a DB cluster. You can change one or more database configuration parameters by specifying
* these parameters and the new values in the request.
*
*
* @param modifyDBClusterRequest
* @return Result of the ModifyDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of storage available across all DB instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is created because users' change.
* @throws InvalidDBSubnetGroupStateException
* The DB subnet group cannot be deleted because it is in use.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName does not refer to an existing DB Cluster parameter group.
* @throws InvalidDBSecurityGroupStateException
* The state of the DB security group does not allow deletion.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBClusterAlreadyExistsException
* User already has a DB cluster with the given identifier.
* @throws StorageTypeNotSupportedException
* StorageType specified cannot be associated with the DB Instance.
* @sample AmazonNeptune.ModifyDBCluster
* @see AWS API
* Documentation
*/
@Override
public DBCluster modifyDBCluster(ModifyDBClusterRequest request) {
request = beforeClientExecution(request);
return executeModifyDBCluster(request);
}
@SdkInternalApi
final DBCluster executeModifyDBCluster(ModifyDBClusterRequest modifyDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBClusterRequestMarshaller().marshall(super.beforeMarshalling(modifyDBClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyDBCluster");
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);
}
}
/**
*
* Modifies the properties of an endpoint in an Amazon Neptune DB cluster.
*
*
* @param modifyDBClusterEndpointRequest
* @return Result of the ModifyDBClusterEndpoint operation returned by the service.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBClusterEndpointStateException
* The requested operation cannot be performed on the endpoint while the endpoint is in this state.
* @throws DBClusterEndpointNotFoundException
* The specified custom endpoint doesn't exist.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @sample AmazonNeptune.ModifyDBClusterEndpoint
* @see AWS API Documentation
*/
@Override
public ModifyDBClusterEndpointResult modifyDBClusterEndpoint(ModifyDBClusterEndpointRequest request) {
request = beforeClientExecution(request);
return executeModifyDBClusterEndpoint(request);
}
@SdkInternalApi
final ModifyDBClusterEndpointResult executeModifyDBClusterEndpoint(ModifyDBClusterEndpointRequest modifyDBClusterEndpointRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBClusterEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBClusterEndpointRequestMarshaller().marshall(super.beforeMarshalling(modifyDBClusterEndpointRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyDBClusterEndpoint");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ModifyDBClusterEndpointResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the parameters of a DB cluster parameter group. To modify more than one parameter, submit a list of the
* following: ParameterName, ParameterValue, and ApplyMethod. A maximum of 20
* parameters can be modified in a single request.
*
*
*
* Changes to dynamic parameters are applied immediately. Changes to static parameters require a reboot without
* failover to the DB cluster associated with the parameter group before the change can take effect.
*
*
*
* After you create a DB cluster parameter group, you should wait at least 5 minutes before creating your first DB
* cluster that uses that DB cluster parameter group as the default parameter group. This allows Amazon Neptune to
* fully complete the create action before the parameter group is used as the default for a new DB cluster. This is
* especially important for parameters that are critical when creating the default database for a DB cluster, such
* as the character set for the default database defined by the character_set_database parameter. You
* can use the Parameter Groups option of the Amazon Neptune console or the
* DescribeDBClusterParameters command to verify that your DB cluster parameter group has been created or
* modified.
*
*
*
* @param modifyDBClusterParameterGroupRequest
* @return Result of the ModifyDBClusterParameterGroup operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @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 cannot delete it when the parameter group is in this state.
* @sample AmazonNeptune.ModifyDBClusterParameterGroup
* @see AWS API Documentation
*/
@Override
public ModifyDBClusterParameterGroupResult modifyDBClusterParameterGroup(ModifyDBClusterParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyDBClusterParameterGroup(request);
}
@SdkInternalApi
final ModifyDBClusterParameterGroupResult executeModifyDBClusterParameterGroup(ModifyDBClusterParameterGroupRequest modifyDBClusterParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBClusterParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBClusterParameterGroupRequestMarshaller().marshall(super.beforeMarshalling(modifyDBClusterParameterGroupRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyDBClusterParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ModifyDBClusterParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds an attribute and values to, or removes an attribute and values from, a manual DB cluster snapshot.
*
*
* To share a manual DB cluster snapshot with other Amazon accounts, specify restore as the
* AttributeName and use the ValuesToAdd parameter to add a list of IDs of the Amazon
* accounts that are authorized to restore the manual DB cluster snapshot. Use the value all to make
* the manual DB cluster snapshot public, which means that it can be copied or restored by all Amazon accounts. Do
* not add the all value for any manual DB cluster snapshots that contain private information that you
* don't want available to all Amazon accounts. If a manual DB cluster snapshot is encrypted, it can be shared, but
* only by specifying a list of authorized Amazon account IDs for the ValuesToAdd parameter. You can't
* use all as a value for that parameter in this case.
*
*
* To view which Amazon accounts have access to copy or restore a manual DB cluster snapshot, or whether a manual DB
* cluster snapshot public or private, use the DescribeDBClusterSnapshotAttributes API action.
*
*
* @param modifyDBClusterSnapshotAttributeRequest
* @return Result of the ModifyDBClusterSnapshotAttribute operation returned by the service.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing DB cluster snapshot.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @throws SharedSnapshotQuotaExceededException
* You have exceeded the maximum number of accounts that you can share a manual DB snapshot with.
* @sample AmazonNeptune.ModifyDBClusterSnapshotAttribute
* @see AWS API Documentation
*/
@Override
public DBClusterSnapshotAttributesResult modifyDBClusterSnapshotAttribute(ModifyDBClusterSnapshotAttributeRequest request) {
request = beforeClientExecution(request);
return executeModifyDBClusterSnapshotAttribute(request);
}
@SdkInternalApi
final DBClusterSnapshotAttributesResult executeModifyDBClusterSnapshotAttribute(
ModifyDBClusterSnapshotAttributeRequest modifyDBClusterSnapshotAttributeRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBClusterSnapshotAttributeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBClusterSnapshotAttributeRequestMarshaller().marshall(super.beforeMarshalling(modifyDBClusterSnapshotAttributeRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyDBClusterSnapshotAttribute");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DBClusterSnapshotAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies settings for a DB instance. You can change one or more database configuration parameters by specifying
* these parameters and the new values in the request. To learn what modifications you can make to your DB instance,
* call DescribeValidDBInstanceModifications before you call ModifyDBInstance.
*
*
* @param modifyDBInstanceRequest
* @return Result of the ModifyDBInstance operation returned by the service.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws InvalidDBSecurityGroupStateException
* The state of the DB security group does not allow deletion.
* @throws DBInstanceAlreadyExistsException
* User already has a DB instance with the given identifier.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws DBSecurityGroupNotFoundException
* DBSecurityGroupName does not refer to an existing DB security group.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @throws InsufficientDBInstanceCapacityException
* Specified DB instance class is not available in the specified Availability Zone.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of storage available across all DB instances.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is created because users' change.
* @throws ProvisionedIopsNotAvailableInAZException
* Provisioned IOPS not available in the specified Availability Zone.
* @throws OptionGroupNotFoundException
* The designated option group could not be found.
* @throws DBUpgradeDependencyFailureException
* The DB upgrade failed because a resource the DB depends on could not be modified.
* @throws StorageTypeNotSupportedException
* StorageType specified cannot be associated with the DB Instance.
* @throws AuthorizationNotFoundException
* Specified CIDRIP or EC2 security group is not authorized for the specified DB security group.
*
* Neptune may not also be authorized via IAM to perform necessary actions on your behalf.
* @throws CertificateNotFoundException
* CertificateIdentifier does not refer to an existing certificate.
* @throws DomainNotFoundException
* Domain does not refer to an existing Active Directory Domain.
* @sample AmazonNeptune.ModifyDBInstance
* @see AWS API
* Documentation
*/
@Override
public DBInstance modifyDBInstance(ModifyDBInstanceRequest request) {
request = beforeClientExecution(request);
return executeModifyDBInstance(request);
}
@SdkInternalApi
final DBInstance executeModifyDBInstance(ModifyDBInstanceRequest modifyDBInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBInstanceRequestMarshaller().marshall(super.beforeMarshalling(modifyDBInstanceRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyDBInstance");
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);
}
}
/**
*
* Modifies the parameters of a DB parameter group. To modify more than one parameter, submit a list of the
* following: ParameterName, ParameterValue, and ApplyMethod. A maximum of 20
* parameters can be modified in a single request.
*
*
*
* Changes to dynamic parameters are applied immediately. Changes to static parameters require a reboot without
* failover to the DB instance associated with the parameter group before the change can take effect.
*
*
*
* After you modify 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 Neptune to fully complete
* the modify 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 Neptune console or the DescribeDBParameters command to
* verify that your DB parameter group has been created or modified.
*
*
*
* @param modifyDBParameterGroupRequest
* @return Result of the ModifyDBParameterGroup operation returned by the service.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @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 cannot delete it when the parameter group is in this state.
* @sample AmazonNeptune.ModifyDBParameterGroup
* @see AWS
* API Documentation
*/
@Override
public ModifyDBParameterGroupResult modifyDBParameterGroup(ModifyDBParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyDBParameterGroup(request);
}
@SdkInternalApi
final ModifyDBParameterGroupResult executeModifyDBParameterGroup(ModifyDBParameterGroupRequest modifyDBParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBParameterGroupRequestMarshaller().marshall(super.beforeMarshalling(modifyDBParameterGroupRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyDBParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ModifyDBParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies an existing DB subnet group. DB subnet groups must contain at least one subnet in at least two AZs in
* the Amazon Region.
*
*
* @param modifyDBSubnetGroupRequest
* @return Result of the ModifyDBSubnetGroup operation returned by the service.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @throws DBSubnetQuotaExceededException
* Request would result in user exceeding the allowed number of subnets in a DB subnet groups.
* @throws SubnetAlreadyInUseException
* The DB subnet is already in use in the Availability Zone.
* @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 AmazonNeptune.ModifyDBSubnetGroup
* @see AWS
* API Documentation
*/
@Override
public DBSubnetGroup modifyDBSubnetGroup(ModifyDBSubnetGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyDBSubnetGroup(request);
}
@SdkInternalApi
final DBSubnetGroup executeModifyDBSubnetGroup(ModifyDBSubnetGroupRequest modifyDBSubnetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyDBSubnetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyDBSubnetGroupRequestMarshaller().marshall(super.beforeMarshalling(modifyDBSubnetGroupRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyDBSubnetGroup");
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);
}
}
/**
*
* Modifies an existing event notification subscription. Note that you can't modify the source identifiers using
* this call; to change source identifiers for a subscription, use the AddSourceIdentifierToSubscription and
* RemoveSourceIdentifierFromSubscription calls.
*
*
* You can see a list of the event categories for a given SourceType by using the DescribeEventCategories
* action.
*
*
* @param modifyEventSubscriptionRequest
* @return Result of the ModifyEventSubscription operation returned by the service.
* @throws EventSubscriptionQuotaExceededException
* You have exceeded the number of events you can subscribe to.
* @throws SubscriptionNotFoundException
* The designated subscription could not be found.
* @throws SNSInvalidTopicException
* The SNS topic is invalid.
* @throws SNSNoAuthorizationException
* There is no SNS authorization.
* @throws SNSTopicArnNotFoundException
* The ARN of the SNS topic could not be found.
* @throws SubscriptionCategoryNotFoundException
* The designated subscription category could not be found.
* @sample AmazonNeptune.ModifyEventSubscription
* @see AWS API Documentation
*/
@Override
public EventSubscription modifyEventSubscription(ModifyEventSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeModifyEventSubscription(request);
}
@SdkInternalApi
final EventSubscription executeModifyEventSubscription(ModifyEventSubscriptionRequest modifyEventSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(modifyEventSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyEventSubscriptionRequestMarshaller().marshall(super.beforeMarshalling(modifyEventSubscriptionRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyEventSubscription");
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);
}
}
/**
*
* Modify a setting for an Amazon Neptune global cluster. You can change one or more database configuration
* parameters by specifying these parameters and their new values in the request.
*
*
* @param modifyGlobalClusterRequest
* @return Result of the ModifyGlobalCluster 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 AmazonNeptune.ModifyGlobalCluster
* @see AWS
* API Documentation
*/
@Override
public GlobalCluster modifyGlobalCluster(ModifyGlobalClusterRequest request) {
request = beforeClientExecution(request);
return executeModifyGlobalCluster(request);
}
@SdkInternalApi
final GlobalCluster executeModifyGlobalCluster(ModifyGlobalClusterRequest modifyGlobalClusterRequest) {
ExecutionContext executionContext = createExecutionContext(modifyGlobalClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyGlobalClusterRequestMarshaller().marshall(super.beforeMarshalling(modifyGlobalClusterRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyGlobalCluster");
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);
}
}
/**
*
* Not supported.
*
*
* @param promoteReadReplicaDBClusterRequest
* @return Result of the PromoteReadReplicaDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @sample AmazonNeptune.PromoteReadReplicaDBCluster
* @see AWS API Documentation
*/
@Override
public DBCluster promoteReadReplicaDBCluster(PromoteReadReplicaDBClusterRequest request) {
request = beforeClientExecution(request);
return executePromoteReadReplicaDBCluster(request);
}
@SdkInternalApi
final DBCluster executePromoteReadReplicaDBCluster(PromoteReadReplicaDBClusterRequest promoteReadReplicaDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(promoteReadReplicaDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PromoteReadReplicaDBClusterRequestMarshaller().marshall(super.beforeMarshalling(promoteReadReplicaDBClusterRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PromoteReadReplicaDBCluster");
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);
}
}
/**
*
* You might need to reboot your DB instance, usually for maintenance reasons. For example, if you make certain
* modifications, or if you change the DB parameter group associated with the DB instance, you must reboot the
* instance for the changes to take effect.
*
*
* Rebooting a DB instance restarts the database engine service. Rebooting a DB instance results in a momentary
* outage, during which the DB instance status is set to rebooting.
*
*
* @param rebootDBInstanceRequest
* @return Result of the RebootDBInstance operation returned by the service.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @sample AmazonNeptune.RebootDBInstance
* @see AWS API
* Documentation
*/
@Override
public DBInstance rebootDBInstance(RebootDBInstanceRequest request) {
request = beforeClientExecution(request);
return executeRebootDBInstance(request);
}
@SdkInternalApi
final DBInstance executeRebootDBInstance(RebootDBInstanceRequest rebootDBInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(rebootDBInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RebootDBInstanceRequestMarshaller().marshall(super.beforeMarshalling(rebootDBInstanceRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RebootDBInstance");
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);
}
}
/**
*
* Detaches a Neptune DB cluster from a Neptune global database. A secondary cluster becomes a normal standalone
* cluster with read-write capability instead of being read-only, and no longer receives data from a the primary
* cluster.
*
*
* @param removeFromGlobalClusterRequest
* @return Result of the RemoveFromGlobalCluster 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.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.RemoveFromGlobalCluster
* @see AWS API Documentation
*/
@Override
public GlobalCluster removeFromGlobalCluster(RemoveFromGlobalClusterRequest request) {
request = beforeClientExecution(request);
return executeRemoveFromGlobalCluster(request);
}
@SdkInternalApi
final GlobalCluster executeRemoveFromGlobalCluster(RemoveFromGlobalClusterRequest removeFromGlobalClusterRequest) {
ExecutionContext executionContext = createExecutionContext(removeFromGlobalClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemoveFromGlobalClusterRequestMarshaller().marshall(super.beforeMarshalling(removeFromGlobalClusterRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemoveFromGlobalCluster");
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);
}
}
/**
*
* Disassociates an Identity and Access Management (IAM) role from a DB cluster.
*
*
* @param removeRoleFromDBClusterRequest
* @return Result of the RemoveRoleFromDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws DBClusterRoleNotFoundException
* The specified IAM role Amazon Resource Name (ARN) is not associated with the specified DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @sample AmazonNeptune.RemoveRoleFromDBCluster
* @see AWS API Documentation
*/
@Override
public RemoveRoleFromDBClusterResult removeRoleFromDBCluster(RemoveRoleFromDBClusterRequest request) {
request = beforeClientExecution(request);
return executeRemoveRoleFromDBCluster(request);
}
@SdkInternalApi
final RemoveRoleFromDBClusterResult executeRemoveRoleFromDBCluster(RemoveRoleFromDBClusterRequest removeRoleFromDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(removeRoleFromDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemoveRoleFromDBClusterRequestMarshaller().marshall(super.beforeMarshalling(removeRoleFromDBClusterRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemoveRoleFromDBCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new RemoveRoleFromDBClusterResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Removes a source identifier from an existing event notification subscription.
*
*
* @param removeSourceIdentifierFromSubscriptionRequest
* @return Result of the RemoveSourceIdentifierFromSubscription operation returned by the service.
* @throws SubscriptionNotFoundException
* The designated subscription could not be found.
* @throws SourceNotFoundException
* The source could not be found.
* @sample AmazonNeptune.RemoveSourceIdentifierFromSubscription
* @see AWS API Documentation
*/
@Override
public EventSubscription removeSourceIdentifierFromSubscription(RemoveSourceIdentifierFromSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeRemoveSourceIdentifierFromSubscription(request);
}
@SdkInternalApi
final EventSubscription executeRemoveSourceIdentifierFromSubscription(
RemoveSourceIdentifierFromSubscriptionRequest removeSourceIdentifierFromSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(removeSourceIdentifierFromSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemoveSourceIdentifierFromSubscriptionRequestMarshaller().marshall(super
.beforeMarshalling(removeSourceIdentifierFromSubscriptionRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemoveSourceIdentifierFromSubscription");
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);
}
}
/**
*
* Removes metadata tags from an Amazon Neptune resource.
*
*
* @param removeTagsFromResourceRequest
* @return Result of the RemoveTagsFromResource operation returned by the service.
* @throws DBInstanceNotFoundException
* DBInstanceIdentifier does not refer to an existing DB instance.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB snapshot.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @sample AmazonNeptune.RemoveTagsFromResource
* @see AWS
* API Documentation
*/
@Override
public RemoveTagsFromResourceResult removeTagsFromResource(RemoveTagsFromResourceRequest request) {
request = beforeClientExecution(request);
return executeRemoveTagsFromResource(request);
}
@SdkInternalApi
final RemoveTagsFromResourceResult executeRemoveTagsFromResource(RemoveTagsFromResourceRequest removeTagsFromResourceRequest) {
ExecutionContext executionContext = createExecutionContext(removeTagsFromResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemoveTagsFromResourceRequestMarshaller().marshall(super.beforeMarshalling(removeTagsFromResourceRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemoveTagsFromResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new RemoveTagsFromResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the parameters of a DB cluster parameter group to the default value. To reset specific parameters submit
* a list of the following: ParameterName and ApplyMethod. To reset the entire DB cluster
* parameter group, specify the DBClusterParameterGroupName and ResetAllParameters
* parameters.
*
*
* When resetting the entire group, dynamic parameters are updated immediately and static parameters are set to
* pending-reboot to take effect on the next DB instance restart or RebootDBInstance request.
* You must call RebootDBInstance for every DB instance in your DB cluster that you want the updated static
* parameter to apply to.
*
*
* @param resetDBClusterParameterGroupRequest
* @return Result of the ResetDBClusterParameterGroup 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 cannot delete it when the parameter group is in this state.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.ResetDBClusterParameterGroup
* @see AWS API Documentation
*/
@Override
public ResetDBClusterParameterGroupResult resetDBClusterParameterGroup(ResetDBClusterParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeResetDBClusterParameterGroup(request);
}
@SdkInternalApi
final ResetDBClusterParameterGroupResult executeResetDBClusterParameterGroup(ResetDBClusterParameterGroupRequest resetDBClusterParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(resetDBClusterParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ResetDBClusterParameterGroupRequestMarshaller().marshall(super.beforeMarshalling(resetDBClusterParameterGroupRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ResetDBClusterParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ResetDBClusterParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the parameters of a DB parameter group to the engine/system default value. To reset specific parameters,
* provide a list of the following: ParameterName and ApplyMethod. To reset the entire DB
* parameter group, specify the DBParameterGroup name and ResetAllParameters parameters.
* When resetting the entire group, dynamic parameters are updated immediately and static parameters are set to
* pending-reboot to take effect on the next DB instance restart or RebootDBInstance
* request.
*
*
* @param resetDBParameterGroupRequest
* @return Result of the ResetDBParameterGroup 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 cannot delete it when the parameter group is in this state.
* @throws DBParameterGroupNotFoundException
* DBParameterGroupName does not refer to an existing DB parameter group.
* @sample AmazonNeptune.ResetDBParameterGroup
* @see AWS
* API Documentation
*/
@Override
public ResetDBParameterGroupResult resetDBParameterGroup(ResetDBParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeResetDBParameterGroup(request);
}
@SdkInternalApi
final ResetDBParameterGroupResult executeResetDBParameterGroup(ResetDBParameterGroupRequest resetDBParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(resetDBParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ResetDBParameterGroupRequestMarshaller().marshall(super.beforeMarshalling(resetDBParameterGroupRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ResetDBParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ResetDBParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new DB cluster from a DB snapshot or DB cluster snapshot.
*
*
* If a DB snapshot is specified, the target DB cluster is created from the source DB snapshot with a default
* configuration and default security group.
*
*
* If a DB cluster snapshot is specified, the target DB cluster is created from the source DB cluster restore point
* with the same configuration as the original source DB cluster, except that the new DB cluster is created with the
* default security group.
*
*
* @param restoreDBClusterFromSnapshotRequest
* @return Result of the RestoreDBClusterFromSnapshot operation returned by the service.
* @throws DBClusterAlreadyExistsException
* User already has a DB cluster with the given identifier.
* @throws DBClusterQuotaExceededException
* User attempted to create a new DB cluster and the user has already reached the maximum allowed DB cluster
* quota.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of storage available across all DB instances.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @throws DBSnapshotNotFoundException
* DBSnapshotIdentifier does not refer to an existing DB snapshot.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing DB cluster snapshot.
* @throws InsufficientDBClusterCapacityException
* The DB cluster does not have enough capacity for the current operation.
* @throws InsufficientStorageClusterCapacityException
* There is insufficient storage available for the current action. You may be able to resolve this error by
* updating your subnet group to use different Availability Zones that have more storage available.
* @throws InvalidDBSnapshotStateException
* The state of the DB snapshot does not allow deletion.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of storage available across all DB instances.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is created because users' change.
* @throws InvalidRestoreException
* Cannot restore from vpc backup to non-vpc DB instance.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws OptionGroupNotFoundException
* The designated option group could not be found.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName does not refer to an existing DB Cluster parameter group.
* @sample AmazonNeptune.RestoreDBClusterFromSnapshot
* @see AWS API Documentation
*/
@Override
public DBCluster restoreDBClusterFromSnapshot(RestoreDBClusterFromSnapshotRequest request) {
request = beforeClientExecution(request);
return executeRestoreDBClusterFromSnapshot(request);
}
@SdkInternalApi
final DBCluster executeRestoreDBClusterFromSnapshot(RestoreDBClusterFromSnapshotRequest restoreDBClusterFromSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(restoreDBClusterFromSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RestoreDBClusterFromSnapshotRequestMarshaller().marshall(super.beforeMarshalling(restoreDBClusterFromSnapshotRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RestoreDBClusterFromSnapshot");
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);
}
}
/**
*
* Restores a DB cluster to an arbitrary point in time. Users can restore to any point in time before
* LatestRestorableTime for up to BackupRetentionPeriod days. The target DB cluster is
* created from the source DB cluster with the same configuration as the original DB cluster, except that the new DB
* cluster is created with the default DB security group.
*
*
*
* This action only restores the DB cluster, not the DB instances for that DB cluster. You must invoke the
* CreateDBInstance action to create DB instances for the restored DB cluster, specifying the identifier of
* the restored DB cluster in DBClusterIdentifier. You can create DB instances only after the
* RestoreDBClusterToPointInTime action has completed and the DB cluster is available.
*
*
*
* @param restoreDBClusterToPointInTimeRequest
* @return Result of the RestoreDBClusterToPointInTime operation returned by the service.
* @throws DBClusterAlreadyExistsException
* User already has a DB cluster with the given identifier.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws DBClusterQuotaExceededException
* User attempted to create a new DB cluster and the user has already reached the maximum allowed DB cluster
* quota.
* @throws DBClusterSnapshotNotFoundException
* DBClusterSnapshotIdentifier does not refer to an existing DB cluster snapshot.
* @throws DBSubnetGroupNotFoundException
* DBSubnetGroupName does not refer to an existing DB subnet group.
* @throws InsufficientDBClusterCapacityException
* The DB cluster does not have enough capacity for the current operation.
* @throws InsufficientStorageClusterCapacityException
* There is insufficient storage available for the current action. You may be able to resolve this error by
* updating your subnet group to use different Availability Zones that have more storage available.
* @throws InvalidDBClusterSnapshotStateException
* The supplied value is not a valid DB cluster snapshot state.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBSnapshotStateException
* The state of the DB snapshot does not allow deletion.
* @throws InvalidRestoreException
* Cannot restore from vpc backup to non-vpc DB instance.
* @throws InvalidSubnetException
* The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.
* @throws InvalidVPCNetworkStateException
* DB subnet group does not cover all Availability Zones after it is created because users' change.
* @throws KMSKeyNotAccessibleException
* Error accessing KMS key.
* @throws OptionGroupNotFoundException
* The designated option group could not be found.
* @throws StorageQuotaExceededException
* Request would result in user exceeding the allowed amount of storage available across all DB instances.
* @throws DBClusterParameterGroupNotFoundException
* DBClusterParameterGroupName does not refer to an existing DB Cluster parameter group.
* @sample AmazonNeptune.RestoreDBClusterToPointInTime
* @see AWS API Documentation
*/
@Override
public DBCluster restoreDBClusterToPointInTime(RestoreDBClusterToPointInTimeRequest request) {
request = beforeClientExecution(request);
return executeRestoreDBClusterToPointInTime(request);
}
@SdkInternalApi
final DBCluster executeRestoreDBClusterToPointInTime(RestoreDBClusterToPointInTimeRequest restoreDBClusterToPointInTimeRequest) {
ExecutionContext executionContext = createExecutionContext(restoreDBClusterToPointInTimeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RestoreDBClusterToPointInTimeRequestMarshaller().marshall(super.beforeMarshalling(restoreDBClusterToPointInTimeRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RestoreDBClusterToPointInTime");
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);
}
}
/**
*
* Starts an Amazon Neptune DB cluster that was stopped using the Amazon console, the Amazon CLI stop-db-cluster
* command, or the StopDBCluster API.
*
*
* @param startDBClusterRequest
* @return Result of the StartDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @sample AmazonNeptune.StartDBCluster
* @see AWS API
* Documentation
*/
@Override
public DBCluster startDBCluster(StartDBClusterRequest request) {
request = beforeClientExecution(request);
return executeStartDBCluster(request);
}
@SdkInternalApi
final DBCluster executeStartDBCluster(StartDBClusterRequest startDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(startDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartDBClusterRequestMarshaller().marshall(super.beforeMarshalling(startDBClusterRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartDBCluster");
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);
}
}
/**
*
* Stops an Amazon Neptune DB cluster. When you stop a DB cluster, Neptune retains the DB cluster's metadata,
* including its endpoints and DB parameter groups.
*
*
* Neptune also retains the transaction logs so you can do a point-in-time restore if necessary.
*
*
* @param stopDBClusterRequest
* @return Result of the StopDBCluster operation returned by the service.
* @throws DBClusterNotFoundException
* DBClusterIdentifier does not refer to an existing DB cluster.
* @throws InvalidDBClusterStateException
* The DB cluster is not in a valid state.
* @throws InvalidDBInstanceStateException
* The specified DB instance is not in the available state.
* @sample AmazonNeptune.StopDBCluster
* @see AWS API
* Documentation
*/
@Override
public DBCluster stopDBCluster(StopDBClusterRequest request) {
request = beforeClientExecution(request);
return executeStopDBCluster(request);
}
@SdkInternalApi
final DBCluster executeStopDBCluster(StopDBClusterRequest stopDBClusterRequest) {
ExecutionContext executionContext = createExecutionContext(stopDBClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StopDBClusterRequestMarshaller().marshall(super.beforeMarshalling(stopDBClusterRequest));
// 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, "Neptune");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StopDBCluster");
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);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallersMap, defaultUnmarshaller);
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@Override
public AmazonNeptuneWaiters waiters() {
if (waiters == null) {
synchronized (this) {
if (waiters == null) {
waiters = new AmazonNeptuneWaiters(this);
}
}
}
return waiters;
}
@Override
public void shutdown() {
super.shutdown();
if (waiters != null) {
waiters.shutdown();
}
}
}