Package software.amazon.awssdk.services.vpclattice

Interface VpcLatticeAsyncClient

  • All Superinterfaces:
    AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
    @Generated("software.amazon.awssdk:codegen")
@ThreadSafe
public interface VpcLatticeAsyncClient
extends AwsClient
    Service client for accessing Amazon VPC Lattice asynchronously. This can be created using the static builder() method.

    Amazon VPC Lattice is a fully managed application networking service that you use to connect, secure, and monitor all of your services across multiple accounts and virtual private clouds (VPCs). Amazon VPC Lattice interconnects your microservices and legacy services within a logical boundary, so that you can discover and manage them more efficiently. For more information, see the Amazon VPC Lattice User Guide

    • Method Detail

      • batchUpdateRule

        default CompletableFuture<BatchUpdateRuleResponse> batchUpdateRule​(BatchUpdateRuleRequest batchUpdateRuleRequest)

        Updates the listener rules in a batch. You can use this operation to change the priority of listener rules. This can be useful when bulk updating or swapping rule priority.

        Parameters:
        batchUpdateRuleRequest -
        Returns:
        A Java Future containing the result of the BatchUpdateRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • batchUpdateRule

        default CompletableFuture<BatchUpdateRuleResponse> batchUpdateRule​(Consumer<BatchUpdateRuleRequest.Builder> batchUpdateRuleRequest)

        Updates the listener rules in a batch. You can use this operation to change the priority of listener rules. This can be useful when bulk updating or swapping rule priority.


        This is a convenience which creates an instance of the BatchUpdateRuleRequest.Builder avoiding the need to create one manually via BatchUpdateRuleRequest.builder()

        Parameters:
        batchUpdateRuleRequest - A Consumer that will call methods on BatchUpdateRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the BatchUpdateRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createAccessLogSubscription

        default CompletableFuture<CreateAccessLogSubscriptionResponse> createAccessLogSubscription​(CreateAccessLogSubscriptionRequest createAccessLogSubscriptionRequest)

        Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis Data Firehose. The service network owner can use the access logs to audit the services in the network. The service network owner will only see access logs from clients and services that are associated with their service network. Access log entries represent traffic originated from VPCs associated with that network. For more information, see Access logs in the Amazon VPC Lattice User Guide.

        Parameters:
        createAccessLogSubscriptionRequest -
        Returns:
        A Java Future containing the result of the CreateAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createAccessLogSubscription

        default CompletableFuture<CreateAccessLogSubscriptionResponse> createAccessLogSubscription​(Consumer<CreateAccessLogSubscriptionRequest.Builder> createAccessLogSubscriptionRequest)

        Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis Data Firehose. The service network owner can use the access logs to audit the services in the network. The service network owner will only see access logs from clients and services that are associated with their service network. Access log entries represent traffic originated from VPCs associated with that network. For more information, see Access logs in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the CreateAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via CreateAccessLogSubscriptionRequest.builder()

        Parameters:
        createAccessLogSubscriptionRequest - A Consumer that will call methods on CreateAccessLogSubscriptionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createListener

        default CompletableFuture<CreateListenerResponse> createListener​(CreateListenerRequest createListenerRequest)

        Creates a listener for a service. Before you start using your Amazon VPC Lattice service, you must add one or more listeners. A listener is a process that checks for connection requests to your services. For more information, see Listeners in the Amazon VPC Lattice User Guide.

        Parameters:
        createListenerRequest -
        Returns:
        A Java Future containing the result of the CreateListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createListener

        default CompletableFuture<CreateListenerResponse> createListener​(Consumer<CreateListenerRequest.Builder> createListenerRequest)

        Creates a listener for a service. Before you start using your Amazon VPC Lattice service, you must add one or more listeners. A listener is a process that checks for connection requests to your services. For more information, see Listeners in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the CreateListenerRequest.Builder avoiding the need to create one manually via CreateListenerRequest.builder()

        Parameters:
        createListenerRequest - A Consumer that will call methods on CreateListenerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createRule

        default CompletableFuture<CreateRuleResponse> createRule​(CreateRuleRequest createRuleRequest)

        Creates a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. For more information, see Listener rules in the Amazon VPC Lattice User Guide.

        Parameters:
        createRuleRequest -
        Returns:
        A Java Future containing the result of the CreateRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createRule

        default CompletableFuture<CreateRuleResponse> createRule​(Consumer<CreateRuleRequest.Builder> createRuleRequest)

        Creates a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. For more information, see Listener rules in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the CreateRuleRequest.Builder avoiding the need to create one manually via CreateRuleRequest.builder()

        Parameters:
        createRuleRequest - A Consumer that will call methods on CreateRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createService

        default CompletableFuture<CreateServiceResponse> createService​(CreateServiceRequest createServiceRequest)

        Creates a service. A service is any software application that can run on instances containers, or serverless functions within an account or virtual private cloud (VPC).

        For more information, see Services in the Amazon VPC Lattice User Guide.

        Parameters:
        createServiceRequest -
        Returns:
        A Java Future containing the result of the CreateService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createService

        default CompletableFuture<CreateServiceResponse> createService​(Consumer<CreateServiceRequest.Builder> createServiceRequest)

        Creates a service. A service is any software application that can run on instances containers, or serverless functions within an account or virtual private cloud (VPC).

        For more information, see Services in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the CreateServiceRequest.Builder avoiding the need to create one manually via CreateServiceRequest.builder()

        Parameters:
        createServiceRequest - A Consumer that will call methods on CreateServiceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createServiceNetwork

        default CompletableFuture<CreateServiceNetworkResponse> createServiceNetwork​(CreateServiceNetworkRequest createServiceNetworkRequest)

        Creates a service network. A service network is a logical boundary for a collection of services. You can associate services and VPCs with a service network.

        For more information, see Service networks in the Amazon VPC Lattice User Guide.

        Parameters:
        createServiceNetworkRequest -
        Returns:
        A Java Future containing the result of the CreateServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createServiceNetwork

        default CompletableFuture<CreateServiceNetworkResponse> createServiceNetwork​(Consumer<CreateServiceNetworkRequest.Builder> createServiceNetworkRequest)

        Creates a service network. A service network is a logical boundary for a collection of services. You can associate services and VPCs with a service network.

        For more information, see Service networks in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the CreateServiceNetworkRequest.Builder avoiding the need to create one manually via CreateServiceNetworkRequest.builder()

        Parameters:
        createServiceNetworkRequest - A Consumer that will call methods on CreateServiceNetworkRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createServiceNetworkServiceAssociation

        default CompletableFuture<CreateServiceNetworkServiceAssociationResponse> createServiceNetworkServiceAssociation​(CreateServiceNetworkServiceAssociationRequest createServiceNetworkServiceAssociationRequest)

        Associates a service with a service network.

        You can't use this operation if the service and service network are already associated or if there is a disassociation or deletion in progress. If the association fails, you can retry the operation by deleting the association and recreating it.

        You cannot associate a service and service network that are shared with a caller. The caller must own either the service or the service network.

        As a result of this operation, the association is created in the service network account and the association owner account.

        Parameters:
        createServiceNetworkServiceAssociationRequest -
        Returns:
        A Java Future containing the result of the CreateServiceNetworkServiceAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createServiceNetworkServiceAssociation

        default CompletableFuture<CreateServiceNetworkServiceAssociationResponse> createServiceNetworkServiceAssociation​(Consumer<CreateServiceNetworkServiceAssociationRequest.Builder> createServiceNetworkServiceAssociationRequest)

        Associates a service with a service network.

        You can't use this operation if the service and service network are already associated or if there is a disassociation or deletion in progress. If the association fails, you can retry the operation by deleting the association and recreating it.

        You cannot associate a service and service network that are shared with a caller. The caller must own either the service or the service network.

        As a result of this operation, the association is created in the service network account and the association owner account.


        This is a convenience which creates an instance of the CreateServiceNetworkServiceAssociationRequest.Builder avoiding the need to create one manually via CreateServiceNetworkServiceAssociationRequest.builder()

        Parameters:
        createServiceNetworkServiceAssociationRequest - A Consumer that will call methods on CreateServiceNetworkServiceAssociationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateServiceNetworkServiceAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createServiceNetworkVpcAssociation

        default CompletableFuture<CreateServiceNetworkVpcAssociationResponse> createServiceNetworkVpcAssociation​(CreateServiceNetworkVpcAssociationRequest createServiceNetworkVpcAssociationRequest)

        Associates a VPC with a service network. When you associate a VPC with the service network, it enables all the resources within that VPC to be clients and communicate with other services in the service network. For more information, see Manage VPC associations in the Amazon VPC Lattice User Guide.

        You can't use this operation if there is a disassociation in progress. If the association fails, retry by deleting the association and recreating it.

        As a result of this operation, the association gets created in the service network account and the VPC owner account.

        Once a security group is added to the VPC association it cannot be removed. You can add or update the security groups being used for the VPC association once a security group is attached. To remove all security groups you must reassociate the VPC.

        Parameters:
        createServiceNetworkVpcAssociationRequest -
        Returns:
        A Java Future containing the result of the CreateServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createServiceNetworkVpcAssociation

        default CompletableFuture<CreateServiceNetworkVpcAssociationResponse> createServiceNetworkVpcAssociation​(Consumer<CreateServiceNetworkVpcAssociationRequest.Builder> createServiceNetworkVpcAssociationRequest)

        Associates a VPC with a service network. When you associate a VPC with the service network, it enables all the resources within that VPC to be clients and communicate with other services in the service network. For more information, see Manage VPC associations in the Amazon VPC Lattice User Guide.

        You can't use this operation if there is a disassociation in progress. If the association fails, retry by deleting the association and recreating it.

        As a result of this operation, the association gets created in the service network account and the VPC owner account.

        Once a security group is added to the VPC association it cannot be removed. You can add or update the security groups being used for the VPC association once a security group is attached. To remove all security groups you must reassociate the VPC.


        This is a convenience which creates an instance of the CreateServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via CreateServiceNetworkVpcAssociationRequest.builder()

        Parameters:
        createServiceNetworkVpcAssociationRequest - A Consumer that will call methods on CreateServiceNetworkVpcAssociationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createTargetGroup

        default CompletableFuture<CreateTargetGroupResponse> createTargetGroup​(CreateTargetGroupRequest createTargetGroupRequest)

        Creates a target group. A target group is a collection of targets, or compute resources, that run your application or service. A target group can only be used by a single service.

        For more information, see Target groups in the Amazon VPC Lattice User Guide.

        Parameters:
        createTargetGroupRequest -
        Returns:
        A Java Future containing the result of the CreateTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createTargetGroup

        default CompletableFuture<CreateTargetGroupResponse> createTargetGroup​(Consumer<CreateTargetGroupRequest.Builder> createTargetGroupRequest)

        Creates a target group. A target group is a collection of targets, or compute resources, that run your application or service. A target group can only be used by a single service.

        For more information, see Target groups in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the CreateTargetGroupRequest.Builder avoiding the need to create one manually via CreateTargetGroupRequest.builder()

        Parameters:
        createTargetGroupRequest - A Consumer that will call methods on CreateTargetGroupRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteAccessLogSubscription

        default CompletableFuture<DeleteAccessLogSubscriptionResponse> deleteAccessLogSubscription​(DeleteAccessLogSubscriptionRequest deleteAccessLogSubscriptionRequest)

        Deletes the specified access log subscription.

        Parameters:
        deleteAccessLogSubscriptionRequest -
        Returns:
        A Java Future containing the result of the DeleteAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteAccessLogSubscription

        default CompletableFuture<DeleteAccessLogSubscriptionResponse> deleteAccessLogSubscription​(Consumer<DeleteAccessLogSubscriptionRequest.Builder> deleteAccessLogSubscriptionRequest)

        Deletes the specified access log subscription.


        This is a convenience which creates an instance of the DeleteAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via DeleteAccessLogSubscriptionRequest.builder()

        Parameters:
        deleteAccessLogSubscriptionRequest - A Consumer that will call methods on DeleteAccessLogSubscriptionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteAuthPolicy

        default CompletableFuture<DeleteAuthPolicyResponse> deleteAuthPolicy​(DeleteAuthPolicyRequest deleteAuthPolicyRequest)

        Deletes the specified auth policy. If an auth is set to Amazon Web Services_IAM and the auth policy is deleted, all requests will be denied by default. If you are trying to remove the auth policy completely, you must set the auth_type to NONE. If auth is enabled on the resource, but no auth policy is set, all requests will be denied.

        Parameters:
        deleteAuthPolicyRequest -
        Returns:
        A Java Future containing the result of the DeleteAuthPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteAuthPolicy

        default CompletableFuture<DeleteAuthPolicyResponse> deleteAuthPolicy​(Consumer<DeleteAuthPolicyRequest.Builder> deleteAuthPolicyRequest)

        Deletes the specified auth policy. If an auth is set to Amazon Web Services_IAM and the auth policy is deleted, all requests will be denied by default. If you are trying to remove the auth policy completely, you must set the auth_type to NONE. If auth is enabled on the resource, but no auth policy is set, all requests will be denied.


        This is a convenience which creates an instance of the DeleteAuthPolicyRequest.Builder avoiding the need to create one manually via DeleteAuthPolicyRequest.builder()

        Parameters:
        deleteAuthPolicyRequest - A Consumer that will call methods on DeleteAuthPolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteAuthPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteListener

        default CompletableFuture<DeleteListenerResponse> deleteListener​(DeleteListenerRequest deleteListenerRequest)

        Deletes the specified listener.

        Parameters:
        deleteListenerRequest -
        Returns:
        A Java Future containing the result of the DeleteListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteListener

        default CompletableFuture<DeleteListenerResponse> deleteListener​(Consumer<DeleteListenerRequest.Builder> deleteListenerRequest)

        Deletes the specified listener.


        This is a convenience which creates an instance of the DeleteListenerRequest.Builder avoiding the need to create one manually via DeleteListenerRequest.builder()

        Parameters:
        deleteListenerRequest - A Consumer that will call methods on DeleteListenerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteResourcePolicy

        default CompletableFuture<DeleteResourcePolicyResponse> deleteResourcePolicy​(DeleteResourcePolicyRequest deleteResourcePolicyRequest)

        Deletes the specified resource policy.

        Parameters:
        deleteResourcePolicyRequest -
        Returns:
        A Java Future containing the result of the DeleteResourcePolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteResourcePolicy

        default CompletableFuture<DeleteResourcePolicyResponse> deleteResourcePolicy​(Consumer<DeleteResourcePolicyRequest.Builder> deleteResourcePolicyRequest)

        Deletes the specified resource policy.


        This is a convenience which creates an instance of the DeleteResourcePolicyRequest.Builder avoiding the need to create one manually via DeleteResourcePolicyRequest.builder()

        Parameters:
        deleteResourcePolicyRequest - A Consumer that will call methods on DeleteResourcePolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteResourcePolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteRule

        default CompletableFuture<DeleteRuleResponse> deleteRule​(DeleteRuleRequest deleteRuleRequest)

        Deletes a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. You can delete additional listener rules, but you cannot delete the default rule.

        For more information, see Listener rules in the Amazon VPC Lattice User Guide.

        Parameters:
        deleteRuleRequest -
        Returns:
        A Java Future containing the result of the DeleteRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteRule

        default CompletableFuture<DeleteRuleResponse> deleteRule​(Consumer<DeleteRuleRequest.Builder> deleteRuleRequest)

        Deletes a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. You can delete additional listener rules, but you cannot delete the default rule.

        For more information, see Listener rules in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the DeleteRuleRequest.Builder avoiding the need to create one manually via DeleteRuleRequest.builder()

        Parameters:
        deleteRuleRequest - A Consumer that will call methods on DeleteRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteService

        default CompletableFuture<DeleteServiceResponse> deleteService​(DeleteServiceRequest deleteServiceRequest)

        Deletes a service. A service can't be deleted if it's associated with a service network. If you delete a service, all resources related to the service, such as the resource policy, auth policy, listeners, listener rules, and access log subscriptions, are also deleted. For more information, see Delete a service in the Amazon VPC Lattice User Guide.

        Parameters:
        deleteServiceRequest -
        Returns:
        A Java Future containing the result of the DeleteService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteService

        default CompletableFuture<DeleteServiceResponse> deleteService​(Consumer<DeleteServiceRequest.Builder> deleteServiceRequest)

        Deletes a service. A service can't be deleted if it's associated with a service network. If you delete a service, all resources related to the service, such as the resource policy, auth policy, listeners, listener rules, and access log subscriptions, are also deleted. For more information, see Delete a service in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the DeleteServiceRequest.Builder avoiding the need to create one manually via DeleteServiceRequest.builder()

        Parameters:
        deleteServiceRequest - A Consumer that will call methods on DeleteServiceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteServiceNetwork

        default CompletableFuture<DeleteServiceNetworkResponse> deleteServiceNetwork​(DeleteServiceNetworkRequest deleteServiceNetworkRequest)

        Deletes a service network. You can only delete the service network if there is no service or VPC associated with it. If you delete a service network, all resources related to the service network, such as the resource policy, auth policy, and access log subscriptions, are also deleted. For more information, see Delete a service network in the Amazon VPC Lattice User Guide.

        Parameters:
        deleteServiceNetworkRequest -
        Returns:
        A Java Future containing the result of the DeleteServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteServiceNetwork

        default CompletableFuture<DeleteServiceNetworkResponse> deleteServiceNetwork​(Consumer<DeleteServiceNetworkRequest.Builder> deleteServiceNetworkRequest)

        Deletes a service network. You can only delete the service network if there is no service or VPC associated with it. If you delete a service network, all resources related to the service network, such as the resource policy, auth policy, and access log subscriptions, are also deleted. For more information, see Delete a service network in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the DeleteServiceNetworkRequest.Builder avoiding the need to create one manually via DeleteServiceNetworkRequest.builder()

        Parameters:
        deleteServiceNetworkRequest - A Consumer that will call methods on DeleteServiceNetworkRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteServiceNetworkServiceAssociation

        default CompletableFuture<DeleteServiceNetworkServiceAssociationResponse> deleteServiceNetworkServiceAssociation​(DeleteServiceNetworkServiceAssociationRequest deleteServiceNetworkServiceAssociationRequest)

        Deletes the association between a specified service and the specific service network. This request will fail if an association is still in progress.

        Parameters:
        deleteServiceNetworkServiceAssociationRequest -
        Returns:
        A Java Future containing the result of the DeleteServiceNetworkServiceAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteServiceNetworkServiceAssociation

        default CompletableFuture<DeleteServiceNetworkServiceAssociationResponse> deleteServiceNetworkServiceAssociation​(Consumer<DeleteServiceNetworkServiceAssociationRequest.Builder> deleteServiceNetworkServiceAssociationRequest)

        Deletes the association between a specified service and the specific service network. This request will fail if an association is still in progress.


        This is a convenience which creates an instance of the DeleteServiceNetworkServiceAssociationRequest.Builder avoiding the need to create one manually via DeleteServiceNetworkServiceAssociationRequest.builder()

        Parameters:
        deleteServiceNetworkServiceAssociationRequest - A Consumer that will call methods on DeleteServiceNetworkServiceAssociationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteServiceNetworkServiceAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteServiceNetworkVpcAssociation

        default CompletableFuture<DeleteServiceNetworkVpcAssociationResponse> deleteServiceNetworkVpcAssociation​(DeleteServiceNetworkVpcAssociationRequest deleteServiceNetworkVpcAssociationRequest)

        Disassociates the VPC from the service network. You can't disassociate the VPC if there is a create or update association in progress.

        Parameters:
        deleteServiceNetworkVpcAssociationRequest -
        Returns:
        A Java Future containing the result of the DeleteServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteServiceNetworkVpcAssociation

        default CompletableFuture<DeleteServiceNetworkVpcAssociationResponse> deleteServiceNetworkVpcAssociation​(Consumer<DeleteServiceNetworkVpcAssociationRequest.Builder> deleteServiceNetworkVpcAssociationRequest)

        Disassociates the VPC from the service network. You can't disassociate the VPC if there is a create or update association in progress.


        This is a convenience which creates an instance of the DeleteServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via DeleteServiceNetworkVpcAssociationRequest.builder()

        Parameters:
        deleteServiceNetworkVpcAssociationRequest - A Consumer that will call methods on DeleteServiceNetworkVpcAssociationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteTargetGroup

        default CompletableFuture<DeleteTargetGroupResponse> deleteTargetGroup​(DeleteTargetGroupRequest deleteTargetGroupRequest)

        Deletes a target group. You can't delete a target group if it is used in a listener rule or if the target group creation is in progress.

        Parameters:
        deleteTargetGroupRequest -
        Returns:
        A Java Future containing the result of the DeleteTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteTargetGroup

        default CompletableFuture<DeleteTargetGroupResponse> deleteTargetGroup​(Consumer<DeleteTargetGroupRequest.Builder> deleteTargetGroupRequest)

        Deletes a target group. You can't delete a target group if it is used in a listener rule or if the target group creation is in progress.


        This is a convenience which creates an instance of the DeleteTargetGroupRequest.Builder avoiding the need to create one manually via DeleteTargetGroupRequest.builder()

        Parameters:
        deleteTargetGroupRequest - A Consumer that will call methods on DeleteTargetGroupRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deregisterTargets

        default CompletableFuture<DeregisterTargetsResponse> deregisterTargets​(DeregisterTargetsRequest deregisterTargetsRequest)

        Deregisters the specified targets from the specified target group.

        Parameters:
        deregisterTargetsRequest -
        Returns:
        A Java Future containing the result of the DeregisterTargets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deregisterTargets

        default CompletableFuture<DeregisterTargetsResponse> deregisterTargets​(Consumer<DeregisterTargetsRequest.Builder> deregisterTargetsRequest)

        Deregisters the specified targets from the specified target group.


        This is a convenience which creates an instance of the DeregisterTargetsRequest.Builder avoiding the need to create one manually via DeregisterTargetsRequest.builder()

        Parameters:
        deregisterTargetsRequest - A Consumer that will call methods on DeregisterTargetsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeregisterTargets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getAccessLogSubscription

        default CompletableFuture<GetAccessLogSubscriptionResponse> getAccessLogSubscription​(GetAccessLogSubscriptionRequest getAccessLogSubscriptionRequest)

        Retrieves information about the specified access log subscription.

        Parameters:
        getAccessLogSubscriptionRequest -
        Returns:
        A Java Future containing the result of the GetAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getAccessLogSubscription

        default CompletableFuture<GetAccessLogSubscriptionResponse> getAccessLogSubscription​(Consumer<GetAccessLogSubscriptionRequest.Builder> getAccessLogSubscriptionRequest)

        Retrieves information about the specified access log subscription.


        This is a convenience which creates an instance of the GetAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via GetAccessLogSubscriptionRequest.builder()

        Parameters:
        getAccessLogSubscriptionRequest - A Consumer that will call methods on GetAccessLogSubscriptionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getAuthPolicy

        default CompletableFuture<GetAuthPolicyResponse> getAuthPolicy​(GetAuthPolicyRequest getAuthPolicyRequest)

        Retrieves information about the auth policy for the specified service or service network.

        Parameters:
        getAuthPolicyRequest -
        Returns:
        A Java Future containing the result of the GetAuthPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getAuthPolicy

        default CompletableFuture<GetAuthPolicyResponse> getAuthPolicy​(Consumer<GetAuthPolicyRequest.Builder> getAuthPolicyRequest)

        Retrieves information about the auth policy for the specified service or service network.


        This is a convenience which creates an instance of the GetAuthPolicyRequest.Builder avoiding the need to create one manually via GetAuthPolicyRequest.builder()

        Parameters:
        getAuthPolicyRequest - A Consumer that will call methods on GetAuthPolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetAuthPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getListener

        default CompletableFuture<GetListenerResponse> getListener​(GetListenerRequest getListenerRequest)

        Retrieves information about the specified listener for the specified service.

        Parameters:
        getListenerRequest -
        Returns:
        A Java Future containing the result of the GetListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getListener

        default CompletableFuture<GetListenerResponse> getListener​(Consumer<GetListenerRequest.Builder> getListenerRequest)

        Retrieves information about the specified listener for the specified service.


        This is a convenience which creates an instance of the GetListenerRequest.Builder avoiding the need to create one manually via GetListenerRequest.builder()

        Parameters:
        getListenerRequest - A Consumer that will call methods on GetListenerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getResourcePolicy

        default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy​(GetResourcePolicyRequest getResourcePolicyRequest)

        Retrieves information about the resource policy. The resource policy is an IAM policy created by AWS RAM on behalf of the resource owner when they share a resource.

        Parameters:
        getResourcePolicyRequest -
        Returns:
        A Java Future containing the result of the GetResourcePolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getResourcePolicy

        default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy​(Consumer<GetResourcePolicyRequest.Builder> getResourcePolicyRequest)

        Retrieves information about the resource policy. The resource policy is an IAM policy created by AWS RAM on behalf of the resource owner when they share a resource.


        This is a convenience which creates an instance of the GetResourcePolicyRequest.Builder avoiding the need to create one manually via GetResourcePolicyRequest.builder()

        Parameters:
        getResourcePolicyRequest - A Consumer that will call methods on GetResourcePolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetResourcePolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getRule

        default CompletableFuture<GetRuleResponse> getRule​(GetRuleRequest getRuleRequest)

        Retrieves information about listener rules. You can also retrieve information about the default listener rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.

        Parameters:
        getRuleRequest -
        Returns:
        A Java Future containing the result of the GetRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getRule

        default CompletableFuture<GetRuleResponse> getRule​(Consumer<GetRuleRequest.Builder> getRuleRequest)

        Retrieves information about listener rules. You can also retrieve information about the default listener rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.


        This is a convenience which creates an instance of the GetRuleRequest.Builder avoiding the need to create one manually via GetRuleRequest.builder()

        Parameters:
        getRuleRequest - A Consumer that will call methods on GetRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getService

        default CompletableFuture<GetServiceResponse> getService​(GetServiceRequest getServiceRequest)

        Retrieves information about the specified service.

        Parameters:
        getServiceRequest -
        Returns:
        A Java Future containing the result of the GetService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getService

        default CompletableFuture<GetServiceResponse> getService​(Consumer<GetServiceRequest.Builder> getServiceRequest)

        Retrieves information about the specified service.


        This is a convenience which creates an instance of the GetServiceRequest.Builder avoiding the need to create one manually via GetServiceRequest.builder()

        Parameters:
        getServiceRequest - A Consumer that will call methods on GetServiceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getServiceNetwork

        default CompletableFuture<GetServiceNetworkResponse> getServiceNetwork​(GetServiceNetworkRequest getServiceNetworkRequest)

        Retrieves information about the specified service network.

        Parameters:
        getServiceNetworkRequest -
        Returns:
        A Java Future containing the result of the GetServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getServiceNetwork

        default CompletableFuture<GetServiceNetworkResponse> getServiceNetwork​(Consumer<GetServiceNetworkRequest.Builder> getServiceNetworkRequest)

        Retrieves information about the specified service network.


        This is a convenience which creates an instance of the GetServiceNetworkRequest.Builder avoiding the need to create one manually via GetServiceNetworkRequest.builder()

        Parameters:
        getServiceNetworkRequest - A Consumer that will call methods on GetServiceNetworkRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getServiceNetworkServiceAssociation

        default CompletableFuture<GetServiceNetworkServiceAssociationResponse> getServiceNetworkServiceAssociation​(GetServiceNetworkServiceAssociationRequest getServiceNetworkServiceAssociationRequest)

        Retrieves information about the specified association between a service network and a service.

        Parameters:
        getServiceNetworkServiceAssociationRequest -
        Returns:
        A Java Future containing the result of the GetServiceNetworkServiceAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getServiceNetworkServiceAssociation

        default CompletableFuture<GetServiceNetworkServiceAssociationResponse> getServiceNetworkServiceAssociation​(Consumer<GetServiceNetworkServiceAssociationRequest.Builder> getServiceNetworkServiceAssociationRequest)

        Retrieves information about the specified association between a service network and a service.


        This is a convenience which creates an instance of the GetServiceNetworkServiceAssociationRequest.Builder avoiding the need to create one manually via GetServiceNetworkServiceAssociationRequest.builder()

        Parameters:
        getServiceNetworkServiceAssociationRequest - A Consumer that will call methods on GetServiceNetworkServiceAssociationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetServiceNetworkServiceAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getServiceNetworkVpcAssociation

        default CompletableFuture<GetServiceNetworkVpcAssociationResponse> getServiceNetworkVpcAssociation​(GetServiceNetworkVpcAssociationRequest getServiceNetworkVpcAssociationRequest)

        Retrieves information about the association between a service network and a VPC.

        Parameters:
        getServiceNetworkVpcAssociationRequest -
        Returns:
        A Java Future containing the result of the GetServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getServiceNetworkVpcAssociation

        default CompletableFuture<GetServiceNetworkVpcAssociationResponse> getServiceNetworkVpcAssociation​(Consumer<GetServiceNetworkVpcAssociationRequest.Builder> getServiceNetworkVpcAssociationRequest)

        Retrieves information about the association between a service network and a VPC.


        This is a convenience which creates an instance of the GetServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via GetServiceNetworkVpcAssociationRequest.builder()

        Parameters:
        getServiceNetworkVpcAssociationRequest - A Consumer that will call methods on GetServiceNetworkVpcAssociationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getTargetGroup

        default CompletableFuture<GetTargetGroupResponse> getTargetGroup​(GetTargetGroupRequest getTargetGroupRequest)

        Retrieves information about the specified target group.

        Parameters:
        getTargetGroupRequest -
        Returns:
        A Java Future containing the result of the GetTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getTargetGroup

        default CompletableFuture<GetTargetGroupResponse> getTargetGroup​(Consumer<GetTargetGroupRequest.Builder> getTargetGroupRequest)

        Retrieves information about the specified target group.


        This is a convenience which creates an instance of the GetTargetGroupRequest.Builder avoiding the need to create one manually via GetTargetGroupRequest.builder()

        Parameters:
        getTargetGroupRequest - A Consumer that will call methods on GetTargetGroupRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listAccessLogSubscriptions

        default CompletableFuture<ListAccessLogSubscriptionsResponse> listAccessLogSubscriptions​(ListAccessLogSubscriptionsRequest listAccessLogSubscriptionsRequest)

        Lists all access log subscriptions for the specified service network or service.

        Parameters:
        listAccessLogSubscriptionsRequest -
        Returns:
        A Java Future containing the result of the ListAccessLogSubscriptions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listAccessLogSubscriptions

        default CompletableFuture<ListAccessLogSubscriptionsResponse> listAccessLogSubscriptions​(Consumer<ListAccessLogSubscriptionsRequest.Builder> listAccessLogSubscriptionsRequest)

        Lists all access log subscriptions for the specified service network or service.


        This is a convenience which creates an instance of the ListAccessLogSubscriptionsRequest.Builder avoiding the need to create one manually via ListAccessLogSubscriptionsRequest.builder()

        Parameters:
        listAccessLogSubscriptionsRequest - A Consumer that will call methods on ListAccessLogSubscriptionsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListAccessLogSubscriptions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listAccessLogSubscriptionsPaginator

        default ListAccessLogSubscriptionsPublisher listAccessLogSubscriptionsPaginator​(ListAccessLogSubscriptionsRequest listAccessLogSubscriptionsRequest)

        This is a variant of listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse 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 maxResults 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 listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) operation.

        Parameters:
        listAccessLogSubscriptionsRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listAccessLogSubscriptionsPaginator

        default ListAccessLogSubscriptionsPublisher listAccessLogSubscriptionsPaginator​(Consumer<ListAccessLogSubscriptionsRequest.Builder> listAccessLogSubscriptionsRequest)

        This is a variant of listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse 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 maxResults 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 listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) operation.


        This is a convenience which creates an instance of the ListAccessLogSubscriptionsRequest.Builder avoiding the need to create one manually via ListAccessLogSubscriptionsRequest.builder()

        Parameters:
        listAccessLogSubscriptionsRequest - A Consumer that will call methods on ListAccessLogSubscriptionsRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listListeners

        default CompletableFuture<ListListenersResponse> listListeners​(ListListenersRequest listListenersRequest)

        Lists the listeners for the specified service.

        Parameters:
        listListenersRequest -
        Returns:
        A Java Future containing the result of the ListListeners operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listListeners

        default CompletableFuture<ListListenersResponse> listListeners​(Consumer<ListListenersRequest.Builder> listListenersRequest)

        Lists the listeners for the specified service.


        This is a convenience which creates an instance of the ListListenersRequest.Builder avoiding the need to create one manually via ListListenersRequest.builder()

        Parameters:
        listListenersRequest - A Consumer that will call methods on ListListenersRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListListeners operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listListenersPaginator

        default ListListenersPublisher listListenersPaginator​(ListListenersRequest listListenersRequest)

        This is a variant of listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListListenersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListListenersResponse 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 maxResults 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 listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) operation.

        Parameters:
        listListenersRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listListenersPaginator

        default ListListenersPublisher listListenersPaginator​(Consumer<ListListenersRequest.Builder> listListenersRequest)

        This is a variant of listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListListenersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListListenersResponse 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 maxResults 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 listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) operation.


        This is a convenience which creates an instance of the ListListenersRequest.Builder avoiding the need to create one manually via ListListenersRequest.builder()

        Parameters:
        listListenersRequest - A Consumer that will call methods on ListListenersRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listRules

        default CompletableFuture<ListRulesResponse> listRules​(ListRulesRequest listRulesRequest)

        Lists the rules for the listener.

        Parameters:
        listRulesRequest -
        Returns:
        A Java Future containing the result of the ListRules operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listRules

        default CompletableFuture<ListRulesResponse> listRules​(Consumer<ListRulesRequest.Builder> listRulesRequest)

        Lists the rules for the listener.


        This is a convenience which creates an instance of the ListRulesRequest.Builder avoiding the need to create one manually via ListRulesRequest.builder()

        Parameters:
        listRulesRequest - A Consumer that will call methods on ListRulesRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListRules operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listRulesPaginator

        default ListRulesPublisher listRulesPaginator​(ListRulesRequest listRulesRequest)

        This is a variant of listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListRulesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListRulesResponse 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 maxResults 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 listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) operation.

        Parameters:
        listRulesRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listRulesPaginator

        default ListRulesPublisher listRulesPaginator​(Consumer<ListRulesRequest.Builder> listRulesRequest)

        This is a variant of listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListRulesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListRulesResponse 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 maxResults 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 listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) operation.


        This is a convenience which creates an instance of the ListRulesRequest.Builder avoiding the need to create one manually via ListRulesRequest.builder()

        Parameters:
        listRulesRequest - A Consumer that will call methods on ListRulesRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkServiceAssociations

        default CompletableFuture<ListServiceNetworkServiceAssociationsResponse> listServiceNetworkServiceAssociations​(ListServiceNetworkServiceAssociationsRequest listServiceNetworkServiceAssociationsRequest)

        Lists the associations between the service network and the service. You can filter the list either by service or service network. You must provide either the service network identifier or the service identifier.

        Every association in Amazon VPC Lattice is given a unique Amazon Resource Name (ARN), such as when a service network is associated with a VPC or when a service is associated with a service network. If the association is for a resource that is shared with another account, the association will include the local account ID as the prefix in the ARN for each account the resource is shared with.

        Parameters:
        listServiceNetworkServiceAssociationsRequest -
        Returns:
        A Java Future containing the result of the ListServiceNetworkServiceAssociations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkServiceAssociations

        default CompletableFuture<ListServiceNetworkServiceAssociationsResponse> listServiceNetworkServiceAssociations​(Consumer<ListServiceNetworkServiceAssociationsRequest.Builder> listServiceNetworkServiceAssociationsRequest)

        Lists the associations between the service network and the service. You can filter the list either by service or service network. You must provide either the service network identifier or the service identifier.

        Every association in Amazon VPC Lattice is given a unique Amazon Resource Name (ARN), such as when a service network is associated with a VPC or when a service is associated with a service network. If the association is for a resource that is shared with another account, the association will include the local account ID as the prefix in the ARN for each account the resource is shared with.


        This is a convenience which creates an instance of the ListServiceNetworkServiceAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkServiceAssociationsRequest.builder()

        Parameters:
        listServiceNetworkServiceAssociationsRequest - A Consumer that will call methods on ListServiceNetworkServiceAssociationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListServiceNetworkServiceAssociations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkServiceAssociationsPaginator

        default ListServiceNetworkServiceAssociationsPublisher listServiceNetworkServiceAssociationsPaginator​(ListServiceNetworkServiceAssociationsRequest listServiceNetworkServiceAssociationsRequest)

        This is a variant of listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse 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 maxResults 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 listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) operation.

        Parameters:
        listServiceNetworkServiceAssociationsRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkServiceAssociationsPaginator

        default ListServiceNetworkServiceAssociationsPublisher listServiceNetworkServiceAssociationsPaginator​(Consumer<ListServiceNetworkServiceAssociationsRequest.Builder> listServiceNetworkServiceAssociationsRequest)

        This is a variant of listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse 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 maxResults 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 listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) operation.


        This is a convenience which creates an instance of the ListServiceNetworkServiceAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkServiceAssociationsRequest.builder()

        Parameters:
        listServiceNetworkServiceAssociationsRequest - A Consumer that will call methods on ListServiceNetworkServiceAssociationsRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkVpcAssociations

        default CompletableFuture<ListServiceNetworkVpcAssociationsResponse> listServiceNetworkVpcAssociations​(ListServiceNetworkVpcAssociationsRequest listServiceNetworkVpcAssociationsRequest)

        Lists the service network and VPC associations. You can filter the list either by VPC or service network. You must provide either the service network identifier or the VPC identifier.

        Parameters:
        listServiceNetworkVpcAssociationsRequest -
        Returns:
        A Java Future containing the result of the ListServiceNetworkVpcAssociations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkVpcAssociations

        default CompletableFuture<ListServiceNetworkVpcAssociationsResponse> listServiceNetworkVpcAssociations​(Consumer<ListServiceNetworkVpcAssociationsRequest.Builder> listServiceNetworkVpcAssociationsRequest)

        Lists the service network and VPC associations. You can filter the list either by VPC or service network. You must provide either the service network identifier or the VPC identifier.


        This is a convenience which creates an instance of the ListServiceNetworkVpcAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkVpcAssociationsRequest.builder()

        Parameters:
        listServiceNetworkVpcAssociationsRequest - A Consumer that will call methods on ListServiceNetworkVpcAssociationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListServiceNetworkVpcAssociations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkVpcAssociationsPaginator

        default ListServiceNetworkVpcAssociationsPublisher listServiceNetworkVpcAssociationsPaginator​(ListServiceNetworkVpcAssociationsRequest listServiceNetworkVpcAssociationsRequest)

        This is a variant of listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse 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 maxResults 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 listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) operation.

        Parameters:
        listServiceNetworkVpcAssociationsRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworkVpcAssociationsPaginator

        default ListServiceNetworkVpcAssociationsPublisher listServiceNetworkVpcAssociationsPaginator​(Consumer<ListServiceNetworkVpcAssociationsRequest.Builder> listServiceNetworkVpcAssociationsRequest)

        This is a variant of listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse 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 maxResults 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 listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) operation.


        This is a convenience which creates an instance of the ListServiceNetworkVpcAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkVpcAssociationsRequest.builder()

        Parameters:
        listServiceNetworkVpcAssociationsRequest - A Consumer that will call methods on ListServiceNetworkVpcAssociationsRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworks

        default CompletableFuture<ListServiceNetworksResponse> listServiceNetworks​(ListServiceNetworksRequest listServiceNetworksRequest)

        Lists the service networks owned by the caller account or shared with the caller account. Also includes the account ID in the ARN to show which account owns the service network.

        Parameters:
        listServiceNetworksRequest -
        Returns:
        A Java Future containing the result of the ListServiceNetworks operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworks

        default CompletableFuture<ListServiceNetworksResponse> listServiceNetworks​(Consumer<ListServiceNetworksRequest.Builder> listServiceNetworksRequest)

        Lists the service networks owned by the caller account or shared with the caller account. Also includes the account ID in the ARN to show which account owns the service network.


        This is a convenience which creates an instance of the ListServiceNetworksRequest.Builder avoiding the need to create one manually via ListServiceNetworksRequest.builder()

        Parameters:
        listServiceNetworksRequest - A Consumer that will call methods on ListServiceNetworksRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListServiceNetworks operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworksPaginator

        default ListServiceNetworksPublisher listServiceNetworksPaginator​(ListServiceNetworksRequest listServiceNetworksRequest)

        This is a variant of listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse 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 maxResults 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 listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) operation.

        Parameters:
        listServiceNetworksRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServiceNetworksPaginator

        default ListServiceNetworksPublisher listServiceNetworksPaginator​(Consumer<ListServiceNetworksRequest.Builder> listServiceNetworksRequest)

        This is a variant of listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse 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 maxResults 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 listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) operation.


        This is a convenience which creates an instance of the ListServiceNetworksRequest.Builder avoiding the need to create one manually via ListServiceNetworksRequest.builder()

        Parameters:
        listServiceNetworksRequest - A Consumer that will call methods on ListServiceNetworksRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServices

        default CompletableFuture<ListServicesResponse> listServices​(ListServicesRequest listServicesRequest)

        Lists the services owned by the caller account or shared with the caller account.

        Parameters:
        listServicesRequest -
        Returns:
        A Java Future containing the result of the ListServices operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServices

        default CompletableFuture<ListServicesResponse> listServices​(Consumer<ListServicesRequest.Builder> listServicesRequest)

        Lists the services owned by the caller account or shared with the caller account.


        This is a convenience which creates an instance of the ListServicesRequest.Builder avoiding the need to create one manually via ListServicesRequest.builder()

        Parameters:
        listServicesRequest - A Consumer that will call methods on ListServicesRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListServices operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServicesPaginator

        default ListServicesPublisher listServicesPaginator​(ListServicesRequest listServicesRequest)

        This is a variant of listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServicesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServicesResponse 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 maxResults 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 listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) operation.

        Parameters:
        listServicesRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listServicesPaginator

        default ListServicesPublisher listServicesPaginator​(Consumer<ListServicesRequest.Builder> listServicesRequest)

        This is a variant of listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServicesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServicesResponse 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 maxResults 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 listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) operation.


        This is a convenience which creates an instance of the ListServicesRequest.Builder avoiding the need to create one manually via ListServicesRequest.builder()

        Parameters:
        listServicesRequest - A Consumer that will call methods on ListServicesRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTagsForResource

        default CompletableFuture<ListTagsForResourceResponse> listTagsForResource​(ListTagsForResourceRequest listTagsForResourceRequest)

        Lists the tags for the specified resource.

        Parameters:
        listTagsForResourceRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTagsForResource

        default CompletableFuture<ListTagsForResourceResponse> listTagsForResource​(Consumer<ListTagsForResourceRequest.Builder> listTagsForResourceRequest)

        Lists the tags for the specified resource.


        This is a convenience which creates an instance of the ListTagsForResourceRequest.Builder avoiding the need to create one manually via ListTagsForResourceRequest.builder()

        Parameters:
        listTagsForResourceRequest - A Consumer that will call methods on ListTagsForResourceRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargetGroups

        default CompletableFuture<ListTargetGroupsResponse> listTargetGroups​(ListTargetGroupsRequest listTargetGroupsRequest)

        Lists your target groups. You can narrow your search by using the filters below in your request.

        Parameters:
        listTargetGroupsRequest -
        Returns:
        A Java Future containing the result of the ListTargetGroups operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargetGroups

        default CompletableFuture<ListTargetGroupsResponse> listTargetGroups​(Consumer<ListTargetGroupsRequest.Builder> listTargetGroupsRequest)

        Lists your target groups. You can narrow your search by using the filters below in your request.


        This is a convenience which creates an instance of the ListTargetGroupsRequest.Builder avoiding the need to create one manually via ListTargetGroupsRequest.builder()

        Parameters:
        listTargetGroupsRequest - A Consumer that will call methods on ListTargetGroupsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListTargetGroups operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargetGroupsPaginator

        default ListTargetGroupsPublisher listTargetGroupsPaginator​(ListTargetGroupsRequest listTargetGroupsRequest)

        This is a variant of listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse 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 maxResults 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 listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) operation.

        Parameters:
        listTargetGroupsRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargetGroupsPaginator

        default ListTargetGroupsPublisher listTargetGroupsPaginator​(Consumer<ListTargetGroupsRequest.Builder> listTargetGroupsRequest)

        This is a variant of listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse 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 maxResults 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 listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) operation.


        This is a convenience which creates an instance of the ListTargetGroupsRequest.Builder avoiding the need to create one manually via ListTargetGroupsRequest.builder()

        Parameters:
        listTargetGroupsRequest - A Consumer that will call methods on ListTargetGroupsRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargets

        default CompletableFuture<ListTargetsResponse> listTargets​(ListTargetsRequest listTargetsRequest)

        Lists the targets for the target group. By default, all targets are included. You can use this API to check the health status of targets. You can also filter the results by target.

        Parameters:
        listTargetsRequest -
        Returns:
        A Java Future containing the result of the ListTargets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargets

        default CompletableFuture<ListTargetsResponse> listTargets​(Consumer<ListTargetsRequest.Builder> listTargetsRequest)

        Lists the targets for the target group. By default, all targets are included. You can use this API to check the health status of targets. You can also filter the results by target.


        This is a convenience which creates an instance of the ListTargetsRequest.Builder avoiding the need to create one manually via ListTargetsRequest.builder()

        Parameters:
        listTargetsRequest - A Consumer that will call methods on ListTargetsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListTargets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargetsPaginator

        default ListTargetsPublisher listTargetsPaginator​(ListTargetsRequest listTargetsRequest)

        This is a variant of listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse 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 maxResults 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 listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) operation.

        Parameters:
        listTargetsRequest -
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTargetsPaginator

        default ListTargetsPublisher listTargetsPaginator​(Consumer<ListTargetsRequest.Builder> listTargetsRequest)

        This is a variant of listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) 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 Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new 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 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse 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 maxResults 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 listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) operation.


        This is a convenience which creates an instance of the ListTargetsRequest.Builder avoiding the need to create one manually via ListTargetsRequest.builder()

        Parameters:
        listTargetsRequest - A Consumer that will call methods on ListTargetsRequest.Builder to create a request.
        Returns:
        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.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • putAuthPolicy

        default CompletableFuture<PutAuthPolicyResponse> putAuthPolicy​(PutAuthPolicyRequest putAuthPolicyRequest)

        Creates or updates the auth policy.

        Parameters:
        putAuthPolicyRequest -
        Returns:
        A Java Future containing the result of the PutAuthPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • putAuthPolicy

        default CompletableFuture<PutAuthPolicyResponse> putAuthPolicy​(Consumer<PutAuthPolicyRequest.Builder> putAuthPolicyRequest)

        Creates or updates the auth policy.


        This is a convenience which creates an instance of the PutAuthPolicyRequest.Builder avoiding the need to create one manually via PutAuthPolicyRequest.builder()

        Parameters:
        putAuthPolicyRequest - A Consumer that will call methods on PutAuthPolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the PutAuthPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • putResourcePolicy

        default CompletableFuture<PutResourcePolicyResponse> putResourcePolicy​(PutResourcePolicyRequest putResourcePolicyRequest)

        Attaches a resource-based permission policy to a service or service network. The policy must contain the same actions and condition statements as the Amazon Web Services Resource Access Manager permission for sharing services and service networks.

        Parameters:
        putResourcePolicyRequest -
        Returns:
        A Java Future containing the result of the PutResourcePolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • putResourcePolicy

        default CompletableFuture<PutResourcePolicyResponse> putResourcePolicy​(Consumer<PutResourcePolicyRequest.Builder> putResourcePolicyRequest)

        Attaches a resource-based permission policy to a service or service network. The policy must contain the same actions and condition statements as the Amazon Web Services Resource Access Manager permission for sharing services and service networks.


        This is a convenience which creates an instance of the PutResourcePolicyRequest.Builder avoiding the need to create one manually via PutResourcePolicyRequest.builder()

        Parameters:
        putResourcePolicyRequest - A Consumer that will call methods on PutResourcePolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the PutResourcePolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • registerTargets

        default CompletableFuture<RegisterTargetsResponse> registerTargets​(RegisterTargetsRequest registerTargetsRequest)

        Registers the targets with the target group. If it's a Lambda target, you can only have one target in a target group.

        Parameters:
        registerTargetsRequest -
        Returns:
        A Java Future containing the result of the RegisterTargets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • registerTargets

        default CompletableFuture<RegisterTargetsResponse> registerTargets​(Consumer<RegisterTargetsRequest.Builder> registerTargetsRequest)

        Registers the targets with the target group. If it's a Lambda target, you can only have one target in a target group.


        This is a convenience which creates an instance of the RegisterTargetsRequest.Builder avoiding the need to create one manually via RegisterTargetsRequest.builder()

        Parameters:
        registerTargetsRequest - A Consumer that will call methods on RegisterTargetsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the RegisterTargets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • tagResource

        default CompletableFuture<TagResourceResponse> tagResource​(TagResourceRequest tagResourceRequest)

        Adds the specified tags to the specified resource.

        Parameters:
        tagResourceRequest -
        Returns:
        A Java Future containing the result of the TagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • tagResource

        default CompletableFuture<TagResourceResponse> tagResource​(Consumer<TagResourceRequest.Builder> tagResourceRequest)

        Adds the specified tags to the specified resource.


        This is a convenience which creates an instance of the TagResourceRequest.Builder avoiding the need to create one manually via TagResourceRequest.builder()

        Parameters:
        tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the TagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • untagResource

        default CompletableFuture<UntagResourceResponse> untagResource​(UntagResourceRequest untagResourceRequest)

        Removes the specified tags from the specified resource.

        Parameters:
        untagResourceRequest -
        Returns:
        A Java Future containing the result of the UntagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • untagResource

        default CompletableFuture<UntagResourceResponse> untagResource​(Consumer<UntagResourceRequest.Builder> untagResourceRequest)

        Removes the specified tags from the specified resource.


        This is a convenience which creates an instance of the UntagResourceRequest.Builder avoiding the need to create one manually via UntagResourceRequest.builder()

        Parameters:
        untagResourceRequest - A Consumer that will call methods on UntagResourceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UntagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ResourceNotFoundException The request references a resource that does not exist.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateAccessLogSubscription

        default CompletableFuture<UpdateAccessLogSubscriptionResponse> updateAccessLogSubscription​(UpdateAccessLogSubscriptionRequest updateAccessLogSubscriptionRequest)

        Updates the specified access log subscription.

        Parameters:
        updateAccessLogSubscriptionRequest -
        Returns:
        A Java Future containing the result of the UpdateAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateAccessLogSubscription

        default CompletableFuture<UpdateAccessLogSubscriptionResponse> updateAccessLogSubscription​(Consumer<UpdateAccessLogSubscriptionRequest.Builder> updateAccessLogSubscriptionRequest)

        Updates the specified access log subscription.


        This is a convenience which creates an instance of the UpdateAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via UpdateAccessLogSubscriptionRequest.builder()

        Parameters:
        updateAccessLogSubscriptionRequest - A Consumer that will call methods on UpdateAccessLogSubscriptionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateAccessLogSubscription operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateListener

        default CompletableFuture<UpdateListenerResponse> updateListener​(UpdateListenerRequest updateListenerRequest)

        Updates the specified listener for the specified service.

        Parameters:
        updateListenerRequest -
        Returns:
        A Java Future containing the result of the UpdateListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateListener

        default CompletableFuture<UpdateListenerResponse> updateListener​(Consumer<UpdateListenerRequest.Builder> updateListenerRequest)

        Updates the specified listener for the specified service.


        This is a convenience which creates an instance of the UpdateListenerRequest.Builder avoiding the need to create one manually via UpdateListenerRequest.builder()

        Parameters:
        updateListenerRequest - A Consumer that will call methods on UpdateListenerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateListener operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateRule

        default CompletableFuture<UpdateRuleResponse> updateRule​(UpdateRuleRequest updateRuleRequest)

        Updates a rule for the listener. You can't modify a default listener rule. To modify a default listener rule, use UpdateListener.

        Parameters:
        updateRuleRequest -
        Returns:
        A Java Future containing the result of the UpdateRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateRule

        default CompletableFuture<UpdateRuleResponse> updateRule​(Consumer<UpdateRuleRequest.Builder> updateRuleRequest)

        Updates a rule for the listener. You can't modify a default listener rule. To modify a default listener rule, use UpdateListener.


        This is a convenience which creates an instance of the UpdateRuleRequest.Builder avoiding the need to create one manually via UpdateRuleRequest.builder()

        Parameters:
        updateRuleRequest - A Consumer that will call methods on UpdateRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateService

        default CompletableFuture<UpdateServiceResponse> updateService​(UpdateServiceRequest updateServiceRequest)

        Updates the specified service.

        Parameters:
        updateServiceRequest -
        Returns:
        A Java Future containing the result of the UpdateService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateService

        default CompletableFuture<UpdateServiceResponse> updateService​(Consumer<UpdateServiceRequest.Builder> updateServiceRequest)

        Updates the specified service.


        This is a convenience which creates an instance of the UpdateServiceRequest.Builder avoiding the need to create one manually via UpdateServiceRequest.builder()

        Parameters:
        updateServiceRequest - A Consumer that will call methods on UpdateServiceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateService operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateServiceNetwork

        default CompletableFuture<UpdateServiceNetworkResponse> updateServiceNetwork​(UpdateServiceNetworkRequest updateServiceNetworkRequest)

        Updates the specified service network.

        Parameters:
        updateServiceNetworkRequest -
        Returns:
        A Java Future containing the result of the UpdateServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateServiceNetwork

        default CompletableFuture<UpdateServiceNetworkResponse> updateServiceNetwork​(Consumer<UpdateServiceNetworkRequest.Builder> updateServiceNetworkRequest)

        Updates the specified service network.


        This is a convenience which creates an instance of the UpdateServiceNetworkRequest.Builder avoiding the need to create one manually via UpdateServiceNetworkRequest.builder()

        Parameters:
        updateServiceNetworkRequest - A Consumer that will call methods on UpdateServiceNetworkRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateServiceNetwork operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateServiceNetworkVpcAssociation

        default CompletableFuture<UpdateServiceNetworkVpcAssociationResponse> updateServiceNetworkVpcAssociation​(UpdateServiceNetworkVpcAssociationRequest updateServiceNetworkVpcAssociationRequest)

        Updates the service network and VPC association. Once you add a security group, it cannot be removed.

        Parameters:
        updateServiceNetworkVpcAssociationRequest -
        Returns:
        A Java Future containing the result of the UpdateServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateServiceNetworkVpcAssociation

        default CompletableFuture<UpdateServiceNetworkVpcAssociationResponse> updateServiceNetworkVpcAssociation​(Consumer<UpdateServiceNetworkVpcAssociationRequest.Builder> updateServiceNetworkVpcAssociationRequest)

        Updates the service network and VPC association. Once you add a security group, it cannot be removed.


        This is a convenience which creates an instance of the UpdateServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via UpdateServiceNetworkVpcAssociationRequest.builder()

        Parameters:
        updateServiceNetworkVpcAssociationRequest - A Consumer that will call methods on UpdateServiceNetworkVpcAssociationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateServiceNetworkVpcAssociation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateTargetGroup

        default CompletableFuture<UpdateTargetGroupResponse> updateTargetGroup​(UpdateTargetGroupRequest updateTargetGroupRequest)

        Updates the specified target group.

        Parameters:
        updateTargetGroupRequest -
        Returns:
        A Java Future containing the result of the UpdateTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateTargetGroup

        default CompletableFuture<UpdateTargetGroupResponse> updateTargetGroup​(Consumer<UpdateTargetGroupRequest.Builder> updateTargetGroupRequest)

        Updates the specified target group.


        This is a convenience which creates an instance of the UpdateTargetGroupRequest.Builder avoiding the need to create one manually via UpdateTargetGroupRequest.builder()

        Parameters:
        updateTargetGroupRequest - A Consumer that will call methods on UpdateTargetGroupRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateTargetGroup operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
        • AccessDeniedException The user does not have sufficient access to perform this action.
        • ThrottlingException The limit on the number of requests per second was exceeded.
        • ResourceNotFoundException The request references a resource that does not exist.
        • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
        • InternalServerException An unexpected error occurred while processing the request.
        • 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.
        • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation