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
invalid reference 
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.

  • Field Details

  • Method Details

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • getBootstrapBrokers

      default CompletableFuture<GetBootstrapBrokersResponse> getBootstrapBrokers(GetBootstrapBrokersRequest getBootstrapBrokersRequest)

      A list of brokers that a client application can use to bootstrap.

      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:

    • getBootstrapBrokers

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

      A list of brokers that a client application can use to bootstrap.


      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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • serviceClientConfiguration

      default KafkaServiceClientConfiguration serviceClientConfiguration()
      Description copied from interface: SdkClient
      The SDK service client configuration exposes client settings to the user, e.g., ClientOverrideConfiguration
      Specified by:
      serviceClientConfiguration in interface AwsClient
      Specified by:
      serviceClientConfiguration in interface SdkClient
      Returns:
      SdkServiceClientConfiguration

    • create

      static KafkaAsyncClient create()
      Create a KafkaAsyncClient with the region loaded from the DefaultAwsRegionProviderChain and credentials loaded from the DefaultCredentialsProvider.

    • builder

      static KafkaAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a KafkaAsyncClient.