@Generated(value="software.amazon.awssdk:codegen") @ThreadSafe public interface Route53RecoveryReadinessAsyncClient extends SdkClient
builder() method.
AWS Route53 Recovery Readiness| Modifier and Type | Field and Description |
|---|---|
static String |
SERVICE_METADATA_ID
Value for looking up the service's metadata from the
ServiceMetadataProvider. |
static String |
SERVICE_NAME |
serviceNameclosestatic final String SERVICE_NAME
static final String SERVICE_METADATA_ID
ServiceMetadataProvider.static Route53RecoveryReadinessAsyncClient create()
Route53RecoveryReadinessAsyncClient with the region loaded from the
DefaultAwsRegionProviderChain and credentials loaded from the
DefaultCredentialsProvider.static Route53RecoveryReadinessAsyncClientBuilder builder()
Route53RecoveryReadinessAsyncClient.default CompletableFuture<CreateCellResponse> createCell(CreateCellRequest createCellRequest)
createCellRequest - The Cell to createdefault CompletableFuture<CreateCellResponse> createCell(Consumer<CreateCellRequest.Builder> createCellRequest)
This is a convenience which creates an instance of the CreateCellRequest.Builder avoiding the need to
create one manually via CreateCellRequest.builder()
createCellRequest - A Consumer that will call methods on CreateCellRequest.Builder to create a request. The
Cell to createdefault CompletableFuture<CreateCrossAccountAuthorizationResponse> createCrossAccountAuthorization(CreateCrossAccountAuthorizationRequest createCrossAccountAuthorizationRequest)
createCrossAccountAuthorizationRequest - The cross account authorizationdefault CompletableFuture<CreateCrossAccountAuthorizationResponse> createCrossAccountAuthorization(Consumer<CreateCrossAccountAuthorizationRequest.Builder> createCrossAccountAuthorizationRequest)
This is a convenience which creates an instance of the CreateCrossAccountAuthorizationRequest.Builder
avoiding the need to create one manually via CreateCrossAccountAuthorizationRequest.builder()
createCrossAccountAuthorizationRequest - A Consumer that will call methods on CreateCrossAccountAuthorizationRequest.Builder to
create a request. The cross account authorizationdefault CompletableFuture<CreateReadinessCheckResponse> createReadinessCheck(CreateReadinessCheckRequest createReadinessCheckRequest)
createReadinessCheckRequest - The ReadinessCheck to createdefault CompletableFuture<CreateReadinessCheckResponse> createReadinessCheck(Consumer<CreateReadinessCheckRequest.Builder> createReadinessCheckRequest)
This is a convenience which creates an instance of the CreateReadinessCheckRequest.Builder avoiding the
need to create one manually via CreateReadinessCheckRequest.builder()
createReadinessCheckRequest - A Consumer that will call methods on CreateReadinessCheckRequest.Builder to create a
request. The ReadinessCheck to createdefault CompletableFuture<CreateRecoveryGroupResponse> createRecoveryGroup(CreateRecoveryGroupRequest createRecoveryGroupRequest)
createRecoveryGroupRequest - The RecoveryGroup to createdefault CompletableFuture<CreateRecoveryGroupResponse> createRecoveryGroup(Consumer<CreateRecoveryGroupRequest.Builder> createRecoveryGroupRequest)
This is a convenience which creates an instance of the CreateRecoveryGroupRequest.Builder avoiding the
need to create one manually via CreateRecoveryGroupRequest.builder()
createRecoveryGroupRequest - A Consumer that will call methods on CreateRecoveryGroupRequest.Builder to create a
request. The RecoveryGroup to createdefault CompletableFuture<CreateResourceSetResponse> createResourceSet(CreateResourceSetRequest createResourceSetRequest)
createResourceSetRequest - The ResourceSet to createdefault CompletableFuture<CreateResourceSetResponse> createResourceSet(Consumer<CreateResourceSetRequest.Builder> createResourceSetRequest)
This is a convenience which creates an instance of the CreateResourceSetRequest.Builder avoiding the need
to create one manually via CreateResourceSetRequest.builder()
createResourceSetRequest - A Consumer that will call methods on CreateResourceSetRequest.Builder to create a request.
The ResourceSet to createdefault CompletableFuture<DeleteCellResponse> deleteCell(DeleteCellRequest deleteCellRequest)
deleteCellRequest - default CompletableFuture<DeleteCellResponse> deleteCell(Consumer<DeleteCellRequest.Builder> deleteCellRequest)
This is a convenience which creates an instance of the DeleteCellRequest.Builder avoiding the need to
create one manually via DeleteCellRequest.builder()
deleteCellRequest - A Consumer that will call methods on DeleteCellRequest.Builder to create a request.default CompletableFuture<DeleteCrossAccountAuthorizationResponse> deleteCrossAccountAuthorization(DeleteCrossAccountAuthorizationRequest deleteCrossAccountAuthorizationRequest)
deleteCrossAccountAuthorizationRequest - default CompletableFuture<DeleteCrossAccountAuthorizationResponse> deleteCrossAccountAuthorization(Consumer<DeleteCrossAccountAuthorizationRequest.Builder> deleteCrossAccountAuthorizationRequest)
This is a convenience which creates an instance of the DeleteCrossAccountAuthorizationRequest.Builder
avoiding the need to create one manually via DeleteCrossAccountAuthorizationRequest.builder()
deleteCrossAccountAuthorizationRequest - A Consumer that will call methods on DeleteCrossAccountAuthorizationRequest.Builder to
create a request.default CompletableFuture<DeleteReadinessCheckResponse> deleteReadinessCheck(DeleteReadinessCheckRequest deleteReadinessCheckRequest)
deleteReadinessCheckRequest - default CompletableFuture<DeleteReadinessCheckResponse> deleteReadinessCheck(Consumer<DeleteReadinessCheckRequest.Builder> deleteReadinessCheckRequest)
This is a convenience which creates an instance of the DeleteReadinessCheckRequest.Builder avoiding the
need to create one manually via DeleteReadinessCheckRequest.builder()
deleteReadinessCheckRequest - A Consumer that will call methods on DeleteReadinessCheckRequest.Builder to create a
request.default CompletableFuture<DeleteRecoveryGroupResponse> deleteRecoveryGroup(DeleteRecoveryGroupRequest deleteRecoveryGroupRequest)
deleteRecoveryGroupRequest - default CompletableFuture<DeleteRecoveryGroupResponse> deleteRecoveryGroup(Consumer<DeleteRecoveryGroupRequest.Builder> deleteRecoveryGroupRequest)
This is a convenience which creates an instance of the DeleteRecoveryGroupRequest.Builder avoiding the
need to create one manually via DeleteRecoveryGroupRequest.builder()
deleteRecoveryGroupRequest - A Consumer that will call methods on DeleteRecoveryGroupRequest.Builder to create a
request.default CompletableFuture<DeleteResourceSetResponse> deleteResourceSet(DeleteResourceSetRequest deleteResourceSetRequest)
deleteResourceSetRequest - default CompletableFuture<DeleteResourceSetResponse> deleteResourceSet(Consumer<DeleteResourceSetRequest.Builder> deleteResourceSetRequest)
This is a convenience which creates an instance of the DeleteResourceSetRequest.Builder avoiding the need
to create one manually via DeleteResourceSetRequest.builder()
deleteResourceSetRequest - A Consumer that will call methods on DeleteResourceSetRequest.Builder to create a request.default CompletableFuture<GetArchitectureRecommendationsResponse> getArchitectureRecommendations(GetArchitectureRecommendationsRequest getArchitectureRecommendationsRequest)
getArchitectureRecommendationsRequest - default CompletableFuture<GetArchitectureRecommendationsResponse> getArchitectureRecommendations(Consumer<GetArchitectureRecommendationsRequest.Builder> getArchitectureRecommendationsRequest)
This is a convenience which creates an instance of the GetArchitectureRecommendationsRequest.Builder
avoiding the need to create one manually via GetArchitectureRecommendationsRequest.builder()
getArchitectureRecommendationsRequest - A Consumer that will call methods on GetArchitectureRecommendationsRequest.Builder to
create a request.default CompletableFuture<GetCellResponse> getCell(GetCellRequest getCellRequest)
getCellRequest - default CompletableFuture<GetCellResponse> getCell(Consumer<GetCellRequest.Builder> getCellRequest)
This is a convenience which creates an instance of the GetCellRequest.Builder avoiding the need to create
one manually via GetCellRequest.builder()
getCellRequest - A Consumer that will call methods on GetCellRequest.Builder to create a request.default CompletableFuture<GetCellReadinessSummaryResponse> getCellReadinessSummary(GetCellReadinessSummaryRequest getCellReadinessSummaryRequest)
getCellReadinessSummaryRequest - default CompletableFuture<GetCellReadinessSummaryResponse> getCellReadinessSummary(Consumer<GetCellReadinessSummaryRequest.Builder> getCellReadinessSummaryRequest)
This is a convenience which creates an instance of the GetCellReadinessSummaryRequest.Builder avoiding
the need to create one manually via GetCellReadinessSummaryRequest.builder()
getCellReadinessSummaryRequest - A Consumer that will call methods on GetCellReadinessSummaryRequest.Builder to create a
request.default GetCellReadinessSummaryPublisher getCellReadinessSummaryPaginator(GetCellReadinessSummaryRequest getCellReadinessSummaryRequest)
This is a variant of
getCellReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetCellReadinessSummaryPublisher publisher = client.getCellReadinessSummaryPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetCellReadinessSummaryPublisher publisher = client.getCellReadinessSummaryPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryResponse 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
getCellReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryRequest)
operation.
getCellReadinessSummaryRequest - default GetCellReadinessSummaryPublisher getCellReadinessSummaryPaginator(Consumer<GetCellReadinessSummaryRequest.Builder> getCellReadinessSummaryRequest)
This is a variant of
getCellReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetCellReadinessSummaryPublisher publisher = client.getCellReadinessSummaryPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetCellReadinessSummaryPublisher publisher = client.getCellReadinessSummaryPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryResponse 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
getCellReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetCellReadinessSummaryRequest)
operation.
This is a convenience which creates an instance of the GetCellReadinessSummaryRequest.Builder avoiding
the need to create one manually via GetCellReadinessSummaryRequest.builder()
getCellReadinessSummaryRequest - A Consumer that will call methods on GetCellReadinessSummaryRequest.Builder to create a
request.default CompletableFuture<GetReadinessCheckResponse> getReadinessCheck(GetReadinessCheckRequest getReadinessCheckRequest)
getReadinessCheckRequest - default CompletableFuture<GetReadinessCheckResponse> getReadinessCheck(Consumer<GetReadinessCheckRequest.Builder> getReadinessCheckRequest)
This is a convenience which creates an instance of the GetReadinessCheckRequest.Builder avoiding the need
to create one manually via GetReadinessCheckRequest.builder()
getReadinessCheckRequest - A Consumer that will call methods on GetReadinessCheckRequest.Builder to create a request.default CompletableFuture<GetReadinessCheckResourceStatusResponse> getReadinessCheckResourceStatus(GetReadinessCheckResourceStatusRequest getReadinessCheckResourceStatusRequest)
getReadinessCheckResourceStatusRequest - default CompletableFuture<GetReadinessCheckResourceStatusResponse> getReadinessCheckResourceStatus(Consumer<GetReadinessCheckResourceStatusRequest.Builder> getReadinessCheckResourceStatusRequest)
This is a convenience which creates an instance of the GetReadinessCheckResourceStatusRequest.Builder
avoiding the need to create one manually via GetReadinessCheckResourceStatusRequest.builder()
getReadinessCheckResourceStatusRequest - A Consumer that will call methods on GetReadinessCheckResourceStatusRequest.Builder to
create a request.default GetReadinessCheckResourceStatusPublisher getReadinessCheckResourceStatusPaginator(GetReadinessCheckResourceStatusRequest getReadinessCheckResourceStatusRequest)
This is a variant of
getReadinessCheckResourceStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckResourceStatusPublisher publisher = client.getReadinessCheckResourceStatusPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckResourceStatusPublisher publisher = client.getReadinessCheckResourceStatusPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusResponse 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
getReadinessCheckResourceStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusRequest)
operation.
getReadinessCheckResourceStatusRequest - default GetReadinessCheckResourceStatusPublisher getReadinessCheckResourceStatusPaginator(Consumer<GetReadinessCheckResourceStatusRequest.Builder> getReadinessCheckResourceStatusRequest)
This is a variant of
getReadinessCheckResourceStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckResourceStatusPublisher publisher = client.getReadinessCheckResourceStatusPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckResourceStatusPublisher publisher = client.getReadinessCheckResourceStatusPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusResponse 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
getReadinessCheckResourceStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckResourceStatusRequest)
operation.
This is a convenience which creates an instance of the GetReadinessCheckResourceStatusRequest.Builder
avoiding the need to create one manually via GetReadinessCheckResourceStatusRequest.builder()
getReadinessCheckResourceStatusRequest - A Consumer that will call methods on GetReadinessCheckResourceStatusRequest.Builder to
create a request.default CompletableFuture<GetReadinessCheckStatusResponse> getReadinessCheckStatus(GetReadinessCheckStatusRequest getReadinessCheckStatusRequest)
getReadinessCheckStatusRequest - default CompletableFuture<GetReadinessCheckStatusResponse> getReadinessCheckStatus(Consumer<GetReadinessCheckStatusRequest.Builder> getReadinessCheckStatusRequest)
This is a convenience which creates an instance of the GetReadinessCheckStatusRequest.Builder avoiding
the need to create one manually via GetReadinessCheckStatusRequest.builder()
getReadinessCheckStatusRequest - A Consumer that will call methods on GetReadinessCheckStatusRequest.Builder to create a
request.default GetReadinessCheckStatusPublisher getReadinessCheckStatusPaginator(GetReadinessCheckStatusRequest getReadinessCheckStatusRequest)
This is a variant of
getReadinessCheckStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckStatusPublisher publisher = client.getReadinessCheckStatusPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckStatusPublisher publisher = client.getReadinessCheckStatusPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusResponse 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
getReadinessCheckStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusRequest)
operation.
getReadinessCheckStatusRequest - default GetReadinessCheckStatusPublisher getReadinessCheckStatusPaginator(Consumer<GetReadinessCheckStatusRequest.Builder> getReadinessCheckStatusRequest)
This is a variant of
getReadinessCheckStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckStatusPublisher publisher = client.getReadinessCheckStatusPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetReadinessCheckStatusPublisher publisher = client.getReadinessCheckStatusPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusResponse 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
getReadinessCheckStatus(software.amazon.awssdk.services.route53recoveryreadiness.model.GetReadinessCheckStatusRequest)
operation.
This is a convenience which creates an instance of the GetReadinessCheckStatusRequest.Builder avoiding
the need to create one manually via GetReadinessCheckStatusRequest.builder()
getReadinessCheckStatusRequest - A Consumer that will call methods on GetReadinessCheckStatusRequest.Builder to create a
request.default CompletableFuture<GetRecoveryGroupResponse> getRecoveryGroup(GetRecoveryGroupRequest getRecoveryGroupRequest)
getRecoveryGroupRequest - default CompletableFuture<GetRecoveryGroupResponse> getRecoveryGroup(Consumer<GetRecoveryGroupRequest.Builder> getRecoveryGroupRequest)
This is a convenience which creates an instance of the GetRecoveryGroupRequest.Builder avoiding the need
to create one manually via GetRecoveryGroupRequest.builder()
getRecoveryGroupRequest - A Consumer that will call methods on GetRecoveryGroupRequest.Builder to create a request.default CompletableFuture<GetRecoveryGroupReadinessSummaryResponse> getRecoveryGroupReadinessSummary(GetRecoveryGroupReadinessSummaryRequest getRecoveryGroupReadinessSummaryRequest)
getRecoveryGroupReadinessSummaryRequest - default CompletableFuture<GetRecoveryGroupReadinessSummaryResponse> getRecoveryGroupReadinessSummary(Consumer<GetRecoveryGroupReadinessSummaryRequest.Builder> getRecoveryGroupReadinessSummaryRequest)
This is a convenience which creates an instance of the GetRecoveryGroupReadinessSummaryRequest.Builder
avoiding the need to create one manually via GetRecoveryGroupReadinessSummaryRequest.builder()
getRecoveryGroupReadinessSummaryRequest - A Consumer that will call methods on GetRecoveryGroupReadinessSummaryRequest.Builder to
create a request.default GetRecoveryGroupReadinessSummaryPublisher getRecoveryGroupReadinessSummaryPaginator(GetRecoveryGroupReadinessSummaryRequest getRecoveryGroupReadinessSummaryRequest)
This is a variant of
getRecoveryGroupReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetRecoveryGroupReadinessSummaryPublisher publisher = client.getRecoveryGroupReadinessSummaryPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetRecoveryGroupReadinessSummaryPublisher publisher = client.getRecoveryGroupReadinessSummaryPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryResponse 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
getRecoveryGroupReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryRequest)
operation.
getRecoveryGroupReadinessSummaryRequest - default GetRecoveryGroupReadinessSummaryPublisher getRecoveryGroupReadinessSummaryPaginator(Consumer<GetRecoveryGroupReadinessSummaryRequest.Builder> getRecoveryGroupReadinessSummaryRequest)
This is a variant of
getRecoveryGroupReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetRecoveryGroupReadinessSummaryPublisher publisher = client.getRecoveryGroupReadinessSummaryPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.GetRecoveryGroupReadinessSummaryPublisher publisher = client.getRecoveryGroupReadinessSummaryPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryResponse 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
getRecoveryGroupReadinessSummary(software.amazon.awssdk.services.route53recoveryreadiness.model.GetRecoveryGroupReadinessSummaryRequest)
operation.
This is a convenience which creates an instance of the GetRecoveryGroupReadinessSummaryRequest.Builder
avoiding the need to create one manually via GetRecoveryGroupReadinessSummaryRequest.builder()
getRecoveryGroupReadinessSummaryRequest - A Consumer that will call methods on GetRecoveryGroupReadinessSummaryRequest.Builder to
create a request.default CompletableFuture<GetResourceSetResponse> getResourceSet(GetResourceSetRequest getResourceSetRequest)
getResourceSetRequest - default CompletableFuture<GetResourceSetResponse> getResourceSet(Consumer<GetResourceSetRequest.Builder> getResourceSetRequest)
This is a convenience which creates an instance of the GetResourceSetRequest.Builder avoiding the need to
create one manually via GetResourceSetRequest.builder()
getResourceSetRequest - A Consumer that will call methods on GetResourceSetRequest.Builder to create a request.default CompletableFuture<ListCellsResponse> listCells(ListCellsRequest listCellsRequest)
listCellsRequest - default CompletableFuture<ListCellsResponse> listCells(Consumer<ListCellsRequest.Builder> listCellsRequest)
This is a convenience which creates an instance of the ListCellsRequest.Builder avoiding the need to
create one manually via ListCellsRequest.builder()
listCellsRequest - A Consumer that will call methods on ListCellsRequest.Builder to create a request.default ListCellsPublisher listCellsPaginator(ListCellsRequest listCellsRequest)
This is a variant of
listCells(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsRequest) operation.
The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCellsPublisher publisher = client.listCellsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCellsPublisher publisher = client.listCellsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsResponse 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
listCells(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsRequest)
operation.
listCellsRequest - default ListCellsPublisher listCellsPaginator(Consumer<ListCellsRequest.Builder> listCellsRequest)
This is a variant of
listCells(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsRequest) operation.
The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCellsPublisher publisher = client.listCellsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCellsPublisher publisher = client.listCellsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsResponse 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
listCells(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCellsRequest)
operation.
This is a convenience which creates an instance of the ListCellsRequest.Builder avoiding the need to
create one manually via ListCellsRequest.builder()
listCellsRequest - A Consumer that will call methods on ListCellsRequest.Builder to create a request.default CompletableFuture<ListCrossAccountAuthorizationsResponse> listCrossAccountAuthorizations(ListCrossAccountAuthorizationsRequest listCrossAccountAuthorizationsRequest)
listCrossAccountAuthorizationsRequest - default CompletableFuture<ListCrossAccountAuthorizationsResponse> listCrossAccountAuthorizations(Consumer<ListCrossAccountAuthorizationsRequest.Builder> listCrossAccountAuthorizationsRequest)
This is a convenience which creates an instance of the ListCrossAccountAuthorizationsRequest.Builder
avoiding the need to create one manually via ListCrossAccountAuthorizationsRequest.builder()
listCrossAccountAuthorizationsRequest - A Consumer that will call methods on ListCrossAccountAuthorizationsRequest.Builder to
create a request.default ListCrossAccountAuthorizationsPublisher listCrossAccountAuthorizationsPaginator(ListCrossAccountAuthorizationsRequest listCrossAccountAuthorizationsRequest)
This is a variant of
listCrossAccountAuthorizations(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCrossAccountAuthorizationsPublisher publisher = client.listCrossAccountAuthorizationsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCrossAccountAuthorizationsPublisher publisher = client.listCrossAccountAuthorizationsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsResponse 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
listCrossAccountAuthorizations(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsRequest)
operation.
listCrossAccountAuthorizationsRequest - default ListCrossAccountAuthorizationsPublisher listCrossAccountAuthorizationsPaginator(Consumer<ListCrossAccountAuthorizationsRequest.Builder> listCrossAccountAuthorizationsRequest)
This is a variant of
listCrossAccountAuthorizations(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCrossAccountAuthorizationsPublisher publisher = client.listCrossAccountAuthorizationsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListCrossAccountAuthorizationsPublisher publisher = client.listCrossAccountAuthorizationsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsResponse 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
listCrossAccountAuthorizations(software.amazon.awssdk.services.route53recoveryreadiness.model.ListCrossAccountAuthorizationsRequest)
operation.
This is a convenience which creates an instance of the ListCrossAccountAuthorizationsRequest.Builder
avoiding the need to create one manually via ListCrossAccountAuthorizationsRequest.builder()
listCrossAccountAuthorizationsRequest - A Consumer that will call methods on ListCrossAccountAuthorizationsRequest.Builder to
create a request.default CompletableFuture<ListReadinessChecksResponse> listReadinessChecks(ListReadinessChecksRequest listReadinessChecksRequest)
listReadinessChecksRequest - default CompletableFuture<ListReadinessChecksResponse> listReadinessChecks(Consumer<ListReadinessChecksRequest.Builder> listReadinessChecksRequest)
This is a convenience which creates an instance of the ListReadinessChecksRequest.Builder avoiding the
need to create one manually via ListReadinessChecksRequest.builder()
listReadinessChecksRequest - A Consumer that will call methods on ListReadinessChecksRequest.Builder to create a
request.default ListReadinessChecksPublisher listReadinessChecksPaginator(ListReadinessChecksRequest listReadinessChecksRequest)
This is a variant of
listReadinessChecks(software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListReadinessChecksPublisher publisher = client.listReadinessChecksPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListReadinessChecksPublisher publisher = client.listReadinessChecksPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksResponse 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
listReadinessChecks(software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksRequest)
operation.
listReadinessChecksRequest - default ListReadinessChecksPublisher listReadinessChecksPaginator(Consumer<ListReadinessChecksRequest.Builder> listReadinessChecksRequest)
This is a variant of
listReadinessChecks(software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListReadinessChecksPublisher publisher = client.listReadinessChecksPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListReadinessChecksPublisher publisher = client.listReadinessChecksPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksResponse 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
listReadinessChecks(software.amazon.awssdk.services.route53recoveryreadiness.model.ListReadinessChecksRequest)
operation.
This is a convenience which creates an instance of the ListReadinessChecksRequest.Builder avoiding the
need to create one manually via ListReadinessChecksRequest.builder()
listReadinessChecksRequest - A Consumer that will call methods on ListReadinessChecksRequest.Builder to create a
request.default CompletableFuture<ListRecoveryGroupsResponse> listRecoveryGroups(ListRecoveryGroupsRequest listRecoveryGroupsRequest)
listRecoveryGroupsRequest - default CompletableFuture<ListRecoveryGroupsResponse> listRecoveryGroups(Consumer<ListRecoveryGroupsRequest.Builder> listRecoveryGroupsRequest)
This is a convenience which creates an instance of the ListRecoveryGroupsRequest.Builder avoiding the
need to create one manually via ListRecoveryGroupsRequest.builder()
listRecoveryGroupsRequest - A Consumer that will call methods on ListRecoveryGroupsRequest.Builder to create a
request.default ListRecoveryGroupsPublisher listRecoveryGroupsPaginator(ListRecoveryGroupsRequest listRecoveryGroupsRequest)
This is a variant of
listRecoveryGroups(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRecoveryGroupsPublisher publisher = client.listRecoveryGroupsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRecoveryGroupsPublisher publisher = client.listRecoveryGroupsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsResponse 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
listRecoveryGroups(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsRequest)
operation.
listRecoveryGroupsRequest - default ListRecoveryGroupsPublisher listRecoveryGroupsPaginator(Consumer<ListRecoveryGroupsRequest.Builder> listRecoveryGroupsRequest)
This is a variant of
listRecoveryGroups(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRecoveryGroupsPublisher publisher = client.listRecoveryGroupsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRecoveryGroupsPublisher publisher = client.listRecoveryGroupsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsResponse 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
listRecoveryGroups(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRecoveryGroupsRequest)
operation.
This is a convenience which creates an instance of the ListRecoveryGroupsRequest.Builder avoiding the
need to create one manually via ListRecoveryGroupsRequest.builder()
listRecoveryGroupsRequest - A Consumer that will call methods on ListRecoveryGroupsRequest.Builder to create a
request.default CompletableFuture<ListResourceSetsResponse> listResourceSets(ListResourceSetsRequest listResourceSetsRequest)
listResourceSetsRequest - default CompletableFuture<ListResourceSetsResponse> listResourceSets(Consumer<ListResourceSetsRequest.Builder> listResourceSetsRequest)
This is a convenience which creates an instance of the ListResourceSetsRequest.Builder avoiding the need
to create one manually via ListResourceSetsRequest.builder()
listResourceSetsRequest - A Consumer that will call methods on ListResourceSetsRequest.Builder to create a request.default ListResourceSetsPublisher listResourceSetsPaginator(ListResourceSetsRequest listResourceSetsRequest)
This is a variant of
listResourceSets(software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListResourceSetsPublisher publisher = client.listResourceSetsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListResourceSetsPublisher publisher = client.listResourceSetsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsResponse 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
listResourceSets(software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsRequest)
operation.
listResourceSetsRequest - default ListResourceSetsPublisher listResourceSetsPaginator(Consumer<ListResourceSetsRequest.Builder> listResourceSetsRequest)
This is a variant of
listResourceSets(software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListResourceSetsPublisher publisher = client.listResourceSetsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListResourceSetsPublisher publisher = client.listResourceSetsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsResponse 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
listResourceSets(software.amazon.awssdk.services.route53recoveryreadiness.model.ListResourceSetsRequest)
operation.
This is a convenience which creates an instance of the ListResourceSetsRequest.Builder avoiding the need
to create one manually via ListResourceSetsRequest.builder()
listResourceSetsRequest - A Consumer that will call methods on ListResourceSetsRequest.Builder to create a request.default CompletableFuture<ListRulesResponse> listRules(ListRulesRequest listRulesRequest)
listRulesRequest - default CompletableFuture<ListRulesResponse> listRules(Consumer<ListRulesRequest.Builder> listRulesRequest)
This is a convenience which creates an instance of the ListRulesRequest.Builder avoiding the need to
create one manually via ListRulesRequest.builder()
listRulesRequest - A Consumer that will call methods on ListRulesRequest.Builder to create a request.default ListRulesPublisher listRulesPaginator(ListRulesRequest listRulesRequest)
This is a variant of
listRules(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesRequest) operation.
The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of MaxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listRules(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesRequest)
operation.
listRulesRequest - default ListRulesPublisher listRulesPaginator(Consumer<ListRulesRequest.Builder> listRulesRequest)
This is a variant of
listRules(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesRequest) operation.
The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.route53recoveryreadiness.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of MaxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listRules(software.amazon.awssdk.services.route53recoveryreadiness.model.ListRulesRequest)
operation.
This is a convenience which creates an instance of the ListRulesRequest.Builder avoiding the need to
create one manually via ListRulesRequest.builder()
listRulesRequest - A Consumer that will call methods on ListRulesRequest.Builder to create a request.default CompletableFuture<ListTagsForResourcesResponse> listTagsForResources(ListTagsForResourcesRequest listTagsForResourcesRequest)
listTagsForResourcesRequest - default CompletableFuture<ListTagsForResourcesResponse> listTagsForResources(Consumer<ListTagsForResourcesRequest.Builder> listTagsForResourcesRequest)
This is a convenience which creates an instance of the ListTagsForResourcesRequest.Builder avoiding the
need to create one manually via ListTagsForResourcesRequest.builder()
listTagsForResourcesRequest - A Consumer that will call methods on ListTagsForResourcesRequest.Builder to create a
request.default CompletableFuture<TagResourceResponse> tagResource(TagResourceRequest tagResourceRequest)
tagResourceRequest - default CompletableFuture<TagResourceResponse> tagResource(Consumer<TagResourceRequest.Builder> tagResourceRequest)
This is a convenience which creates an instance of the TagResourceRequest.Builder avoiding the need to
create one manually via TagResourceRequest.builder()
tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.default CompletableFuture<UntagResourceResponse> untagResource(UntagResourceRequest untagResourceRequest)
untagResourceRequest - default CompletableFuture<UntagResourceResponse> untagResource(Consumer<UntagResourceRequest.Builder> untagResourceRequest)
This is a convenience which creates an instance of the UntagResourceRequest.Builder avoiding the need to
create one manually via UntagResourceRequest.builder()
untagResourceRequest - A Consumer that will call methods on UntagResourceRequest.Builder to create a request.default CompletableFuture<UpdateCellResponse> updateCell(UpdateCellRequest updateCellRequest)
updateCellRequest - Parameters to update for the Celldefault CompletableFuture<UpdateCellResponse> updateCell(Consumer<UpdateCellRequest.Builder> updateCellRequest)
This is a convenience which creates an instance of the UpdateCellRequest.Builder avoiding the need to
create one manually via UpdateCellRequest.builder()
updateCellRequest - A Consumer that will call methods on UpdateCellRequest.Builder to create a request.
Parameters to update for the Celldefault CompletableFuture<UpdateReadinessCheckResponse> updateReadinessCheck(UpdateReadinessCheckRequest updateReadinessCheckRequest)
updateReadinessCheckRequest - The new Readiness Check valuesdefault CompletableFuture<UpdateReadinessCheckResponse> updateReadinessCheck(Consumer<UpdateReadinessCheckRequest.Builder> updateReadinessCheckRequest)
This is a convenience which creates an instance of the UpdateReadinessCheckRequest.Builder avoiding the
need to create one manually via UpdateReadinessCheckRequest.builder()
updateReadinessCheckRequest - A Consumer that will call methods on UpdateReadinessCheckRequest.Builder to create a
request. The new Readiness Check valuesdefault CompletableFuture<UpdateRecoveryGroupResponse> updateRecoveryGroup(UpdateRecoveryGroupRequest updateRecoveryGroupRequest)
updateRecoveryGroupRequest - Parameters to update for the RecoveryGroupdefault CompletableFuture<UpdateRecoveryGroupResponse> updateRecoveryGroup(Consumer<UpdateRecoveryGroupRequest.Builder> updateRecoveryGroupRequest)
This is a convenience which creates an instance of the UpdateRecoveryGroupRequest.Builder avoiding the
need to create one manually via UpdateRecoveryGroupRequest.builder()
updateRecoveryGroupRequest - A Consumer that will call methods on UpdateRecoveryGroupRequest.Builder to create a
request. Parameters to update for the RecoveryGroupdefault CompletableFuture<UpdateResourceSetResponse> updateResourceSet(UpdateResourceSetRequest updateResourceSetRequest)
updateResourceSetRequest - configuration for the desireddefault CompletableFuture<UpdateResourceSetResponse> updateResourceSet(Consumer<UpdateResourceSetRequest.Builder> updateResourceSetRequest)
This is a convenience which creates an instance of the UpdateResourceSetRequest.Builder avoiding the need
to create one manually via UpdateResourceSetRequest.builder()
updateResourceSetRequest - A Consumer that will call methods on UpdateResourceSetRequest.Builder to create a request.
configuration for the desiredCopyright © 2022. All rights reserved.