software.amazon.awssdk.services.kinesis.KinesisAsyncClient Maven / Gradle / Ivy
Show all versions of kinesis Show documentation
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.kinesis;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkPublicApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.awscore.AwsClient;
import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamRequest;
import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamResponse;
import software.amazon.awssdk.services.kinesis.model.CreateStreamRequest;
import software.amazon.awssdk.services.kinesis.model.CreateStreamResponse;
import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodRequest;
import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodResponse;
import software.amazon.awssdk.services.kinesis.model.DeleteResourcePolicyRequest;
import software.amazon.awssdk.services.kinesis.model.DeleteResourcePolicyResponse;
import software.amazon.awssdk.services.kinesis.model.DeleteStreamRequest;
import software.amazon.awssdk.services.kinesis.model.DeleteStreamResponse;
import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerRequest;
import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerResponse;
import software.amazon.awssdk.services.kinesis.model.DescribeLimitsRequest;
import software.amazon.awssdk.services.kinesis.model.DescribeLimitsResponse;
import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerRequest;
import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerResponse;
import software.amazon.awssdk.services.kinesis.model.DescribeStreamRequest;
import software.amazon.awssdk.services.kinesis.model.DescribeStreamResponse;
import software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryRequest;
import software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryResponse;
import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringRequest;
import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringResponse;
import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringRequest;
import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringResponse;
import software.amazon.awssdk.services.kinesis.model.GetRecordsRequest;
import software.amazon.awssdk.services.kinesis.model.GetRecordsResponse;
import software.amazon.awssdk.services.kinesis.model.GetResourcePolicyRequest;
import software.amazon.awssdk.services.kinesis.model.GetResourcePolicyResponse;
import software.amazon.awssdk.services.kinesis.model.GetShardIteratorRequest;
import software.amazon.awssdk.services.kinesis.model.GetShardIteratorResponse;
import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodRequest;
import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodResponse;
import software.amazon.awssdk.services.kinesis.model.ListShardsRequest;
import software.amazon.awssdk.services.kinesis.model.ListShardsResponse;
import software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest;
import software.amazon.awssdk.services.kinesis.model.ListStreamConsumersResponse;
import software.amazon.awssdk.services.kinesis.model.ListStreamsRequest;
import software.amazon.awssdk.services.kinesis.model.ListStreamsResponse;
import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamRequest;
import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamResponse;
import software.amazon.awssdk.services.kinesis.model.MergeShardsRequest;
import software.amazon.awssdk.services.kinesis.model.MergeShardsResponse;
import software.amazon.awssdk.services.kinesis.model.PutRecordRequest;
import software.amazon.awssdk.services.kinesis.model.PutRecordResponse;
import software.amazon.awssdk.services.kinesis.model.PutRecordsRequest;
import software.amazon.awssdk.services.kinesis.model.PutRecordsResponse;
import software.amazon.awssdk.services.kinesis.model.PutResourcePolicyRequest;
import software.amazon.awssdk.services.kinesis.model.PutResourcePolicyResponse;
import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerRequest;
import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerResponse;
import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamRequest;
import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamResponse;
import software.amazon.awssdk.services.kinesis.model.SplitShardRequest;
import software.amazon.awssdk.services.kinesis.model.SplitShardResponse;
import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionRequest;
import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionResponse;
import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionRequest;
import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionResponse;
import software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest;
import software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponseHandler;
import software.amazon.awssdk.services.kinesis.model.UpdateShardCountRequest;
import software.amazon.awssdk.services.kinesis.model.UpdateShardCountResponse;
import software.amazon.awssdk.services.kinesis.model.UpdateStreamModeRequest;
import software.amazon.awssdk.services.kinesis.model.UpdateStreamModeResponse;
import software.amazon.awssdk.services.kinesis.paginators.ListStreamConsumersPublisher;
import software.amazon.awssdk.services.kinesis.paginators.ListStreamsPublisher;
import software.amazon.awssdk.services.kinesis.waiters.KinesisAsyncWaiter;
/**
* Service client for accessing Kinesis asynchronously. This can be created using the static {@link #builder()}
* method.The asynchronous client performs non-blocking I/O when configured with any {@code SdkAsyncHttpClient}
* supported in the SDK. However, full non-blocking is not guaranteed as the async client may perform blocking calls in
* some cases such as credentials retrieval and endpoint discovery as part of the async API call.
*
* Amazon Kinesis Data Streams Service API Reference
*
* Amazon Kinesis Data Streams is a managed service that scales elastically for real-time processing of streaming big
* data.
*
*/
@Generated("software.amazon.awssdk:codegen")
@SdkPublicApi
@ThreadSafe
public interface KinesisAsyncClient extends AwsClient {
String SERVICE_NAME = "kinesis";
/**
* Value for looking up the service's metadata from the
* {@link software.amazon.awssdk.regions.ServiceMetadataProvider}.
*/
String SERVICE_METADATA_ID = "kinesis";
/**
*
* Adds or updates tags for the specified Kinesis data stream. You can assign up to 50 tags to a data stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If tags have already been assigned to the stream, AddTagsToStream overwrites any existing tags that
* correspond to the specified tag keys.
*
*
* AddTagsToStream has a limit of five transactions per second per account.
*
*
* @param addTagsToStreamRequest
* Represents the input for AddTagsToStream.
* @return A Java Future containing the result of the AddTagsToStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.AddTagsToStream
* @see AWS API
* Documentation
*/
default CompletableFuture addTagsToStream(AddTagsToStreamRequest addTagsToStreamRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds or updates tags for the specified Kinesis data stream. You can assign up to 50 tags to a data stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If tags have already been assigned to the stream, AddTagsToStream overwrites any existing tags that
* correspond to the specified tag keys.
*
*
* AddTagsToStream has a limit of five transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link AddTagsToStreamRequest.Builder} avoiding the need
* to create one manually via {@link AddTagsToStreamRequest#builder()}
*
*
* @param addTagsToStreamRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.AddTagsToStreamRequest.Builder} to create a request.
* Represents the input for AddTagsToStream.
* @return A Java Future containing the result of the AddTagsToStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.AddTagsToStream
* @see AWS API
* Documentation
*/
default CompletableFuture addTagsToStream(
Consumer addTagsToStreamRequest) {
return addTagsToStream(AddTagsToStreamRequest.builder().applyMutation(addTagsToStreamRequest).build());
}
/**
*
* Creates a Kinesis data stream. A stream captures and transports data records that are continuously emitted from
* different data sources or producers. Scale-out within a stream is explicitly supported by means of shards,
* which are uniquely identified groups of data records in a stream.
*
*
* You can create your data stream using either on-demand or provisioned capacity mode. Data streams with an
* on-demand mode require no capacity planning and automatically scale to handle gigabytes of write and read
* throughput per minute. With the on-demand mode, Kinesis Data Streams automatically manages the shards in order to
* provide the necessary throughput. For the data streams with a provisioned mode, you must specify the number of
* shards for the data stream. Each shard can support reads up to five transactions per second, up to a maximum data
* read total of 2 MiB per second. Each shard can support writes up to 1,000 records per second, up to a maximum
* data write total of 1 MiB per second. If the amount of data input increases or decreases, you can add or remove
* shards.
*
*
* The stream name identifies the stream. The name is scoped to the Amazon Web Services account used by the
* application. It is also scoped by Amazon Web Services Region. That is, two streams in two different accounts can
* have the same name, and two streams in the same account, but in two different Regions, can have the same name.
*
*
* CreateStream is an asynchronous operation. Upon receiving a CreateStream request,
* Kinesis Data Streams immediately returns and sets the stream status to CREATING. After the stream is
* created, Kinesis Data Streams sets the stream status to ACTIVE. You should perform read and write
* operations only on an ACTIVE stream.
*
*
* You receive a LimitExceededException when making a CreateStream request when you try to
* do one of the following:
*
*
* -
*
* Have more than five streams in the CREATING state at any point in time.
*
*
* -
*
* Create more shards than are authorized for your account.
*
*
*
*
* For the default shard limit for an Amazon Web Services account, see Amazon Kinesis Data Streams
* Limits in the Amazon Kinesis Data Streams Developer Guide. To increase this limit, contact Amazon Web Services
* Support.
*
*
* You can use DescribeStreamSummary to check the stream status, which is returned in
* StreamStatus.
*
*
* CreateStream has a limit of five transactions per second per account.
*
*
* You can add tags to the stream when making a CreateStream request by setting the Tags
* parameter. If you pass Tags parameter, in addition to having kinesis:createStream
* permission, you must also have kinesis:addTagsToStream permission for the stream that will be
* created. Tags will take effect from the CREATING status of the stream.
*
*
* @param createStreamRequest
* Represents the input for CreateStream.
* @return A Java Future containing the result of the CreateStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.CreateStream
* @see AWS API
* Documentation
*/
default CompletableFuture createStream(CreateStreamRequest createStreamRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a Kinesis data stream. A stream captures and transports data records that are continuously emitted from
* different data sources or producers. Scale-out within a stream is explicitly supported by means of shards,
* which are uniquely identified groups of data records in a stream.
*
*
* You can create your data stream using either on-demand or provisioned capacity mode. Data streams with an
* on-demand mode require no capacity planning and automatically scale to handle gigabytes of write and read
* throughput per minute. With the on-demand mode, Kinesis Data Streams automatically manages the shards in order to
* provide the necessary throughput. For the data streams with a provisioned mode, you must specify the number of
* shards for the data stream. Each shard can support reads up to five transactions per second, up to a maximum data
* read total of 2 MiB per second. Each shard can support writes up to 1,000 records per second, up to a maximum
* data write total of 1 MiB per second. If the amount of data input increases or decreases, you can add or remove
* shards.
*
*
* The stream name identifies the stream. The name is scoped to the Amazon Web Services account used by the
* application. It is also scoped by Amazon Web Services Region. That is, two streams in two different accounts can
* have the same name, and two streams in the same account, but in two different Regions, can have the same name.
*
*
* CreateStream is an asynchronous operation. Upon receiving a CreateStream request,
* Kinesis Data Streams immediately returns and sets the stream status to CREATING. After the stream is
* created, Kinesis Data Streams sets the stream status to ACTIVE. You should perform read and write
* operations only on an ACTIVE stream.
*
*
* You receive a LimitExceededException when making a CreateStream request when you try to
* do one of the following:
*
*
* -
*
* Have more than five streams in the CREATING state at any point in time.
*
*
* -
*
* Create more shards than are authorized for your account.
*
*
*
*
* For the default shard limit for an Amazon Web Services account, see Amazon Kinesis Data Streams
* Limits in the Amazon Kinesis Data Streams Developer Guide. To increase this limit, contact Amazon Web Services
* Support.
*
*
* You can use DescribeStreamSummary to check the stream status, which is returned in
* StreamStatus.
*
*
* CreateStream has a limit of five transactions per second per account.
*
*
* You can add tags to the stream when making a CreateStream request by setting the Tags
* parameter. If you pass Tags parameter, in addition to having kinesis:createStream
* permission, you must also have kinesis:addTagsToStream permission for the stream that will be
* created. Tags will take effect from the CREATING status of the stream.
*
*
*
* This is a convenience which creates an instance of the {@link CreateStreamRequest.Builder} avoiding the need to
* create one manually via {@link CreateStreamRequest#builder()}
*
*
* @param createStreamRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.CreateStreamRequest.Builder} to create a request.
* Represents the input for CreateStream.
* @return A Java Future containing the result of the CreateStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.CreateStream
* @see AWS API
* Documentation
*/
default CompletableFuture createStream(Consumer createStreamRequest) {
return createStream(CreateStreamRequest.builder().applyMutation(createStreamRequest).build());
}
/**
*
* Decreases the Kinesis data stream's retention period, which is the length of time data records are accessible
* after they are added to the stream. The minimum value of a stream's retention period is 24 hours.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* This operation may result in lost data. For example, if the stream's retention period is 48 hours and is
* decreased to 24 hours, any data already in the stream that is older than 24 hours is inaccessible.
*
*
* @param decreaseStreamRetentionPeriodRequest
* Represents the input for DecreaseStreamRetentionPeriod.
* @return A Java Future containing the result of the DecreaseStreamRetentionPeriod operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DecreaseStreamRetentionPeriod
* @see AWS API Documentation
*/
default CompletableFuture decreaseStreamRetentionPeriod(
DecreaseStreamRetentionPeriodRequest decreaseStreamRetentionPeriodRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Decreases the Kinesis data stream's retention period, which is the length of time data records are accessible
* after they are added to the stream. The minimum value of a stream's retention period is 24 hours.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* This operation may result in lost data. For example, if the stream's retention period is 48 hours and is
* decreased to 24 hours, any data already in the stream that is older than 24 hours is inaccessible.
*
*
*
* This is a convenience which creates an instance of the {@link DecreaseStreamRetentionPeriodRequest.Builder}
* avoiding the need to create one manually via {@link DecreaseStreamRetentionPeriodRequest#builder()}
*
*
* @param decreaseStreamRetentionPeriodRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodRequest.Builder} to
* create a request. Represents the input for DecreaseStreamRetentionPeriod.
* @return A Java Future containing the result of the DecreaseStreamRetentionPeriod operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DecreaseStreamRetentionPeriod
* @see AWS API Documentation
*/
default CompletableFuture decreaseStreamRetentionPeriod(
Consumer decreaseStreamRetentionPeriodRequest) {
return decreaseStreamRetentionPeriod(DecreaseStreamRetentionPeriodRequest.builder()
.applyMutation(decreaseStreamRetentionPeriodRequest).build());
}
/**
*
* Delete a policy for the specified data stream or consumer. Request patterns can be one of the following:
*
*
* -
*
* Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
*
*
* -
*
* Consumer pattern:
* ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
*
*
*
*
* @param deleteResourcePolicyRequest
* @return A Java Future containing the result of the DeleteResourcePolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DeleteResourcePolicy
* @see AWS
* API Documentation
*/
default CompletableFuture deleteResourcePolicy(
DeleteResourcePolicyRequest deleteResourcePolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Delete a policy for the specified data stream or consumer. Request patterns can be one of the following:
*
*
* -
*
* Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
*
*
* -
*
* Consumer pattern:
* ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
*
*
*
*
*
* This is a convenience which creates an instance of the {@link DeleteResourcePolicyRequest.Builder} avoiding the
* need to create one manually via {@link DeleteResourcePolicyRequest#builder()}
*
*
* @param deleteResourcePolicyRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DeleteResourcePolicyRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteResourcePolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DeleteResourcePolicy
* @see AWS
* API Documentation
*/
default CompletableFuture deleteResourcePolicy(
Consumer deleteResourcePolicyRequest) {
return deleteResourcePolicy(DeleteResourcePolicyRequest.builder().applyMutation(deleteResourcePolicyRequest).build());
}
/**
*
* Deletes a Kinesis data stream and all its shards and data. You must shut down any applications that are operating
* on the stream before you delete the stream. If an application attempts to operate on a deleted stream, it
* receives the exception ResourceNotFoundException.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If the stream is in the ACTIVE state, you can delete it. After a DeleteStream request,
* the specified stream is in the DELETING state until Kinesis Data Streams completes the deletion.
*
*
* Note: Kinesis Data Streams might continue to accept data read and write operations, such as
* PutRecord, PutRecords, and GetRecords, on a stream in the DELETING state until
* the stream deletion is complete.
*
*
* When you delete a stream, any shards in that stream are also deleted, and any tags are dissociated from the
* stream.
*
*
* You can use the DescribeStreamSummary operation to check the state of the stream, which is returned in
* StreamStatus.
*
*
* DeleteStream has a limit of five transactions per second per account.
*
*
* @param deleteStreamRequest
* Represents the input for DeleteStream.
* @return A Java Future containing the result of the DeleteStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DeleteStream
* @see AWS API
* Documentation
*/
default CompletableFuture deleteStream(DeleteStreamRequest deleteStreamRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a Kinesis data stream and all its shards and data. You must shut down any applications that are operating
* on the stream before you delete the stream. If an application attempts to operate on a deleted stream, it
* receives the exception ResourceNotFoundException.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If the stream is in the ACTIVE state, you can delete it. After a DeleteStream request,
* the specified stream is in the DELETING state until Kinesis Data Streams completes the deletion.
*
*
* Note: Kinesis Data Streams might continue to accept data read and write operations, such as
* PutRecord, PutRecords, and GetRecords, on a stream in the DELETING state until
* the stream deletion is complete.
*
*
* When you delete a stream, any shards in that stream are also deleted, and any tags are dissociated from the
* stream.
*
*
* You can use the DescribeStreamSummary operation to check the state of the stream, which is returned in
* StreamStatus.
*
*
* DeleteStream has a limit of five transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteStreamRequest.Builder} avoiding the need to
* create one manually via {@link DeleteStreamRequest#builder()}
*
*
* @param deleteStreamRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DeleteStreamRequest.Builder} to create a request.
* Represents the input for DeleteStream.
* @return A Java Future containing the result of the DeleteStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DeleteStream
* @see AWS API
* Documentation
*/
default CompletableFuture deleteStream(Consumer deleteStreamRequest) {
return deleteStream(DeleteStreamRequest.builder().applyMutation(deleteStreamRequest).build());
}
/**
*
* To deregister a consumer, provide its ARN. Alternatively, you can provide the ARN of the data stream and the name
* you gave the consumer when you registered it. You may also provide all three parameters, as long as they don't
* conflict with each other. If you don't know the name or ARN of the consumer that you want to deregister, you can
* use the ListStreamConsumers operation to get a list of the descriptions of all the consumers that are
* currently registered with a given data stream. The description of a consumer contains its name and ARN.
*
*
* This operation has a limit of five transactions per second per stream.
*
*
* @param deregisterStreamConsumerRequest
* @return A Java Future containing the result of the DeregisterStreamConsumer operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DeregisterStreamConsumer
* @see AWS API Documentation
*/
default CompletableFuture deregisterStreamConsumer(
DeregisterStreamConsumerRequest deregisterStreamConsumerRequest) {
throw new UnsupportedOperationException();
}
/**
*
* To deregister a consumer, provide its ARN. Alternatively, you can provide the ARN of the data stream and the name
* you gave the consumer when you registered it. You may also provide all three parameters, as long as they don't
* conflict with each other. If you don't know the name or ARN of the consumer that you want to deregister, you can
* use the ListStreamConsumers operation to get a list of the descriptions of all the consumers that are
* currently registered with a given data stream. The description of a consumer contains its name and ARN.
*
*
* This operation has a limit of five transactions per second per stream.
*
*
*
* This is a convenience which creates an instance of the {@link DeregisterStreamConsumerRequest.Builder} avoiding
* the need to create one manually via {@link DeregisterStreamConsumerRequest#builder()}
*
*
* @param deregisterStreamConsumerRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeregisterStreamConsumer operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DeregisterStreamConsumer
* @see AWS API Documentation
*/
default CompletableFuture deregisterStreamConsumer(
Consumer deregisterStreamConsumerRequest) {
return deregisterStreamConsumer(DeregisterStreamConsumerRequest.builder().applyMutation(deregisterStreamConsumerRequest)
.build());
}
/**
*
* Describes the shard limits and usage for the account.
*
*
* If you update your account limits, the old limits might be returned for a few minutes.
*
*
* This operation has a limit of one transaction per second per account.
*
*
* @param describeLimitsRequest
* @return A Java Future containing the result of the DescribeLimits operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeLimits
* @see AWS API
* Documentation
*/
default CompletableFuture describeLimits(DescribeLimitsRequest describeLimitsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Describes the shard limits and usage for the account.
*
*
* If you update your account limits, the old limits might be returned for a few minutes.
*
*
* This operation has a limit of one transaction per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeLimitsRequest.Builder} avoiding the need to
* create one manually via {@link DescribeLimitsRequest#builder()}
*
*
* @param describeLimitsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DescribeLimitsRequest.Builder} to create a request.
* @return A Java Future containing the result of the DescribeLimits operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeLimits
* @see AWS API
* Documentation
*/
default CompletableFuture describeLimits(Consumer describeLimitsRequest) {
return describeLimits(DescribeLimitsRequest.builder().applyMutation(describeLimitsRequest).build());
}
/**
*
* Describes the shard limits and usage for the account.
*
*
* If you update your account limits, the old limits might be returned for a few minutes.
*
*
* This operation has a limit of one transaction per second per account.
*
*
* @return A Java Future containing the result of the DescribeLimits operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeLimits
* @see AWS API
* Documentation
*/
default CompletableFuture describeLimits() {
return describeLimits(DescribeLimitsRequest.builder().build());
}
/**
*
* Describes the specified Kinesis data stream.
*
*
*
* This API has been revised. It's highly recommended that you use the DescribeStreamSummary API to get a
* summarized description of the specified Kinesis data stream and the ListShards API to list the shards in a
* specified data stream and obtain information about each shard.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* The information returned includes the stream name, Amazon Resource Name (ARN), creation time, enhanced metric
* configuration, and shard map. The shard map is an array of shard objects. For each shard object, there is the
* hash key and sequence number ranges that the shard spans, and the IDs of any earlier shards that played in a role
* in creating the shard. Every record ingested in the stream is identified by a sequence number, which is assigned
* when the record is put into the stream.
*
*
* You can limit the number of shards returned by each call. For more information, see Retrieving
* Shards from a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
* There are no guarantees about the chronological order shards returned. To process shards in chronological order,
* use the ID of the parent shard to track the lineage to the oldest shard.
*
*
* This operation has a limit of 10 transactions per second per account.
*
*
* @param describeStreamRequest
* Represents the input for DescribeStream.
* @return A Java Future containing the result of the DescribeStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeStream
* @see AWS API
* Documentation
*/
default CompletableFuture describeStream(DescribeStreamRequest describeStreamRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Describes the specified Kinesis data stream.
*
*
*
* This API has been revised. It's highly recommended that you use the DescribeStreamSummary API to get a
* summarized description of the specified Kinesis data stream and the ListShards API to list the shards in a
* specified data stream and obtain information about each shard.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* The information returned includes the stream name, Amazon Resource Name (ARN), creation time, enhanced metric
* configuration, and shard map. The shard map is an array of shard objects. For each shard object, there is the
* hash key and sequence number ranges that the shard spans, and the IDs of any earlier shards that played in a role
* in creating the shard. Every record ingested in the stream is identified by a sequence number, which is assigned
* when the record is put into the stream.
*
*
* You can limit the number of shards returned by each call. For more information, see Retrieving
* Shards from a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
* There are no guarantees about the chronological order shards returned. To process shards in chronological order,
* use the ID of the parent shard to track the lineage to the oldest shard.
*
*
* This operation has a limit of 10 transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeStreamRequest.Builder} avoiding the need to
* create one manually via {@link DescribeStreamRequest#builder()}
*
*
* @param describeStreamRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DescribeStreamRequest.Builder} to create a request.
* Represents the input for DescribeStream.
* @return A Java Future containing the result of the DescribeStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeStream
* @see AWS API
* Documentation
*/
default CompletableFuture describeStream(Consumer describeStreamRequest) {
return describeStream(DescribeStreamRequest.builder().applyMutation(describeStreamRequest).build());
}
/**
*
* To get the description of a registered consumer, provide the ARN of the consumer. Alternatively, you can provide
* the ARN of the data stream and the name you gave the consumer when you registered it. You may also provide all
* three parameters, as long as they don't conflict with each other. If you don't know the name or ARN of the
* consumer that you want to describe, you can use the ListStreamConsumers operation to get a list of the
* descriptions of all the consumers that are currently registered with a given data stream.
*
*
* This operation has a limit of 20 transactions per second per stream.
*
*
*
* When making a cross-account call with DescribeStreamConsumer, make sure to provide the ARN of the
* consumer.
*
*
*
* @param describeStreamConsumerRequest
* @return A Java Future containing the result of the DescribeStreamConsumer operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeStreamConsumer
* @see AWS API Documentation
*/
default CompletableFuture describeStreamConsumer(
DescribeStreamConsumerRequest describeStreamConsumerRequest) {
throw new UnsupportedOperationException();
}
/**
*
* To get the description of a registered consumer, provide the ARN of the consumer. Alternatively, you can provide
* the ARN of the data stream and the name you gave the consumer when you registered it. You may also provide all
* three parameters, as long as they don't conflict with each other. If you don't know the name or ARN of the
* consumer that you want to describe, you can use the ListStreamConsumers operation to get a list of the
* descriptions of all the consumers that are currently registered with a given data stream.
*
*
* This operation has a limit of 20 transactions per second per stream.
*
*
*
* When making a cross-account call with DescribeStreamConsumer, make sure to provide the ARN of the
* consumer.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeStreamConsumerRequest.Builder} avoiding the
* need to create one manually via {@link DescribeStreamConsumerRequest#builder()}
*
*
* @param describeStreamConsumerRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeStreamConsumer operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeStreamConsumer
* @see AWS API Documentation
*/
default CompletableFuture describeStreamConsumer(
Consumer describeStreamConsumerRequest) {
return describeStreamConsumer(DescribeStreamConsumerRequest.builder().applyMutation(describeStreamConsumerRequest)
.build());
}
/**
*
* Provides a summarized description of the specified Kinesis data stream without the shard list.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* The information returned includes the stream name, Amazon Resource Name (ARN), status, record retention period,
* approximate creation time, monitoring, encryption details, and open shard count.
*
*
* DescribeStreamSummary has a limit of 20 transactions per second per account.
*
*
* @param describeStreamSummaryRequest
* @return A Java Future containing the result of the DescribeStreamSummary operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeStreamSummary
* @see AWS
* API Documentation
*/
default CompletableFuture describeStreamSummary(
DescribeStreamSummaryRequest describeStreamSummaryRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides a summarized description of the specified Kinesis data stream without the shard list.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* The information returned includes the stream name, Amazon Resource Name (ARN), status, record retention period,
* approximate creation time, monitoring, encryption details, and open shard count.
*
*
* DescribeStreamSummary has a limit of 20 transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeStreamSummaryRequest.Builder} avoiding the
* need to create one manually via {@link DescribeStreamSummaryRequest#builder()}
*
*
* @param describeStreamSummaryRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeStreamSummary operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DescribeStreamSummary
* @see AWS
* API Documentation
*/
default CompletableFuture describeStreamSummary(
Consumer describeStreamSummaryRequest) {
return describeStreamSummary(DescribeStreamSummaryRequest.builder().applyMutation(describeStreamSummaryRequest).build());
}
/**
*
* Disables enhanced monitoring.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* @param disableEnhancedMonitoringRequest
* Represents the input for DisableEnhancedMonitoring.
* @return A Java Future containing the result of the DisableEnhancedMonitoring operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DisableEnhancedMonitoring
* @see AWS API Documentation
*/
default CompletableFuture disableEnhancedMonitoring(
DisableEnhancedMonitoringRequest disableEnhancedMonitoringRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Disables enhanced monitoring.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* This is a convenience which creates an instance of the {@link DisableEnhancedMonitoringRequest.Builder} avoiding
* the need to create one manually via {@link DisableEnhancedMonitoringRequest#builder()}
*
*
* @param disableEnhancedMonitoringRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringRequest.Builder} to create a
* request. Represents the input for DisableEnhancedMonitoring.
* @return A Java Future containing the result of the DisableEnhancedMonitoring operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.DisableEnhancedMonitoring
* @see AWS API Documentation
*/
default CompletableFuture disableEnhancedMonitoring(
Consumer disableEnhancedMonitoringRequest) {
return disableEnhancedMonitoring(DisableEnhancedMonitoringRequest.builder()
.applyMutation(disableEnhancedMonitoringRequest).build());
}
/**
*
* Enables enhanced Kinesis data stream monitoring for shard-level metrics.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* @param enableEnhancedMonitoringRequest
* Represents the input for EnableEnhancedMonitoring.
* @return A Java Future containing the result of the EnableEnhancedMonitoring operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.EnableEnhancedMonitoring
* @see AWS API Documentation
*/
default CompletableFuture enableEnhancedMonitoring(
EnableEnhancedMonitoringRequest enableEnhancedMonitoringRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Enables enhanced Kinesis data stream monitoring for shard-level metrics.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* This is a convenience which creates an instance of the {@link EnableEnhancedMonitoringRequest.Builder} avoiding
* the need to create one manually via {@link EnableEnhancedMonitoringRequest#builder()}
*
*
* @param enableEnhancedMonitoringRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringRequest.Builder} to create a
* request. Represents the input for EnableEnhancedMonitoring.
* @return A Java Future containing the result of the EnableEnhancedMonitoring operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.EnableEnhancedMonitoring
* @see AWS API Documentation
*/
default CompletableFuture enableEnhancedMonitoring(
Consumer enableEnhancedMonitoringRequest) {
return enableEnhancedMonitoring(EnableEnhancedMonitoringRequest.builder().applyMutation(enableEnhancedMonitoringRequest)
.build());
}
/**
*
* Gets data records from a Kinesis data stream's shard.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Specify a shard iterator using the ShardIterator parameter. The shard iterator specifies the
* position in the shard from which you want to start reading data records sequentially. If there are no records
* available in the portion of the shard that the iterator points to, GetRecords returns an empty list. It
* might take multiple calls to get to a portion of the shard that contains records.
*
*
* You can scale by provisioning multiple shards per stream while considering service limits (for more information,
* see Amazon Kinesis Data
* Streams Limits in the Amazon Kinesis Data Streams Developer Guide). Your application should have one
* thread per shard, each reading continuously from its stream. To read from a stream continually, call
* GetRecords in a loop. Use GetShardIterator to get the shard iterator to specify in the first
* GetRecords call. GetRecords returns a new shard iterator in NextShardIterator. Specify
* the shard iterator returned in NextShardIterator in subsequent calls to GetRecords. If the
* shard has been closed, the shard iterator can't return more data and GetRecords returns null
* in NextShardIterator. You can terminate the loop when the shard is closed, or when the shard
* iterator reaches the record with the sequence number or other attribute that marks it as the last record to
* process.
*
*
* Each data record can be up to 1 MiB in size, and each shard can read up to 2 MiB per second. You can ensure that
* your calls don't exceed the maximum supported size or throughput by using the Limit parameter to
* specify the maximum number of records that GetRecords can return. Consider your average record size when
* determining this limit. The maximum number of records that can be returned per call is 10,000.
*
*
* The size of the data returned by GetRecords varies depending on the utilization of the shard. It is
* recommended that consumer applications retrieve records via the GetRecords command using the 5 TPS
* limit to remain caught up. Retrieving records less frequently can lead to consumer applications falling behind.
* The maximum size of data that GetRecords can return is 10 MiB. If a call returns this amount of data,
* subsequent calls made within the next 5 seconds throw ProvisionedThroughputExceededException. If
* there is insufficient provisioned throughput on the stream, subsequent calls made within the next 1 second throw
* ProvisionedThroughputExceededException. GetRecords doesn't return any data when it throws an
* exception. For this reason, we recommend that you wait 1 second between calls to GetRecords. However, it's
* possible that the application will get exceptions for longer than 1 second.
*
*
* To detect whether the application is falling behind in processing, you can use the
* MillisBehindLatest response attribute. You can also monitor the stream using CloudWatch metrics and
* other mechanisms (see Monitoring in
* the Amazon Kinesis Data Streams Developer Guide).
*
*
* Each Amazon Kinesis record includes a value, ApproximateArrivalTimestamp, that is set when a stream
* successfully receives and stores a record. This is commonly referred to as a server-side time stamp, whereas a
* client-side time stamp is set when a data producer creates or sends the record to a stream (a data producer is
* any data source putting data records into a stream, for example with PutRecords). The time stamp has
* millisecond precision. There are no guarantees about the time stamp accuracy, or that the time stamp is always
* increasing. For example, records in a shard or across a stream might have time stamps that are out of order.
*
*
* This operation has a limit of five transactions per second per shard.
*
*
* @param getRecordsRequest
* Represents the input for GetRecords.
* @return A Java Future containing the result of the GetRecords operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - ExpiredIteratorException The provided iterator exceeds the maximum age allowed.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.GetRecords
* @see AWS API
* Documentation
*/
default CompletableFuture getRecords(GetRecordsRequest getRecordsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets data records from a Kinesis data stream's shard.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Specify a shard iterator using the ShardIterator parameter. The shard iterator specifies the
* position in the shard from which you want to start reading data records sequentially. If there are no records
* available in the portion of the shard that the iterator points to, GetRecords returns an empty list. It
* might take multiple calls to get to a portion of the shard that contains records.
*
*
* You can scale by provisioning multiple shards per stream while considering service limits (for more information,
* see Amazon Kinesis Data
* Streams Limits in the Amazon Kinesis Data Streams Developer Guide). Your application should have one
* thread per shard, each reading continuously from its stream. To read from a stream continually, call
* GetRecords in a loop. Use GetShardIterator to get the shard iterator to specify in the first
* GetRecords call. GetRecords returns a new shard iterator in NextShardIterator. Specify
* the shard iterator returned in NextShardIterator in subsequent calls to GetRecords. If the
* shard has been closed, the shard iterator can't return more data and GetRecords returns null
* in NextShardIterator. You can terminate the loop when the shard is closed, or when the shard
* iterator reaches the record with the sequence number or other attribute that marks it as the last record to
* process.
*
*
* Each data record can be up to 1 MiB in size, and each shard can read up to 2 MiB per second. You can ensure that
* your calls don't exceed the maximum supported size or throughput by using the Limit parameter to
* specify the maximum number of records that GetRecords can return. Consider your average record size when
* determining this limit. The maximum number of records that can be returned per call is 10,000.
*
*
* The size of the data returned by GetRecords varies depending on the utilization of the shard. It is
* recommended that consumer applications retrieve records via the GetRecords command using the 5 TPS
* limit to remain caught up. Retrieving records less frequently can lead to consumer applications falling behind.
* The maximum size of data that GetRecords can return is 10 MiB. If a call returns this amount of data,
* subsequent calls made within the next 5 seconds throw ProvisionedThroughputExceededException. If
* there is insufficient provisioned throughput on the stream, subsequent calls made within the next 1 second throw
* ProvisionedThroughputExceededException. GetRecords doesn't return any data when it throws an
* exception. For this reason, we recommend that you wait 1 second between calls to GetRecords. However, it's
* possible that the application will get exceptions for longer than 1 second.
*
*
* To detect whether the application is falling behind in processing, you can use the
* MillisBehindLatest response attribute. You can also monitor the stream using CloudWatch metrics and
* other mechanisms (see Monitoring in
* the Amazon Kinesis Data Streams Developer Guide).
*
*
* Each Amazon Kinesis record includes a value, ApproximateArrivalTimestamp, that is set when a stream
* successfully receives and stores a record. This is commonly referred to as a server-side time stamp, whereas a
* client-side time stamp is set when a data producer creates or sends the record to a stream (a data producer is
* any data source putting data records into a stream, for example with PutRecords). The time stamp has
* millisecond precision. There are no guarantees about the time stamp accuracy, or that the time stamp is always
* increasing. For example, records in a shard or across a stream might have time stamps that are out of order.
*
*
* This operation has a limit of five transactions per second per shard.
*
*
*
* This is a convenience which creates an instance of the {@link GetRecordsRequest.Builder} avoiding the need to
* create one manually via {@link GetRecordsRequest#builder()}
*
*
* @param getRecordsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.GetRecordsRequest.Builder} to create a request.
* Represents the input for GetRecords.
* @return A Java Future containing the result of the GetRecords operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - ExpiredIteratorException The provided iterator exceeds the maximum age allowed.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.GetRecords
* @see AWS API
* Documentation
*/
default CompletableFuture getRecords(Consumer getRecordsRequest) {
return getRecords(GetRecordsRequest.builder().applyMutation(getRecordsRequest).build());
}
/**
*
* Returns a policy attached to the specified data stream or consumer. Request patterns can be one of the following:
*
*
* -
*
* Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
*
*
* -
*
* Consumer pattern:
* ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
*
*
*
*
* @param getResourcePolicyRequest
* @return A Java Future containing the result of the GetResourcePolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.GetResourcePolicy
* @see AWS API
* Documentation
*/
default CompletableFuture getResourcePolicy(GetResourcePolicyRequest getResourcePolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a policy attached to the specified data stream or consumer. Request patterns can be one of the following:
*
*
* -
*
* Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
*
*
* -
*
* Consumer pattern:
* ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
*
*
*
*
*
* This is a convenience which creates an instance of the {@link GetResourcePolicyRequest.Builder} avoiding the need
* to create one manually via {@link GetResourcePolicyRequest#builder()}
*
*
* @param getResourcePolicyRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.GetResourcePolicyRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetResourcePolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.GetResourcePolicy
* @see AWS API
* Documentation
*/
default CompletableFuture getResourcePolicy(
Consumer getResourcePolicyRequest) {
return getResourcePolicy(GetResourcePolicyRequest.builder().applyMutation(getResourcePolicyRequest).build());
}
/**
*
* Gets an Amazon Kinesis shard iterator. A shard iterator expires 5 minutes after it is returned to the requester.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* A shard iterator specifies the shard position from which to start reading data records sequentially. The position
* is specified using the sequence number of a data record in a shard. A sequence number is the identifier
* associated with every record ingested in the stream, and is assigned when a record is put into the stream. Each
* stream has one or more shards.
*
*
* You must specify the shard iterator type. For example, you can set the ShardIteratorType parameter
* to read exactly from the position denoted by a specific sequence number by using the
* AT_SEQUENCE_NUMBER shard iterator type. Alternatively, the parameter can read right after the
* sequence number by using the AFTER_SEQUENCE_NUMBER shard iterator type, using sequence numbers
* returned by earlier calls to PutRecord, PutRecords, GetRecords, or DescribeStream. In
* the request, you can specify the shard iterator type AT_TIMESTAMP to read records from an arbitrary
* point in time, TRIM_HORIZON to cause ShardIterator to point to the last untrimmed
* record in the shard in the system (the oldest data record in the shard), or LATEST so that you
* always read the most recent data in the shard.
*
*
* When you read repeatedly from a stream, use a GetShardIterator request to get the first shard iterator for
* use in your first GetRecords request and for subsequent reads use the shard iterator returned by the
* GetRecords request in NextShardIterator. A new shard iterator is returned by every
* GetRecords request in NextShardIterator, which you use in the ShardIterator
* parameter of the next GetRecords request.
*
*
* If a GetShardIterator request is made too often, you receive a
* ProvisionedThroughputExceededException. For more information about throughput limits, see
* GetRecords, and Streams Limits in the
* Amazon Kinesis Data Streams Developer Guide.
*
*
* If the shard is closed, GetShardIterator returns a valid iterator for the last sequence number of the
* shard. A shard can be closed as a result of using SplitShard or MergeShards.
*
*
* GetShardIterator has a limit of five transactions per second per account per open shard.
*
*
* @param getShardIteratorRequest
* Represents the input for GetShardIterator.
* @return A Java Future containing the result of the GetShardIterator operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.GetShardIterator
* @see AWS API
* Documentation
*/
default CompletableFuture getShardIterator(GetShardIteratorRequest getShardIteratorRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets an Amazon Kinesis shard iterator. A shard iterator expires 5 minutes after it is returned to the requester.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* A shard iterator specifies the shard position from which to start reading data records sequentially. The position
* is specified using the sequence number of a data record in a shard. A sequence number is the identifier
* associated with every record ingested in the stream, and is assigned when a record is put into the stream. Each
* stream has one or more shards.
*
*
* You must specify the shard iterator type. For example, you can set the ShardIteratorType parameter
* to read exactly from the position denoted by a specific sequence number by using the
* AT_SEQUENCE_NUMBER shard iterator type. Alternatively, the parameter can read right after the
* sequence number by using the AFTER_SEQUENCE_NUMBER shard iterator type, using sequence numbers
* returned by earlier calls to PutRecord, PutRecords, GetRecords, or DescribeStream. In
* the request, you can specify the shard iterator type AT_TIMESTAMP to read records from an arbitrary
* point in time, TRIM_HORIZON to cause ShardIterator to point to the last untrimmed
* record in the shard in the system (the oldest data record in the shard), or LATEST so that you
* always read the most recent data in the shard.
*
*
* When you read repeatedly from a stream, use a GetShardIterator request to get the first shard iterator for
* use in your first GetRecords request and for subsequent reads use the shard iterator returned by the
* GetRecords request in NextShardIterator. A new shard iterator is returned by every
* GetRecords request in NextShardIterator, which you use in the ShardIterator
* parameter of the next GetRecords request.
*
*
* If a GetShardIterator request is made too often, you receive a
* ProvisionedThroughputExceededException. For more information about throughput limits, see
* GetRecords, and Streams Limits in the
* Amazon Kinesis Data Streams Developer Guide.
*
*
* If the shard is closed, GetShardIterator returns a valid iterator for the last sequence number of the
* shard. A shard can be closed as a result of using SplitShard or MergeShards.
*
*
* GetShardIterator has a limit of five transactions per second per account per open shard.
*
*
*
* This is a convenience which creates an instance of the {@link GetShardIteratorRequest.Builder} avoiding the need
* to create one manually via {@link GetShardIteratorRequest#builder()}
*
*
* @param getShardIteratorRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.GetShardIteratorRequest.Builder} to create a request.
* Represents the input for GetShardIterator.
* @return A Java Future containing the result of the GetShardIterator operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.GetShardIterator
* @see AWS API
* Documentation
*/
default CompletableFuture getShardIterator(
Consumer getShardIteratorRequest) {
return getShardIterator(GetShardIteratorRequest.builder().applyMutation(getShardIteratorRequest).build());
}
/**
*
* Increases the Kinesis data stream's retention period, which is the length of time data records are accessible
* after they are added to the stream. The maximum value of a stream's retention period is 8760 hours (365 days).
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If you choose a longer stream retention period, this operation increases the time period during which records
* that have not yet expired are accessible. However, it does not make previous, expired data (older than the
* stream's previous retention period) accessible after the operation has been called. For example, if a stream's
* retention period is set to 24 hours and is increased to 168 hours, any data that is older than 24 hours remains
* inaccessible to consumer applications.
*
*
* @param increaseStreamRetentionPeriodRequest
* Represents the input for IncreaseStreamRetentionPeriod.
* @return A Java Future containing the result of the IncreaseStreamRetentionPeriod operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.IncreaseStreamRetentionPeriod
* @see AWS API Documentation
*/
default CompletableFuture increaseStreamRetentionPeriod(
IncreaseStreamRetentionPeriodRequest increaseStreamRetentionPeriodRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Increases the Kinesis data stream's retention period, which is the length of time data records are accessible
* after they are added to the stream. The maximum value of a stream's retention period is 8760 hours (365 days).
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If you choose a longer stream retention period, this operation increases the time period during which records
* that have not yet expired are accessible. However, it does not make previous, expired data (older than the
* stream's previous retention period) accessible after the operation has been called. For example, if a stream's
* retention period is set to 24 hours and is increased to 168 hours, any data that is older than 24 hours remains
* inaccessible to consumer applications.
*
*
*
* This is a convenience which creates an instance of the {@link IncreaseStreamRetentionPeriodRequest.Builder}
* avoiding the need to create one manually via {@link IncreaseStreamRetentionPeriodRequest#builder()}
*
*
* @param increaseStreamRetentionPeriodRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodRequest.Builder} to
* create a request. Represents the input for IncreaseStreamRetentionPeriod.
* @return A Java Future containing the result of the IncreaseStreamRetentionPeriod operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.IncreaseStreamRetentionPeriod
* @see AWS API Documentation
*/
default CompletableFuture increaseStreamRetentionPeriod(
Consumer increaseStreamRetentionPeriodRequest) {
return increaseStreamRetentionPeriod(IncreaseStreamRetentionPeriodRequest.builder()
.applyMutation(increaseStreamRetentionPeriodRequest).build());
}
/**
*
* Lists the shards in a stream and provides information about each shard. This operation has a limit of 1000
* transactions per second per data stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* This action does not list expired shards. For information about expired shards, see Data Routing, Data Persistence, and Shard State after a Reshard.
*
*
*
* This API is a new operation that is used by the Amazon Kinesis Client Library (KCL). If you have a fine-grained
* IAM policy that only allows specific operations, you must update your policy to allow calls to this API. For more
* information, see Controlling
* Access to Amazon Kinesis Data Streams Resources Using IAM.
*
*
*
* @param listShardsRequest
* @return A Java Future containing the result of the ListShards operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListShards
* @see AWS API
* Documentation
*/
default CompletableFuture listShards(ListShardsRequest listShardsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists the shards in a stream and provides information about each shard. This operation has a limit of 1000
* transactions per second per data stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* This action does not list expired shards. For information about expired shards, see Data Routing, Data Persistence, and Shard State after a Reshard.
*
*
*
* This API is a new operation that is used by the Amazon Kinesis Client Library (KCL). If you have a fine-grained
* IAM policy that only allows specific operations, you must update your policy to allow calls to this API. For more
* information, see Controlling
* Access to Amazon Kinesis Data Streams Resources Using IAM.
*
*
*
* This is a convenience which creates an instance of the {@link ListShardsRequest.Builder} avoiding the need to
* create one manually via {@link ListShardsRequest#builder()}
*
*
* @param listShardsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.ListShardsRequest.Builder} to create a request.
* @return A Java Future containing the result of the ListShards operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListShards
* @see AWS API
* Documentation
*/
default CompletableFuture listShards(Consumer listShardsRequest) {
return listShards(ListShardsRequest.builder().applyMutation(listShardsRequest).build());
}
/**
*
* Lists the consumers registered to receive data from a stream using enhanced fan-out, and provides information
* about each consumer.
*
*
* This operation has a limit of 5 transactions per second per stream.
*
*
* @param listStreamConsumersRequest
* @return A Java Future containing the result of the ListStreamConsumers operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreamConsumers
* @see AWS
* API Documentation
*/
default CompletableFuture listStreamConsumers(
ListStreamConsumersRequest listStreamConsumersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists the consumers registered to receive data from a stream using enhanced fan-out, and provides information
* about each consumer.
*
*
* This operation has a limit of 5 transactions per second per stream.
*
*
*
* This is a convenience which creates an instance of the {@link ListStreamConsumersRequest.Builder} avoiding the
* need to create one manually via {@link ListStreamConsumersRequest#builder()}
*
*
* @param listStreamConsumersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListStreamConsumers operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreamConsumers
* @see AWS
* API Documentation
*/
default CompletableFuture listStreamConsumers(
Consumer listStreamConsumersRequest) {
return listStreamConsumers(ListStreamConsumersRequest.builder().applyMutation(listStreamConsumersRequest).build());
}
/**
*
* This is a variant of
* {@link #listStreamConsumers(software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamConsumersPublisher publisher = client.listStreamConsumersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamConsumersPublisher publisher = client.listStreamConsumersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.kinesis.model.ListStreamConsumersResponse 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
* {@link #listStreamConsumers(software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest)}
* operation.
*
*
* @param listStreamConsumersRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreamConsumers
* @see AWS
* API Documentation
*/
default ListStreamConsumersPublisher listStreamConsumersPaginator(ListStreamConsumersRequest listStreamConsumersRequest) {
return new ListStreamConsumersPublisher(this, listStreamConsumersRequest);
}
/**
*
* This is a variant of
* {@link #listStreamConsumers(software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamConsumersPublisher publisher = client.listStreamConsumersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamConsumersPublisher publisher = client.listStreamConsumersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.kinesis.model.ListStreamConsumersResponse 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
* {@link #listStreamConsumers(software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListStreamConsumersRequest.Builder} avoiding the
* need to create one manually via {@link ListStreamConsumersRequest#builder()}
*
*
* @param listStreamConsumersRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreamConsumers
* @see AWS
* API Documentation
*/
default ListStreamConsumersPublisher listStreamConsumersPaginator(
Consumer listStreamConsumersRequest) {
return listStreamConsumersPaginator(ListStreamConsumersRequest.builder().applyMutation(listStreamConsumersRequest)
.build());
}
/**
*
* Lists your Kinesis data streams.
*
*
* The number of streams may be too large to return from a single call to ListStreams. You can limit
* the number of returned streams using the Limit parameter. If you do not specify a value for the
* Limit parameter, Kinesis Data Streams uses the default limit, which is currently 100.
*
*
* You can detect if there are more streams available to list by using the HasMoreStreams flag from the
* returned output. If there are more streams available, you can request more streams by using the name of the last
* stream returned by the ListStreams request in the ExclusiveStartStreamName parameter in
* a subsequent request to ListStreams. The group of stream names returned by the subsequent request is
* then added to the list. You can continue this process until all the stream names have been collected in the list.
*
*
* ListStreams has a limit of five transactions per second per account.
*
*
* @param listStreamsRequest
* Represents the input for ListStreams.
* @return A Java Future containing the result of the ListStreams operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreams
* @see AWS API
* Documentation
*/
default CompletableFuture listStreams(ListStreamsRequest listStreamsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists your Kinesis data streams.
*
*
* The number of streams may be too large to return from a single call to ListStreams. You can limit
* the number of returned streams using the Limit parameter. If you do not specify a value for the
* Limit parameter, Kinesis Data Streams uses the default limit, which is currently 100.
*
*
* You can detect if there are more streams available to list by using the HasMoreStreams flag from the
* returned output. If there are more streams available, you can request more streams by using the name of the last
* stream returned by the ListStreams request in the ExclusiveStartStreamName parameter in
* a subsequent request to ListStreams. The group of stream names returned by the subsequent request is
* then added to the list. You can continue this process until all the stream names have been collected in the list.
*
*
* ListStreams has a limit of five transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link ListStreamsRequest.Builder} avoiding the need to
* create one manually via {@link ListStreamsRequest#builder()}
*
*
* @param listStreamsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.ListStreamsRequest.Builder} to create a request.
* Represents the input for ListStreams.
* @return A Java Future containing the result of the ListStreams operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreams
* @see AWS API
* Documentation
*/
default CompletableFuture listStreams(Consumer listStreamsRequest) {
return listStreams(ListStreamsRequest.builder().applyMutation(listStreamsRequest).build());
}
/**
*
* Lists your Kinesis data streams.
*
*
* The number of streams may be too large to return from a single call to ListStreams. You can limit
* the number of returned streams using the Limit parameter. If you do not specify a value for the
* Limit parameter, Kinesis Data Streams uses the default limit, which is currently 100.
*
*
* You can detect if there are more streams available to list by using the HasMoreStreams flag from the
* returned output. If there are more streams available, you can request more streams by using the name of the last
* stream returned by the ListStreams request in the ExclusiveStartStreamName parameter in
* a subsequent request to ListStreams. The group of stream names returned by the subsequent request is
* then added to the list. You can continue this process until all the stream names have been collected in the list.
*
*
* ListStreams has a limit of five transactions per second per account.
*
*
* @return A Java Future containing the result of the ListStreams operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreams
* @see AWS API
* Documentation
*/
default CompletableFuture listStreams() {
return listStreams(ListStreamsRequest.builder().build());
}
/**
*
* This is a variant of {@link #listStreams(software.amazon.awssdk.services.kinesis.model.ListStreamsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamsPublisher publisher = client.listStreamsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamsPublisher publisher = client.listStreamsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.kinesis.model.ListStreamsResponse 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 Limit won't limit the number of results you get with the paginator. It
* only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listStreams(software.amazon.awssdk.services.kinesis.model.ListStreamsRequest)} operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreams
* @see AWS API
* Documentation
*/
default ListStreamsPublisher listStreamsPaginator() {
return listStreamsPaginator(ListStreamsRequest.builder().build());
}
/**
*
* This is a variant of {@link #listStreams(software.amazon.awssdk.services.kinesis.model.ListStreamsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamsPublisher publisher = client.listStreamsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamsPublisher publisher = client.listStreamsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.kinesis.model.ListStreamsResponse 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 Limit won't limit the number of results you get with the paginator. It
* only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listStreams(software.amazon.awssdk.services.kinesis.model.ListStreamsRequest)} operation.
*
*
* @param listStreamsRequest
* Represents the input for ListStreams.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreams
* @see AWS API
* Documentation
*/
default ListStreamsPublisher listStreamsPaginator(ListStreamsRequest listStreamsRequest) {
return new ListStreamsPublisher(this, listStreamsRequest);
}
/**
*
* This is a variant of {@link #listStreams(software.amazon.awssdk.services.kinesis.model.ListStreamsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamsPublisher publisher = client.listStreamsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.kinesis.paginators.ListStreamsPublisher publisher = client.listStreamsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.kinesis.model.ListStreamsResponse 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 Limit won't limit the number of results you get with the paginator. It
* only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listStreams(software.amazon.awssdk.services.kinesis.model.ListStreamsRequest)} operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListStreamsRequest.Builder} avoiding the need to
* create one manually via {@link ListStreamsRequest#builder()}
*
*
* @param listStreamsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.ListStreamsRequest.Builder} to create a request.
* Represents the input for ListStreams.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ExpiredNextTokenException The pagination token passed to the operation is expired.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListStreams
* @see AWS API
* Documentation
*/
default ListStreamsPublisher listStreamsPaginator(Consumer listStreamsRequest) {
return listStreamsPaginator(ListStreamsRequest.builder().applyMutation(listStreamsRequest).build());
}
/**
*
* Lists the tags for the specified Kinesis data stream. This operation has a limit of five transactions per second
* per account.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* @param listTagsForStreamRequest
* Represents the input for ListTagsForStream.
* @return A Java Future containing the result of the ListTagsForStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListTagsForStream
* @see AWS API
* Documentation
*/
default CompletableFuture listTagsForStream(ListTagsForStreamRequest listTagsForStreamRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists the tags for the specified Kinesis data stream. This operation has a limit of five transactions per second
* per account.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* This is a convenience which creates an instance of the {@link ListTagsForStreamRequest.Builder} avoiding the need
* to create one manually via {@link ListTagsForStreamRequest#builder()}
*
*
* @param listTagsForStreamRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.ListTagsForStreamRequest.Builder} to create a
* request. Represents the input for ListTagsForStream.
* @return A Java Future containing the result of the ListTagsForStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.ListTagsForStream
* @see AWS API
* Documentation
*/
default CompletableFuture listTagsForStream(
Consumer listTagsForStreamRequest) {
return listTagsForStream(ListTagsForStreamRequest.builder().applyMutation(listTagsForStreamRequest).build());
}
/**
*
* Merges two adjacent shards in a Kinesis data stream and combines them into a single shard to reduce the stream's
* capacity to ingest and transport data. This API is only supported for the data streams with the provisioned
* capacity mode. Two shards are considered adjacent if the union of the hash key ranges for the two shards form a
* contiguous set with no gaps. For example, if you have two shards, one with a hash key range of 276...381 and the
* other with a hash key range of 382...454, then you could merge these two shards into a single shard that would
* have a hash key range of 276...454. After the merge, the single child shard receives data for all hash key values
* covered by the two parent shards.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* MergeShards is called when there is a need to reduce the overall capacity of a stream because of
* excess capacity that is not being used. You must specify the shard to be merged and the adjacent shard for a
* stream. For more information about merging shards, see Merge Two
* Shards in the Amazon Kinesis Data Streams Developer Guide.
*
*
* If the stream is in the ACTIVE state, you can call MergeShards. If a stream is in the
* CREATING, UPDATING, or DELETING state, MergeShards returns a
* ResourceInUseException. If the specified stream does not exist, MergeShards returns a
* ResourceNotFoundException.
*
*
* You can use DescribeStreamSummary to check the state of the stream, which is returned in
* StreamStatus.
*
*
* MergeShards is an asynchronous operation. Upon receiving a MergeShards request, Amazon
* Kinesis Data Streams immediately returns a response and sets the StreamStatus to
* UPDATING. After the operation is completed, Kinesis Data Streams sets the StreamStatus
* to ACTIVE. Read and write operations continue to work while the stream is in the
* UPDATING state.
*
*
* You use DescribeStreamSummary and the ListShards APIs to determine the shard IDs that are specified
* in the MergeShards request.
*
*
* If you try to operate on too many streams in parallel using CreateStream, DeleteStream,
* MergeShards, or SplitShard, you receive a LimitExceededException.
*
*
* MergeShards has a limit of five transactions per second per account.
*
*
* @param mergeShardsRequest
* Represents the input for MergeShards.
* @return A Java Future containing the result of the MergeShards operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ValidationException Specifies that you tried to invoke this API for a data stream with the on-demand
* capacity mode. This API is only supported for data streams with the provisioned capacity mode.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.MergeShards
* @see AWS API
* Documentation
*/
default CompletableFuture mergeShards(MergeShardsRequest mergeShardsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Merges two adjacent shards in a Kinesis data stream and combines them into a single shard to reduce the stream's
* capacity to ingest and transport data. This API is only supported for the data streams with the provisioned
* capacity mode. Two shards are considered adjacent if the union of the hash key ranges for the two shards form a
* contiguous set with no gaps. For example, if you have two shards, one with a hash key range of 276...381 and the
* other with a hash key range of 382...454, then you could merge these two shards into a single shard that would
* have a hash key range of 276...454. After the merge, the single child shard receives data for all hash key values
* covered by the two parent shards.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* MergeShards is called when there is a need to reduce the overall capacity of a stream because of
* excess capacity that is not being used. You must specify the shard to be merged and the adjacent shard for a
* stream. For more information about merging shards, see Merge Two
* Shards in the Amazon Kinesis Data Streams Developer Guide.
*
*
* If the stream is in the ACTIVE state, you can call MergeShards. If a stream is in the
* CREATING, UPDATING, or DELETING state, MergeShards returns a
* ResourceInUseException. If the specified stream does not exist, MergeShards returns a
* ResourceNotFoundException.
*
*
* You can use DescribeStreamSummary to check the state of the stream, which is returned in
* StreamStatus.
*
*
* MergeShards is an asynchronous operation. Upon receiving a MergeShards request, Amazon
* Kinesis Data Streams immediately returns a response and sets the StreamStatus to
* UPDATING. After the operation is completed, Kinesis Data Streams sets the StreamStatus
* to ACTIVE. Read and write operations continue to work while the stream is in the
* UPDATING state.
*
*
* You use DescribeStreamSummary and the ListShards APIs to determine the shard IDs that are specified
* in the MergeShards request.
*
*
* If you try to operate on too many streams in parallel using CreateStream, DeleteStream,
* MergeShards, or SplitShard, you receive a LimitExceededException.
*
*
* MergeShards has a limit of five transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link MergeShardsRequest.Builder} avoiding the need to
* create one manually via {@link MergeShardsRequest#builder()}
*
*
* @param mergeShardsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.MergeShardsRequest.Builder} to create a request.
* Represents the input for MergeShards.
* @return A Java Future containing the result of the MergeShards operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ValidationException Specifies that you tried to invoke this API for a data stream with the on-demand
* capacity mode. This API is only supported for data streams with the provisioned capacity mode.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.MergeShards
* @see AWS API
* Documentation
*/
default CompletableFuture mergeShards(Consumer mergeShardsRequest) {
return mergeShards(MergeShardsRequest.builder().applyMutation(mergeShardsRequest).build());
}
/**
*
* Writes a single data record into an Amazon Kinesis data stream. Call PutRecord to send data into the
* stream for real-time ingestion and subsequent processing, one record at a time. Each shard can support writes up
* to 1,000 records per second, up to a maximum data write total of 1 MiB per second.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* You must specify the name of the stream that captures, stores, and transports the data; a partition key; and the
* data blob itself.
*
*
* The data blob can be any type of data; for example, a segment from a log file, geographic/location data, website
* clickstream data, and so on.
*
*
* The partition key is used by Kinesis Data Streams to distribute data across shards. Kinesis Data Streams
* segregates the data records that belong to a stream into multiple shards, using the partition key associated with
* each data record to determine the shard to which a given data record belongs.
*
*
* Partition keys are Unicode strings, with a maximum length limit of 256 characters for each key. An MD5 hash
* function is used to map partition keys to 128-bit integer values and to map associated data records to shards
* using the hash key ranges of the shards. You can override hashing the partition key to determine the shard by
* explicitly specifying a hash value using the ExplicitHashKey parameter. For more information, see Adding Data to a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
* PutRecord returns the shard ID of where the data record was placed and the sequence number that was
* assigned to the data record.
*
*
* Sequence numbers increase over time and are specific to a shard within a stream, not across all shards within a
* stream. To guarantee strictly increasing ordering, write serially to a shard and use the
* SequenceNumberForOrdering parameter. For more information, see Adding Data to a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
*
* After you write a record to a stream, you cannot modify that record or its order within the stream.
*
*
*
* If a PutRecord request cannot be processed because of insufficient provisioned throughput on the
* shard involved in the request, PutRecord throws ProvisionedThroughputExceededException.
*
*
* By default, data records are accessible for 24 hours from the time that they are added to a stream. You can use
* IncreaseStreamRetentionPeriod or DecreaseStreamRetentionPeriod to modify this retention period.
*
*
* @param putRecordRequest
* Represents the input for PutRecord.
* @return A Java Future containing the result of the PutRecord operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.PutRecord
* @see AWS API
* Documentation
*/
default CompletableFuture putRecord(PutRecordRequest putRecordRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Writes a single data record into an Amazon Kinesis data stream. Call PutRecord to send data into the
* stream for real-time ingestion and subsequent processing, one record at a time. Each shard can support writes up
* to 1,000 records per second, up to a maximum data write total of 1 MiB per second.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* You must specify the name of the stream that captures, stores, and transports the data; a partition key; and the
* data blob itself.
*
*
* The data blob can be any type of data; for example, a segment from a log file, geographic/location data, website
* clickstream data, and so on.
*
*
* The partition key is used by Kinesis Data Streams to distribute data across shards. Kinesis Data Streams
* segregates the data records that belong to a stream into multiple shards, using the partition key associated with
* each data record to determine the shard to which a given data record belongs.
*
*
* Partition keys are Unicode strings, with a maximum length limit of 256 characters for each key. An MD5 hash
* function is used to map partition keys to 128-bit integer values and to map associated data records to shards
* using the hash key ranges of the shards. You can override hashing the partition key to determine the shard by
* explicitly specifying a hash value using the ExplicitHashKey parameter. For more information, see Adding Data to a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
* PutRecord returns the shard ID of where the data record was placed and the sequence number that was
* assigned to the data record.
*
*
* Sequence numbers increase over time and are specific to a shard within a stream, not across all shards within a
* stream. To guarantee strictly increasing ordering, write serially to a shard and use the
* SequenceNumberForOrdering parameter. For more information, see Adding Data to a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
*
* After you write a record to a stream, you cannot modify that record or its order within the stream.
*
*
*
* If a PutRecord request cannot be processed because of insufficient provisioned throughput on the
* shard involved in the request, PutRecord throws ProvisionedThroughputExceededException.
*
*
* By default, data records are accessible for 24 hours from the time that they are added to a stream. You can use
* IncreaseStreamRetentionPeriod or DecreaseStreamRetentionPeriod to modify this retention period.
*
*
*
* This is a convenience which creates an instance of the {@link PutRecordRequest.Builder} avoiding the need to
* create one manually via {@link PutRecordRequest#builder()}
*
*
* @param putRecordRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.PutRecordRequest.Builder} to create a request.
* Represents the input for PutRecord.
* @return A Java Future containing the result of the PutRecord operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.PutRecord
* @see AWS API
* Documentation
*/
default CompletableFuture putRecord(Consumer putRecordRequest) {
return putRecord(PutRecordRequest.builder().applyMutation(putRecordRequest).build());
}
/**
*
* Writes multiple data records into a Kinesis data stream in a single call (also referred to as a
* PutRecords request). Use this operation to send data into the stream for data ingestion and
* processing.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Each PutRecords request can support up to 500 records. Each record in the request can be as large as
* 1 MiB, up to a limit of 5 MiB for the entire request, including partition keys. Each shard can support writes up
* to 1,000 records per second, up to a maximum data write total of 1 MiB per second.
*
*
* You must specify the name of the stream that captures, stores, and transports the data; and an array of request
* Records, with each record in the array requiring a partition key and data blob. The record size
* limit applies to the total size of the partition key and data blob.
*
*
* The data blob can be any type of data; for example, a segment from a log file, geographic/location data, website
* clickstream data, and so on.
*
*
* The partition key is used by Kinesis Data Streams as input to a hash function that maps the partition key and
* associated data to a specific shard. An MD5 hash function is used to map partition keys to 128-bit integer values
* and to map associated data records to shards. As a result of this hashing mechanism, all data records with the
* same partition key map to the same shard within the stream. For more information, see Adding Data to a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
* Each record in the Records array may include an optional parameter, ExplicitHashKey,
* which overrides the partition key to shard mapping. This parameter allows a data producer to determine explicitly
* the shard where the record is stored. For more information, see Adding Multiple Records with PutRecords in the Amazon Kinesis Data Streams Developer Guide.
*
*
* The PutRecords response includes an array of response Records. Each record in the
* response array directly correlates with a record in the request array using natural ordering, from the top to the
* bottom of the request and response. The response Records array always includes the same number of
* records as the request array.
*
*
* The response Records array includes both successfully and unsuccessfully processed records. Kinesis
* Data Streams attempts to process all records in each PutRecords request. A single record failure
* does not stop the processing of subsequent records. As a result, PutRecords doesn't guarantee the ordering of
* records. If you need to read records in the same order they are written to the stream, use PutRecord
* instead of PutRecords, and write to the same shard.
*
*
* A successfully processed record includes ShardId and SequenceNumber values. The
* ShardId parameter identifies the shard in the stream where the record is stored. The
* SequenceNumber parameter is an identifier assigned to the put record, unique to all records in the
* stream.
*
*
* An unsuccessfully processed record includes ErrorCode and ErrorMessage values.
* ErrorCode reflects the type of error and can be one of the following values:
* ProvisionedThroughputExceededException or InternalFailure. ErrorMessage
* provides more detailed information about the ProvisionedThroughputExceededException exception
* including the account ID, stream name, and shard ID of the record that was throttled. For more information about
* partially successful responses, see Adding Multiple Records with PutRecords in the Amazon Kinesis Data Streams Developer Guide.
*
*
*
* After you write a record to a stream, you cannot modify that record or its order within the stream.
*
*
*
* By default, data records are accessible for 24 hours from the time that they are added to a stream. You can use
* IncreaseStreamRetentionPeriod or DecreaseStreamRetentionPeriod to modify this retention period.
*
*
* @param putRecordsRequest
* A PutRecords request.
* @return A Java Future containing the result of the PutRecords operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.PutRecords
* @see AWS API
* Documentation
*/
default CompletableFuture putRecords(PutRecordsRequest putRecordsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Writes multiple data records into a Kinesis data stream in a single call (also referred to as a
* PutRecords request). Use this operation to send data into the stream for data ingestion and
* processing.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Each PutRecords request can support up to 500 records. Each record in the request can be as large as
* 1 MiB, up to a limit of 5 MiB for the entire request, including partition keys. Each shard can support writes up
* to 1,000 records per second, up to a maximum data write total of 1 MiB per second.
*
*
* You must specify the name of the stream that captures, stores, and transports the data; and an array of request
* Records, with each record in the array requiring a partition key and data blob. The record size
* limit applies to the total size of the partition key and data blob.
*
*
* The data blob can be any type of data; for example, a segment from a log file, geographic/location data, website
* clickstream data, and so on.
*
*
* The partition key is used by Kinesis Data Streams as input to a hash function that maps the partition key and
* associated data to a specific shard. An MD5 hash function is used to map partition keys to 128-bit integer values
* and to map associated data records to shards. As a result of this hashing mechanism, all data records with the
* same partition key map to the same shard within the stream. For more information, see Adding Data to a Stream in the Amazon Kinesis Data Streams Developer Guide.
*
*
* Each record in the Records array may include an optional parameter, ExplicitHashKey,
* which overrides the partition key to shard mapping. This parameter allows a data producer to determine explicitly
* the shard where the record is stored. For more information, see Adding Multiple Records with PutRecords in the Amazon Kinesis Data Streams Developer Guide.
*
*
* The PutRecords response includes an array of response Records. Each record in the
* response array directly correlates with a record in the request array using natural ordering, from the top to the
* bottom of the request and response. The response Records array always includes the same number of
* records as the request array.
*
*
* The response Records array includes both successfully and unsuccessfully processed records. Kinesis
* Data Streams attempts to process all records in each PutRecords request. A single record failure
* does not stop the processing of subsequent records. As a result, PutRecords doesn't guarantee the ordering of
* records. If you need to read records in the same order they are written to the stream, use PutRecord
* instead of PutRecords, and write to the same shard.
*
*
* A successfully processed record includes ShardId and SequenceNumber values. The
* ShardId parameter identifies the shard in the stream where the record is stored. The
* SequenceNumber parameter is an identifier assigned to the put record, unique to all records in the
* stream.
*
*
* An unsuccessfully processed record includes ErrorCode and ErrorMessage values.
* ErrorCode reflects the type of error and can be one of the following values:
* ProvisionedThroughputExceededException or InternalFailure. ErrorMessage
* provides more detailed information about the ProvisionedThroughputExceededException exception
* including the account ID, stream name, and shard ID of the record that was throttled. For more information about
* partially successful responses, see Adding Multiple Records with PutRecords in the Amazon Kinesis Data Streams Developer Guide.
*
*
*
* After you write a record to a stream, you cannot modify that record or its order within the stream.
*
*
*
* By default, data records are accessible for 24 hours from the time that they are added to a stream. You can use
* IncreaseStreamRetentionPeriod or DecreaseStreamRetentionPeriod to modify this retention period.
*
*
*
* This is a convenience which creates an instance of the {@link PutRecordsRequest.Builder} avoiding the need to
* create one manually via {@link PutRecordsRequest#builder()}
*
*
* @param putRecordsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.PutRecordsRequest.Builder} to create a request. A
* PutRecords request.
* @return A Java Future containing the result of the PutRecords operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ProvisionedThroughputExceededException The request rate for the stream is too high, or the requested
* data is too large for the available throughput. Reduce the frequency or size of your requests. For more
* information, see Streams Limits in
* the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential
* Backoff in Amazon Web Services in the Amazon Web Services General Reference.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.PutRecords
* @see AWS API
* Documentation
*/
default CompletableFuture putRecords(Consumer putRecordsRequest) {
return putRecords(PutRecordsRequest.builder().applyMutation(putRecordsRequest).build());
}
/**
*
* Attaches a resource-based policy to a data stream or registered consumer. If you are using an identity other than
* the root user of the Amazon Web Services account that owns the resource, the calling identity must have the
* PutResourcePolicy permissions on the specified Kinesis Data Streams resource and belong to the
* owner's account in order to use this operation. If you don't have PutResourcePolicy permissions,
* Amazon Kinesis Data Streams returns a 403 Access Denied error. If you receive a
* ResourceNotFoundException, check to see if you passed a valid stream or consumer resource.
*
*
* Request patterns can be one of the following:
*
*
* -
*
* Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
*
*
* -
*
* Consumer pattern:
* ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
*
*
*
*
* For more information, see Controlling Access to Amazon
* Kinesis Data Streams Resources Using IAM.
*
*
* @param putResourcePolicyRequest
* @return A Java Future containing the result of the PutResourcePolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.PutResourcePolicy
* @see AWS API
* Documentation
*/
default CompletableFuture putResourcePolicy(PutResourcePolicyRequest putResourcePolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Attaches a resource-based policy to a data stream or registered consumer. If you are using an identity other than
* the root user of the Amazon Web Services account that owns the resource, the calling identity must have the
* PutResourcePolicy permissions on the specified Kinesis Data Streams resource and belong to the
* owner's account in order to use this operation. If you don't have PutResourcePolicy permissions,
* Amazon Kinesis Data Streams returns a 403 Access Denied error. If you receive a
* ResourceNotFoundException, check to see if you passed a valid stream or consumer resource.
*
*
* Request patterns can be one of the following:
*
*
* -
*
* Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
*
*
* -
*
* Consumer pattern:
* ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
*
*
*
*
* For more information, see Controlling Access to Amazon
* Kinesis Data Streams Resources Using IAM.
*
*
*
* This is a convenience which creates an instance of the {@link PutResourcePolicyRequest.Builder} avoiding the need
* to create one manually via {@link PutResourcePolicyRequest#builder()}
*
*
* @param putResourcePolicyRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.PutResourcePolicyRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the PutResourcePolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.PutResourcePolicy
* @see AWS API
* Documentation
*/
default CompletableFuture putResourcePolicy(
Consumer putResourcePolicyRequest) {
return putResourcePolicy(PutResourcePolicyRequest.builder().applyMutation(putResourcePolicyRequest).build());
}
/**
*
* Registers a consumer with a Kinesis data stream. When you use this operation, the consumer you register can then
* call SubscribeToShard to receive data from the stream using enhanced fan-out, at a rate of up to 2 MiB per
* second for every shard you subscribe to. This rate is unaffected by the total number of consumers that read from
* the same stream.
*
*
* You can register up to 20 consumers per stream. A given consumer can only be registered with one stream at a
* time.
*
*
* For an example of how to use this operation, see Enhanced Fan-Out Using
* the Kinesis Data Streams API.
*
*
* The use of this operation has a limit of five transactions per second per account. Also, only 5 consumers can be
* created simultaneously. In other words, you cannot have more than 5 consumers in a CREATING status
* at the same time. Registering a 6th consumer while there are 5 in a CREATING status results in a
* LimitExceededException.
*
*
* @param registerStreamConsumerRequest
* @return A Java Future containing the result of the RegisterStreamConsumer operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.RegisterStreamConsumer
* @see AWS API Documentation
*/
default CompletableFuture registerStreamConsumer(
RegisterStreamConsumerRequest registerStreamConsumerRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Registers a consumer with a Kinesis data stream. When you use this operation, the consumer you register can then
* call SubscribeToShard to receive data from the stream using enhanced fan-out, at a rate of up to 2 MiB per
* second for every shard you subscribe to. This rate is unaffected by the total number of consumers that read from
* the same stream.
*
*
* You can register up to 20 consumers per stream. A given consumer can only be registered with one stream at a
* time.
*
*
* For an example of how to use this operation, see Enhanced Fan-Out Using
* the Kinesis Data Streams API.
*
*
* The use of this operation has a limit of five transactions per second per account. Also, only 5 consumers can be
* created simultaneously. In other words, you cannot have more than 5 consumers in a CREATING status
* at the same time. Registering a 6th consumer while there are 5 in a CREATING status results in a
* LimitExceededException.
*
*
*
* This is a convenience which creates an instance of the {@link RegisterStreamConsumerRequest.Builder} avoiding the
* need to create one manually via {@link RegisterStreamConsumerRequest#builder()}
*
*
* @param registerStreamConsumerRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the RegisterStreamConsumer operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.RegisterStreamConsumer
* @see AWS API Documentation
*/
default CompletableFuture registerStreamConsumer(
Consumer registerStreamConsumerRequest) {
return registerStreamConsumer(RegisterStreamConsumerRequest.builder().applyMutation(registerStreamConsumerRequest)
.build());
}
/**
*
* Removes tags from the specified Kinesis data stream. Removed tags are deleted and cannot be recovered after this
* operation successfully completes.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If you specify a tag that does not exist, it is ignored.
*
*
* RemoveTagsFromStream has a limit of five transactions per second per account.
*
*
* @param removeTagsFromStreamRequest
* Represents the input for RemoveTagsFromStream.
* @return A Java Future containing the result of the RemoveTagsFromStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.RemoveTagsFromStream
* @see AWS
* API Documentation
*/
default CompletableFuture removeTagsFromStream(
RemoveTagsFromStreamRequest removeTagsFromStreamRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes tags from the specified Kinesis data stream. Removed tags are deleted and cannot be recovered after this
* operation successfully completes.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* If you specify a tag that does not exist, it is ignored.
*
*
* RemoveTagsFromStream has a limit of five transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link RemoveTagsFromStreamRequest.Builder} avoiding the
* need to create one manually via {@link RemoveTagsFromStreamRequest#builder()}
*
*
* @param removeTagsFromStreamRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamRequest.Builder} to create a
* request. Represents the input for RemoveTagsFromStream.
* @return A Java Future containing the result of the RemoveTagsFromStream operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.RemoveTagsFromStream
* @see AWS
* API Documentation
*/
default CompletableFuture removeTagsFromStream(
Consumer removeTagsFromStreamRequest) {
return removeTagsFromStream(RemoveTagsFromStreamRequest.builder().applyMutation(removeTagsFromStreamRequest).build());
}
/**
*
* Splits a shard into two new shards in the Kinesis data stream, to increase the stream's capacity to ingest and
* transport data. SplitShard is called when there is a need to increase the overall capacity of a
* stream because of an expected increase in the volume of data records being ingested. This API is only supported
* for the data streams with the provisioned capacity mode.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* You can also use SplitShard when a shard appears to be approaching its maximum utilization; for
* example, the producers sending data into the specific shard are suddenly sending more than previously
* anticipated. You can also call SplitShard to increase stream capacity, so that more Kinesis Data
* Streams applications can simultaneously read data from the stream for real-time processing.
*
*
* You must specify the shard to be split and the new hash key, which is the position in the shard where the shard
* gets split in two. In many cases, the new hash key might be the average of the beginning and ending hash key, but
* it can be any hash key value in the range being mapped into the shard. For more information, see Split a
* Shard in the Amazon Kinesis Data Streams Developer Guide.
*
*
* You can use DescribeStreamSummary and the ListShards APIs to determine the shard ID and hash key
* values for the ShardToSplit and NewStartingHashKey parameters that are specified in the
* SplitShard request.
*
*
* SplitShard is an asynchronous operation. Upon receiving a SplitShard request, Kinesis
* Data Streams immediately returns a response and sets the stream status to UPDATING. After the
* operation is completed, Kinesis Data Streams sets the stream status to ACTIVE. Read and write
* operations continue to work while the stream is in the UPDATING state.
*
*
* You can use DescribeStreamSummary to check the status of the stream, which is returned in
* StreamStatus. If the stream is in the ACTIVE state, you can call
* SplitShard.
*
*
* If the specified stream does not exist, DescribeStreamSummary returns a
* ResourceNotFoundException. If you try to create more shards than are authorized for your account,
* you receive a LimitExceededException.
*
*
* For the default shard limit for an Amazon Web Services account, see Kinesis Data Streams
* Limits in the Amazon Kinesis Data Streams Developer Guide. To increase this limit, contact Amazon Web Services
* Support.
*
*
* If you try to operate on too many streams simultaneously using CreateStream, DeleteStream,
* MergeShards, and/or SplitShard, you receive a LimitExceededException.
*
*
* SplitShard has a limit of five transactions per second per account.
*
*
* @param splitShardRequest
* Represents the input for SplitShard.
* @return A Java Future containing the result of the SplitShard operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ValidationException Specifies that you tried to invoke this API for a data stream with the on-demand
* capacity mode. This API is only supported for data streams with the provisioned capacity mode.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.SplitShard
* @see AWS API
* Documentation
*/
default CompletableFuture splitShard(SplitShardRequest splitShardRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Splits a shard into two new shards in the Kinesis data stream, to increase the stream's capacity to ingest and
* transport data. SplitShard is called when there is a need to increase the overall capacity of a
* stream because of an expected increase in the volume of data records being ingested. This API is only supported
* for the data streams with the provisioned capacity mode.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* You can also use SplitShard when a shard appears to be approaching its maximum utilization; for
* example, the producers sending data into the specific shard are suddenly sending more than previously
* anticipated. You can also call SplitShard to increase stream capacity, so that more Kinesis Data
* Streams applications can simultaneously read data from the stream for real-time processing.
*
*
* You must specify the shard to be split and the new hash key, which is the position in the shard where the shard
* gets split in two. In many cases, the new hash key might be the average of the beginning and ending hash key, but
* it can be any hash key value in the range being mapped into the shard. For more information, see Split a
* Shard in the Amazon Kinesis Data Streams Developer Guide.
*
*
* You can use DescribeStreamSummary and the ListShards APIs to determine the shard ID and hash key
* values for the ShardToSplit and NewStartingHashKey parameters that are specified in the
* SplitShard request.
*
*
* SplitShard is an asynchronous operation. Upon receiving a SplitShard request, Kinesis
* Data Streams immediately returns a response and sets the stream status to UPDATING. After the
* operation is completed, Kinesis Data Streams sets the stream status to ACTIVE. Read and write
* operations continue to work while the stream is in the UPDATING state.
*
*
* You can use DescribeStreamSummary to check the status of the stream, which is returned in
* StreamStatus. If the stream is in the ACTIVE state, you can call
* SplitShard.
*
*
* If the specified stream does not exist, DescribeStreamSummary returns a
* ResourceNotFoundException. If you try to create more shards than are authorized for your account,
* you receive a LimitExceededException.
*
*
* For the default shard limit for an Amazon Web Services account, see Kinesis Data Streams
* Limits in the Amazon Kinesis Data Streams Developer Guide. To increase this limit, contact Amazon Web Services
* Support.
*
*
* If you try to operate on too many streams simultaneously using CreateStream, DeleteStream,
* MergeShards, and/or SplitShard, you receive a LimitExceededException.
*
*
* SplitShard has a limit of five transactions per second per account.
*
*
*
* This is a convenience which creates an instance of the {@link SplitShardRequest.Builder} avoiding the need to
* create one manually via {@link SplitShardRequest#builder()}
*
*
* @param splitShardRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.SplitShardRequest.Builder} to create a request.
* Represents the input for SplitShard.
* @return A Java Future containing the result of the SplitShard operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ValidationException Specifies that you tried to invoke this API for a data stream with the on-demand
* capacity mode. This API is only supported for data streams with the provisioned capacity mode.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.SplitShard
* @see AWS API
* Documentation
*/
default CompletableFuture splitShard(Consumer splitShardRequest) {
return splitShard(SplitShardRequest.builder().applyMutation(splitShardRequest).build());
}
/**
*
* Enables or updates server-side encryption using an Amazon Web Services KMS key for a specified stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Starting encryption is an asynchronous operation. Upon receiving the request, Kinesis Data Streams returns
* immediately and sets the status of the stream to UPDATING. After the update is complete, Kinesis
* Data Streams sets the status of the stream back to ACTIVE. Updating or applying encryption normally
* takes a few seconds to complete, but it can take minutes. You can continue to read and write data to your stream
* while its status is UPDATING. Once the status of the stream is ACTIVE, encryption
* begins for records written to the stream.
*
*
* API Limits: You can successfully apply a new Amazon Web Services KMS key for server-side encryption 25 times in a
* rolling 24-hour period.
*
*
* Note: It can take up to 5 seconds after the stream is in an ACTIVE status before all records written
* to the stream are encrypted. After you enable encryption, you can verify that encryption is applied by inspecting
* the API response from PutRecord or PutRecords.
*
*
* @param startStreamEncryptionRequest
* @return A Java Future containing the result of the StartStreamEncryption operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.StartStreamEncryption
* @see AWS
* API Documentation
*/
default CompletableFuture startStreamEncryption(
StartStreamEncryptionRequest startStreamEncryptionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Enables or updates server-side encryption using an Amazon Web Services KMS key for a specified stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Starting encryption is an asynchronous operation. Upon receiving the request, Kinesis Data Streams returns
* immediately and sets the status of the stream to UPDATING. After the update is complete, Kinesis
* Data Streams sets the status of the stream back to ACTIVE. Updating or applying encryption normally
* takes a few seconds to complete, but it can take minutes. You can continue to read and write data to your stream
* while its status is UPDATING. Once the status of the stream is ACTIVE, encryption
* begins for records written to the stream.
*
*
* API Limits: You can successfully apply a new Amazon Web Services KMS key for server-side encryption 25 times in a
* rolling 24-hour period.
*
*
* Note: It can take up to 5 seconds after the stream is in an ACTIVE status before all records written
* to the stream are encrypted. After you enable encryption, you can verify that encryption is applied by inspecting
* the API response from PutRecord or PutRecords.
*
*
*
* This is a convenience which creates an instance of the {@link StartStreamEncryptionRequest.Builder} avoiding the
* need to create one manually via {@link StartStreamEncryptionRequest#builder()}
*
*
* @param startStreamEncryptionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the StartStreamEncryption operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - KmsDisabledException The request was rejected because the specified customer master key (CMK) isn't
* enabled.
* - KmsInvalidStateException The request was rejected because the state of the specified resource isn't
* valid for this request. For more information, see How Key State Affects Use of
* a Customer Master Key in the Amazon Web Services Key Management Service Developer Guide.
* - KmsAccessDeniedException The ciphertext references a key that doesn't exist or that you don't have
* access to.
* - KmsNotFoundException The request was rejected because the specified entity or resource can't be
* found.
* - KmsOptInRequiredException The Amazon Web Services access key ID needs a subscription for the service.
*
* - KmsThrottlingException The request was denied due to request throttling. For more information about
* throttling, see Limits
* in the Amazon Web Services Key Management Service Developer Guide.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.StartStreamEncryption
* @see AWS
* API Documentation
*/
default CompletableFuture startStreamEncryption(
Consumer startStreamEncryptionRequest) {
return startStreamEncryption(StartStreamEncryptionRequest.builder().applyMutation(startStreamEncryptionRequest).build());
}
/**
*
* Disables server-side encryption for a specified stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Stopping encryption is an asynchronous operation. Upon receiving the request, Kinesis Data Streams returns
* immediately and sets the status of the stream to UPDATING. After the update is complete, Kinesis
* Data Streams sets the status of the stream back to ACTIVE. Stopping encryption normally takes a few
* seconds to complete, but it can take minutes. You can continue to read and write data to your stream while its
* status is UPDATING. Once the status of the stream is ACTIVE, records written to the
* stream are no longer encrypted by Kinesis Data Streams.
*
*
* API Limits: You can successfully disable server-side encryption 25 times in a rolling 24-hour period.
*
*
* Note: It can take up to 5 seconds after the stream is in an ACTIVE status before all records written
* to the stream are no longer subject to encryption. After you disabled encryption, you can verify that encryption
* is not applied by inspecting the API response from PutRecord or PutRecords.
*
*
* @param stopStreamEncryptionRequest
* @return A Java Future containing the result of the StopStreamEncryption operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.StopStreamEncryption
* @see AWS
* API Documentation
*/
default CompletableFuture stopStreamEncryption(
StopStreamEncryptionRequest stopStreamEncryptionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Disables server-side encryption for a specified stream.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Stopping encryption is an asynchronous operation. Upon receiving the request, Kinesis Data Streams returns
* immediately and sets the status of the stream to UPDATING. After the update is complete, Kinesis
* Data Streams sets the status of the stream back to ACTIVE. Stopping encryption normally takes a few
* seconds to complete, but it can take minutes. You can continue to read and write data to your stream while its
* status is UPDATING. Once the status of the stream is ACTIVE, records written to the
* stream are no longer encrypted by Kinesis Data Streams.
*
*
* API Limits: You can successfully disable server-side encryption 25 times in a rolling 24-hour period.
*
*
* Note: It can take up to 5 seconds after the stream is in an ACTIVE status before all records written
* to the stream are no longer subject to encryption. After you disabled encryption, you can verify that encryption
* is not applied by inspecting the API response from PutRecord or PutRecords.
*
*
*
* This is a convenience which creates an instance of the {@link StopStreamEncryptionRequest.Builder} avoiding the
* need to create one manually via {@link StopStreamEncryptionRequest#builder()}
*
*
* @param stopStreamEncryptionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the StopStreamEncryption operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.StopStreamEncryption
* @see AWS
* API Documentation
*/
default CompletableFuture stopStreamEncryption(
Consumer stopStreamEncryptionRequest) {
return stopStreamEncryption(StopStreamEncryptionRequest.builder().applyMutation(stopStreamEncryptionRequest).build());
}
/**
*
* This operation establishes an HTTP/2 connection between the consumer you specify in the ConsumerARN
* parameter and the shard you specify in the ShardId parameter. After the connection is successfully
* established, Kinesis Data Streams pushes records from the shard to the consumer over this connection. Before you
* call this operation, call RegisterStreamConsumer to register the consumer with Kinesis Data Streams.
*
*
* When the SubscribeToShard call succeeds, your consumer starts receiving events of type
* SubscribeToShardEvent over the HTTP/2 connection for up to 5 minutes, after which time you need to call
* SubscribeToShard again to renew the subscription if you want to continue to receive records.
*
*
* You can make one call to SubscribeToShard per second per registered consumer per shard. For example,
* if you have a 4000 shard stream and two registered stream consumers, you can make one
* SubscribeToShard request per second for each combination of shard and registered consumer, allowing
* you to subscribe both consumers to all 4000 shards in one second.
*
*
* If you call SubscribeToShard again with the same ConsumerARN and ShardId
* within 5 seconds of a successful call, you'll get a ResourceInUseException. If you call
* SubscribeToShard 5 seconds or more after a successful call, the second call takes over the
* subscription and the previous connection expires or fails with a ResourceInUseException.
*
*
* For an example of how to use this operation, see Enhanced Fan-Out Using
* the Kinesis Data Streams API.
*
*
* @param subscribeToShardRequest
* @return A Java Future containing the result of the SubscribeToShard operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.SubscribeToShard
* @see AWS API
* Documentation
*/
default CompletableFuture subscribeToShard(SubscribeToShardRequest subscribeToShardRequest,
SubscribeToShardResponseHandler asyncResponseHandler) {
throw new UnsupportedOperationException();
}
/**
*
* This operation establishes an HTTP/2 connection between the consumer you specify in the ConsumerARN
* parameter and the shard you specify in the ShardId parameter. After the connection is successfully
* established, Kinesis Data Streams pushes records from the shard to the consumer over this connection. Before you
* call this operation, call RegisterStreamConsumer to register the consumer with Kinesis Data Streams.
*
*
* When the SubscribeToShard call succeeds, your consumer starts receiving events of type
* SubscribeToShardEvent over the HTTP/2 connection for up to 5 minutes, after which time you need to call
* SubscribeToShard again to renew the subscription if you want to continue to receive records.
*
*
* You can make one call to SubscribeToShard per second per registered consumer per shard. For example,
* if you have a 4000 shard stream and two registered stream consumers, you can make one
* SubscribeToShard request per second for each combination of shard and registered consumer, allowing
* you to subscribe both consumers to all 4000 shards in one second.
*
*
* If you call SubscribeToShard again with the same ConsumerARN and ShardId
* within 5 seconds of a successful call, you'll get a ResourceInUseException. If you call
* SubscribeToShard 5 seconds or more after a successful call, the second call takes over the
* subscription and the previous connection expires or fails with a ResourceInUseException.
*
*
* For an example of how to use this operation, see Enhanced Fan-Out Using
* the Kinesis Data Streams API.
*
*
*
* This is a convenience which creates an instance of the {@link SubscribeToShardRequest.Builder} avoiding the need
* to create one manually via {@link SubscribeToShardRequest#builder()}
*
*
* @param subscribeToShardRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest.Builder} to create a request.
* @return A Java Future containing the result of the SubscribeToShard operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.SubscribeToShard
* @see AWS API
* Documentation
*/
default CompletableFuture subscribeToShard(Consumer subscribeToShardRequest,
SubscribeToShardResponseHandler asyncResponseHandler) {
return subscribeToShard(SubscribeToShardRequest.builder().applyMutation(subscribeToShardRequest).build(),
asyncResponseHandler);
}
/**
*
* Updates the shard count of the specified stream to the specified number of shards. This API is only supported for
* the data streams with the provisioned capacity mode.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Updating the shard count is an asynchronous operation. Upon receiving the request, Kinesis Data Streams returns
* immediately and sets the status of the stream to UPDATING. After the update is complete, Kinesis
* Data Streams sets the status of the stream back to ACTIVE. Depending on the size of the stream, the
* scaling action could take a few minutes to complete. You can continue to read and write data to your stream while
* its status is UPDATING.
*
*
* To update the shard count, Kinesis Data Streams performs splits or merges on individual shards. This can cause
* short-lived shards to be created, in addition to the final shards. These short-lived shards count towards your
* total shard limit for your account in the Region.
*
*
* When using this operation, we recommend that you specify a target shard count that is a multiple of 25% (25%,
* 50%, 75%, 100%). You can specify any target value within your shard limit. However, if you specify a target that
* isn't a multiple of 25%, the scaling action might take longer to complete.
*
*
* This operation has the following default limits. By default, you cannot do the following:
*
*
* -
*
* Scale more than ten times per rolling 24-hour period per stream
*
*
* -
*
* Scale up to more than double your current shard count for a stream
*
*
* -
*
* Scale down below half your current shard count for a stream
*
*
* -
*
* Scale up to more than 10000 shards in a stream
*
*
* -
*
* Scale a stream with more than 10000 shards down unless the result is less than 10000 shards
*
*
* -
*
* Scale up to more than the shard limit for your account
*
*
* -
*
* Make over 10 TPS. TPS over 10 will trigger the LimitExceededException
*
*
*
*
* For the default limits for an Amazon Web Services account, see Streams Limits in the
* Amazon Kinesis Data Streams Developer Guide. To request an increase in the call rate limit, the shard
* limit for this API, or your overall shard limit, use the limits form.
*
*
* @param updateShardCountRequest
* @return A Java Future containing the result of the UpdateShardCount operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ValidationException Specifies that you tried to invoke this API for a data stream with the on-demand
* capacity mode. This API is only supported for data streams with the provisioned capacity mode.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.UpdateShardCount
* @see AWS API
* Documentation
*/
default CompletableFuture updateShardCount(UpdateShardCountRequest updateShardCountRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates the shard count of the specified stream to the specified number of shards. This API is only supported for
* the data streams with the provisioned capacity mode.
*
*
*
* When invoking this API, you must use either the StreamARN or the StreamName parameter,
* or both. It is recommended that you use the StreamARN input parameter when you invoke this API.
*
*
*
* Updating the shard count is an asynchronous operation. Upon receiving the request, Kinesis Data Streams returns
* immediately and sets the status of the stream to UPDATING. After the update is complete, Kinesis
* Data Streams sets the status of the stream back to ACTIVE. Depending on the size of the stream, the
* scaling action could take a few minutes to complete. You can continue to read and write data to your stream while
* its status is UPDATING.
*
*
* To update the shard count, Kinesis Data Streams performs splits or merges on individual shards. This can cause
* short-lived shards to be created, in addition to the final shards. These short-lived shards count towards your
* total shard limit for your account in the Region.
*
*
* When using this operation, we recommend that you specify a target shard count that is a multiple of 25% (25%,
* 50%, 75%, 100%). You can specify any target value within your shard limit. However, if you specify a target that
* isn't a multiple of 25%, the scaling action might take longer to complete.
*
*
* This operation has the following default limits. By default, you cannot do the following:
*
*
* -
*
* Scale more than ten times per rolling 24-hour period per stream
*
*
* -
*
* Scale up to more than double your current shard count for a stream
*
*
* -
*
* Scale down below half your current shard count for a stream
*
*
* -
*
* Scale up to more than 10000 shards in a stream
*
*
* -
*
* Scale a stream with more than 10000 shards down unless the result is less than 10000 shards
*
*
* -
*
* Scale up to more than the shard limit for your account
*
*
* -
*
* Make over 10 TPS. TPS over 10 will trigger the LimitExceededException
*
*
*
*
* For the default limits for an Amazon Web Services account, see Streams Limits in the
* Amazon Kinesis Data Streams Developer Guide. To request an increase in the call rate limit, the shard
* limit for this API, or your overall shard limit, use the limits form.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateShardCountRequest.Builder} avoiding the need
* to create one manually via {@link UpdateShardCountRequest#builder()}
*
*
* @param updateShardCountRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.UpdateShardCountRequest.Builder} to create a request.
* @return A Java Future containing the result of the UpdateShardCount operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - ValidationException Specifies that you tried to invoke this API for a data stream with the on-demand
* capacity mode. This API is only supported for data streams with the provisioned capacity mode.
* - AccessDeniedException Specifies that you do not have the permissions required to perform this
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.UpdateShardCount
* @see AWS API
* Documentation
*/
default CompletableFuture updateShardCount(
Consumer updateShardCountRequest) {
return updateShardCount(UpdateShardCountRequest.builder().applyMutation(updateShardCountRequest).build());
}
/**
*
* Updates the capacity mode of the data stream. Currently, in Kinesis Data Streams, you can choose between an
* on-demand capacity mode and a provisioned capacity mode for your data stream.
*
*
* @param updateStreamModeRequest
* @return A Java Future containing the result of the UpdateStreamMode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.UpdateStreamMode
* @see AWS API
* Documentation
*/
default CompletableFuture updateStreamMode(UpdateStreamModeRequest updateStreamModeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates the capacity mode of the data stream. Currently, in Kinesis Data Streams, you can choose between an
* on-demand capacity mode and a provisioned capacity mode for your data stream.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateStreamModeRequest.Builder} avoiding the need
* to create one manually via {@link UpdateStreamModeRequest#builder()}
*
*
* @param updateStreamModeRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.kinesis.model.UpdateStreamModeRequest.Builder} to create a request.
* @return A Java Future containing the result of the UpdateStreamMode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException A specified parameter exceeds its restrictions, is not supported, or can't
* be used. For more information, see the returned message.
* - LimitExceededException The requested resource exceeds the maximum number allowed, or the number of
* concurrent stream requests exceeds the maximum number allowed.
* - ResourceInUseException The resource is not available for this operation. For successful operation,
* the resource must be in the
ACTIVE state.
* - ResourceNotFoundException The requested resource could not be found. The stream might not be
* specified correctly.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample KinesisAsyncClient.UpdateStreamMode
* @see AWS API
* Documentation
*/
default CompletableFuture updateStreamMode(
Consumer updateStreamModeRequest) {
return updateStreamMode(UpdateStreamModeRequest.builder().applyMutation(updateStreamModeRequest).build());
}
/**
* Create an instance of {@link KinesisAsyncWaiter} using this client.
*
* Waiters created via this method are managed by the SDK and resources will be released when the service client is
* closed.
*
* @return an instance of {@link KinesisAsyncWaiter}
*/
default KinesisAsyncWaiter waiter() {
throw new UnsupportedOperationException();
}
@Override
default KinesisServiceClientConfiguration serviceClientConfiguration() {
throw new UnsupportedOperationException();
}
/**
* Create a {@link KinesisAsyncClient} with the region loaded from the
* {@link software.amazon.awssdk.regions.providers.DefaultAwsRegionProviderChain} and credentials loaded from the
* {@link software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider}.
*/
static KinesisAsyncClient create() {
return builder().build();
}
/**
* Create a builder that can be used to configure and create a {@link KinesisAsyncClient}.
*/
static KinesisAsyncClientBuilder builder() {
return new DefaultKinesisAsyncClientBuilder();
}
}