Package software.amazon.awssdk.services.kafka

Interface KafkaAsyncClient

  • All Superinterfaces:
    AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
    @Generated("software.amazon.awssdk:codegen")
@ThreadSafe
public interface KafkaAsyncClient
extends AwsClient
    Service client for accessing Kafka asynchronously. This can be created using the static builder() method.The asynchronous client performs non-blocking I/O when configured with any SdkAsyncHttpClient supported in the SDK. However, full non-blocking is not guaranteed as the async client may perform blocking calls in some cases such as credentials retrieval and endpoint discovery as part of the async API call.

    The operations for managing an Amazon MSK cluster.

    • Method Detail

      • batchAssociateScramSecret

        default CompletableFuture<BatchAssociateScramSecretResponse> batchAssociateScramSecret​(BatchAssociateScramSecretRequest batchAssociateScramSecretRequest)

        Associates one or more Scram Secrets with an Amazon MSK cluster.

        Parameters:
        batchAssociateScramSecretRequest -

        Associates sasl scram secrets to cluster.

        Returns:
        A Java Future containing the result of the BatchAssociateScramSecret operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • batchAssociateScramSecret

        default CompletableFuture<BatchAssociateScramSecretResponse> batchAssociateScramSecret​(Consumer<BatchAssociateScramSecretRequest.Builder> batchAssociateScramSecretRequest)

        Associates one or more Scram Secrets with an Amazon MSK cluster.


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

        Parameters:
        batchAssociateScramSecretRequest - A Consumer that will call methods on BatchAssociateScramSecretRequest.Builder to create a request.

        Associates sasl scram secrets to cluster.

        Returns:
        A Java Future containing the result of the BatchAssociateScramSecret operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • batchDisassociateScramSecret

        default CompletableFuture<BatchDisassociateScramSecretResponse> batchDisassociateScramSecret​(BatchDisassociateScramSecretRequest batchDisassociateScramSecretRequest)

        Disassociates one or more Scram Secrets from an Amazon MSK cluster.

        Parameters:
        batchDisassociateScramSecretRequest -

        Disassociates sasl scram secrets to cluster.

        Returns:
        A Java Future containing the result of the BatchDisassociateScramSecret operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • batchDisassociateScramSecret

        default CompletableFuture<BatchDisassociateScramSecretResponse> batchDisassociateScramSecret​(Consumer<BatchDisassociateScramSecretRequest.Builder> batchDisassociateScramSecretRequest)

        Disassociates one or more Scram Secrets from an Amazon MSK cluster.


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

        Parameters:
        batchDisassociateScramSecretRequest - A Consumer that will call methods on BatchDisassociateScramSecretRequest.Builder to create a request.

        Disassociates sasl scram secrets to cluster.

        Returns:
        A Java Future containing the result of the BatchDisassociateScramSecret operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createCluster

        default CompletableFuture<CreateClusterResponse> createCluster​(CreateClusterRequest createClusterRequest)

        Creates a new MSK cluster.

        Parameters:
        createClusterRequest -
        Returns:
        A Java Future containing the result of the CreateCluster operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createCluster

        default CompletableFuture<CreateClusterResponse> createCluster​(Consumer<CreateClusterRequest.Builder> createClusterRequest)

        Creates a new MSK cluster.


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

        Parameters:
        createClusterRequest - A Consumer that will call methods on CreateClusterRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateCluster operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createClusterV2

        default CompletableFuture<CreateClusterV2Response> createClusterV2​(CreateClusterV2Request createClusterV2Request)

        Creates a new MSK cluster.

        Parameters:
        createClusterV2Request -
        Returns:
        A Java Future containing the result of the CreateClusterV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createClusterV2

        default CompletableFuture<CreateClusterV2Response> createClusterV2​(Consumer<CreateClusterV2Request.Builder> createClusterV2Request)

        Creates a new MSK cluster.


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

        Parameters:
        createClusterV2Request - A Consumer that will call methods on CreateClusterV2Request.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateClusterV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createConfiguration

        default CompletableFuture<CreateConfigurationResponse> createConfiguration​(CreateConfigurationRequest createConfigurationRequest)

        Creates a new MSK configuration.

        Parameters:
        createConfigurationRequest -
        Returns:
        A Java Future containing the result of the CreateConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createConfiguration

        default CompletableFuture<CreateConfigurationResponse> createConfiguration​(Consumer<CreateConfigurationRequest.Builder> createConfigurationRequest)

        Creates a new MSK configuration.


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

        Parameters:
        createConfigurationRequest - A Consumer that will call methods on CreateConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createReplicator

        default CompletableFuture<CreateReplicatorResponse> createReplicator​(CreateReplicatorRequest createReplicatorRequest)

        Creates the replicator.

        Parameters:
        createReplicatorRequest - Creates a replicator using the specified configuration.
        Returns:
        A Java Future containing the result of the CreateReplicator operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • ConflictException HTTP Status Code 409: Conflict. This replicator name already exists. Retry your request with another name.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createReplicator

        default CompletableFuture<CreateReplicatorResponse> createReplicator​(Consumer<CreateReplicatorRequest.Builder> createReplicatorRequest)

        Creates the replicator.


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

        Parameters:
        createReplicatorRequest - A Consumer that will call methods on CreateReplicatorRequest.Builder to create a request. Creates a replicator using the specified configuration.
        Returns:
        A Java Future containing the result of the CreateReplicator operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • ConflictException HTTP Status Code 409: Conflict. This replicator name already exists. Retry your request with another name.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createVpcConnection

        default CompletableFuture<CreateVpcConnectionResponse> createVpcConnection​(CreateVpcConnectionRequest createVpcConnectionRequest)

        Creates a new MSK VPC connection.

        Parameters:
        createVpcConnectionRequest -
        Returns:
        A Java Future containing the result of the CreateVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createVpcConnection

        default CompletableFuture<CreateVpcConnectionResponse> createVpcConnection​(Consumer<CreateVpcConnectionRequest.Builder> createVpcConnectionRequest)

        Creates a new MSK VPC connection.


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

        Parameters:
        createVpcConnectionRequest - A Consumer that will call methods on CreateVpcConnectionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteCluster

        default CompletableFuture<DeleteClusterResponse> deleteCluster​(DeleteClusterRequest deleteClusterRequest)

        Deletes the MSK cluster specified by the Amazon Resource Name (ARN) in the request.

        Parameters:
        deleteClusterRequest -
        Returns:
        A Java Future containing the result of the DeleteCluster operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteCluster

        default CompletableFuture<DeleteClusterResponse> deleteCluster​(Consumer<DeleteClusterRequest.Builder> deleteClusterRequest)

        Deletes the MSK cluster specified by the Amazon Resource Name (ARN) in the request.


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

        Parameters:
        deleteClusterRequest - A Consumer that will call methods on DeleteClusterRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteCluster operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteClusterPolicy

        default CompletableFuture<DeleteClusterPolicyResponse> deleteClusterPolicy​(DeleteClusterPolicyRequest deleteClusterPolicyRequest)

        Deletes the MSK cluster policy specified by the Amazon Resource Name (ARN) in the request.

        Parameters:
        deleteClusterPolicyRequest -
        Returns:
        A Java Future containing the result of the DeleteClusterPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteClusterPolicy

        default CompletableFuture<DeleteClusterPolicyResponse> deleteClusterPolicy​(Consumer<DeleteClusterPolicyRequest.Builder> deleteClusterPolicyRequest)

        Deletes the MSK cluster policy specified by the Amazon Resource Name (ARN) in the request.


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

        Parameters:
        deleteClusterPolicyRequest - A Consumer that will call methods on DeleteClusterPolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteClusterPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteConfiguration

        default CompletableFuture<DeleteConfigurationResponse> deleteConfiguration​(DeleteConfigurationRequest deleteConfigurationRequest)

        Deletes an MSK Configuration.

        Parameters:
        deleteConfigurationRequest -
        Returns:
        A Java Future containing the result of the DeleteConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteConfiguration

        default CompletableFuture<DeleteConfigurationResponse> deleteConfiguration​(Consumer<DeleteConfigurationRequest.Builder> deleteConfigurationRequest)

        Deletes an MSK Configuration.


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

        Parameters:
        deleteConfigurationRequest - A Consumer that will call methods on DeleteConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteReplicator

        default CompletableFuture<DeleteReplicatorResponse> deleteReplicator​(DeleteReplicatorRequest deleteReplicatorRequest)

        Deletes a replicator.

        Parameters:
        deleteReplicatorRequest -
        Returns:
        A Java Future containing the result of the DeleteReplicator operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteReplicator

        default CompletableFuture<DeleteReplicatorResponse> deleteReplicator​(Consumer<DeleteReplicatorRequest.Builder> deleteReplicatorRequest)

        Deletes a replicator.


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

        Parameters:
        deleteReplicatorRequest - A Consumer that will call methods on DeleteReplicatorRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteReplicator operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteVpcConnection

        default CompletableFuture<DeleteVpcConnectionResponse> deleteVpcConnection​(DeleteVpcConnectionRequest deleteVpcConnectionRequest)

        Deletes a MSK VPC connection.

        Parameters:
        deleteVpcConnectionRequest -
        Returns:
        A Java Future containing the result of the DeleteVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteVpcConnection

        default CompletableFuture<DeleteVpcConnectionResponse> deleteVpcConnection​(Consumer<DeleteVpcConnectionRequest.Builder> deleteVpcConnectionRequest)

        Deletes a MSK VPC connection.


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

        Parameters:
        deleteVpcConnectionRequest - A Consumer that will call methods on DeleteVpcConnectionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeCluster

        default CompletableFuture<DescribeClusterResponse> describeCluster​(DescribeClusterRequest describeClusterRequest)

        Returns a description of the MSK cluster whose Amazon Resource Name (ARN) is specified in the request.

        Parameters:
        describeClusterRequest -
        Returns:
        A Java Future containing the result of the DescribeCluster operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeCluster

        default CompletableFuture<DescribeClusterResponse> describeCluster​(Consumer<DescribeClusterRequest.Builder> describeClusterRequest)

        Returns a description of the MSK cluster whose Amazon Resource Name (ARN) is specified in the request.


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

        Parameters:
        describeClusterRequest - A Consumer that will call methods on DescribeClusterRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeCluster operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeClusterOperation

        default CompletableFuture<DescribeClusterOperationResponse> describeClusterOperation​(DescribeClusterOperationRequest describeClusterOperationRequest)

        Returns a description of the cluster operation specified by the ARN.

        Parameters:
        describeClusterOperationRequest -
        Returns:
        A Java Future containing the result of the DescribeClusterOperation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeClusterOperation

        default CompletableFuture<DescribeClusterOperationResponse> describeClusterOperation​(Consumer<DescribeClusterOperationRequest.Builder> describeClusterOperationRequest)

        Returns a description of the cluster operation specified by the ARN.


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

        Parameters:
        describeClusterOperationRequest - A Consumer that will call methods on DescribeClusterOperationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeClusterOperation operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeClusterOperationV2

        default CompletableFuture<DescribeClusterOperationV2Response> describeClusterOperationV2​(DescribeClusterOperationV2Request describeClusterOperationV2Request)

        Returns a description of the cluster operation specified by the ARN.

        Parameters:
        describeClusterOperationV2Request -
        Returns:
        A Java Future containing the result of the DescribeClusterOperationV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.

        • UnauthorizedException

          HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.

        • InternalServerErrorException

          HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.

        • NotFoundException

          HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.

        • ServiceUnavailableException

          HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.

        • TooManyRequestsException

          HTTP Status Code 429: Limit exceeded. Resource limit reached.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeClusterOperationV2

        default CompletableFuture<DescribeClusterOperationV2Response> describeClusterOperationV2​(Consumer<DescribeClusterOperationV2Request.Builder> describeClusterOperationV2Request)

        Returns a description of the cluster operation specified by the ARN.


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

        Parameters:
        describeClusterOperationV2Request - A Consumer that will call methods on DescribeClusterOperationV2Request.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeClusterOperationV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.

        • UnauthorizedException

          HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.

        • InternalServerErrorException

          HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.

        • NotFoundException

          HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.

        • ServiceUnavailableException

          HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.

        • TooManyRequestsException

          HTTP Status Code 429: Limit exceeded. Resource limit reached.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeClusterV2

        default CompletableFuture<DescribeClusterV2Response> describeClusterV2​(DescribeClusterV2Request describeClusterV2Request)

        Returns a description of the MSK cluster whose Amazon Resource Name (ARN) is specified in the request.

        Parameters:
        describeClusterV2Request -
        Returns:
        A Java Future containing the result of the DescribeClusterV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeClusterV2

        default CompletableFuture<DescribeClusterV2Response> describeClusterV2​(Consumer<DescribeClusterV2Request.Builder> describeClusterV2Request)

        Returns a description of the MSK cluster whose Amazon Resource Name (ARN) is specified in the request.


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

        Parameters:
        describeClusterV2Request - A Consumer that will call methods on DescribeClusterV2Request.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeClusterV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeConfiguration

        default CompletableFuture<DescribeConfigurationResponse> describeConfiguration​(DescribeConfigurationRequest describeConfigurationRequest)

        Returns a description of this MSK configuration.

        Parameters:
        describeConfigurationRequest -
        Returns:
        A Java Future containing the result of the DescribeConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeConfiguration

        default CompletableFuture<DescribeConfigurationResponse> describeConfiguration​(Consumer<DescribeConfigurationRequest.Builder> describeConfigurationRequest)

        Returns a description of this MSK configuration.


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

        Parameters:
        describeConfigurationRequest - A Consumer that will call methods on DescribeConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeConfigurationRevision

        default CompletableFuture<DescribeConfigurationRevisionResponse> describeConfigurationRevision​(DescribeConfigurationRevisionRequest describeConfigurationRevisionRequest)

        Returns a description of this revision of the configuration.

        Parameters:
        describeConfigurationRevisionRequest -
        Returns:
        A Java Future containing the result of the DescribeConfigurationRevision operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeConfigurationRevision

        default CompletableFuture<DescribeConfigurationRevisionResponse> describeConfigurationRevision​(Consumer<DescribeConfigurationRevisionRequest.Builder> describeConfigurationRevisionRequest)

        Returns a description of this revision of the configuration.


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

        Parameters:
        describeConfigurationRevisionRequest - A Consumer that will call methods on DescribeConfigurationRevisionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeConfigurationRevision operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeReplicator

        default CompletableFuture<DescribeReplicatorResponse> describeReplicator​(DescribeReplicatorRequest describeReplicatorRequest)

        Describes a replicator.

        Parameters:
        describeReplicatorRequest -
        Returns:
        A Java Future containing the result of the DescribeReplicator operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeReplicator

        default CompletableFuture<DescribeReplicatorResponse> describeReplicator​(Consumer<DescribeReplicatorRequest.Builder> describeReplicatorRequest)

        Describes a replicator.


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

        Parameters:
        describeReplicatorRequest - A Consumer that will call methods on DescribeReplicatorRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeReplicator operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeVpcConnection

        default CompletableFuture<DescribeVpcConnectionResponse> describeVpcConnection​(DescribeVpcConnectionRequest describeVpcConnectionRequest)

        Returns a description of this MSK VPC connection.

        Parameters:
        describeVpcConnectionRequest -
        Returns:
        A Java Future containing the result of the DescribeVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • describeVpcConnection

        default CompletableFuture<DescribeVpcConnectionResponse> describeVpcConnection​(Consumer<DescribeVpcConnectionRequest.Builder> describeVpcConnectionRequest)

        Returns a description of this MSK VPC connection.


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

        Parameters:
        describeVpcConnectionRequest - A Consumer that will call methods on DescribeVpcConnectionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DescribeVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getBootstrapBrokers

        default CompletableFuture<GetBootstrapBrokersResponse> getBootstrapBrokers​(GetBootstrapBrokersRequest getBootstrapBrokersRequest)

        A list of brokers that a client application can use to bootstrap. This list doesn't necessarily include all of the brokers in the cluster. The following Python 3.6 example shows how you can use the Amazon Resource Name (ARN) of a cluster to get its bootstrap brokers. If you don't know the ARN of your cluster, you can use the ListClusters operation to get the ARNs of all the clusters in this account and Region.

        Parameters:
        getBootstrapBrokersRequest -
        Returns:
        A Java Future containing the result of the GetBootstrapBrokers operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getBootstrapBrokers

        default CompletableFuture<GetBootstrapBrokersResponse> getBootstrapBrokers​(Consumer<GetBootstrapBrokersRequest.Builder> getBootstrapBrokersRequest)

        A list of brokers that a client application can use to bootstrap. This list doesn't necessarily include all of the brokers in the cluster. The following Python 3.6 example shows how you can use the Amazon Resource Name (ARN) of a cluster to get its bootstrap brokers. If you don't know the ARN of your cluster, you can use the ListClusters operation to get the ARNs of all the clusters in this account and Region.


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

        Parameters:
        getBootstrapBrokersRequest - A Consumer that will call methods on GetBootstrapBrokersRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetBootstrapBrokers operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ConflictException

          This cluster name already exists. Retry your request using another name.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getClusterPolicy

        default CompletableFuture<GetClusterPolicyResponse> getClusterPolicy​(GetClusterPolicyRequest getClusterPolicyRequest)

        Get the MSK cluster policy specified by the Amazon Resource Name (ARN) in the request.

        Parameters:
        getClusterPolicyRequest -
        Returns:
        A Java Future containing the result of the GetClusterPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getClusterPolicy

        default CompletableFuture<GetClusterPolicyResponse> getClusterPolicy​(Consumer<GetClusterPolicyRequest.Builder> getClusterPolicyRequest)

        Get the MSK cluster policy specified by the Amazon Resource Name (ARN) in the request.


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

        Parameters:
        getClusterPolicyRequest - A Consumer that will call methods on GetClusterPolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetClusterPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getCompatibleKafkaVersions

        default CompletableFuture<GetCompatibleKafkaVersionsResponse> getCompatibleKafkaVersions​(GetCompatibleKafkaVersionsRequest getCompatibleKafkaVersionsRequest)

        Gets the Apache Kafka versions to which you can update the MSK cluster.

        Parameters:
        getCompatibleKafkaVersionsRequest -
        Returns:
        A Java Future containing the result of the GetCompatibleKafkaVersions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException n

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

          n
        • UnauthorizedException n

          The request is not authorized. The provided credentials couldn't be validated.

          n
        • InternalServerErrorException n

          There was an unexpected internal server error. Retrying your request might resolve the issue.

          n
        • ForbiddenException n

          Access forbidden. Check your credentials and then retry your request.

          n
        • NotFoundException n

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

          n
        • ServiceUnavailableException n

          503 response

          n
        • TooManyRequestsException n

          429 response

          n
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getCompatibleKafkaVersions

        default CompletableFuture<GetCompatibleKafkaVersionsResponse> getCompatibleKafkaVersions​(Consumer<GetCompatibleKafkaVersionsRequest.Builder> getCompatibleKafkaVersionsRequest)

        Gets the Apache Kafka versions to which you can update the MSK cluster.


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

        Parameters:
        getCompatibleKafkaVersionsRequest - A Consumer that will call methods on GetCompatibleKafkaVersionsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetCompatibleKafkaVersions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException n

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

          n
        • UnauthorizedException n

          The request is not authorized. The provided credentials couldn't be validated.

          n
        • InternalServerErrorException n

          There was an unexpected internal server error. Retrying your request might resolve the issue.

          n
        • ForbiddenException n

          Access forbidden. Check your credentials and then retry your request.

          n
        • NotFoundException n

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

          n
        • ServiceUnavailableException n

          503 response

          n
        • TooManyRequestsException n

          429 response

          n
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClientVpcConnections

        default CompletableFuture<ListClientVpcConnectionsResponse> listClientVpcConnections​(ListClientVpcConnectionsRequest listClientVpcConnectionsRequest)

        Returns a list of all the VPC connections in this Region.

        Parameters:
        listClientVpcConnectionsRequest -
        Returns:
        A Java Future containing the result of the ListClientVpcConnections operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClientVpcConnections

        default CompletableFuture<ListClientVpcConnectionsResponse> listClientVpcConnections​(Consumer<ListClientVpcConnectionsRequest.Builder> listClientVpcConnectionsRequest)

        Returns a list of all the VPC connections in this Region.


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

        Parameters:
        listClientVpcConnectionsRequest - A Consumer that will call methods on ListClientVpcConnectionsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListClientVpcConnections operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClientVpcConnectionsPaginator

        default ListClientVpcConnectionsPublisher listClientVpcConnectionsPaginator​(ListClientVpcConnectionsRequest listClientVpcConnectionsRequest)

        This is a variant of listClientVpcConnections(software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsRequest) 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.kafka.paginators.ListClientVpcConnectionsPublisher publisher = client.listClientVpcConnectionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClientVpcConnectionsPublisher publisher = client.listClientVpcConnectionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsResponse 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 listClientVpcConnections(software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsRequest) operation.

        Parameters:
        listClientVpcConnectionsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClientVpcConnectionsPaginator

        default ListClientVpcConnectionsPublisher listClientVpcConnectionsPaginator​(Consumer<ListClientVpcConnectionsRequest.Builder> listClientVpcConnectionsRequest)

        This is a variant of listClientVpcConnections(software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsRequest) 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.kafka.paginators.ListClientVpcConnectionsPublisher publisher = client.listClientVpcConnectionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClientVpcConnectionsPublisher publisher = client.listClientVpcConnectionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsResponse 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 listClientVpcConnections(software.amazon.awssdk.services.kafka.model.ListClientVpcConnectionsRequest) operation.


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

        Parameters:
        listClientVpcConnectionsRequest - A Consumer that will call methods on ListClientVpcConnectionsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperations

        default CompletableFuture<ListClusterOperationsResponse> listClusterOperations​(ListClusterOperationsRequest listClusterOperationsRequest)

        Returns a list of all the operations that have been performed on the specified MSK cluster.

        Parameters:
        listClusterOperationsRequest -
        Returns:
        A Java Future containing the result of the ListClusterOperations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperations

        default CompletableFuture<ListClusterOperationsResponse> listClusterOperations​(Consumer<ListClusterOperationsRequest.Builder> listClusterOperationsRequest)

        Returns a list of all the operations that have been performed on the specified MSK cluster.


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

        Parameters:
        listClusterOperationsRequest - A Consumer that will call methods on ListClusterOperationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListClusterOperations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperationsPaginator

        default ListClusterOperationsPublisher listClusterOperationsPaginator​(ListClusterOperationsRequest listClusterOperationsRequest)

        This is a variant of listClusterOperations(software.amazon.awssdk.services.kafka.model.ListClusterOperationsRequest) 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.kafka.paginators.ListClusterOperationsPublisher publisher = client.listClusterOperationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClusterOperationsPublisher publisher = client.listClusterOperationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClusterOperationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClusterOperationsResponse 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 listClusterOperations(software.amazon.awssdk.services.kafka.model.ListClusterOperationsRequest) operation.

        Parameters:
        listClusterOperationsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperationsPaginator

        default ListClusterOperationsPublisher listClusterOperationsPaginator​(Consumer<ListClusterOperationsRequest.Builder> listClusterOperationsRequest)

        This is a variant of listClusterOperations(software.amazon.awssdk.services.kafka.model.ListClusterOperationsRequest) 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.kafka.paginators.ListClusterOperationsPublisher publisher = client.listClusterOperationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClusterOperationsPublisher publisher = client.listClusterOperationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClusterOperationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClusterOperationsResponse 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 listClusterOperations(software.amazon.awssdk.services.kafka.model.ListClusterOperationsRequest) operation.


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

        Parameters:
        listClusterOperationsRequest - A Consumer that will call methods on ListClusterOperationsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperationsV2

        default CompletableFuture<ListClusterOperationsV2Response> listClusterOperationsV2​(ListClusterOperationsV2Request listClusterOperationsV2Request)

        Returns a list of all the operations that have been performed on the specified MSK cluster.

        Parameters:
        listClusterOperationsV2Request -
        Returns:
        A Java Future containing the result of the ListClusterOperationsV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.

        • UnauthorizedException

          HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.

        • InternalServerErrorException

          HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.

        • NotFoundException

          HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.

        • ServiceUnavailableException

          HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.

        • TooManyRequestsException

          HTTP Status Code 429: Limit exceeded. Resource limit reached.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperationsV2

        default CompletableFuture<ListClusterOperationsV2Response> listClusterOperationsV2​(Consumer<ListClusterOperationsV2Request.Builder> listClusterOperationsV2Request)

        Returns a list of all the operations that have been performed on the specified MSK cluster.


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

        Parameters:
        listClusterOperationsV2Request - A Consumer that will call methods on ListClusterOperationsV2Request.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListClusterOperationsV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.

        • UnauthorizedException

          HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.

        • InternalServerErrorException

          HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.

        • NotFoundException

          HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.

        • ServiceUnavailableException

          HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.

        • TooManyRequestsException

          HTTP Status Code 429: Limit exceeded. Resource limit reached.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperationsV2Paginator

        default ListClusterOperationsV2Publisher listClusterOperationsV2Paginator​(ListClusterOperationsV2Request listClusterOperationsV2Request)

        This is a variant of listClusterOperationsV2(software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Request) 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.kafka.paginators.ListClusterOperationsV2Publisher publisher = client.listClusterOperationsV2Paginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClusterOperationsV2Publisher publisher = client.listClusterOperationsV2Paginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Response>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Response 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 listClusterOperationsV2(software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Request) operation.

        Parameters:
        listClusterOperationsV2Request -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.

        • UnauthorizedException

          HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.

        • InternalServerErrorException

          HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.

        • NotFoundException

          HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.

        • ServiceUnavailableException

          HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.

        • TooManyRequestsException

          HTTP Status Code 429: Limit exceeded. Resource limit reached.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusterOperationsV2Paginator

        default ListClusterOperationsV2Publisher listClusterOperationsV2Paginator​(Consumer<ListClusterOperationsV2Request.Builder> listClusterOperationsV2Request)

        This is a variant of listClusterOperationsV2(software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Request) 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.kafka.paginators.ListClusterOperationsV2Publisher publisher = client.listClusterOperationsV2Paginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClusterOperationsV2Publisher publisher = client.listClusterOperationsV2Paginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Response>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Response 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 listClusterOperationsV2(software.amazon.awssdk.services.kafka.model.ListClusterOperationsV2Request) operation.


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

        Parameters:
        listClusterOperationsV2Request - A Consumer that will call methods on ListClusterOperationsV2Request.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.

        • UnauthorizedException

          HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.

        • InternalServerErrorException

          HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.

        • NotFoundException

          HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.

        • ServiceUnavailableException

          HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.

        • TooManyRequestsException

          HTTP Status Code 429: Limit exceeded. Resource limit reached.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusters

        default CompletableFuture<ListClustersResponse> listClusters​(ListClustersRequest listClustersRequest)

        Returns a list of all the MSK clusters in the current Region.

        Parameters:
        listClustersRequest -
        Returns:
        A Java Future containing the result of the ListClusters operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusters

        default CompletableFuture<ListClustersResponse> listClusters​(Consumer<ListClustersRequest.Builder> listClustersRequest)

        Returns a list of all the MSK clusters in the current Region.


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

        Parameters:
        listClustersRequest - A Consumer that will call methods on ListClustersRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListClusters operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClusters

        default CompletableFuture<ListClustersResponse> listClusters()

        Returns a list of all the MSK clusters in the current Region.

        Returns:
        A Java Future containing the result of the ListClusters operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClustersPaginator

        default ListClustersPublisher listClustersPaginator()

        This is a variant of listClusters(software.amazon.awssdk.services.kafka.model.ListClustersRequest) 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.kafka.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClustersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClustersResponse 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 listClusters(software.amazon.awssdk.services.kafka.model.ListClustersRequest) operation.

        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClustersPaginator

        default ListClustersPublisher listClustersPaginator​(ListClustersRequest listClustersRequest)

        This is a variant of listClusters(software.amazon.awssdk.services.kafka.model.ListClustersRequest) 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.kafka.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClustersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClustersResponse 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 listClusters(software.amazon.awssdk.services.kafka.model.ListClustersRequest) operation.

        Parameters:
        listClustersRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClustersPaginator

        default ListClustersPublisher listClustersPaginator​(Consumer<ListClustersRequest.Builder> listClustersRequest)

        This is a variant of listClusters(software.amazon.awssdk.services.kafka.model.ListClustersRequest) 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.kafka.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClustersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClustersResponse 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 listClusters(software.amazon.awssdk.services.kafka.model.ListClustersRequest) operation.


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

        Parameters:
        listClustersRequest - A Consumer that will call methods on ListClustersRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClustersV2

        default CompletableFuture<ListClustersV2Response> listClustersV2​(ListClustersV2Request listClustersV2Request)

        Returns a list of all the MSK clusters in the current Region.

        Parameters:
        listClustersV2Request -
        Returns:
        A Java Future containing the result of the ListClustersV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClustersV2

        default CompletableFuture<ListClustersV2Response> listClustersV2​(Consumer<ListClustersV2Request.Builder> listClustersV2Request)

        Returns a list of all the MSK clusters in the current Region.


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

        Parameters:
        listClustersV2Request - A Consumer that will call methods on ListClustersV2Request.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListClustersV2 operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClustersV2Paginator

        default ListClustersV2Publisher listClustersV2Paginator​(ListClustersV2Request listClustersV2Request)

        This is a variant of listClustersV2(software.amazon.awssdk.services.kafka.model.ListClustersV2Request) 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.kafka.paginators.ListClustersV2Publisher publisher = client.listClustersV2Paginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClustersV2Publisher publisher = client.listClustersV2Paginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClustersV2Response>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClustersV2Response 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 listClustersV2(software.amazon.awssdk.services.kafka.model.ListClustersV2Request) operation.

        Parameters:
        listClustersV2Request -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listClustersV2Paginator

        default ListClustersV2Publisher listClustersV2Paginator​(Consumer<ListClustersV2Request.Builder> listClustersV2Request)

        This is a variant of listClustersV2(software.amazon.awssdk.services.kafka.model.ListClustersV2Request) 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.kafka.paginators.ListClustersV2Publisher publisher = client.listClustersV2Paginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListClustersV2Publisher publisher = client.listClustersV2Paginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListClustersV2Response>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListClustersV2Response 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 listClustersV2(software.amazon.awssdk.services.kafka.model.ListClustersV2Request) operation.


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

        Parameters:
        listClustersV2Request - A Consumer that will call methods on ListClustersV2Request.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurationRevisions

        default CompletableFuture<ListConfigurationRevisionsResponse> listConfigurationRevisions​(ListConfigurationRevisionsRequest listConfigurationRevisionsRequest)

        Returns a list of all the MSK configurations in this Region.

        Parameters:
        listConfigurationRevisionsRequest -
        Returns:
        A Java Future containing the result of the ListConfigurationRevisions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurationRevisions

        default CompletableFuture<ListConfigurationRevisionsResponse> listConfigurationRevisions​(Consumer<ListConfigurationRevisionsRequest.Builder> listConfigurationRevisionsRequest)

        Returns a list of all the MSK configurations in this Region.


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

        Parameters:
        listConfigurationRevisionsRequest - A Consumer that will call methods on ListConfigurationRevisionsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListConfigurationRevisions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurationRevisionsPaginator

        default ListConfigurationRevisionsPublisher listConfigurationRevisionsPaginator​(ListConfigurationRevisionsRequest listConfigurationRevisionsRequest)

        This is a variant of listConfigurationRevisions(software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsRequest) 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.kafka.paginators.ListConfigurationRevisionsPublisher publisher = client.listConfigurationRevisionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListConfigurationRevisionsPublisher publisher = client.listConfigurationRevisionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsResponse 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 listConfigurationRevisions(software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsRequest) operation.

        Parameters:
        listConfigurationRevisionsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurationRevisionsPaginator

        default ListConfigurationRevisionsPublisher listConfigurationRevisionsPaginator​(Consumer<ListConfigurationRevisionsRequest.Builder> listConfigurationRevisionsRequest)

        This is a variant of listConfigurationRevisions(software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsRequest) 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.kafka.paginators.ListConfigurationRevisionsPublisher publisher = client.listConfigurationRevisionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListConfigurationRevisionsPublisher publisher = client.listConfigurationRevisionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsResponse 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 listConfigurationRevisions(software.amazon.awssdk.services.kafka.model.ListConfigurationRevisionsRequest) operation.


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

        Parameters:
        listConfigurationRevisionsRequest - A Consumer that will call methods on ListConfigurationRevisionsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurations

        default CompletableFuture<ListConfigurationsResponse> listConfigurations​(ListConfigurationsRequest listConfigurationsRequest)

        Returns a list of all the MSK configurations in this Region.

        Parameters:
        listConfigurationsRequest -
        Returns:
        A Java Future containing the result of the ListConfigurations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurations

        default CompletableFuture<ListConfigurationsResponse> listConfigurations​(Consumer<ListConfigurationsRequest.Builder> listConfigurationsRequest)

        Returns a list of all the MSK configurations in this Region.


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

        Parameters:
        listConfigurationsRequest - A Consumer that will call methods on ListConfigurationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListConfigurations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurationsPaginator

        default ListConfigurationsPublisher listConfigurationsPaginator​(ListConfigurationsRequest listConfigurationsRequest)

        This is a variant of listConfigurations(software.amazon.awssdk.services.kafka.model.ListConfigurationsRequest) 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.kafka.paginators.ListConfigurationsPublisher publisher = client.listConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListConfigurationsPublisher publisher = client.listConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListConfigurationsResponse 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 listConfigurations(software.amazon.awssdk.services.kafka.model.ListConfigurationsRequest) operation.

        Parameters:
        listConfigurationsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listConfigurationsPaginator

        default ListConfigurationsPublisher listConfigurationsPaginator​(Consumer<ListConfigurationsRequest.Builder> listConfigurationsRequest)

        This is a variant of listConfigurations(software.amazon.awssdk.services.kafka.model.ListConfigurationsRequest) 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.kafka.paginators.ListConfigurationsPublisher publisher = client.listConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListConfigurationsPublisher publisher = client.listConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListConfigurationsResponse 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 listConfigurations(software.amazon.awssdk.services.kafka.model.ListConfigurationsRequest) operation.


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

        Parameters:
        listConfigurationsRequest - A Consumer that will call methods on ListConfigurationsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listKafkaVersions

        default CompletableFuture<ListKafkaVersionsResponse> listKafkaVersions​(ListKafkaVersionsRequest listKafkaVersionsRequest)

        Returns a list of Apache Kafka versions.

        Parameters:
        listKafkaVersionsRequest -
        Returns:
        A Java Future containing the result of the ListKafkaVersions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listKafkaVersions

        default CompletableFuture<ListKafkaVersionsResponse> listKafkaVersions​(Consumer<ListKafkaVersionsRequest.Builder> listKafkaVersionsRequest)

        Returns a list of Apache Kafka versions.


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

        Parameters:
        listKafkaVersionsRequest - A Consumer that will call methods on ListKafkaVersionsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListKafkaVersions operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listKafkaVersionsPaginator

        default ListKafkaVersionsPublisher listKafkaVersionsPaginator​(ListKafkaVersionsRequest listKafkaVersionsRequest)

        This is a variant of listKafkaVersions(software.amazon.awssdk.services.kafka.model.ListKafkaVersionsRequest) 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.kafka.paginators.ListKafkaVersionsPublisher publisher = client.listKafkaVersionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListKafkaVersionsPublisher publisher = client.listKafkaVersionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListKafkaVersionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListKafkaVersionsResponse 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 listKafkaVersions(software.amazon.awssdk.services.kafka.model.ListKafkaVersionsRequest) operation.

        Parameters:
        listKafkaVersionsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listKafkaVersionsPaginator

        default ListKafkaVersionsPublisher listKafkaVersionsPaginator​(Consumer<ListKafkaVersionsRequest.Builder> listKafkaVersionsRequest)

        This is a variant of listKafkaVersions(software.amazon.awssdk.services.kafka.model.ListKafkaVersionsRequest) 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.kafka.paginators.ListKafkaVersionsPublisher publisher = client.listKafkaVersionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListKafkaVersionsPublisher publisher = client.listKafkaVersionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListKafkaVersionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListKafkaVersionsResponse 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 listKafkaVersions(software.amazon.awssdk.services.kafka.model.ListKafkaVersionsRequest) operation.


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

        Parameters:
        listKafkaVersionsRequest - A Consumer that will call methods on ListKafkaVersionsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNodes

        default CompletableFuture<ListNodesResponse> listNodes​(ListNodesRequest listNodesRequest)

        Returns a list of the broker nodes in the cluster.

        Parameters:
        listNodesRequest -
        Returns:
        A Java Future containing the result of the ListNodes operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNodes

        default CompletableFuture<ListNodesResponse> listNodes​(Consumer<ListNodesRequest.Builder> listNodesRequest)

        Returns a list of the broker nodes in the cluster.


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

        Parameters:
        listNodesRequest - A Consumer that will call methods on ListNodesRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListNodes operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNodesPaginator

        default ListNodesPublisher listNodesPaginator​(ListNodesRequest listNodesRequest)

        This is a variant of listNodes(software.amazon.awssdk.services.kafka.model.ListNodesRequest) 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.kafka.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListNodesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListNodesResponse 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 listNodes(software.amazon.awssdk.services.kafka.model.ListNodesRequest) operation.

        Parameters:
        listNodesRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNodesPaginator

        default ListNodesPublisher listNodesPaginator​(Consumer<ListNodesRequest.Builder> listNodesRequest)

        This is a variant of listNodes(software.amazon.awssdk.services.kafka.model.ListNodesRequest) 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.kafka.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListNodesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListNodesResponse 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 listNodes(software.amazon.awssdk.services.kafka.model.ListNodesRequest) operation.


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

        Parameters:
        listNodesRequest - A Consumer that will call methods on ListNodesRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listReplicators

        default CompletableFuture<ListReplicatorsResponse> listReplicators​(ListReplicatorsRequest listReplicatorsRequest)

        Lists the replicators.

        Parameters:
        listReplicatorsRequest -
        Returns:
        A Java Future containing the result of the ListReplicators operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listReplicators

        default CompletableFuture<ListReplicatorsResponse> listReplicators​(Consumer<ListReplicatorsRequest.Builder> listReplicatorsRequest)

        Lists the replicators.


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

        Parameters:
        listReplicatorsRequest - A Consumer that will call methods on ListReplicatorsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListReplicators operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listReplicatorsPaginator

        default ListReplicatorsPublisher listReplicatorsPaginator​(ListReplicatorsRequest listReplicatorsRequest)

        This is a variant of listReplicators(software.amazon.awssdk.services.kafka.model.ListReplicatorsRequest) 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.kafka.paginators.ListReplicatorsPublisher publisher = client.listReplicatorsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListReplicatorsPublisher publisher = client.listReplicatorsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListReplicatorsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListReplicatorsResponse 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 listReplicators(software.amazon.awssdk.services.kafka.model.ListReplicatorsRequest) operation.

        Parameters:
        listReplicatorsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listReplicatorsPaginator

        default ListReplicatorsPublisher listReplicatorsPaginator​(Consumer<ListReplicatorsRequest.Builder> listReplicatorsRequest)

        This is a variant of listReplicators(software.amazon.awssdk.services.kafka.model.ListReplicatorsRequest) 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.kafka.paginators.ListReplicatorsPublisher publisher = client.listReplicatorsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListReplicatorsPublisher publisher = client.listReplicatorsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListReplicatorsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListReplicatorsResponse 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 listReplicators(software.amazon.awssdk.services.kafka.model.ListReplicatorsRequest) operation.


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

        Parameters:
        listReplicatorsRequest - A Consumer that will call methods on ListReplicatorsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listScramSecrets

        default CompletableFuture<ListScramSecretsResponse> listScramSecrets​(ListScramSecretsRequest listScramSecretsRequest)

        Returns a list of the Scram Secrets associated with an Amazon MSK cluster.

        Parameters:
        listScramSecretsRequest -
        Returns:
        A Java Future containing the result of the ListScramSecrets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listScramSecrets

        default CompletableFuture<ListScramSecretsResponse> listScramSecrets​(Consumer<ListScramSecretsRequest.Builder> listScramSecretsRequest)

        Returns a list of the Scram Secrets associated with an Amazon MSK cluster.


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

        Parameters:
        listScramSecretsRequest - A Consumer that will call methods on ListScramSecretsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListScramSecrets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listScramSecretsPaginator

        default ListScramSecretsPublisher listScramSecretsPaginator​(ListScramSecretsRequest listScramSecretsRequest)

        This is a variant of listScramSecrets(software.amazon.awssdk.services.kafka.model.ListScramSecretsRequest) 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.kafka.paginators.ListScramSecretsPublisher publisher = client.listScramSecretsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListScramSecretsPublisher publisher = client.listScramSecretsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListScramSecretsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListScramSecretsResponse 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 listScramSecrets(software.amazon.awssdk.services.kafka.model.ListScramSecretsRequest) operation.

        Parameters:
        listScramSecretsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listScramSecretsPaginator

        default ListScramSecretsPublisher listScramSecretsPaginator​(Consumer<ListScramSecretsRequest.Builder> listScramSecretsRequest)

        This is a variant of listScramSecrets(software.amazon.awssdk.services.kafka.model.ListScramSecretsRequest) 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.kafka.paginators.ListScramSecretsPublisher publisher = client.listScramSecretsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListScramSecretsPublisher publisher = client.listScramSecretsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListScramSecretsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListScramSecretsResponse 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 listScramSecrets(software.amazon.awssdk.services.kafka.model.ListScramSecretsRequest) operation.


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

        Parameters:
        listScramSecretsRequest - A Consumer that will call methods on ListScramSecretsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException 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)

        Returns a list of the tags associated with 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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException 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)

        Returns a list of the tags associated with 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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listVpcConnections

        default CompletableFuture<ListVpcConnectionsResponse> listVpcConnections​(ListVpcConnectionsRequest listVpcConnectionsRequest)

        Returns a list of all the VPC connections in this Region.

        Parameters:
        listVpcConnectionsRequest -
        Returns:
        A Java Future containing the result of the ListVpcConnections operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listVpcConnections

        default CompletableFuture<ListVpcConnectionsResponse> listVpcConnections​(Consumer<ListVpcConnectionsRequest.Builder> listVpcConnectionsRequest)

        Returns a list of all the VPC connections in this Region.


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

        Parameters:
        listVpcConnectionsRequest - A Consumer that will call methods on ListVpcConnectionsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListVpcConnections operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listVpcConnectionsPaginator

        default ListVpcConnectionsPublisher listVpcConnectionsPaginator​(ListVpcConnectionsRequest listVpcConnectionsRequest)

        This is a variant of listVpcConnections(software.amazon.awssdk.services.kafka.model.ListVpcConnectionsRequest) 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.kafka.paginators.ListVpcConnectionsPublisher publisher = client.listVpcConnectionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListVpcConnectionsPublisher publisher = client.listVpcConnectionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListVpcConnectionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListVpcConnectionsResponse 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 listVpcConnections(software.amazon.awssdk.services.kafka.model.ListVpcConnectionsRequest) operation.

        Parameters:
        listVpcConnectionsRequest -
        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listVpcConnectionsPaginator

        default ListVpcConnectionsPublisher listVpcConnectionsPaginator​(Consumer<ListVpcConnectionsRequest.Builder> listVpcConnectionsRequest)

        This is a variant of listVpcConnections(software.amazon.awssdk.services.kafka.model.ListVpcConnectionsRequest) 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.kafka.paginators.ListVpcConnectionsPublisher publisher = client.listVpcConnectionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.kafka.paginators.ListVpcConnectionsPublisher publisher = client.listVpcConnectionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.kafka.model.ListVpcConnectionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.kafka.model.ListVpcConnectionsResponse 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 listVpcConnections(software.amazon.awssdk.services.kafka.model.ListVpcConnectionsRequest) operation.


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

        Parameters:
        listVpcConnectionsRequest - A Consumer that will call methods on ListVpcConnectionsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • putClusterPolicy

        default CompletableFuture<PutClusterPolicyResponse> putClusterPolicy​(PutClusterPolicyRequest putClusterPolicyRequest)

        Creates or updates the MSK cluster policy specified by the cluster Amazon Resource Name (ARN) in the request.

        Parameters:
        putClusterPolicyRequest -
        Returns:
        A Java Future containing the result of the PutClusterPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • putClusterPolicy

        default CompletableFuture<PutClusterPolicyResponse> putClusterPolicy​(Consumer<PutClusterPolicyRequest.Builder> putClusterPolicyRequest)

        Creates or updates the MSK cluster policy specified by the cluster Amazon Resource Name (ARN) in the request.


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

        Parameters:
        putClusterPolicyRequest - A Consumer that will call methods on PutClusterPolicyRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the PutClusterPolicy operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • rebootBroker

        default CompletableFuture<RebootBrokerResponse> rebootBroker​(RebootBrokerRequest rebootBrokerRequest)
        Reboots brokers.
        Parameters:
        rebootBrokerRequest - Reboots a node.
        Returns:
        A Java Future containing the result of the RebootBroker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • rebootBroker

        default CompletableFuture<RebootBrokerResponse> rebootBroker​(Consumer<RebootBrokerRequest.Builder> rebootBrokerRequest)
        Reboots brokers.

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

        Parameters:
        rebootBrokerRequest - A Consumer that will call methods on RebootBrokerRequest.Builder to create a request. Reboots a node.
        Returns:
        A Java Future containing the result of the RebootBroker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • rejectClientVpcConnection

        default CompletableFuture<RejectClientVpcConnectionResponse> rejectClientVpcConnection​(RejectClientVpcConnectionRequest rejectClientVpcConnectionRequest)

        Returns empty response.

        Parameters:
        rejectClientVpcConnectionRequest -
        Returns:
        A Java Future containing the result of the RejectClientVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • rejectClientVpcConnection

        default CompletableFuture<RejectClientVpcConnectionResponse> rejectClientVpcConnection​(Consumer<RejectClientVpcConnectionRequest.Builder> rejectClientVpcConnectionRequest)

        Returns empty response.


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

        Parameters:
        rejectClientVpcConnectionRequest - A Consumer that will call methods on RejectClientVpcConnectionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the RejectClientVpcConnection operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException 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 tags to the specified MSK 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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException 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 tags to the specified MSK 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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException 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 tags associated with the keys that are provided in the query.

        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException 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 tags associated with the keys that are provided in the query.


        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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateBrokerCount

        default CompletableFuture<UpdateBrokerCountResponse> updateBrokerCount​(UpdateBrokerCountRequest updateBrokerCountRequest)

        Updates the number of broker nodes in the cluster.

        Parameters:
        updateBrokerCountRequest -
        Returns:
        A Java Future containing the result of the UpdateBrokerCount operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateBrokerCount

        default CompletableFuture<UpdateBrokerCountResponse> updateBrokerCount​(Consumer<UpdateBrokerCountRequest.Builder> updateBrokerCountRequest)

        Updates the number of broker nodes in the cluster.


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

        Parameters:
        updateBrokerCountRequest - A Consumer that will call methods on UpdateBrokerCountRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateBrokerCount operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateBrokerStorage

        default CompletableFuture<UpdateBrokerStorageResponse> updateBrokerStorage​(UpdateBrokerStorageRequest updateBrokerStorageRequest)

        Updates the EBS storage associated with MSK brokers.

        Parameters:
        updateBrokerStorageRequest -
        Returns:
        A Java Future containing the result of the UpdateBrokerStorage operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateBrokerStorage

        default CompletableFuture<UpdateBrokerStorageResponse> updateBrokerStorage​(Consumer<UpdateBrokerStorageRequest.Builder> updateBrokerStorageRequest)

        Updates the EBS storage associated with MSK brokers.


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

        Parameters:
        updateBrokerStorageRequest - A Consumer that will call methods on UpdateBrokerStorageRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateBrokerStorage operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateBrokerType

        default CompletableFuture<UpdateBrokerTypeResponse> updateBrokerType​(UpdateBrokerTypeRequest updateBrokerTypeRequest)

        Updates EC2 instance type.

        Parameters:
        updateBrokerTypeRequest -
        Returns:
        A Java Future containing the result of the UpdateBrokerType operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateBrokerType

        default CompletableFuture<UpdateBrokerTypeResponse> updateBrokerType​(Consumer<UpdateBrokerTypeRequest.Builder> updateBrokerTypeRequest)

        Updates EC2 instance type.


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

        Parameters:
        updateBrokerTypeRequest - A Consumer that will call methods on UpdateBrokerTypeRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateBrokerType operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateClusterConfiguration

        default CompletableFuture<UpdateClusterConfigurationResponse> updateClusterConfiguration​(UpdateClusterConfigurationRequest updateClusterConfigurationRequest)

        Updates the cluster with the configuration that is specified in the request body.

        Parameters:
        updateClusterConfigurationRequest -
        Returns:
        A Java Future containing the result of the UpdateClusterConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateClusterConfiguration

        default CompletableFuture<UpdateClusterConfigurationResponse> updateClusterConfiguration​(Consumer<UpdateClusterConfigurationRequest.Builder> updateClusterConfigurationRequest)

        Updates the cluster with the configuration that is specified in the request body.


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

        Parameters:
        updateClusterConfigurationRequest - A Consumer that will call methods on UpdateClusterConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateClusterConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateClusterKafkaVersion

        default CompletableFuture<UpdateClusterKafkaVersionResponse> updateClusterKafkaVersion​(UpdateClusterKafkaVersionRequest updateClusterKafkaVersionRequest)

        Updates the Apache Kafka version for the cluster.

        Parameters:
        updateClusterKafkaVersionRequest -
        Returns:
        A Java Future containing the result of the UpdateClusterKafkaVersion operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateClusterKafkaVersion

        default CompletableFuture<UpdateClusterKafkaVersionResponse> updateClusterKafkaVersion​(Consumer<UpdateClusterKafkaVersionRequest.Builder> updateClusterKafkaVersionRequest)

        Updates the Apache Kafka version for the cluster.


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

        Parameters:
        updateClusterKafkaVersionRequest - A Consumer that will call methods on UpdateClusterKafkaVersionRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateClusterKafkaVersion operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • TooManyRequestsException

          429 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateConfiguration

        default CompletableFuture<UpdateConfigurationResponse> updateConfiguration​(UpdateConfigurationRequest updateConfigurationRequest)

        Updates an MSK configuration.

        Parameters:
        updateConfigurationRequest -
        Returns:
        A Java Future containing the result of the UpdateConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateConfiguration

        default CompletableFuture<UpdateConfigurationResponse> updateConfiguration​(Consumer<UpdateConfigurationRequest.Builder> updateConfigurationRequest)

        Updates an MSK configuration.


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

        Parameters:
        updateConfigurationRequest - A Consumer that will call methods on UpdateConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateConnectivity

        default CompletableFuture<UpdateConnectivityResponse> updateConnectivity​(UpdateConnectivityRequest updateConnectivityRequest)

        Updates the cluster's connectivity configuration.

        Parameters:
        updateConnectivityRequest - Request body for UpdateConnectivity.
        Returns:
        A Java Future containing the result of the UpdateConnectivity operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateConnectivity

        default CompletableFuture<UpdateConnectivityResponse> updateConnectivity​(Consumer<UpdateConnectivityRequest.Builder> updateConnectivityRequest)

        Updates the cluster's connectivity configuration.


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

        Parameters:
        updateConnectivityRequest - A Consumer that will call methods on UpdateConnectivityRequest.Builder to create a request. Request body for UpdateConnectivity.
        Returns:
        A Java Future containing the result of the UpdateConnectivity operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          503 response

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateMonitoring

        default CompletableFuture<UpdateMonitoringResponse> updateMonitoring​(UpdateMonitoringRequest updateMonitoringRequest)

        Updates the monitoring settings for the cluster. You can use this operation to specify which Apache Kafka metrics you want Amazon MSK to send to Amazon CloudWatch. You can also specify settings for open monitoring with Prometheus.

        Parameters:
        updateMonitoringRequest - Request body for UpdateMonitoring.
        Returns:
        A Java Future containing the result of the UpdateMonitoring operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateMonitoring

        default CompletableFuture<UpdateMonitoringResponse> updateMonitoring​(Consumer<UpdateMonitoringRequest.Builder> updateMonitoringRequest)

        Updates the monitoring settings for the cluster. You can use this operation to specify which Apache Kafka metrics you want Amazon MSK to send to Amazon CloudWatch. You can also specify settings for open monitoring with Prometheus.


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

        Parameters:
        updateMonitoringRequest - A Consumer that will call methods on UpdateMonitoringRequest.Builder to create a request. Request body for UpdateMonitoring.
        Returns:
        A Java Future containing the result of the UpdateMonitoring operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceUnavailableException

          503 response

        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your 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.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateReplicationInfo

        default CompletableFuture<UpdateReplicationInfoResponse> updateReplicationInfo​(UpdateReplicationInfoRequest updateReplicationInfoRequest)

        Updates replication info of a replicator.

        Parameters:
        updateReplicationInfoRequest - Update information relating to replication between a given source and target Kafka cluster.
        Returns:
        A Java Future containing the result of the UpdateReplicationInfo operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateReplicationInfo

        default CompletableFuture<UpdateReplicationInfoResponse> updateReplicationInfo​(Consumer<UpdateReplicationInfoRequest.Builder> updateReplicationInfoRequest)

        Updates replication info of a replicator.


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

        Parameters:
        updateReplicationInfoRequest - A Consumer that will call methods on UpdateReplicationInfoRequest.Builder to create a request. Update information relating to replication between a given source and target Kafka cluster.
        Returns:
        A Java Future containing the result of the UpdateReplicationInfo operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateSecurity

        default CompletableFuture<UpdateSecurityResponse> updateSecurity​(UpdateSecurityRequest updateSecurityRequest)

        Updates the security settings for the cluster. You can use this operation to specify encryption and authentication on existing clusters.

        Parameters:
        updateSecurityRequest -
        Returns:
        A Java Future containing the result of the UpdateSecurity operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          The service cannot complete the request.

        • TooManyRequestsException

          The request throughput limit was exceeded.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateSecurity

        default CompletableFuture<UpdateSecurityResponse> updateSecurity​(Consumer<UpdateSecurityRequest.Builder> updateSecurityRequest)

        Updates the security settings for the cluster. You can use this operation to specify encryption and authentication on existing clusters.


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

        Parameters:
        updateSecurityRequest - A Consumer that will call methods on UpdateSecurityRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateSecurity operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException

          The request isn't valid because the input is incorrect. Correct your input and then submit it again.

        • UnauthorizedException

          The request is not authorized. The provided credentials couldn't be validated.

        • InternalServerErrorException

          There was an unexpected internal server error. Retrying your request might resolve the issue.

        • ForbiddenException

          Access forbidden. Check your credentials and then retry your request.

        • NotFoundException

          The resource could not be found due to incorrect input. Correct the input, then retry the request.

        • ServiceUnavailableException

          The service cannot complete the request.

        • TooManyRequestsException

          The request throughput limit was exceeded.

        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateStorage

        default CompletableFuture<UpdateStorageResponse> updateStorage​(UpdateStorageRequest updateStorageRequest)
        Updates cluster broker volume size (or) sets cluster storage mode to TIERED.
        Parameters:
        updateStorageRequest -

        Request object for UpdateStorage api. Its used to update the storage attributes for the cluster.

        Returns:
        A Java Future containing the result of the UpdateStorage operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateStorage

        default CompletableFuture<UpdateStorageResponse> updateStorage​(Consumer<UpdateStorageRequest.Builder> updateStorageRequest)
        Updates cluster broker volume size (or) sets cluster storage mode to TIERED.

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

        Parameters:
        updateStorageRequest - A Consumer that will call methods on UpdateStorageRequest.Builder to create a request.

        Request object for UpdateStorage api. Its used to update the storage attributes for the cluster.

        Returns:
        A Java Future containing the result of the UpdateStorage operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • BadRequestException HTTP Status Code 400: Bad request due to incorrect input. Correct your request and then retry it.
        • UnauthorizedException HTTP Status Code 401: Unauthorized request. The provided credentials couldn't be validated.
        • InternalServerErrorException HTTP Status Code 500: Unexpected internal server error. Retrying your request might resolve the issue.
        • ForbiddenException HTTP Status Code 403: Access forbidden. Correct your credentials and then retry your request.
        • NotFoundException HTTP Status Code 404: Resource not found due to incorrect input. Correct your request and then retry it.
        • ServiceUnavailableException HTTP Status Code 503: Service Unavailable. Retrying your request in some time might resolve the issue.
        • TooManyRequestsException HTTP Status Code 429: Limit exceeded. Resource limit reached.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • KafkaException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation