software.amazon.awssdk.services.neptune.NeptuneAsyncClient Maven / Gradle / Ivy
Show all versions of neptune Show documentation
/*
* Copyright 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 software.amazon.awssdk.services.neptune;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkPublicApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.awscore.AwsClient;
import software.amazon.awssdk.services.neptune.model.AddRoleToDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.AddRoleToDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.AddSourceIdentifierToSubscriptionRequest;
import software.amazon.awssdk.services.neptune.model.AddSourceIdentifierToSubscriptionResponse;
import software.amazon.awssdk.services.neptune.model.AddTagsToResourceRequest;
import software.amazon.awssdk.services.neptune.model.AddTagsToResourceResponse;
import software.amazon.awssdk.services.neptune.model.ApplyPendingMaintenanceActionRequest;
import software.amazon.awssdk.services.neptune.model.ApplyPendingMaintenanceActionResponse;
import software.amazon.awssdk.services.neptune.model.CopyDbClusterParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.CopyDbClusterParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.CopyDbClusterSnapshotRequest;
import software.amazon.awssdk.services.neptune.model.CopyDbClusterSnapshotResponse;
import software.amazon.awssdk.services.neptune.model.CopyDbParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.CopyDbParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterEndpointRequest;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterEndpointResponse;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterSnapshotRequest;
import software.amazon.awssdk.services.neptune.model.CreateDbClusterSnapshotResponse;
import software.amazon.awssdk.services.neptune.model.CreateDbInstanceRequest;
import software.amazon.awssdk.services.neptune.model.CreateDbInstanceResponse;
import software.amazon.awssdk.services.neptune.model.CreateDbParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.CreateDbParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.CreateDbSubnetGroupRequest;
import software.amazon.awssdk.services.neptune.model.CreateDbSubnetGroupResponse;
import software.amazon.awssdk.services.neptune.model.CreateEventSubscriptionRequest;
import software.amazon.awssdk.services.neptune.model.CreateEventSubscriptionResponse;
import software.amazon.awssdk.services.neptune.model.CreateGlobalClusterRequest;
import software.amazon.awssdk.services.neptune.model.CreateGlobalClusterResponse;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterEndpointRequest;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterEndpointResponse;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterSnapshotRequest;
import software.amazon.awssdk.services.neptune.model.DeleteDbClusterSnapshotResponse;
import software.amazon.awssdk.services.neptune.model.DeleteDbInstanceRequest;
import software.amazon.awssdk.services.neptune.model.DeleteDbInstanceResponse;
import software.amazon.awssdk.services.neptune.model.DeleteDbParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.DeleteDbParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.DeleteDbSubnetGroupRequest;
import software.amazon.awssdk.services.neptune.model.DeleteDbSubnetGroupResponse;
import software.amazon.awssdk.services.neptune.model.DeleteEventSubscriptionRequest;
import software.amazon.awssdk.services.neptune.model.DeleteEventSubscriptionResponse;
import software.amazon.awssdk.services.neptune.model.DeleteGlobalClusterRequest;
import software.amazon.awssdk.services.neptune.model.DeleteGlobalClusterResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotAttributesRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotAttributesResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbClustersResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbInstancesResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbParametersRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbParametersResponse;
import software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultClusterParametersRequest;
import software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultClusterParametersResponse;
import software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersRequest;
import software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersResponse;
import software.amazon.awssdk.services.neptune.model.DescribeEventCategoriesRequest;
import software.amazon.awssdk.services.neptune.model.DescribeEventCategoriesResponse;
import software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeEventsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeEventsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersRequest;
import software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersResponse;
import software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsResponse;
import software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest;
import software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsResponse;
import software.amazon.awssdk.services.neptune.model.DescribeValidDbInstanceModificationsRequest;
import software.amazon.awssdk.services.neptune.model.DescribeValidDbInstanceModificationsResponse;
import software.amazon.awssdk.services.neptune.model.FailoverDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.FailoverDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.FailoverGlobalClusterRequest;
import software.amazon.awssdk.services.neptune.model.FailoverGlobalClusterResponse;
import software.amazon.awssdk.services.neptune.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.neptune.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterEndpointRequest;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterEndpointResponse;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterSnapshotAttributeRequest;
import software.amazon.awssdk.services.neptune.model.ModifyDbClusterSnapshotAttributeResponse;
import software.amazon.awssdk.services.neptune.model.ModifyDbInstanceRequest;
import software.amazon.awssdk.services.neptune.model.ModifyDbInstanceResponse;
import software.amazon.awssdk.services.neptune.model.ModifyDbParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.ModifyDbParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.ModifyDbSubnetGroupRequest;
import software.amazon.awssdk.services.neptune.model.ModifyDbSubnetGroupResponse;
import software.amazon.awssdk.services.neptune.model.ModifyEventSubscriptionRequest;
import software.amazon.awssdk.services.neptune.model.ModifyEventSubscriptionResponse;
import software.amazon.awssdk.services.neptune.model.ModifyGlobalClusterRequest;
import software.amazon.awssdk.services.neptune.model.ModifyGlobalClusterResponse;
import software.amazon.awssdk.services.neptune.model.PromoteReadReplicaDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.PromoteReadReplicaDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.RebootDbInstanceRequest;
import software.amazon.awssdk.services.neptune.model.RebootDbInstanceResponse;
import software.amazon.awssdk.services.neptune.model.RemoveFromGlobalClusterRequest;
import software.amazon.awssdk.services.neptune.model.RemoveFromGlobalClusterResponse;
import software.amazon.awssdk.services.neptune.model.RemoveRoleFromDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.RemoveRoleFromDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.RemoveSourceIdentifierFromSubscriptionRequest;
import software.amazon.awssdk.services.neptune.model.RemoveSourceIdentifierFromSubscriptionResponse;
import software.amazon.awssdk.services.neptune.model.RemoveTagsFromResourceRequest;
import software.amazon.awssdk.services.neptune.model.RemoveTagsFromResourceResponse;
import software.amazon.awssdk.services.neptune.model.ResetDbClusterParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.ResetDbClusterParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.ResetDbParameterGroupRequest;
import software.amazon.awssdk.services.neptune.model.ResetDbParameterGroupResponse;
import software.amazon.awssdk.services.neptune.model.RestoreDbClusterFromSnapshotRequest;
import software.amazon.awssdk.services.neptune.model.RestoreDbClusterFromSnapshotResponse;
import software.amazon.awssdk.services.neptune.model.RestoreDbClusterToPointInTimeRequest;
import software.amazon.awssdk.services.neptune.model.RestoreDbClusterToPointInTimeResponse;
import software.amazon.awssdk.services.neptune.model.StartDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.StartDbClusterResponse;
import software.amazon.awssdk.services.neptune.model.StopDbClusterRequest;
import software.amazon.awssdk.services.neptune.model.StopDbClusterResponse;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterEndpointsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParameterGroupsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParametersPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterSnapshotsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBClustersPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBEngineVersionsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBInstancesPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBParameterGroupsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBParametersPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeDBSubnetGroupsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeEngineDefaultParametersPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeEventSubscriptionsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeEventsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeGlobalClustersPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribeOrderableDBInstanceOptionsPublisher;
import software.amazon.awssdk.services.neptune.paginators.DescribePendingMaintenanceActionsPublisher;
import software.amazon.awssdk.services.neptune.waiters.NeptuneAsyncWaiter;
/**
* Service client for accessing Amazon Neptune asynchronously. This can be created using the static {@link #builder()}
* method.The asynchronous client performs non-blocking I/O when configured with any {@code SdkAsyncHttpClient}
* supported in the SDK. However, full non-blocking is not guaranteed as the async client may perform blocking calls in
* some cases such as credentials retrieval and endpoint discovery as part of the async API call.
*
* 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.
*
*/
@Generated("software.amazon.awssdk:codegen")
@SdkPublicApi
@ThreadSafe
public interface NeptuneAsyncClient extends AwsClient {
String SERVICE_NAME = "rds";
/**
* Value for looking up the service's metadata from the
* {@link software.amazon.awssdk.regions.ServiceMetadataProvider}.
*/
String SERVICE_METADATA_ID = "rds";
/**
*
* Associates an Identity and Access Management (IAM) role with an Neptune DB cluster.
*
*
* @param addRoleToDbClusterRequest
* @return A Java Future containing the result of the AddRoleToDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbClusterRoleAlreadyExistsException The specified IAM role Amazon Resource Name (ARN) is already
* associated with the specified DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterRoleQuotaExceededException You have exceeded the maximum number of IAM roles that can be
* associated with the specified DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.AddRoleToDBCluster
* @see AWS
* API Documentation
*/
default CompletableFuture addRoleToDBCluster(AddRoleToDbClusterRequest addRoleToDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Associates an Identity and Access Management (IAM) role with an Neptune DB cluster.
*
*
*
* This is a convenience which creates an instance of the {@link AddRoleToDbClusterRequest.Builder} avoiding the
* need to create one manually via {@link AddRoleToDbClusterRequest#builder()}
*
*
* @param addRoleToDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.AddRoleToDbClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the AddRoleToDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbClusterRoleAlreadyExistsException The specified IAM role Amazon Resource Name (ARN) is already
* associated with the specified DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterRoleQuotaExceededException You have exceeded the maximum number of IAM roles that can be
* associated with the specified DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.AddRoleToDBCluster
* @see AWS
* API Documentation
*/
default CompletableFuture addRoleToDBCluster(
Consumer addRoleToDbClusterRequest) {
return addRoleToDBCluster(AddRoleToDbClusterRequest.builder().applyMutation(addRoleToDbClusterRequest).build());
}
/**
*
* Adds a source identifier to an existing event notification subscription.
*
*
* @param addSourceIdentifierToSubscriptionRequest
* @return A Java Future containing the result of the AddSourceIdentifierToSubscription operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SourceNotFoundException The source could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.AddSourceIdentifierToSubscription
* @see AWS API Documentation
*/
default CompletableFuture addSourceIdentifierToSubscription(
AddSourceIdentifierToSubscriptionRequest addSourceIdentifierToSubscriptionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds a source identifier to an existing event notification subscription.
*
*
*
* This is a convenience which creates an instance of the {@link AddSourceIdentifierToSubscriptionRequest.Builder}
* avoiding the need to create one manually via {@link AddSourceIdentifierToSubscriptionRequest#builder()}
*
*
* @param addSourceIdentifierToSubscriptionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.AddSourceIdentifierToSubscriptionRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the AddSourceIdentifierToSubscription operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SourceNotFoundException The source could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.AddSourceIdentifierToSubscription
* @see AWS API Documentation
*/
default CompletableFuture addSourceIdentifierToSubscription(
Consumer addSourceIdentifierToSubscriptionRequest) {
return addSourceIdentifierToSubscription(AddSourceIdentifierToSubscriptionRequest.builder()
.applyMutation(addSourceIdentifierToSubscriptionRequest).build());
}
/**
*
* 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 A Java Future containing the result of the AddTagsToResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.AddTagsToResource
* @see AWS API
* Documentation
*/
default CompletableFuture addTagsToResource(AddTagsToResourceRequest addTagsToResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link AddTagsToResourceRequest.Builder} avoiding the need
* to create one manually via {@link AddTagsToResourceRequest#builder()}
*
*
* @param addTagsToResourceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.AddTagsToResourceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the AddTagsToResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.AddTagsToResource
* @see AWS API
* Documentation
*/
default CompletableFuture addTagsToResource(
Consumer addTagsToResourceRequest) {
return addTagsToResource(AddTagsToResourceRequest.builder().applyMutation(addTagsToResourceRequest).build());
}
/**
*
* Applies a pending maintenance action to a resource (for example, to a DB instance).
*
*
* @param applyPendingMaintenanceActionRequest
* @return A Java Future containing the result of the ApplyPendingMaintenanceAction operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ApplyPendingMaintenanceAction
* @see AWS API Documentation
*/
default CompletableFuture applyPendingMaintenanceAction(
ApplyPendingMaintenanceActionRequest applyPendingMaintenanceActionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Applies a pending maintenance action to a resource (for example, to a DB instance).
*
*
*
* This is a convenience which creates an instance of the {@link ApplyPendingMaintenanceActionRequest.Builder}
* avoiding the need to create one manually via {@link ApplyPendingMaintenanceActionRequest#builder()}
*
*
* @param applyPendingMaintenanceActionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ApplyPendingMaintenanceActionRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ApplyPendingMaintenanceAction operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ApplyPendingMaintenanceAction
* @see AWS API Documentation
*/
default CompletableFuture applyPendingMaintenanceAction(
Consumer applyPendingMaintenanceActionRequest) {
return applyPendingMaintenanceAction(ApplyPendingMaintenanceActionRequest.builder()
.applyMutation(applyPendingMaintenanceActionRequest).build());
}
/**
*
* Copies the specified DB cluster parameter group.
*
*
* @param copyDbClusterParameterGroupRequest
* @return A Java Future containing the result of the CopyDBClusterParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CopyDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture copyDBClusterParameterGroup(
CopyDbClusterParameterGroupRequest copyDbClusterParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Copies the specified DB cluster parameter group.
*
*
*
* This is a convenience which creates an instance of the {@link CopyDbClusterParameterGroupRequest.Builder}
* avoiding the need to create one manually via {@link CopyDbClusterParameterGroupRequest#builder()}
*
*
* @param copyDbClusterParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CopyDbClusterParameterGroupRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the CopyDBClusterParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CopyDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture copyDBClusterParameterGroup(
Consumer copyDbClusterParameterGroupRequest) {
return copyDBClusterParameterGroup(CopyDbClusterParameterGroupRequest.builder()
.applyMutation(copyDbClusterParameterGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the CopyDBClusterSnapshot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotAlreadyExistsException User already has a DB cluster snapshot with the given
* identifier.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CopyDBClusterSnapshot
* @see AWS
* API Documentation
*/
default CompletableFuture copyDBClusterSnapshot(
CopyDbClusterSnapshotRequest copyDbClusterSnapshotRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link CopyDbClusterSnapshotRequest.Builder} avoiding the
* need to create one manually via {@link CopyDbClusterSnapshotRequest#builder()}
*
*
* @param copyDbClusterSnapshotRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CopyDbClusterSnapshotRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CopyDBClusterSnapshot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotAlreadyExistsException User already has a DB cluster snapshot with the given
* identifier.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CopyDBClusterSnapshot
* @see AWS
* API Documentation
*/
default CompletableFuture copyDBClusterSnapshot(
Consumer copyDbClusterSnapshotRequest) {
return copyDBClusterSnapshot(CopyDbClusterSnapshotRequest.builder().applyMutation(copyDbClusterSnapshotRequest).build());
}
/**
*
* Copies the specified DB parameter group.
*
*
* @param copyDbParameterGroupRequest
* @return A Java Future containing the result of the CopyDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CopyDBParameterGroup
* @see AWS
* API Documentation
*/
default CompletableFuture copyDBParameterGroup(
CopyDbParameterGroupRequest copyDbParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Copies the specified DB parameter group.
*
*
*
* This is a convenience which creates an instance of the {@link CopyDbParameterGroupRequest.Builder} avoiding the
* need to create one manually via {@link CopyDbParameterGroupRequest#builder()}
*
*
* @param copyDbParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CopyDbParameterGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CopyDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CopyDBParameterGroup
* @see AWS
* API Documentation
*/
default CompletableFuture copyDBParameterGroup(
Consumer copyDbParameterGroupRequest) {
return copyDBParameterGroup(CopyDbParameterGroupRequest.builder().applyMutation(copyDbParameterGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the CreateDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - 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.
* - DbClusterQuotaExceededException User attempted to create a new DB cluster and the user has already
* reached the maximum allowed DB cluster quota.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbSubnetGroupStateException The DB subnet group cannot be deleted because it is in use.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture createDBCluster(CreateDbClusterRequest createDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link CreateDbClusterRequest.Builder} avoiding the need
* to create one manually via {@link CreateDbClusterRequest#builder()}
*
*
* @param createDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateDbClusterRequest.Builder} to create a request.
* @return A Java Future containing the result of the CreateDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - 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.
* - DbClusterQuotaExceededException User attempted to create a new DB cluster and the user has already
* reached the maximum allowed DB cluster quota.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbSubnetGroupStateException The DB subnet group cannot be deleted because it is in use.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture createDBCluster(
Consumer createDbClusterRequest) {
return createDBCluster(CreateDbClusterRequest.builder().applyMutation(createDbClusterRequest).build());
}
/**
*
* Creates a new custom endpoint and associates it with an Amazon Neptune DB cluster.
*
*
* @param createDbClusterEndpointRequest
* @return A Java Future containing the result of the CreateDBClusterEndpoint operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterEndpointQuotaExceededException The cluster already has the maximum number of custom
* endpoints.
* - DbClusterEndpointAlreadyExistsException The specified custom endpoint cannot be created because it
* already exists.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBClusterEndpoint
* @see AWS API Documentation
*/
default CompletableFuture createDBClusterEndpoint(
CreateDbClusterEndpointRequest createDbClusterEndpointRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a new custom endpoint and associates it with an Amazon Neptune DB cluster.
*
*
*
* This is a convenience which creates an instance of the {@link CreateDbClusterEndpointRequest.Builder} avoiding
* the need to create one manually via {@link CreateDbClusterEndpointRequest#builder()}
*
*
* @param createDbClusterEndpointRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateDbClusterEndpointRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateDBClusterEndpoint operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterEndpointQuotaExceededException The cluster already has the maximum number of custom
* endpoints.
* - DbClusterEndpointAlreadyExistsException The specified custom endpoint cannot be created because it
* already exists.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBClusterEndpoint
* @see AWS API Documentation
*/
default CompletableFuture createDBClusterEndpoint(
Consumer createDbClusterEndpointRequest) {
return createDBClusterEndpoint(CreateDbClusterEndpointRequest.builder().applyMutation(createDbClusterEndpointRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the CreateDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture createDBClusterParameterGroup(
CreateDbClusterParameterGroupRequest createDbClusterParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link CreateDbClusterParameterGroupRequest.Builder}
* avoiding the need to create one manually via {@link CreateDbClusterParameterGroupRequest#builder()}
*
*
* @param createDbClusterParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateDbClusterParameterGroupRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the CreateDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture createDBClusterParameterGroup(
Consumer createDbClusterParameterGroupRequest) {
return createDBClusterParameterGroup(CreateDbClusterParameterGroupRequest.builder()
.applyMutation(createDbClusterParameterGroupRequest).build());
}
/**
*
* Creates a snapshot of a DB cluster.
*
*
* @param createDbClusterSnapshotRequest
* @return A Java Future containing the result of the CreateDBClusterSnapshot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotAlreadyExistsException User already has a DB cluster snapshot with the given
* identifier.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBClusterSnapshot
* @see AWS API Documentation
*/
default CompletableFuture createDBClusterSnapshot(
CreateDbClusterSnapshotRequest createDbClusterSnapshotRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a snapshot of a DB cluster.
*
*
*
* This is a convenience which creates an instance of the {@link CreateDbClusterSnapshotRequest.Builder} avoiding
* the need to create one manually via {@link CreateDbClusterSnapshotRequest#builder()}
*
*
* @param createDbClusterSnapshotRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateDbClusterSnapshotRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateDBClusterSnapshot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotAlreadyExistsException User already has a DB cluster snapshot with the given
* identifier.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBClusterSnapshot
* @see AWS API Documentation
*/
default CompletableFuture createDBClusterSnapshot(
Consumer createDbClusterSnapshotRequest) {
return createDBClusterSnapshot(CreateDbClusterSnapshotRequest.builder().applyMutation(createDbClusterSnapshotRequest)
.build());
}
/**
*
* Creates a new DB instance.
*
*
* @param createDbInstanceRequest
* @return A Java Future containing the result of the CreateDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceAlreadyExistsException User already has a DB instance with the given identifier.
* - InsufficientDbInstanceCapacityException Specified DB instance class is not available in the specified
* Availability Zone.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - DbSecurityGroupNotFoundException DBSecurityGroupName does not refer to an existing DB security
* group.
* - InstanceQuotaExceededException Request would result in user exceeding the allowed number of DB
* instances.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - ProvisionedIopsNotAvailableInAzException Provisioned IOPS not available in the specified Availability
* Zone.
* - OptionGroupNotFoundException The designated option group could not be found.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - StorageTypeNotSupportedException StorageType specified cannot be associated with the DB
* Instance.
* - 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.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - DomainNotFoundException Domain does not refer to an existing Active Directory Domain.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture createDBInstance(CreateDbInstanceRequest createDbInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a new DB instance.
*
*
*
* This is a convenience which creates an instance of the {@link CreateDbInstanceRequest.Builder} avoiding the need
* to create one manually via {@link CreateDbInstanceRequest#builder()}
*
*
* @param createDbInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateDbInstanceRequest.Builder} to create a request.
* @return A Java Future containing the result of the CreateDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceAlreadyExistsException User already has a DB instance with the given identifier.
* - InsufficientDbInstanceCapacityException Specified DB instance class is not available in the specified
* Availability Zone.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - DbSecurityGroupNotFoundException DBSecurityGroupName does not refer to an existing DB security
* group.
* - InstanceQuotaExceededException Request would result in user exceeding the allowed number of DB
* instances.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - ProvisionedIopsNotAvailableInAzException Provisioned IOPS not available in the specified Availability
* Zone.
* - OptionGroupNotFoundException The designated option group could not be found.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - StorageTypeNotSupportedException StorageType specified cannot be associated with the DB
* Instance.
* - 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.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - DomainNotFoundException Domain does not refer to an existing Active Directory Domain.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture createDBInstance(
Consumer createDbInstanceRequest) {
return createDBInstance(CreateDbInstanceRequest.builder().applyMutation(createDbInstanceRequest).build());
}
/**
*
* 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 A Java Future containing the result of the CreateDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture createDBParameterGroup(
CreateDbParameterGroupRequest createDbParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link CreateDbParameterGroupRequest.Builder} avoiding the
* need to create one manually via {@link CreateDbParameterGroupRequest#builder()}
*
*
* @param createDbParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateDbParameterGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupQuotaExceededException Request would result in user exceeding the allowed number of
* DB parameter groups.
* - DbParameterGroupAlreadyExistsException A DB parameter group with the same name exists.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture createDBParameterGroup(
Consumer createDbParameterGroupRequest) {
return createDBParameterGroup(CreateDbParameterGroupRequest.builder().applyMutation(createDbParameterGroupRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the CreateDBSubnetGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupAlreadyExistsException DBSubnetGroupName is already used by an existing DB subnet
* group.
* - DbSubnetGroupQuotaExceededException Request would result in user exceeding the allowed number of DB
* subnet groups.
* - DbSubnetQuotaExceededException Request would result in user exceeding the allowed number of subnets
* in a DB subnet groups.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBSubnetGroup
* @see AWS
* API Documentation
*/
default CompletableFuture createDBSubnetGroup(
CreateDbSubnetGroupRequest createDbSubnetGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a new DB subnet group. DB subnet groups must contain at least one subnet in at least two AZs in the
* Amazon Region.
*
*
*
* This is a convenience which creates an instance of the {@link CreateDbSubnetGroupRequest.Builder} avoiding the
* need to create one manually via {@link CreateDbSubnetGroupRequest#builder()}
*
*
* @param createDbSubnetGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateDbSubnetGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateDBSubnetGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupAlreadyExistsException DBSubnetGroupName is already used by an existing DB subnet
* group.
* - DbSubnetGroupQuotaExceededException Request would result in user exceeding the allowed number of DB
* subnet groups.
* - DbSubnetQuotaExceededException Request would result in user exceeding the allowed number of subnets
* in a DB subnet groups.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateDBSubnetGroup
* @see AWS
* API Documentation
*/
default CompletableFuture createDBSubnetGroup(
Consumer createDbSubnetGroupRequest) {
return createDBSubnetGroup(CreateDbSubnetGroupRequest.builder().applyMutation(createDbSubnetGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the CreateEventSubscription operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - EventSubscriptionQuotaExceededException You have exceeded the number of events you can subscribe to.
* - SubscriptionAlreadyExistException This subscription already exists.
* - SnsInvalidTopicException The SNS topic is invalid.
* - SnsNoAuthorizationException There is no SNS authorization.
* - SnsTopicArnNotFoundException The ARN of the SNS topic could not be found.
* - SubscriptionCategoryNotFoundException The designated subscription category could not be found.
* - SourceNotFoundException The source could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateEventSubscription
* @see AWS API Documentation
*/
default CompletableFuture createEventSubscription(
CreateEventSubscriptionRequest createEventSubscriptionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link CreateEventSubscriptionRequest.Builder} avoiding
* the need to create one manually via {@link CreateEventSubscriptionRequest#builder()}
*
*
* @param createEventSubscriptionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateEventSubscriptionRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateEventSubscription operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - EventSubscriptionQuotaExceededException You have exceeded the number of events you can subscribe to.
* - SubscriptionAlreadyExistException This subscription already exists.
* - SnsInvalidTopicException The SNS topic is invalid.
* - SnsNoAuthorizationException There is no SNS authorization.
* - SnsTopicArnNotFoundException The ARN of the SNS topic could not be found.
* - SubscriptionCategoryNotFoundException The designated subscription category could not be found.
* - SourceNotFoundException The source could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateEventSubscription
* @see AWS API Documentation
*/
default CompletableFuture createEventSubscription(
Consumer createEventSubscriptionRequest) {
return createEventSubscription(CreateEventSubscriptionRequest.builder().applyMutation(createEventSubscriptionRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the CreateGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterAlreadyExistsException The
GlobalClusterIdentifier already exists. Choose a
* new global database identifier (unique name) to create a new global database cluster.
* - GlobalClusterQuotaExceededException The number of global database clusters for this account is
* already at the maximum allowed.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture createGlobalCluster(
CreateGlobalClusterRequest createGlobalClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link CreateGlobalClusterRequest.Builder} avoiding the
* need to create one manually via {@link CreateGlobalClusterRequest#builder()}
*
*
* @param createGlobalClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.CreateGlobalClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterAlreadyExistsException The
GlobalClusterIdentifier already exists. Choose a
* new global database identifier (unique name) to create a new global database cluster.
* - GlobalClusterQuotaExceededException The number of global database clusters for this account is
* already at the maximum allowed.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.CreateGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture createGlobalCluster(
Consumer createGlobalClusterRequest) {
return createGlobalCluster(CreateGlobalClusterRequest.builder().applyMutation(createGlobalClusterRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DeleteDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterSnapshotAlreadyExistsException User already has a DB cluster snapshot with the given
* identifier.
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture deleteDBCluster(DeleteDbClusterRequest deleteDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteDbClusterRequest.Builder} avoiding the need
* to create one manually via {@link DeleteDbClusterRequest#builder()}
*
*
* @param deleteDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteDbClusterRequest.Builder} to create a request.
* @return A Java Future containing the result of the DeleteDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterSnapshotAlreadyExistsException User already has a DB cluster snapshot with the given
* identifier.
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture deleteDBCluster(
Consumer deleteDbClusterRequest) {
return deleteDBCluster(DeleteDbClusterRequest.builder().applyMutation(deleteDbClusterRequest).build());
}
/**
*
* Deletes a custom endpoint and removes it from an Amazon Neptune DB cluster.
*
*
* @param deleteDbClusterEndpointRequest
* @return A Java Future containing the result of the DeleteDBClusterEndpoint operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbClusterEndpointStateException The requested operation cannot be performed on the endpoint
* while the endpoint is in this state.
* - DbClusterEndpointNotFoundException The specified custom endpoint doesn't exist.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBClusterEndpoint
* @see AWS API Documentation
*/
default CompletableFuture deleteDBClusterEndpoint(
DeleteDbClusterEndpointRequest deleteDbClusterEndpointRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a custom endpoint and removes it from an Amazon Neptune DB cluster.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteDbClusterEndpointRequest.Builder} avoiding
* the need to create one manually via {@link DeleteDbClusterEndpointRequest#builder()}
*
*
* @param deleteDbClusterEndpointRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteDbClusterEndpointRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteDBClusterEndpoint operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbClusterEndpointStateException The requested operation cannot be performed on the endpoint
* while the endpoint is in this state.
* - DbClusterEndpointNotFoundException The specified custom endpoint doesn't exist.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBClusterEndpoint
* @see AWS API Documentation
*/
default CompletableFuture deleteDBClusterEndpoint(
Consumer deleteDbClusterEndpointRequest) {
return deleteDBClusterEndpoint(DeleteDbClusterEndpointRequest.builder().applyMutation(deleteDbClusterEndpointRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the DeleteDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture deleteDBClusterParameterGroup(
DeleteDbClusterParameterGroupRequest deleteDbClusterParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a specified DB cluster parameter group. The DB cluster parameter group to be deleted can't be associated
* with any DB clusters.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteDbClusterParameterGroupRequest.Builder}
* avoiding the need to create one manually via {@link DeleteDbClusterParameterGroupRequest#builder()}
*
*
* @param deleteDbClusterParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteDbClusterParameterGroupRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the DeleteDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture deleteDBClusterParameterGroup(
Consumer deleteDbClusterParameterGroupRequest) {
return deleteDBClusterParameterGroup(DeleteDbClusterParameterGroupRequest.builder()
.applyMutation(deleteDbClusterParameterGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DeleteDBClusterSnapshot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBClusterSnapshot
* @see AWS API Documentation
*/
default CompletableFuture deleteDBClusterSnapshot(
DeleteDbClusterSnapshotRequest deleteDbClusterSnapshotRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteDbClusterSnapshotRequest.Builder} avoiding
* the need to create one manually via {@link DeleteDbClusterSnapshotRequest#builder()}
*
*
* @param deleteDbClusterSnapshotRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteDbClusterSnapshotRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteDBClusterSnapshot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBClusterSnapshot
* @see AWS API Documentation
*/
default CompletableFuture deleteDBClusterSnapshot(
Consumer deleteDbClusterSnapshotRequest) {
return deleteDBClusterSnapshot(DeleteDbClusterSnapshotRequest.builder().applyMutation(deleteDbClusterSnapshotRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the DeleteDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbSnapshotAlreadyExistsException DBSnapshotIdentifier is already used by an existing snapshot.
*
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture deleteDBInstance(DeleteDbInstanceRequest deleteDbInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteDbInstanceRequest.Builder} avoiding the need
* to create one manually via {@link DeleteDbInstanceRequest#builder()}
*
*
* @param deleteDbInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteDbInstanceRequest.Builder} to create a request.
* @return A Java Future containing the result of the DeleteDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbSnapshotAlreadyExistsException DBSnapshotIdentifier is already used by an existing snapshot.
*
* - SnapshotQuotaExceededException Request would result in user exceeding the allowed number of DB
* snapshots.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture deleteDBInstance(
Consumer deleteDbInstanceRequest) {
return deleteDBInstance(DeleteDbInstanceRequest.builder().applyMutation(deleteDbInstanceRequest).build());
}
/**
*
* Deletes a specified DBParameterGroup. The DBParameterGroup to be deleted can't be associated with any DB
* instances.
*
*
* @param deleteDbParameterGroupRequest
* @return A Java Future containing the result of the DeleteDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture deleteDBParameterGroup(
DeleteDbParameterGroupRequest deleteDbParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a specified DBParameterGroup. The DBParameterGroup to be deleted can't be associated with any DB
* instances.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteDbParameterGroupRequest.Builder} avoiding the
* need to create one manually via {@link DeleteDbParameterGroupRequest#builder()}
*
*
* @param deleteDbParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteDbParameterGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture deleteDBParameterGroup(
Consumer deleteDbParameterGroupRequest) {
return deleteDBParameterGroup(DeleteDbParameterGroupRequest.builder().applyMutation(deleteDbParameterGroupRequest)
.build());
}
/**
*
* Deletes a DB subnet group.
*
*
*
* The specified database subnet group must not be associated with any DB instances.
*
*
*
* @param deleteDbSubnetGroupRequest
* @return A Java Future containing the result of the DeleteDBSubnetGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbSubnetGroupStateException The DB subnet group cannot be deleted because it is in use.
* - InvalidDbSubnetStateException The DB subnet is not in the available state.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBSubnetGroup
* @see AWS
* API Documentation
*/
default CompletableFuture deleteDBSubnetGroup(
DeleteDbSubnetGroupRequest deleteDbSubnetGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a DB subnet group.
*
*
*
* The specified database subnet group must not be associated with any DB instances.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteDbSubnetGroupRequest.Builder} avoiding the
* need to create one manually via {@link DeleteDbSubnetGroupRequest#builder()}
*
*
* @param deleteDbSubnetGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteDbSubnetGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteDBSubnetGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbSubnetGroupStateException The DB subnet group cannot be deleted because it is in use.
* - InvalidDbSubnetStateException The DB subnet is not in the available state.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteDBSubnetGroup
* @see AWS
* API Documentation
*/
default CompletableFuture deleteDBSubnetGroup(
Consumer deleteDbSubnetGroupRequest) {
return deleteDBSubnetGroup(DeleteDbSubnetGroupRequest.builder().applyMutation(deleteDbSubnetGroupRequest).build());
}
/**
*
* Deletes an event notification subscription.
*
*
* @param deleteEventSubscriptionRequest
* @return A Java Future containing the result of the DeleteEventSubscription operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - InvalidEventSubscriptionStateException The event subscription is in an invalid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteEventSubscription
* @see AWS API Documentation
*/
default CompletableFuture deleteEventSubscription(
DeleteEventSubscriptionRequest deleteEventSubscriptionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes an event notification subscription.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteEventSubscriptionRequest.Builder} avoiding
* the need to create one manually via {@link DeleteEventSubscriptionRequest#builder()}
*
*
* @param deleteEventSubscriptionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteEventSubscriptionRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteEventSubscription operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - InvalidEventSubscriptionStateException The event subscription is in an invalid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteEventSubscription
* @see AWS API Documentation
*/
default CompletableFuture deleteEventSubscription(
Consumer deleteEventSubscriptionRequest) {
return deleteEventSubscription(DeleteEventSubscriptionRequest.builder().applyMutation(deleteEventSubscriptionRequest)
.build());
}
/**
*
* Deletes a global database. The primary and all secondary clusters must already be detached or deleted first.
*
*
* @param deleteGlobalClusterRequest
* @return A Java Future containing the result of the DeleteGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture deleteGlobalCluster(
DeleteGlobalClusterRequest deleteGlobalClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a global database. The primary and all secondary clusters must already be detached or deleted first.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteGlobalClusterRequest.Builder} avoiding the
* need to create one manually via {@link DeleteGlobalClusterRequest#builder()}
*
*
* @param deleteGlobalClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DeleteGlobalClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DeleteGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture deleteGlobalCluster(
Consumer deleteGlobalClusterRequest) {
return deleteGlobalCluster(DeleteGlobalClusterRequest.builder().applyMutation(deleteGlobalClusterRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DescribeDBClusterEndpoints operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterEndpoints
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterEndpoints(
DescribeDbClusterEndpointsRequest describeDbClusterEndpointsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about endpoints for an Amazon Neptune DB cluster.
*
*
*
* This operation can also return information for Amazon RDS clusters and Amazon DocDB clusters.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterEndpointsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbClusterEndpointsRequest#builder()}
*
*
* @param describeDbClusterEndpointsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the DescribeDBClusterEndpoints operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterEndpoints
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterEndpoints(
Consumer describeDbClusterEndpointsRequest) {
return describeDBClusterEndpoints(DescribeDbClusterEndpointsRequest.builder()
.applyMutation(describeDbClusterEndpointsRequest).build());
}
/**
*
* This is a variant of
* {@link #describeDBClusterEndpoints(software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterEndpointsPublisher publisher = client.describeDBClusterEndpointsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterEndpointsPublisher publisher = client.describeDBClusterEndpointsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterEndpoints(software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsRequest)}
* operation.
*
*
* @param describeDbClusterEndpointsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterEndpoints
* @see AWS API Documentation
*/
default DescribeDBClusterEndpointsPublisher describeDBClusterEndpointsPaginator(
DescribeDbClusterEndpointsRequest describeDbClusterEndpointsRequest) {
return new DescribeDBClusterEndpointsPublisher(this, describeDbClusterEndpointsRequest);
}
/**
*
* This is a variant of
* {@link #describeDBClusterEndpoints(software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterEndpointsPublisher publisher = client.describeDBClusterEndpointsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterEndpointsPublisher publisher = client.describeDBClusterEndpointsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterEndpoints(software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterEndpointsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbClusterEndpointsRequest#builder()}
*
*
* @param describeDbClusterEndpointsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterEndpointsRequest.Builder} to create
* a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterEndpoints
* @see AWS API Documentation
*/
default DescribeDBClusterEndpointsPublisher describeDBClusterEndpointsPaginator(
Consumer describeDbClusterEndpointsRequest) {
return describeDBClusterEndpointsPaginator(DescribeDbClusterEndpointsRequest.builder()
.applyMutation(describeDbClusterEndpointsRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DescribeDBClusterParameterGroups operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameterGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterParameterGroups(
DescribeDbClusterParameterGroupsRequest describeDbClusterParameterGroupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterParameterGroupsRequest.Builder}
* avoiding the need to create one manually via {@link DescribeDbClusterParameterGroupsRequest#builder()}
*
*
* @param describeDbClusterParameterGroupsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the DescribeDBClusterParameterGroups operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameterGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterParameterGroups(
Consumer describeDbClusterParameterGroupsRequest) {
return describeDBClusterParameterGroups(DescribeDbClusterParameterGroupsRequest.builder()
.applyMutation(describeDbClusterParameterGroupsRequest).build());
}
/**
*
* 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.
*
*
* @return A Java Future containing the result of the DescribeDBClusterParameterGroups operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameterGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterParameterGroups() {
return describeDBClusterParameterGroups(DescribeDbClusterParameterGroupsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBClusterParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParameterGroupsPublisher publisher = client.describeDBClusterParameterGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParameterGroupsPublisher publisher = client.describeDBClusterParameterGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameterGroups
* @see AWS API Documentation
*/
default DescribeDBClusterParameterGroupsPublisher describeDBClusterParameterGroupsPaginator() {
return describeDBClusterParameterGroupsPaginator(DescribeDbClusterParameterGroupsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBClusterParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParameterGroupsPublisher publisher = client.describeDBClusterParameterGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParameterGroupsPublisher publisher = client.describeDBClusterParameterGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest)}
* operation.
*
*
* @param describeDbClusterParameterGroupsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameterGroups
* @see AWS API Documentation
*/
default DescribeDBClusterParameterGroupsPublisher describeDBClusterParameterGroupsPaginator(
DescribeDbClusterParameterGroupsRequest describeDbClusterParameterGroupsRequest) {
return new DescribeDBClusterParameterGroupsPublisher(this, describeDbClusterParameterGroupsRequest);
}
/**
*
* This is a variant of
* {@link #describeDBClusterParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParameterGroupsPublisher publisher = client.describeDBClusterParameterGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParameterGroupsPublisher publisher = client.describeDBClusterParameterGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterParameterGroupsRequest.Builder}
* avoiding the need to create one manually via {@link DescribeDbClusterParameterGroupsRequest#builder()}
*
*
* @param describeDbClusterParameterGroupsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterParameterGroupsRequest.Builder} to
* create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameterGroups
* @see AWS API Documentation
*/
default DescribeDBClusterParameterGroupsPublisher describeDBClusterParameterGroupsPaginator(
Consumer describeDbClusterParameterGroupsRequest) {
return describeDBClusterParameterGroupsPaginator(DescribeDbClusterParameterGroupsRequest.builder()
.applyMutation(describeDbClusterParameterGroupsRequest).build());
}
/**
*
* Returns the detailed parameter list for a particular DB cluster parameter group.
*
*
* @param describeDbClusterParametersRequest
* @return A Java Future containing the result of the DescribeDBClusterParameters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameters
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterParameters(
DescribeDbClusterParametersRequest describeDbClusterParametersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the detailed parameter list for a particular DB cluster parameter group.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterParametersRequest.Builder}
* avoiding the need to create one manually via {@link DescribeDbClusterParametersRequest#builder()}
*
*
* @param describeDbClusterParametersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the DescribeDBClusterParameters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameters
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterParameters(
Consumer describeDbClusterParametersRequest) {
return describeDBClusterParameters(DescribeDbClusterParametersRequest.builder()
.applyMutation(describeDbClusterParametersRequest).build());
}
/**
*
* This is a variant of
* {@link #describeDBClusterParameters(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParametersPublisher publisher = client.describeDBClusterParametersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParametersPublisher publisher = client.describeDBClusterParametersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterParameters(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersRequest)}
* operation.
*
*
* @param describeDbClusterParametersRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameters
* @see AWS API Documentation
*/
default DescribeDBClusterParametersPublisher describeDBClusterParametersPaginator(
DescribeDbClusterParametersRequest describeDbClusterParametersRequest) {
return new DescribeDBClusterParametersPublisher(this, describeDbClusterParametersRequest);
}
/**
*
* This is a variant of
* {@link #describeDBClusterParameters(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParametersPublisher publisher = client.describeDBClusterParametersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterParametersPublisher publisher = client.describeDBClusterParametersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterParameters(software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterParametersRequest.Builder}
* avoiding the need to create one manually via {@link DescribeDbClusterParametersRequest#builder()}
*
*
* @param describeDbClusterParametersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterParametersRequest.Builder} to create
* a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterParameters
* @see AWS API Documentation
*/
default DescribeDBClusterParametersPublisher describeDBClusterParametersPaginator(
Consumer describeDbClusterParametersRequest) {
return describeDBClusterParametersPaginator(DescribeDbClusterParametersRequest.builder()
.applyMutation(describeDbClusterParametersRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DescribeDBClusterSnapshotAttributes operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshotAttributes
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterSnapshotAttributes(
DescribeDbClusterSnapshotAttributesRequest describeDbClusterSnapshotAttributesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterSnapshotAttributesRequest.Builder}
* avoiding the need to create one manually via {@link DescribeDbClusterSnapshotAttributesRequest#builder()}
*
*
* @param describeDbClusterSnapshotAttributesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotAttributesRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the DescribeDBClusterSnapshotAttributes operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshotAttributes
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterSnapshotAttributes(
Consumer describeDbClusterSnapshotAttributesRequest) {
return describeDBClusterSnapshotAttributes(DescribeDbClusterSnapshotAttributesRequest.builder()
.applyMutation(describeDbClusterSnapshotAttributesRequest).build());
}
/**
*
* Returns information about DB cluster snapshots. This API action supports pagination.
*
*
* @param describeDbClusterSnapshotsRequest
* @return A Java Future containing the result of the DescribeDBClusterSnapshots operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshots
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterSnapshots(
DescribeDbClusterSnapshotsRequest describeDbClusterSnapshotsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about DB cluster snapshots. This API action supports pagination.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterSnapshotsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbClusterSnapshotsRequest#builder()}
*
*
* @param describeDbClusterSnapshotsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the DescribeDBClusterSnapshots operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshots
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterSnapshots(
Consumer describeDbClusterSnapshotsRequest) {
return describeDBClusterSnapshots(DescribeDbClusterSnapshotsRequest.builder()
.applyMutation(describeDbClusterSnapshotsRequest).build());
}
/**
*
* Returns information about DB cluster snapshots. This API action supports pagination.
*
*
* @return A Java Future containing the result of the DescribeDBClusterSnapshots operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshots
* @see AWS API Documentation
*/
default CompletableFuture describeDBClusterSnapshots() {
return describeDBClusterSnapshots(DescribeDbClusterSnapshotsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBClusterSnapshots(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterSnapshotsPublisher publisher = client.describeDBClusterSnapshotsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterSnapshotsPublisher publisher = client.describeDBClusterSnapshotsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterSnapshots(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshots
* @see AWS API Documentation
*/
default DescribeDBClusterSnapshotsPublisher describeDBClusterSnapshotsPaginator() {
return describeDBClusterSnapshotsPaginator(DescribeDbClusterSnapshotsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBClusterSnapshots(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterSnapshotsPublisher publisher = client.describeDBClusterSnapshotsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterSnapshotsPublisher publisher = client.describeDBClusterSnapshotsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterSnapshots(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest)}
* operation.
*
*
* @param describeDbClusterSnapshotsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshots
* @see AWS API Documentation
*/
default DescribeDBClusterSnapshotsPublisher describeDBClusterSnapshotsPaginator(
DescribeDbClusterSnapshotsRequest describeDbClusterSnapshotsRequest) {
return new DescribeDBClusterSnapshotsPublisher(this, describeDbClusterSnapshotsRequest);
}
/**
*
* This is a variant of
* {@link #describeDBClusterSnapshots(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterSnapshotsPublisher publisher = client.describeDBClusterSnapshotsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClusterSnapshotsPublisher publisher = client.describeDBClusterSnapshotsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusterSnapshots(software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClusterSnapshotsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbClusterSnapshotsRequest#builder()}
*
*
* @param describeDbClusterSnapshotsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClusterSnapshotsRequest.Builder} to create
* a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusterSnapshots
* @see AWS API Documentation
*/
default DescribeDBClusterSnapshotsPublisher describeDBClusterSnapshotsPaginator(
Consumer describeDbClusterSnapshotsRequest) {
return describeDBClusterSnapshotsPaginator(DescribeDbClusterSnapshotsRequest.builder()
.applyMutation(describeDbClusterSnapshotsRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DescribeDBClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusters
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBClusters(DescribeDbClustersRequest describeDbClustersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about provisioned DB clusters, and supports pagination.
*
*
*
* This operation can also return information for Amazon RDS clusters and Amazon DocDB clusters.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClustersRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbClustersRequest#builder()}
*
*
* @param describeDbClustersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeDBClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusters
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBClusters(
Consumer describeDbClustersRequest) {
return describeDBClusters(DescribeDbClustersRequest.builder().applyMutation(describeDbClustersRequest).build());
}
/**
*
* Returns information about provisioned DB clusters, and supports pagination.
*
*
*
* This operation can also return information for Amazon RDS clusters and Amazon DocDB clusters.
*
*
*
* @return A Java Future containing the result of the DescribeDBClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusters
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBClusters() {
return describeDBClusters(DescribeDbClustersRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBClusters(software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClustersPublisher publisher = client.describeDBClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClustersPublisher publisher = client.describeDBClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusters(software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusters
* @see AWS
* API Documentation
*/
default DescribeDBClustersPublisher describeDBClustersPaginator() {
return describeDBClustersPaginator(DescribeDbClustersRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBClusters(software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClustersPublisher publisher = client.describeDBClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClustersPublisher publisher = client.describeDBClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusters(software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest)}
* operation.
*
*
* @param describeDbClustersRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusters
* @see AWS
* API Documentation
*/
default DescribeDBClustersPublisher describeDBClustersPaginator(DescribeDbClustersRequest describeDbClustersRequest) {
return new DescribeDBClustersPublisher(this, describeDbClustersRequest);
}
/**
*
* This is a variant of
* {@link #describeDBClusters(software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClustersPublisher publisher = client.describeDBClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBClustersPublisher publisher = client.describeDBClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBClusters(software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbClustersRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbClustersRequest#builder()}
*
*
* @param describeDbClustersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbClustersRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBClusters
* @see AWS
* API Documentation
*/
default DescribeDBClustersPublisher describeDBClustersPaginator(
Consumer describeDbClustersRequest) {
return describeDBClustersPaginator(DescribeDbClustersRequest.builder().applyMutation(describeDbClustersRequest).build());
}
/**
*
* Returns a list of the available DB engines.
*
*
* @param describeDbEngineVersionsRequest
* @return A Java Future containing the result of the DescribeDBEngineVersions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBEngineVersions
* @see AWS API Documentation
*/
default CompletableFuture describeDBEngineVersions(
DescribeDbEngineVersionsRequest describeDbEngineVersionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of the available DB engines.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbEngineVersionsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbEngineVersionsRequest#builder()}
*
*
* @param describeDbEngineVersionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeDBEngineVersions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBEngineVersions
* @see AWS API Documentation
*/
default CompletableFuture describeDBEngineVersions(
Consumer describeDbEngineVersionsRequest) {
return describeDBEngineVersions(DescribeDbEngineVersionsRequest.builder().applyMutation(describeDbEngineVersionsRequest)
.build());
}
/**
*
* Returns a list of the available DB engines.
*
*
* @return A Java Future containing the result of the DescribeDBEngineVersions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBEngineVersions
* @see AWS API Documentation
*/
default CompletableFuture describeDBEngineVersions() {
return describeDBEngineVersions(DescribeDbEngineVersionsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBEngineVersions(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBEngineVersionsPublisher publisher = client.describeDBEngineVersionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBEngineVersionsPublisher publisher = client.describeDBEngineVersionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBEngineVersions(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBEngineVersions
* @see AWS API Documentation
*/
default DescribeDBEngineVersionsPublisher describeDBEngineVersionsPaginator() {
return describeDBEngineVersionsPaginator(DescribeDbEngineVersionsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBEngineVersions(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBEngineVersionsPublisher publisher = client.describeDBEngineVersionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBEngineVersionsPublisher publisher = client.describeDBEngineVersionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBEngineVersions(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest)}
* operation.
*
*
* @param describeDbEngineVersionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBEngineVersions
* @see AWS API Documentation
*/
default DescribeDBEngineVersionsPublisher describeDBEngineVersionsPaginator(
DescribeDbEngineVersionsRequest describeDbEngineVersionsRequest) {
return new DescribeDBEngineVersionsPublisher(this, describeDbEngineVersionsRequest);
}
/**
*
* This is a variant of
* {@link #describeDBEngineVersions(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBEngineVersionsPublisher publisher = client.describeDBEngineVersionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBEngineVersionsPublisher publisher = client.describeDBEngineVersionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBEngineVersions(software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbEngineVersionsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbEngineVersionsRequest#builder()}
*
*
* @param describeDbEngineVersionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbEngineVersionsRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBEngineVersions
* @see AWS API Documentation
*/
default DescribeDBEngineVersionsPublisher describeDBEngineVersionsPaginator(
Consumer describeDbEngineVersionsRequest) {
return describeDBEngineVersionsPaginator(DescribeDbEngineVersionsRequest.builder()
.applyMutation(describeDbEngineVersionsRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DescribeDBInstances operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBInstances
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBInstances(
DescribeDbInstancesRequest describeDbInstancesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about provisioned instances, and supports pagination.
*
*
*
* This operation can also return information for Amazon RDS instances and Amazon DocDB instances.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbInstancesRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbInstancesRequest#builder()}
*
*
* @param describeDbInstancesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeDBInstances operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBInstances
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBInstances(
Consumer describeDbInstancesRequest) {
return describeDBInstances(DescribeDbInstancesRequest.builder().applyMutation(describeDbInstancesRequest).build());
}
/**
*
* Returns information about provisioned instances, and supports pagination.
*
*
*
* This operation can also return information for Amazon RDS instances and Amazon DocDB instances.
*
*
*
* @return A Java Future containing the result of the DescribeDBInstances operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBInstances
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBInstances() {
return describeDBInstances(DescribeDbInstancesRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBInstances(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBInstancesPublisher publisher = client.describeDBInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBInstancesPublisher publisher = client.describeDBInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBInstances(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBInstances
* @see AWS
* API Documentation
*/
default DescribeDBInstancesPublisher describeDBInstancesPaginator() {
return describeDBInstancesPaginator(DescribeDbInstancesRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBInstances(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBInstancesPublisher publisher = client.describeDBInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBInstancesPublisher publisher = client.describeDBInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBInstances(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest)}
* operation.
*
*
* @param describeDbInstancesRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBInstances
* @see AWS
* API Documentation
*/
default DescribeDBInstancesPublisher describeDBInstancesPaginator(DescribeDbInstancesRequest describeDbInstancesRequest) {
return new DescribeDBInstancesPublisher(this, describeDbInstancesRequest);
}
/**
*
* This is a variant of
* {@link #describeDBInstances(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBInstancesPublisher publisher = client.describeDBInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBInstancesPublisher publisher = client.describeDBInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBInstances(software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbInstancesRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbInstancesRequest#builder()}
*
*
* @param describeDbInstancesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbInstancesRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBInstances
* @see AWS
* API Documentation
*/
default DescribeDBInstancesPublisher describeDBInstancesPaginator(
Consumer describeDbInstancesRequest) {
return describeDBInstancesPaginator(DescribeDbInstancesRequest.builder().applyMutation(describeDbInstancesRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the DescribeDBParameterGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameterGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBParameterGroups(
DescribeDbParameterGroupsRequest describeDbParameterGroupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of DBParameterGroup descriptions. If a DBParameterGroupName is
* specified, the list will contain only the description of the specified DB parameter group.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbParameterGroupsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbParameterGroupsRequest#builder()}
*
*
* @param describeDbParameterGroupsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeDBParameterGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameterGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBParameterGroups(
Consumer describeDbParameterGroupsRequest) {
return describeDBParameterGroups(DescribeDbParameterGroupsRequest.builder()
.applyMutation(describeDbParameterGroupsRequest).build());
}
/**
*
* Returns a list of DBParameterGroup descriptions. If a DBParameterGroupName is
* specified, the list will contain only the description of the specified DB parameter group.
*
*
* @return A Java Future containing the result of the DescribeDBParameterGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameterGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBParameterGroups() {
return describeDBParameterGroups(DescribeDbParameterGroupsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParameterGroupsPublisher publisher = client.describeDBParameterGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParameterGroupsPublisher publisher = client.describeDBParameterGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameterGroups
* @see AWS API Documentation
*/
default DescribeDBParameterGroupsPublisher describeDBParameterGroupsPaginator() {
return describeDBParameterGroupsPaginator(DescribeDbParameterGroupsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParameterGroupsPublisher publisher = client.describeDBParameterGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParameterGroupsPublisher publisher = client.describeDBParameterGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest)}
* operation.
*
*
* @param describeDbParameterGroupsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameterGroups
* @see AWS API Documentation
*/
default DescribeDBParameterGroupsPublisher describeDBParameterGroupsPaginator(
DescribeDbParameterGroupsRequest describeDbParameterGroupsRequest) {
return new DescribeDBParameterGroupsPublisher(this, describeDbParameterGroupsRequest);
}
/**
*
* This is a variant of
* {@link #describeDBParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParameterGroupsPublisher publisher = client.describeDBParameterGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParameterGroupsPublisher publisher = client.describeDBParameterGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBParameterGroups(software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbParameterGroupsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeDbParameterGroupsRequest#builder()}
*
*
* @param describeDbParameterGroupsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbParameterGroupsRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameterGroups
* @see AWS API Documentation
*/
default DescribeDBParameterGroupsPublisher describeDBParameterGroupsPaginator(
Consumer describeDbParameterGroupsRequest) {
return describeDBParameterGroupsPaginator(DescribeDbParameterGroupsRequest.builder()
.applyMutation(describeDbParameterGroupsRequest).build());
}
/**
*
* Returns the detailed parameter list for a particular DB parameter group.
*
*
* @param describeDbParametersRequest
* @return A Java Future containing the result of the DescribeDBParameters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameters
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBParameters(
DescribeDbParametersRequest describeDbParametersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the detailed parameter list for a particular DB parameter group.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbParametersRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbParametersRequest#builder()}
*
*
* @param describeDbParametersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbParametersRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeDBParameters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameters
* @see AWS
* API Documentation
*/
default CompletableFuture describeDBParameters(
Consumer describeDbParametersRequest) {
return describeDBParameters(DescribeDbParametersRequest.builder().applyMutation(describeDbParametersRequest).build());
}
/**
*
* This is a variant of
* {@link #describeDBParameters(software.amazon.awssdk.services.neptune.model.DescribeDbParametersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParametersPublisher publisher = client.describeDBParametersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParametersPublisher publisher = client.describeDBParametersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbParametersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBParameters(software.amazon.awssdk.services.neptune.model.DescribeDbParametersRequest)}
* operation.
*
*
* @param describeDbParametersRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameters
* @see AWS
* API Documentation
*/
default DescribeDBParametersPublisher describeDBParametersPaginator(DescribeDbParametersRequest describeDbParametersRequest) {
return new DescribeDBParametersPublisher(this, describeDbParametersRequest);
}
/**
*
* This is a variant of
* {@link #describeDBParameters(software.amazon.awssdk.services.neptune.model.DescribeDbParametersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParametersPublisher publisher = client.describeDBParametersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBParametersPublisher publisher = client.describeDBParametersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbParametersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBParameters(software.amazon.awssdk.services.neptune.model.DescribeDbParametersRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbParametersRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbParametersRequest#builder()}
*
*
* @param describeDbParametersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbParametersRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBParameters
* @see AWS
* API Documentation
*/
default DescribeDBParametersPublisher describeDBParametersPaginator(
Consumer describeDbParametersRequest) {
return describeDBParametersPaginator(DescribeDbParametersRequest.builder().applyMutation(describeDbParametersRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the DescribeDBSubnetGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBSubnetGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBSubnetGroups(
DescribeDbSubnetGroupsRequest describeDbSubnetGroupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbSubnetGroupsRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbSubnetGroupsRequest#builder()}
*
*
* @param describeDbSubnetGroupsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeDBSubnetGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBSubnetGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBSubnetGroups(
Consumer describeDbSubnetGroupsRequest) {
return describeDBSubnetGroups(DescribeDbSubnetGroupsRequest.builder().applyMutation(describeDbSubnetGroupsRequest)
.build());
}
/**
*
* 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.
*
*
* @return A Java Future containing the result of the DescribeDBSubnetGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBSubnetGroups
* @see AWS API Documentation
*/
default CompletableFuture describeDBSubnetGroups() {
return describeDBSubnetGroups(DescribeDbSubnetGroupsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBSubnetGroups(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBSubnetGroupsPublisher publisher = client.describeDBSubnetGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBSubnetGroupsPublisher publisher = client.describeDBSubnetGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBSubnetGroups(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBSubnetGroups
* @see AWS API Documentation
*/
default DescribeDBSubnetGroupsPublisher describeDBSubnetGroupsPaginator() {
return describeDBSubnetGroupsPaginator(DescribeDbSubnetGroupsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeDBSubnetGroups(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBSubnetGroupsPublisher publisher = client.describeDBSubnetGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBSubnetGroupsPublisher publisher = client.describeDBSubnetGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBSubnetGroups(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest)}
* operation.
*
*
* @param describeDbSubnetGroupsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBSubnetGroups
* @see AWS API Documentation
*/
default DescribeDBSubnetGroupsPublisher describeDBSubnetGroupsPaginator(
DescribeDbSubnetGroupsRequest describeDbSubnetGroupsRequest) {
return new DescribeDBSubnetGroupsPublisher(this, describeDbSubnetGroupsRequest);
}
/**
*
* This is a variant of
* {@link #describeDBSubnetGroups(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBSubnetGroupsPublisher publisher = client.describeDBSubnetGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeDBSubnetGroupsPublisher publisher = client.describeDBSubnetGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeDBSubnetGroups(software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeDbSubnetGroupsRequest.Builder} avoiding the
* need to create one manually via {@link DescribeDbSubnetGroupsRequest#builder()}
*
*
* @param describeDbSubnetGroupsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeDbSubnetGroupsRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeDBSubnetGroups
* @see AWS API Documentation
*/
default DescribeDBSubnetGroupsPublisher describeDBSubnetGroupsPaginator(
Consumer describeDbSubnetGroupsRequest) {
return describeDBSubnetGroupsPaginator(DescribeDbSubnetGroupsRequest.builder()
.applyMutation(describeDbSubnetGroupsRequest).build());
}
/**
*
* Returns the default engine and system parameter information for the cluster database engine.
*
*
* @param describeEngineDefaultClusterParametersRequest
* @return A Java Future containing the result of the DescribeEngineDefaultClusterParameters operation returned by
* the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEngineDefaultClusterParameters
* @see AWS API Documentation
*/
default CompletableFuture describeEngineDefaultClusterParameters(
DescribeEngineDefaultClusterParametersRequest describeEngineDefaultClusterParametersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the default engine and system parameter information for the cluster database engine.
*
*
*
* This is a convenience which creates an instance of the
* {@link DescribeEngineDefaultClusterParametersRequest.Builder} avoiding the need to create one manually via
* {@link DescribeEngineDefaultClusterParametersRequest#builder()}
*
*
* @param describeEngineDefaultClusterParametersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultClusterParametersRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the DescribeEngineDefaultClusterParameters operation returned by
* the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEngineDefaultClusterParameters
* @see AWS API Documentation
*/
default CompletableFuture describeEngineDefaultClusterParameters(
Consumer describeEngineDefaultClusterParametersRequest) {
return describeEngineDefaultClusterParameters(DescribeEngineDefaultClusterParametersRequest.builder()
.applyMutation(describeEngineDefaultClusterParametersRequest).build());
}
/**
*
* Returns the default engine and system parameter information for the specified database engine.
*
*
* @param describeEngineDefaultParametersRequest
* @return A Java Future containing the result of the DescribeEngineDefaultParameters operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEngineDefaultParameters
* @see AWS API Documentation
*/
default CompletableFuture describeEngineDefaultParameters(
DescribeEngineDefaultParametersRequest describeEngineDefaultParametersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the default engine and system parameter information for the specified database engine.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeEngineDefaultParametersRequest.Builder}
* avoiding the need to create one manually via {@link DescribeEngineDefaultParametersRequest#builder()}
*
*
* @param describeEngineDefaultParametersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the DescribeEngineDefaultParameters operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEngineDefaultParameters
* @see AWS API Documentation
*/
default CompletableFuture describeEngineDefaultParameters(
Consumer describeEngineDefaultParametersRequest) {
return describeEngineDefaultParameters(DescribeEngineDefaultParametersRequest.builder()
.applyMutation(describeEngineDefaultParametersRequest).build());
}
/**
*
* This is a variant of
* {@link #describeEngineDefaultParameters(software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEngineDefaultParametersPublisher publisher = client.describeEngineDefaultParametersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEngineDefaultParametersPublisher publisher = client.describeEngineDefaultParametersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEngineDefaultParameters(software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersRequest)}
* operation.
*
*
* @param describeEngineDefaultParametersRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEngineDefaultParameters
* @see AWS API Documentation
*/
default DescribeEngineDefaultParametersPublisher describeEngineDefaultParametersPaginator(
DescribeEngineDefaultParametersRequest describeEngineDefaultParametersRequest) {
return new DescribeEngineDefaultParametersPublisher(this, describeEngineDefaultParametersRequest);
}
/**
*
* This is a variant of
* {@link #describeEngineDefaultParameters(software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEngineDefaultParametersPublisher publisher = client.describeEngineDefaultParametersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEngineDefaultParametersPublisher publisher = client.describeEngineDefaultParametersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEngineDefaultParameters(software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeEngineDefaultParametersRequest.Builder}
* avoiding the need to create one manually via {@link DescribeEngineDefaultParametersRequest#builder()}
*
*
* @param describeEngineDefaultParametersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEngineDefaultParametersRequest.Builder} to
* create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEngineDefaultParameters
* @see AWS API Documentation
*/
default DescribeEngineDefaultParametersPublisher describeEngineDefaultParametersPaginator(
Consumer describeEngineDefaultParametersRequest) {
return describeEngineDefaultParametersPaginator(DescribeEngineDefaultParametersRequest.builder()
.applyMutation(describeEngineDefaultParametersRequest).build());
}
/**
*
* Displays a list of categories for all event source types, or, if specified, for a specified source type.
*
*
* @param describeEventCategoriesRequest
* @return A Java Future containing the result of the DescribeEventCategories operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventCategories
* @see AWS API Documentation
*/
default CompletableFuture describeEventCategories(
DescribeEventCategoriesRequest describeEventCategoriesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Displays a list of categories for all event source types, or, if specified, for a specified source type.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeEventCategoriesRequest.Builder} avoiding
* the need to create one manually via {@link DescribeEventCategoriesRequest#builder()}
*
*
* @param describeEventCategoriesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEventCategoriesRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeEventCategories operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventCategories
* @see AWS API Documentation
*/
default CompletableFuture describeEventCategories(
Consumer describeEventCategoriesRequest) {
return describeEventCategories(DescribeEventCategoriesRequest.builder().applyMutation(describeEventCategoriesRequest)
.build());
}
/**
*
* Displays a list of categories for all event source types, or, if specified, for a specified source type.
*
*
* @return A Java Future containing the result of the DescribeEventCategories operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventCategories
* @see AWS API Documentation
*/
default CompletableFuture describeEventCategories() {
return describeEventCategories(DescribeEventCategoriesRequest.builder().build());
}
/**
*
* 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 A Java Future containing the result of the DescribeEventSubscriptions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventSubscriptions
* @see AWS API Documentation
*/
default CompletableFuture describeEventSubscriptions(
DescribeEventSubscriptionsRequest describeEventSubscriptionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeEventSubscriptionsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeEventSubscriptionsRequest#builder()}
*
*
* @param describeEventSubscriptionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the DescribeEventSubscriptions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventSubscriptions
* @see AWS API Documentation
*/
default CompletableFuture describeEventSubscriptions(
Consumer describeEventSubscriptionsRequest) {
return describeEventSubscriptions(DescribeEventSubscriptionsRequest.builder()
.applyMutation(describeEventSubscriptionsRequest).build());
}
/**
*
* 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.
*
*
* @return A Java Future containing the result of the DescribeEventSubscriptions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventSubscriptions
* @see AWS API Documentation
*/
default CompletableFuture describeEventSubscriptions() {
return describeEventSubscriptions(DescribeEventSubscriptionsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeEventSubscriptions(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventSubscriptionsPublisher publisher = client.describeEventSubscriptionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventSubscriptionsPublisher publisher = client.describeEventSubscriptionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEventSubscriptions(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventSubscriptions
* @see AWS API Documentation
*/
default DescribeEventSubscriptionsPublisher describeEventSubscriptionsPaginator() {
return describeEventSubscriptionsPaginator(DescribeEventSubscriptionsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describeEventSubscriptions(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventSubscriptionsPublisher publisher = client.describeEventSubscriptionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventSubscriptionsPublisher publisher = client.describeEventSubscriptionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEventSubscriptions(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest)}
* operation.
*
*
* @param describeEventSubscriptionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventSubscriptions
* @see AWS API Documentation
*/
default DescribeEventSubscriptionsPublisher describeEventSubscriptionsPaginator(
DescribeEventSubscriptionsRequest describeEventSubscriptionsRequest) {
return new DescribeEventSubscriptionsPublisher(this, describeEventSubscriptionsRequest);
}
/**
*
* This is a variant of
* {@link #describeEventSubscriptions(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventSubscriptionsPublisher publisher = client.describeEventSubscriptionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventSubscriptionsPublisher publisher = client.describeEventSubscriptionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEventSubscriptions(software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeEventSubscriptionsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeEventSubscriptionsRequest#builder()}
*
*
* @param describeEventSubscriptionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEventSubscriptionsRequest.Builder} to create
* a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEventSubscriptions
* @see AWS API Documentation
*/
default DescribeEventSubscriptionsPublisher describeEventSubscriptionsPaginator(
Consumer describeEventSubscriptionsRequest) {
return describeEventSubscriptionsPaginator(DescribeEventSubscriptionsRequest.builder()
.applyMutation(describeEventSubscriptionsRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DescribeEvents operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEvents
* @see AWS API
* Documentation
*/
default CompletableFuture describeEvents(DescribeEventsRequest describeEventsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeEventsRequest.Builder} avoiding the need to
* create one manually via {@link DescribeEventsRequest#builder()}
*
*
* @param describeEventsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEventsRequest.Builder} to create a request.
* @return A Java Future containing the result of the DescribeEvents operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEvents
* @see AWS API
* Documentation
*/
default CompletableFuture describeEvents(Consumer describeEventsRequest) {
return describeEvents(DescribeEventsRequest.builder().applyMutation(describeEventsRequest).build());
}
/**
*
* 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.
*
*
* @return A Java Future containing the result of the DescribeEvents operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEvents
* @see AWS API
* Documentation
*/
default CompletableFuture describeEvents() {
return describeEvents(DescribeEventsRequest.builder().build());
}
/**
*
* This is a variant of {@link #describeEvents(software.amazon.awssdk.services.neptune.model.DescribeEventsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventsPublisher publisher = client.describeEventsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventsPublisher publisher = client.describeEventsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEventsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEvents(software.amazon.awssdk.services.neptune.model.DescribeEventsRequest)} operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEvents
* @see AWS API
* Documentation
*/
default DescribeEventsPublisher describeEventsPaginator() {
return describeEventsPaginator(DescribeEventsRequest.builder().build());
}
/**
*
* This is a variant of {@link #describeEvents(software.amazon.awssdk.services.neptune.model.DescribeEventsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventsPublisher publisher = client.describeEventsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventsPublisher publisher = client.describeEventsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEventsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEvents(software.amazon.awssdk.services.neptune.model.DescribeEventsRequest)} operation.
*
*
* @param describeEventsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEvents
* @see AWS API
* Documentation
*/
default DescribeEventsPublisher describeEventsPaginator(DescribeEventsRequest describeEventsRequest) {
return new DescribeEventsPublisher(this, describeEventsRequest);
}
/**
*
* This is a variant of {@link #describeEvents(software.amazon.awssdk.services.neptune.model.DescribeEventsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventsPublisher publisher = client.describeEventsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeEventsPublisher publisher = client.describeEventsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeEventsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeEvents(software.amazon.awssdk.services.neptune.model.DescribeEventsRequest)} operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeEventsRequest.Builder} avoiding the need to
* create one manually via {@link DescribeEventsRequest#builder()}
*
*
* @param describeEventsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeEventsRequest.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeEvents
* @see AWS API
* Documentation
*/
default DescribeEventsPublisher describeEventsPaginator(Consumer describeEventsRequest) {
return describeEventsPaginator(DescribeEventsRequest.builder().applyMutation(describeEventsRequest).build());
}
/**
*
* Returns information about Neptune global database clusters. This API supports pagination.
*
*
* @param describeGlobalClustersRequest
* @return A Java Future containing the result of the DescribeGlobalClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeGlobalClusters
* @see AWS API Documentation
*/
default CompletableFuture describeGlobalClusters(
DescribeGlobalClustersRequest describeGlobalClustersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about Neptune global database clusters. This API supports pagination.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeGlobalClustersRequest.Builder} avoiding the
* need to create one manually via {@link DescribeGlobalClustersRequest#builder()}
*
*
* @param describeGlobalClustersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeGlobalClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeGlobalClusters
* @see AWS API Documentation
*/
default CompletableFuture describeGlobalClusters(
Consumer describeGlobalClustersRequest) {
return describeGlobalClusters(DescribeGlobalClustersRequest.builder().applyMutation(describeGlobalClustersRequest)
.build());
}
/**
*
* This is a variant of
* {@link #describeGlobalClusters(software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeGlobalClustersPublisher publisher = client.describeGlobalClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeGlobalClustersPublisher publisher = client.describeGlobalClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeGlobalClusters(software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersRequest)}
* operation.
*
*
* @param describeGlobalClustersRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeGlobalClusters
* @see AWS API Documentation
*/
default DescribeGlobalClustersPublisher describeGlobalClustersPaginator(
DescribeGlobalClustersRequest describeGlobalClustersRequest) {
return new DescribeGlobalClustersPublisher(this, describeGlobalClustersRequest);
}
/**
*
* This is a variant of
* {@link #describeGlobalClusters(software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeGlobalClustersPublisher publisher = client.describeGlobalClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeGlobalClustersPublisher publisher = client.describeGlobalClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeGlobalClusters(software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeGlobalClustersRequest.Builder} avoiding the
* need to create one manually via {@link DescribeGlobalClustersRequest#builder()}
*
*
* @param describeGlobalClustersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeGlobalClustersRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeGlobalClusters
* @see AWS API Documentation
*/
default DescribeGlobalClustersPublisher describeGlobalClustersPaginator(
Consumer describeGlobalClustersRequest) {
return describeGlobalClustersPaginator(DescribeGlobalClustersRequest.builder()
.applyMutation(describeGlobalClustersRequest).build());
}
/**
*
* Returns a list of orderable DB instance options for the specified engine.
*
*
* @param describeOrderableDbInstanceOptionsRequest
* @return A Java Future containing the result of the DescribeOrderableDBInstanceOptions operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeOrderableDBInstanceOptions
* @see AWS API Documentation
*/
default CompletableFuture describeOrderableDBInstanceOptions(
DescribeOrderableDbInstanceOptionsRequest describeOrderableDbInstanceOptionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of orderable DB instance options for the specified engine.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeOrderableDbInstanceOptionsRequest.Builder}
* avoiding the need to create one manually via {@link DescribeOrderableDbInstanceOptionsRequest#builder()}
*
*
* @param describeOrderableDbInstanceOptionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the DescribeOrderableDBInstanceOptions operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeOrderableDBInstanceOptions
* @see AWS API Documentation
*/
default CompletableFuture describeOrderableDBInstanceOptions(
Consumer describeOrderableDbInstanceOptionsRequest) {
return describeOrderableDBInstanceOptions(DescribeOrderableDbInstanceOptionsRequest.builder()
.applyMutation(describeOrderableDbInstanceOptionsRequest).build());
}
/**
*
* This is a variant of
* {@link #describeOrderableDBInstanceOptions(software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeOrderableDBInstanceOptionsPublisher publisher = client.describeOrderableDBInstanceOptionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeOrderableDBInstanceOptionsPublisher publisher = client.describeOrderableDBInstanceOptionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeOrderableDBInstanceOptions(software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsRequest)}
* operation.
*
*
* @param describeOrderableDbInstanceOptionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeOrderableDBInstanceOptions
* @see AWS API Documentation
*/
default DescribeOrderableDBInstanceOptionsPublisher describeOrderableDBInstanceOptionsPaginator(
DescribeOrderableDbInstanceOptionsRequest describeOrderableDbInstanceOptionsRequest) {
return new DescribeOrderableDBInstanceOptionsPublisher(this, describeOrderableDbInstanceOptionsRequest);
}
/**
*
* This is a variant of
* {@link #describeOrderableDBInstanceOptions(software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeOrderableDBInstanceOptionsPublisher publisher = client.describeOrderableDBInstanceOptionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribeOrderableDBInstanceOptionsPublisher publisher = client.describeOrderableDBInstanceOptionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describeOrderableDBInstanceOptions(software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeOrderableDbInstanceOptionsRequest.Builder}
* avoiding the need to create one manually via {@link DescribeOrderableDbInstanceOptionsRequest#builder()}
*
*
* @param describeOrderableDbInstanceOptionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeOrderableDbInstanceOptionsRequest.Builder} to
* create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeOrderableDBInstanceOptions
* @see AWS API Documentation
*/
default DescribeOrderableDBInstanceOptionsPublisher describeOrderableDBInstanceOptionsPaginator(
Consumer describeOrderableDbInstanceOptionsRequest) {
return describeOrderableDBInstanceOptionsPaginator(DescribeOrderableDbInstanceOptionsRequest.builder()
.applyMutation(describeOrderableDbInstanceOptionsRequest).build());
}
/**
*
* Returns a list of resources (for example, DB instances) that have at least one pending maintenance action.
*
*
* @param describePendingMaintenanceActionsRequest
* @return A Java Future containing the result of the DescribePendingMaintenanceActions operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribePendingMaintenanceActions
* @see AWS API Documentation
*/
default CompletableFuture describePendingMaintenanceActions(
DescribePendingMaintenanceActionsRequest describePendingMaintenanceActionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of resources (for example, DB instances) that have at least one pending maintenance action.
*
*
*
* This is a convenience which creates an instance of the {@link DescribePendingMaintenanceActionsRequest.Builder}
* avoiding the need to create one manually via {@link DescribePendingMaintenanceActionsRequest#builder()}
*
*
* @param describePendingMaintenanceActionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the DescribePendingMaintenanceActions operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribePendingMaintenanceActions
* @see AWS API Documentation
*/
default CompletableFuture describePendingMaintenanceActions(
Consumer describePendingMaintenanceActionsRequest) {
return describePendingMaintenanceActions(DescribePendingMaintenanceActionsRequest.builder()
.applyMutation(describePendingMaintenanceActionsRequest).build());
}
/**
*
* Returns a list of resources (for example, DB instances) that have at least one pending maintenance action.
*
*
* @return A Java Future containing the result of the DescribePendingMaintenanceActions operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribePendingMaintenanceActions
* @see AWS API Documentation
*/
default CompletableFuture describePendingMaintenanceActions() {
return describePendingMaintenanceActions(DescribePendingMaintenanceActionsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describePendingMaintenanceActions(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribePendingMaintenanceActionsPublisher publisher = client.describePendingMaintenanceActionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribePendingMaintenanceActionsPublisher publisher = client.describePendingMaintenanceActionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describePendingMaintenanceActions(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest)}
* operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribePendingMaintenanceActions
* @see AWS API Documentation
*/
default DescribePendingMaintenanceActionsPublisher describePendingMaintenanceActionsPaginator() {
return describePendingMaintenanceActionsPaginator(DescribePendingMaintenanceActionsRequest.builder().build());
}
/**
*
* This is a variant of
* {@link #describePendingMaintenanceActions(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribePendingMaintenanceActionsPublisher publisher = client.describePendingMaintenanceActionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribePendingMaintenanceActionsPublisher publisher = client.describePendingMaintenanceActionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describePendingMaintenanceActions(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest)}
* operation.
*
*
* @param describePendingMaintenanceActionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribePendingMaintenanceActions
* @see AWS API Documentation
*/
default DescribePendingMaintenanceActionsPublisher describePendingMaintenanceActionsPaginator(
DescribePendingMaintenanceActionsRequest describePendingMaintenanceActionsRequest) {
return new DescribePendingMaintenanceActionsPublisher(this, describePendingMaintenanceActionsRequest);
}
/**
*
* This is a variant of
* {@link #describePendingMaintenanceActions(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribePendingMaintenanceActionsPublisher publisher = client.describePendingMaintenanceActionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.neptune.paginators.DescribePendingMaintenanceActionsPublisher publisher = client.describePendingMaintenanceActionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxRecords won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #describePendingMaintenanceActions(software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link DescribePendingMaintenanceActionsRequest.Builder}
* avoiding the need to create one manually via {@link DescribePendingMaintenanceActionsRequest#builder()}
*
*
* @param describePendingMaintenanceActionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribePendingMaintenanceActionsRequest.Builder} to
* create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The specified resource ID was not found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribePendingMaintenanceActions
* @see AWS API Documentation
*/
default DescribePendingMaintenanceActionsPublisher describePendingMaintenanceActionsPaginator(
Consumer describePendingMaintenanceActionsRequest) {
return describePendingMaintenanceActionsPaginator(DescribePendingMaintenanceActionsRequest.builder()
.applyMutation(describePendingMaintenanceActionsRequest).build());
}
/**
*
* 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 A Java Future containing the result of the DescribeValidDBInstanceModifications operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeValidDBInstanceModifications
* @see AWS API Documentation
*/
default CompletableFuture describeValidDBInstanceModifications(
DescribeValidDbInstanceModificationsRequest describeValidDbInstanceModificationsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* You can call DescribeValidDBInstanceModifications to learn what modifications you can make to your DB
* instance. You can use this information when you call ModifyDBInstance.
*
*
*
* This is a convenience which creates an instance of the
* {@link DescribeValidDbInstanceModificationsRequest.Builder} avoiding the need to create one manually via
* {@link DescribeValidDbInstanceModificationsRequest#builder()}
*
*
* @param describeValidDbInstanceModificationsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.DescribeValidDbInstanceModificationsRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the DescribeValidDBInstanceModifications operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.DescribeValidDBInstanceModifications
* @see AWS API Documentation
*/
default CompletableFuture describeValidDBInstanceModifications(
Consumer describeValidDbInstanceModificationsRequest) {
return describeValidDBInstanceModifications(DescribeValidDbInstanceModificationsRequest.builder()
.applyMutation(describeValidDbInstanceModificationsRequest).build());
}
/**
*
* 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 A Java Future containing the result of the FailoverDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.FailoverDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture failoverDBCluster(FailoverDbClusterRequest failoverDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link FailoverDbClusterRequest.Builder} avoiding the need
* to create one manually via {@link FailoverDbClusterRequest#builder()}
*
*
* @param failoverDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.FailoverDbClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the FailoverDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.FailoverDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture failoverDBCluster(
Consumer failoverDbClusterRequest) {
return failoverDBCluster(FailoverDbClusterRequest.builder().applyMutation(failoverDbClusterRequest).build());
}
/**
*
* 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 A Java Future containing the result of the FailoverGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.FailoverGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture failoverGlobalCluster(
FailoverGlobalClusterRequest failoverGlobalClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link FailoverGlobalClusterRequest.Builder} avoiding the
* need to create one manually via {@link FailoverGlobalClusterRequest#builder()}
*
*
* @param failoverGlobalClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.FailoverGlobalClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the FailoverGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.FailoverGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture failoverGlobalCluster(
Consumer failoverGlobalClusterRequest) {
return failoverGlobalCluster(FailoverGlobalClusterRequest.builder().applyMutation(failoverGlobalClusterRequest).build());
}
/**
*
* Lists all tags on an Amazon Neptune resource.
*
*
* @param listTagsForResourceRequest
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ListTagsForResource
* @see AWS
* API Documentation
*/
default CompletableFuture listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists all tags on an Amazon Neptune resource.
*
*
*
* This is a convenience which creates an instance of the {@link ListTagsForResourceRequest.Builder} avoiding the
* need to create one manually via {@link ListTagsForResourceRequest#builder()}
*
*
* @param listTagsForResourceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ListTagsForResourceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ListTagsForResource
* @see AWS
* API Documentation
*/
default CompletableFuture listTagsForResource(
Consumer listTagsForResourceRequest) {
return listTagsForResource(ListTagsForResourceRequest.builder().applyMutation(listTagsForResourceRequest).build());
}
/**
*
* 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 A Java Future containing the result of the ModifyDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - InvalidDbSubnetGroupStateException The DB subnet group cannot be deleted because it is in use.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - InvalidDbSecurityGroupStateException The state of the DB security group does not allow deletion.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - StorageTypeNotSupportedException StorageType specified cannot be associated with the DB
* Instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture modifyDBCluster(ModifyDbClusterRequest modifyDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyDbClusterRequest.Builder} avoiding the need
* to create one manually via {@link ModifyDbClusterRequest#builder()}
*
*
* @param modifyDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyDbClusterRequest.Builder} to create a request.
* @return A Java Future containing the result of the ModifyDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - InvalidDbSubnetGroupStateException The DB subnet group cannot be deleted because it is in use.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - InvalidDbSecurityGroupStateException The state of the DB security group does not allow deletion.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - StorageTypeNotSupportedException StorageType specified cannot be associated with the DB
* Instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture modifyDBCluster(
Consumer modifyDbClusterRequest) {
return modifyDBCluster(ModifyDbClusterRequest.builder().applyMutation(modifyDbClusterRequest).build());
}
/**
*
* Modifies the properties of an endpoint in an Amazon Neptune DB cluster.
*
*
* @param modifyDbClusterEndpointRequest
* @return A Java Future containing the result of the ModifyDBClusterEndpoint operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbClusterEndpointStateException The requested operation cannot be performed on the endpoint
* while the endpoint is in this state.
* - DbClusterEndpointNotFoundException The specified custom endpoint doesn't exist.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBClusterEndpoint
* @see AWS API Documentation
*/
default CompletableFuture modifyDBClusterEndpoint(
ModifyDbClusterEndpointRequest modifyDbClusterEndpointRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Modifies the properties of an endpoint in an Amazon Neptune DB cluster.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyDbClusterEndpointRequest.Builder} avoiding
* the need to create one manually via {@link ModifyDbClusterEndpointRequest#builder()}
*
*
* @param modifyDbClusterEndpointRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyDbClusterEndpointRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ModifyDBClusterEndpoint operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbClusterEndpointStateException The requested operation cannot be performed on the endpoint
* while the endpoint is in this state.
* - DbClusterEndpointNotFoundException The specified custom endpoint doesn't exist.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBClusterEndpoint
* @see AWS API Documentation
*/
default CompletableFuture modifyDBClusterEndpoint(
Consumer modifyDbClusterEndpointRequest) {
return modifyDBClusterEndpoint(ModifyDbClusterEndpointRequest.builder().applyMutation(modifyDbClusterEndpointRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the ModifyDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - 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.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture modifyDBClusterParameterGroup(
ModifyDbClusterParameterGroupRequest modifyDbClusterParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyDbClusterParameterGroupRequest.Builder}
* avoiding the need to create one manually via {@link ModifyDbClusterParameterGroupRequest#builder()}
*
*
* @param modifyDbClusterParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyDbClusterParameterGroupRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ModifyDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - 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.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture modifyDBClusterParameterGroup(
Consumer modifyDbClusterParameterGroupRequest) {
return modifyDBClusterParameterGroup(ModifyDbClusterParameterGroupRequest.builder()
.applyMutation(modifyDbClusterParameterGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the ModifyDBClusterSnapshotAttribute operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SharedSnapshotQuotaExceededException You have exceeded the maximum number of accounts that you can
* share a manual DB snapshot with.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBClusterSnapshotAttribute
* @see AWS API Documentation
*/
default CompletableFuture modifyDBClusterSnapshotAttribute(
ModifyDbClusterSnapshotAttributeRequest modifyDbClusterSnapshotAttributeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyDbClusterSnapshotAttributeRequest.Builder}
* avoiding the need to create one manually via {@link ModifyDbClusterSnapshotAttributeRequest#builder()}
*
*
* @param modifyDbClusterSnapshotAttributeRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyDbClusterSnapshotAttributeRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ModifyDBClusterSnapshotAttribute operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - SharedSnapshotQuotaExceededException You have exceeded the maximum number of accounts that you can
* share a manual DB snapshot with.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBClusterSnapshotAttribute
* @see AWS API Documentation
*/
default CompletableFuture modifyDBClusterSnapshotAttribute(
Consumer modifyDbClusterSnapshotAttributeRequest) {
return modifyDBClusterSnapshotAttribute(ModifyDbClusterSnapshotAttributeRequest.builder()
.applyMutation(modifyDbClusterSnapshotAttributeRequest).build());
}
/**
*
* 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 A Java Future containing the result of the ModifyDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - InvalidDbSecurityGroupStateException The state of the DB security group does not allow deletion.
* - DbInstanceAlreadyExistsException User already has a DB instance with the given identifier.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSecurityGroupNotFoundException DBSecurityGroupName does not refer to an existing DB security
* group.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - InsufficientDbInstanceCapacityException Specified DB instance class is not available in the specified
* Availability Zone.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - ProvisionedIopsNotAvailableInAzException Provisioned IOPS not available in the specified Availability
* Zone.
* - OptionGroupNotFoundException The designated option group could not be found.
* - DbUpgradeDependencyFailureException The DB upgrade failed because a resource the DB depends on could
* not be modified.
* - StorageTypeNotSupportedException StorageType specified cannot be associated with the DB
* Instance.
* - 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.
* - CertificateNotFoundException CertificateIdentifier does not refer to an existing certificate.
* - DomainNotFoundException Domain does not refer to an existing Active Directory Domain.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture modifyDBInstance(ModifyDbInstanceRequest modifyDbInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyDbInstanceRequest.Builder} avoiding the need
* to create one manually via {@link ModifyDbInstanceRequest#builder()}
*
*
* @param modifyDbInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyDbInstanceRequest.Builder} to create a request.
* @return A Java Future containing the result of the ModifyDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - InvalidDbSecurityGroupStateException The state of the DB security group does not allow deletion.
* - DbInstanceAlreadyExistsException User already has a DB instance with the given identifier.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSecurityGroupNotFoundException DBSecurityGroupName does not refer to an existing DB security
* group.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - InsufficientDbInstanceCapacityException Specified DB instance class is not available in the specified
* Availability Zone.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - ProvisionedIopsNotAvailableInAzException Provisioned IOPS not available in the specified Availability
* Zone.
* - OptionGroupNotFoundException The designated option group could not be found.
* - DbUpgradeDependencyFailureException The DB upgrade failed because a resource the DB depends on could
* not be modified.
* - StorageTypeNotSupportedException StorageType specified cannot be associated with the DB
* Instance.
* - 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.
* - CertificateNotFoundException CertificateIdentifier does not refer to an existing certificate.
* - DomainNotFoundException Domain does not refer to an existing Active Directory Domain.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture modifyDBInstance(
Consumer modifyDbInstanceRequest) {
return modifyDBInstance(ModifyDbInstanceRequest.builder().applyMutation(modifyDbInstanceRequest).build());
}
/**
*
* 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 A Java Future containing the result of the ModifyDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - 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.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture modifyDBParameterGroup(
ModifyDbParameterGroupRequest modifyDbParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyDbParameterGroupRequest.Builder} avoiding the
* need to create one manually via {@link ModifyDbParameterGroupRequest#builder()}
*
*
* @param modifyDbParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyDbParameterGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ModifyDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - 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.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture modifyDBParameterGroup(
Consumer modifyDbParameterGroupRequest) {
return modifyDBParameterGroup(ModifyDbParameterGroupRequest.builder().applyMutation(modifyDbParameterGroupRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the ModifyDBSubnetGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - DbSubnetQuotaExceededException Request would result in user exceeding the allowed number of subnets
* in a DB subnet groups.
* - SubnetAlreadyInUseException The DB subnet is already in use in the Availability Zone.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBSubnetGroup
* @see AWS
* API Documentation
*/
default CompletableFuture modifyDBSubnetGroup(
ModifyDbSubnetGroupRequest modifyDbSubnetGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Modifies an existing DB subnet group. DB subnet groups must contain at least one subnet in at least two AZs in
* the Amazon Region.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyDbSubnetGroupRequest.Builder} avoiding the
* need to create one manually via {@link ModifyDbSubnetGroupRequest#builder()}
*
*
* @param modifyDbSubnetGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyDbSubnetGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ModifyDBSubnetGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - DbSubnetQuotaExceededException Request would result in user exceeding the allowed number of subnets
* in a DB subnet groups.
* - SubnetAlreadyInUseException The DB subnet is already in use in the Availability Zone.
* - DbSubnetGroupDoesNotCoverEnoughAZsException Subnets in the DB subnet group should cover at least two
* Availability Zones unless there is only one Availability Zone.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyDBSubnetGroup
* @see AWS
* API Documentation
*/
default CompletableFuture modifyDBSubnetGroup(
Consumer modifyDbSubnetGroupRequest) {
return modifyDBSubnetGroup(ModifyDbSubnetGroupRequest.builder().applyMutation(modifyDbSubnetGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the ModifyEventSubscription operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - EventSubscriptionQuotaExceededException You have exceeded the number of events you can subscribe to.
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SnsInvalidTopicException The SNS topic is invalid.
* - SnsNoAuthorizationException There is no SNS authorization.
* - SnsTopicArnNotFoundException The ARN of the SNS topic could not be found.
* - SubscriptionCategoryNotFoundException The designated subscription category could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyEventSubscription
* @see AWS API Documentation
*/
default CompletableFuture modifyEventSubscription(
ModifyEventSubscriptionRequest modifyEventSubscriptionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyEventSubscriptionRequest.Builder} avoiding
* the need to create one manually via {@link ModifyEventSubscriptionRequest#builder()}
*
*
* @param modifyEventSubscriptionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyEventSubscriptionRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ModifyEventSubscription operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - EventSubscriptionQuotaExceededException You have exceeded the number of events you can subscribe to.
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SnsInvalidTopicException The SNS topic is invalid.
* - SnsNoAuthorizationException There is no SNS authorization.
* - SnsTopicArnNotFoundException The ARN of the SNS topic could not be found.
* - SubscriptionCategoryNotFoundException The designated subscription category could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyEventSubscription
* @see AWS API Documentation
*/
default CompletableFuture modifyEventSubscription(
Consumer modifyEventSubscriptionRequest) {
return modifyEventSubscription(ModifyEventSubscriptionRequest.builder().applyMutation(modifyEventSubscriptionRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the ModifyGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture modifyGlobalCluster(
ModifyGlobalClusterRequest modifyGlobalClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyGlobalClusterRequest.Builder} avoiding the
* need to create one manually via {@link ModifyGlobalClusterRequest#builder()}
*
*
* @param modifyGlobalClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ModifyGlobalClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ModifyGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ModifyGlobalCluster
* @see AWS
* API Documentation
*/
default CompletableFuture modifyGlobalCluster(
Consumer modifyGlobalClusterRequest) {
return modifyGlobalCluster(ModifyGlobalClusterRequest.builder().applyMutation(modifyGlobalClusterRequest).build());
}
/**
*
* Not supported.
*
*
* @param promoteReadReplicaDbClusterRequest
* @return A Java Future containing the result of the PromoteReadReplicaDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.PromoteReadReplicaDBCluster
* @see AWS API Documentation
*/
default CompletableFuture promoteReadReplicaDBCluster(
PromoteReadReplicaDbClusterRequest promoteReadReplicaDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Not supported.
*
*
*
* This is a convenience which creates an instance of the {@link PromoteReadReplicaDbClusterRequest.Builder}
* avoiding the need to create one manually via {@link PromoteReadReplicaDbClusterRequest#builder()}
*
*
* @param promoteReadReplicaDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.PromoteReadReplicaDbClusterRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the PromoteReadReplicaDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.PromoteReadReplicaDBCluster
* @see AWS API Documentation
*/
default CompletableFuture promoteReadReplicaDBCluster(
Consumer promoteReadReplicaDbClusterRequest) {
return promoteReadReplicaDBCluster(PromoteReadReplicaDbClusterRequest.builder()
.applyMutation(promoteReadReplicaDbClusterRequest).build());
}
/**
*
* 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 A Java Future containing the result of the RebootDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RebootDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture rebootDBInstance(RebootDbInstanceRequest rebootDbInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link RebootDbInstanceRequest.Builder} avoiding the need
* to create one manually via {@link RebootDbInstanceRequest#builder()}
*
*
* @param rebootDbInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.RebootDbInstanceRequest.Builder} to create a request.
* @return A Java Future containing the result of the RebootDBInstance operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RebootDBInstance
* @see AWS API
* Documentation
*/
default CompletableFuture rebootDBInstance(
Consumer rebootDbInstanceRequest) {
return rebootDBInstance(RebootDbInstanceRequest.builder().applyMutation(rebootDbInstanceRequest).build());
}
/**
*
* 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 A Java Future containing the result of the RemoveFromGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveFromGlobalCluster
* @see AWS API Documentation
*/
default CompletableFuture removeFromGlobalCluster(
RemoveFromGlobalClusterRequest removeFromGlobalClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link RemoveFromGlobalClusterRequest.Builder} avoiding
* the need to create one manually via {@link RemoveFromGlobalClusterRequest#builder()}
*
*
* @param removeFromGlobalClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.RemoveFromGlobalClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the RemoveFromGlobalCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - GlobalClusterNotFoundException The
GlobalClusterIdentifier doesn't refer to an existing
* global database cluster.
* - InvalidGlobalClusterStateException The global cluster is in an invalid state and can't perform the
* requested operation.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveFromGlobalCluster
* @see AWS API Documentation
*/
default CompletableFuture removeFromGlobalCluster(
Consumer removeFromGlobalClusterRequest) {
return removeFromGlobalCluster(RemoveFromGlobalClusterRequest.builder().applyMutation(removeFromGlobalClusterRequest)
.build());
}
/**
*
* Disassociates an Identity and Access Management (IAM) role from a DB cluster.
*
*
* @param removeRoleFromDbClusterRequest
* @return A Java Future containing the result of the RemoveRoleFromDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbClusterRoleNotFoundException The specified IAM role Amazon Resource Name (ARN) is not associated
* with the specified DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveRoleFromDBCluster
* @see AWS API Documentation
*/
default CompletableFuture removeRoleFromDBCluster(
RemoveRoleFromDbClusterRequest removeRoleFromDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Disassociates an Identity and Access Management (IAM) role from a DB cluster.
*
*
*
* This is a convenience which creates an instance of the {@link RemoveRoleFromDbClusterRequest.Builder} avoiding
* the need to create one manually via {@link RemoveRoleFromDbClusterRequest#builder()}
*
*
* @param removeRoleFromDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.RemoveRoleFromDbClusterRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the RemoveRoleFromDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbClusterRoleNotFoundException The specified IAM role Amazon Resource Name (ARN) is not associated
* with the specified DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveRoleFromDBCluster
* @see AWS API Documentation
*/
default CompletableFuture removeRoleFromDBCluster(
Consumer removeRoleFromDbClusterRequest) {
return removeRoleFromDBCluster(RemoveRoleFromDbClusterRequest.builder().applyMutation(removeRoleFromDbClusterRequest)
.build());
}
/**
*
* Removes a source identifier from an existing event notification subscription.
*
*
* @param removeSourceIdentifierFromSubscriptionRequest
* @return A Java Future containing the result of the RemoveSourceIdentifierFromSubscription operation returned by
* the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SourceNotFoundException The source could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveSourceIdentifierFromSubscription
* @see AWS API Documentation
*/
default CompletableFuture removeSourceIdentifierFromSubscription(
RemoveSourceIdentifierFromSubscriptionRequest removeSourceIdentifierFromSubscriptionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes a source identifier from an existing event notification subscription.
*
*
*
* This is a convenience which creates an instance of the
* {@link RemoveSourceIdentifierFromSubscriptionRequest.Builder} avoiding the need to create one manually via
* {@link RemoveSourceIdentifierFromSubscriptionRequest#builder()}
*
*
* @param removeSourceIdentifierFromSubscriptionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.RemoveSourceIdentifierFromSubscriptionRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the RemoveSourceIdentifierFromSubscription operation returned by
* the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SubscriptionNotFoundException The designated subscription could not be found.
* - SourceNotFoundException The source could not be found.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveSourceIdentifierFromSubscription
* @see AWS API Documentation
*/
default CompletableFuture removeSourceIdentifierFromSubscription(
Consumer removeSourceIdentifierFromSubscriptionRequest) {
return removeSourceIdentifierFromSubscription(RemoveSourceIdentifierFromSubscriptionRequest.builder()
.applyMutation(removeSourceIdentifierFromSubscriptionRequest).build());
}
/**
*
* Removes metadata tags from an Amazon Neptune resource.
*
*
* @param removeTagsFromResourceRequest
* @return A Java Future containing the result of the RemoveTagsFromResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveTagsFromResource
* @see AWS API Documentation
*/
default CompletableFuture removeTagsFromResource(
RemoveTagsFromResourceRequest removeTagsFromResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes metadata tags from an Amazon Neptune resource.
*
*
*
* This is a convenience which creates an instance of the {@link RemoveTagsFromResourceRequest.Builder} avoiding the
* need to create one manually via {@link RemoveTagsFromResourceRequest#builder()}
*
*
* @param removeTagsFromResourceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.RemoveTagsFromResourceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the RemoveTagsFromResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbInstanceNotFoundException DBInstanceIdentifier does not refer to an existing DB instance.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RemoveTagsFromResource
* @see AWS API Documentation
*/
default CompletableFuture removeTagsFromResource(
Consumer removeTagsFromResourceRequest) {
return removeTagsFromResource(RemoveTagsFromResourceRequest.builder().applyMutation(removeTagsFromResourceRequest)
.build());
}
/**
*
* 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 A Java Future containing the result of the ResetDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ResetDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture resetDBClusterParameterGroup(
ResetDbClusterParameterGroupRequest resetDbClusterParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ResetDbClusterParameterGroupRequest.Builder}
* avoiding the need to create one manually via {@link ResetDbClusterParameterGroupRequest#builder()}
*
*
* @param resetDbClusterParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ResetDbClusterParameterGroupRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ResetDBClusterParameterGroup operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ResetDBClusterParameterGroup
* @see AWS API Documentation
*/
default CompletableFuture resetDBClusterParameterGroup(
Consumer resetDbClusterParameterGroupRequest) {
return resetDBClusterParameterGroup(ResetDbClusterParameterGroupRequest.builder()
.applyMutation(resetDbClusterParameterGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the ResetDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ResetDBParameterGroup
* @see AWS
* API Documentation
*/
default CompletableFuture resetDBParameterGroup(
ResetDbParameterGroupRequest resetDbParameterGroupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link ResetDbParameterGroupRequest.Builder} avoiding the
* need to create one manually via {@link ResetDbParameterGroupRequest#builder()}
*
*
* @param resetDbParameterGroupRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.ResetDbParameterGroupRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ResetDBParameterGroup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - 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.
* - DbParameterGroupNotFoundException DBParameterGroupName does not refer to an existing DB
* parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.ResetDBParameterGroup
* @see AWS
* API Documentation
*/
default CompletableFuture resetDBParameterGroup(
Consumer resetDbParameterGroupRequest) {
return resetDBParameterGroup(ResetDbParameterGroupRequest.builder().applyMutation(resetDbParameterGroupRequest).build());
}
/**
*
* 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 A Java Future containing the result of the RestoreDBClusterFromSnapshot operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - DbClusterQuotaExceededException User attempted to create a new DB cluster and the user has already
* reached the maximum allowed DB cluster quota.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - InsufficientDbClusterCapacityException The DB cluster does not have enough capacity for the current
* operation.
* - 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.
* - InvalidDbSnapshotStateException The state of the DB snapshot does not allow deletion.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - InvalidRestoreException Cannot restore from vpc backup to non-vpc DB instance.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - OptionGroupNotFoundException The designated option group could not be found.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RestoreDBClusterFromSnapshot
* @see AWS API Documentation
*/
default CompletableFuture restoreDBClusterFromSnapshot(
RestoreDbClusterFromSnapshotRequest restoreDbClusterFromSnapshotRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link RestoreDbClusterFromSnapshotRequest.Builder}
* avoiding the need to create one manually via {@link RestoreDbClusterFromSnapshotRequest#builder()}
*
*
* @param restoreDbClusterFromSnapshotRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.RestoreDbClusterFromSnapshotRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the RestoreDBClusterFromSnapshot operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - DbClusterQuotaExceededException User attempted to create a new DB cluster and the user has already
* reached the maximum allowed DB cluster quota.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - DbSnapshotNotFoundException DBSnapshotIdentifier does not refer to an existing DB snapshot.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - InsufficientDbClusterCapacityException The DB cluster does not have enough capacity for the current
* operation.
* - 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.
* - InvalidDbSnapshotStateException The state of the DB snapshot does not allow deletion.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - InvalidRestoreException Cannot restore from vpc backup to non-vpc DB instance.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - OptionGroupNotFoundException The designated option group could not be found.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RestoreDBClusterFromSnapshot
* @see AWS API Documentation
*/
default CompletableFuture restoreDBClusterFromSnapshot(
Consumer restoreDbClusterFromSnapshotRequest) {
return restoreDBClusterFromSnapshot(RestoreDbClusterFromSnapshotRequest.builder()
.applyMutation(restoreDbClusterFromSnapshotRequest).build());
}
/**
*
* 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 A Java Future containing the result of the RestoreDBClusterToPointInTime operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbClusterQuotaExceededException User attempted to create a new DB cluster and the user has already
* reached the maximum allowed DB cluster quota.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InsufficientDbClusterCapacityException The DB cluster does not have enough capacity for the current
* operation.
* - 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.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbSnapshotStateException The state of the DB snapshot does not allow deletion.
* - InvalidRestoreException Cannot restore from vpc backup to non-vpc DB instance.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - OptionGroupNotFoundException The designated option group could not be found.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RestoreDBClusterToPointInTime
* @see AWS API Documentation
*/
default CompletableFuture restoreDBClusterToPointInTime(
RestoreDbClusterToPointInTimeRequest restoreDbClusterToPointInTimeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link RestoreDbClusterToPointInTimeRequest.Builder}
* avoiding the need to create one manually via {@link RestoreDbClusterToPointInTimeRequest#builder()}
*
*
* @param restoreDbClusterToPointInTimeRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.RestoreDbClusterToPointInTimeRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the RestoreDBClusterToPointInTime operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterAlreadyExistsException User already has a DB cluster with the given identifier.
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - DbClusterQuotaExceededException User attempted to create a new DB cluster and the user has already
* reached the maximum allowed DB cluster quota.
* - DbClusterSnapshotNotFoundException DBClusterSnapshotIdentifier does not refer to an existing
* DB cluster snapshot.
* - DbSubnetGroupNotFoundException DBSubnetGroupName does not refer to an existing DB subnet
* group.
* - InsufficientDbClusterCapacityException The DB cluster does not have enough capacity for the current
* operation.
* - 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.
* - InvalidDbClusterSnapshotStateException The supplied value is not a valid DB cluster snapshot state.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbSnapshotStateException The state of the DB snapshot does not allow deletion.
* - InvalidRestoreException Cannot restore from vpc backup to non-vpc DB instance.
* - InvalidSubnetException The requested subnet is invalid, or multiple subnets were requested that are
* not all in a common VPC.
* - InvalidVpcNetworkStateException DB subnet group does not cover all Availability Zones after it is
* created because users' change.
* - KmsKeyNotAccessibleException Error accessing KMS key.
* - OptionGroupNotFoundException The designated option group could not be found.
* - StorageQuotaExceededException Request would result in user exceeding the allowed amount of storage
* available across all DB instances.
* - DbClusterParameterGroupNotFoundException DBClusterParameterGroupName does not refer to an
* existing DB Cluster parameter group.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.RestoreDBClusterToPointInTime
* @see AWS API Documentation
*/
default CompletableFuture restoreDBClusterToPointInTime(
Consumer restoreDbClusterToPointInTimeRequest) {
return restoreDBClusterToPointInTime(RestoreDbClusterToPointInTimeRequest.builder()
.applyMutation(restoreDbClusterToPointInTimeRequest).build());
}
/**
*
* 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 A Java Future containing the result of the StartDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.StartDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture startDBCluster(StartDbClusterRequest startDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Starts an Amazon Neptune DB cluster that was stopped using the Amazon console, the Amazon CLI stop-db-cluster
* command, or the StopDBCluster API.
*
*
*
* This is a convenience which creates an instance of the {@link StartDbClusterRequest.Builder} avoiding the need to
* create one manually via {@link StartDbClusterRequest#builder()}
*
*
* @param startDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.StartDbClusterRequest.Builder} to create a request.
* @return A Java Future containing the result of the StartDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.StartDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture startDBCluster(Consumer startDbClusterRequest) {
return startDBCluster(StartDbClusterRequest.builder().applyMutation(startDbClusterRequest).build());
}
/**
*
* 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 A Java Future containing the result of the StopDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.StopDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture stopDBCluster(StopDbClusterRequest stopDbClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* 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.
*
*
*
* This is a convenience which creates an instance of the {@link StopDbClusterRequest.Builder} avoiding the need to
* create one manually via {@link StopDbClusterRequest#builder()}
*
*
* @param stopDbClusterRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.neptune.model.StopDbClusterRequest.Builder} to create a request.
* @return A Java Future containing the result of the StopDBCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - DbClusterNotFoundException DBClusterIdentifier does not refer to an existing DB cluster.
* - InvalidDbClusterStateException The DB cluster is not in a valid state.
* - InvalidDbInstanceStateException The specified DB instance is not in the available state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - NeptuneException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample NeptuneAsyncClient.StopDBCluster
* @see AWS API
* Documentation
*/
default CompletableFuture stopDBCluster(Consumer stopDbClusterRequest) {
return stopDBCluster(StopDbClusterRequest.builder().applyMutation(stopDbClusterRequest).build());
}
/**
* Create an instance of {@link NeptuneAsyncWaiter} using this client.
*
* Waiters created via this method are managed by the SDK and resources will be released when the service client is
* closed.
*
* @return an instance of {@link NeptuneAsyncWaiter}
*/
default NeptuneAsyncWaiter waiter() {
throw new UnsupportedOperationException();
}
@Override
default NeptuneServiceClientConfiguration serviceClientConfiguration() {
throw new UnsupportedOperationException();
}
/**
* Create a {@link NeptuneAsyncClient} with the region loaded from the
* {@link software.amazon.awssdk.regions.providers.DefaultAwsRegionProviderChain} and credentials loaded from the
* {@link software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider}.
*/
static NeptuneAsyncClient create() {
return builder().build();
}
/**
* Create a builder that can be used to configure and create a {@link NeptuneAsyncClient}.
*/
static NeptuneAsyncClientBuilder builder() {
return new DefaultNeptuneAsyncClientBuilder();
}
}