software.amazon.awssdk.services.emr.EmrAsyncClient Maven / Gradle / Ivy
/*
* 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.emr;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.core.SdkClient;
import software.amazon.awssdk.services.emr.model.AddInstanceFleetRequest;
import software.amazon.awssdk.services.emr.model.AddInstanceFleetResponse;
import software.amazon.awssdk.services.emr.model.AddInstanceGroupsRequest;
import software.amazon.awssdk.services.emr.model.AddInstanceGroupsResponse;
import software.amazon.awssdk.services.emr.model.AddJobFlowStepsRequest;
import software.amazon.awssdk.services.emr.model.AddJobFlowStepsResponse;
import software.amazon.awssdk.services.emr.model.AddTagsRequest;
import software.amazon.awssdk.services.emr.model.AddTagsResponse;
import software.amazon.awssdk.services.emr.model.CancelStepsRequest;
import software.amazon.awssdk.services.emr.model.CancelStepsResponse;
import software.amazon.awssdk.services.emr.model.CreateSecurityConfigurationRequest;
import software.amazon.awssdk.services.emr.model.CreateSecurityConfigurationResponse;
import software.amazon.awssdk.services.emr.model.CreateStudioRequest;
import software.amazon.awssdk.services.emr.model.CreateStudioResponse;
import software.amazon.awssdk.services.emr.model.CreateStudioSessionMappingRequest;
import software.amazon.awssdk.services.emr.model.CreateStudioSessionMappingResponse;
import software.amazon.awssdk.services.emr.model.DeleteSecurityConfigurationRequest;
import software.amazon.awssdk.services.emr.model.DeleteSecurityConfigurationResponse;
import software.amazon.awssdk.services.emr.model.DeleteStudioRequest;
import software.amazon.awssdk.services.emr.model.DeleteStudioResponse;
import software.amazon.awssdk.services.emr.model.DeleteStudioSessionMappingRequest;
import software.amazon.awssdk.services.emr.model.DeleteStudioSessionMappingResponse;
import software.amazon.awssdk.services.emr.model.DescribeClusterRequest;
import software.amazon.awssdk.services.emr.model.DescribeClusterResponse;
import software.amazon.awssdk.services.emr.model.DescribeNotebookExecutionRequest;
import software.amazon.awssdk.services.emr.model.DescribeNotebookExecutionResponse;
import software.amazon.awssdk.services.emr.model.DescribeSecurityConfigurationRequest;
import software.amazon.awssdk.services.emr.model.DescribeSecurityConfigurationResponse;
import software.amazon.awssdk.services.emr.model.DescribeStepRequest;
import software.amazon.awssdk.services.emr.model.DescribeStepResponse;
import software.amazon.awssdk.services.emr.model.DescribeStudioRequest;
import software.amazon.awssdk.services.emr.model.DescribeStudioResponse;
import software.amazon.awssdk.services.emr.model.GetBlockPublicAccessConfigurationRequest;
import software.amazon.awssdk.services.emr.model.GetBlockPublicAccessConfigurationResponse;
import software.amazon.awssdk.services.emr.model.GetManagedScalingPolicyRequest;
import software.amazon.awssdk.services.emr.model.GetManagedScalingPolicyResponse;
import software.amazon.awssdk.services.emr.model.GetStudioSessionMappingRequest;
import software.amazon.awssdk.services.emr.model.GetStudioSessionMappingResponse;
import software.amazon.awssdk.services.emr.model.ListBootstrapActionsRequest;
import software.amazon.awssdk.services.emr.model.ListBootstrapActionsResponse;
import software.amazon.awssdk.services.emr.model.ListClustersRequest;
import software.amazon.awssdk.services.emr.model.ListClustersResponse;
import software.amazon.awssdk.services.emr.model.ListInstanceFleetsRequest;
import software.amazon.awssdk.services.emr.model.ListInstanceFleetsResponse;
import software.amazon.awssdk.services.emr.model.ListInstanceGroupsRequest;
import software.amazon.awssdk.services.emr.model.ListInstanceGroupsResponse;
import software.amazon.awssdk.services.emr.model.ListInstancesRequest;
import software.amazon.awssdk.services.emr.model.ListInstancesResponse;
import software.amazon.awssdk.services.emr.model.ListNotebookExecutionsRequest;
import software.amazon.awssdk.services.emr.model.ListNotebookExecutionsResponse;
import software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsRequest;
import software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsResponse;
import software.amazon.awssdk.services.emr.model.ListStepsRequest;
import software.amazon.awssdk.services.emr.model.ListStepsResponse;
import software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsRequest;
import software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsResponse;
import software.amazon.awssdk.services.emr.model.ListStudiosRequest;
import software.amazon.awssdk.services.emr.model.ListStudiosResponse;
import software.amazon.awssdk.services.emr.model.ModifyClusterRequest;
import software.amazon.awssdk.services.emr.model.ModifyClusterResponse;
import software.amazon.awssdk.services.emr.model.ModifyInstanceFleetRequest;
import software.amazon.awssdk.services.emr.model.ModifyInstanceFleetResponse;
import software.amazon.awssdk.services.emr.model.ModifyInstanceGroupsRequest;
import software.amazon.awssdk.services.emr.model.ModifyInstanceGroupsResponse;
import software.amazon.awssdk.services.emr.model.PutAutoScalingPolicyRequest;
import software.amazon.awssdk.services.emr.model.PutAutoScalingPolicyResponse;
import software.amazon.awssdk.services.emr.model.PutBlockPublicAccessConfigurationRequest;
import software.amazon.awssdk.services.emr.model.PutBlockPublicAccessConfigurationResponse;
import software.amazon.awssdk.services.emr.model.PutManagedScalingPolicyRequest;
import software.amazon.awssdk.services.emr.model.PutManagedScalingPolicyResponse;
import software.amazon.awssdk.services.emr.model.RemoveAutoScalingPolicyRequest;
import software.amazon.awssdk.services.emr.model.RemoveAutoScalingPolicyResponse;
import software.amazon.awssdk.services.emr.model.RemoveManagedScalingPolicyRequest;
import software.amazon.awssdk.services.emr.model.RemoveManagedScalingPolicyResponse;
import software.amazon.awssdk.services.emr.model.RemoveTagsRequest;
import software.amazon.awssdk.services.emr.model.RemoveTagsResponse;
import software.amazon.awssdk.services.emr.model.RunJobFlowRequest;
import software.amazon.awssdk.services.emr.model.RunJobFlowResponse;
import software.amazon.awssdk.services.emr.model.SetTerminationProtectionRequest;
import software.amazon.awssdk.services.emr.model.SetTerminationProtectionResponse;
import software.amazon.awssdk.services.emr.model.SetVisibleToAllUsersRequest;
import software.amazon.awssdk.services.emr.model.SetVisibleToAllUsersResponse;
import software.amazon.awssdk.services.emr.model.StartNotebookExecutionRequest;
import software.amazon.awssdk.services.emr.model.StartNotebookExecutionResponse;
import software.amazon.awssdk.services.emr.model.StopNotebookExecutionRequest;
import software.amazon.awssdk.services.emr.model.StopNotebookExecutionResponse;
import software.amazon.awssdk.services.emr.model.TerminateJobFlowsRequest;
import software.amazon.awssdk.services.emr.model.TerminateJobFlowsResponse;
import software.amazon.awssdk.services.emr.model.UpdateStudioRequest;
import software.amazon.awssdk.services.emr.model.UpdateStudioResponse;
import software.amazon.awssdk.services.emr.model.UpdateStudioSessionMappingRequest;
import software.amazon.awssdk.services.emr.model.UpdateStudioSessionMappingResponse;
import software.amazon.awssdk.services.emr.paginators.ListBootstrapActionsPublisher;
import software.amazon.awssdk.services.emr.paginators.ListClustersPublisher;
import software.amazon.awssdk.services.emr.paginators.ListInstanceFleetsPublisher;
import software.amazon.awssdk.services.emr.paginators.ListInstanceGroupsPublisher;
import software.amazon.awssdk.services.emr.paginators.ListInstancesPublisher;
import software.amazon.awssdk.services.emr.paginators.ListNotebookExecutionsPublisher;
import software.amazon.awssdk.services.emr.paginators.ListSecurityConfigurationsPublisher;
import software.amazon.awssdk.services.emr.paginators.ListStepsPublisher;
import software.amazon.awssdk.services.emr.paginators.ListStudioSessionMappingsPublisher;
import software.amazon.awssdk.services.emr.paginators.ListStudiosPublisher;
import software.amazon.awssdk.services.emr.waiters.EmrAsyncWaiter;
/**
* Service client for accessing Amazon EMR asynchronously. This can be created using the static {@link #builder()}
* method.
*
*
* Amazon EMR is a web service that makes it easier to process large amounts of data efficiently. Amazon EMR uses Hadoop
* processing combined with several AWS services to do tasks such as web indexing, data mining, log file analysis,
* machine learning, scientific simulation, and data warehouse management.
*
*/
@Generated("software.amazon.awssdk:codegen")
public interface EmrAsyncClient extends SdkClient {
String SERVICE_NAME = "elasticmapreduce";
/**
* Value for looking up the service's metadata from the
* {@link software.amazon.awssdk.regions.ServiceMetadataProvider}.
*/
String SERVICE_METADATA_ID = "elasticmapreduce";
/**
* Create a {@link EmrAsyncClient} 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 EmrAsyncClient create() {
return builder().build();
}
/**
* Create a builder that can be used to configure and create a {@link EmrAsyncClient}.
*/
static EmrAsyncClientBuilder builder() {
return new DefaultEmrAsyncClientBuilder();
}
/**
*
* Adds an instance fleet to a running cluster.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x.
*
*
*
* @param addInstanceFleetRequest
* @return A Java Future containing the result of the AddInstanceFleet operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddInstanceFleet
* @see AWS API Documentation
*/
default CompletableFuture addInstanceFleet(AddInstanceFleetRequest addInstanceFleetRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds an instance fleet to a running cluster.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x.
*
*
*
* This is a convenience which creates an instance of the {@link AddInstanceFleetRequest.Builder} avoiding the need
* to create one manually via {@link AddInstanceFleetRequest#builder()}
*
*
* @param addInstanceFleetRequest
* A {@link Consumer} that will call methods on {@link AddInstanceFleetInput.Builder} to create a request.
* @return A Java Future containing the result of the AddInstanceFleet operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddInstanceFleet
* @see AWS API Documentation
*/
default CompletableFuture addInstanceFleet(
Consumer addInstanceFleetRequest) {
return addInstanceFleet(AddInstanceFleetRequest.builder().applyMutation(addInstanceFleetRequest).build());
}
/**
*
* Adds one or more instance groups to a running cluster.
*
*
* @param addInstanceGroupsRequest
* Input to an AddInstanceGroups call.
* @return A Java Future containing the result of the AddInstanceGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddInstanceGroups
* @see AWS API Documentation
*/
default CompletableFuture addInstanceGroups(AddInstanceGroupsRequest addInstanceGroupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds one or more instance groups to a running cluster.
*
*
*
* This is a convenience which creates an instance of the {@link AddInstanceGroupsRequest.Builder} avoiding the need
* to create one manually via {@link AddInstanceGroupsRequest#builder()}
*
*
* @param addInstanceGroupsRequest
* A {@link Consumer} that will call methods on {@link AddInstanceGroupsInput.Builder} to create a request.
* Input to an AddInstanceGroups call.
* @return A Java Future containing the result of the AddInstanceGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddInstanceGroups
* @see AWS API Documentation
*/
default CompletableFuture addInstanceGroups(
Consumer addInstanceGroupsRequest) {
return addInstanceGroups(AddInstanceGroupsRequest.builder().applyMutation(addInstanceGroupsRequest).build());
}
/**
*
* AddJobFlowSteps adds new steps to a running cluster. A maximum of 256 steps are allowed in each job flow.
*
*
* If your cluster is long-running (such as a Hive data warehouse) or complex, you may require more than 256 steps
* to process your data. You can bypass the 256-step limitation in various ways, including using SSH to connect to
* the master node and submitting queries directly to the software running on the master node, such as Hive and
* Hadoop. For more information on how to do this, see Add More than 256 Steps to
* a Cluster in the Amazon EMR Management Guide.
*
*
* A step specifies the location of a JAR file stored either on the master node of the cluster or in Amazon S3. Each
* step is performed by the main function of the main class of the JAR file. The main class can be specified either
* in the manifest of the JAR or by using the MainFunction parameter of the step.
*
*
* Amazon EMR executes each step in the order listed. For a step to be considered complete, the main function must
* exit with a zero exit code and all Hadoop jobs started while the step was running must have completed and run
* successfully.
*
*
* You can only add steps to a cluster that is in one of the following states: STARTING, BOOTSTRAPPING, RUNNING, or
* WAITING.
*
*
* @param addJobFlowStepsRequest
* The input argument to the AddJobFlowSteps operation.
* @return A Java Future containing the result of the AddJobFlowSteps operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddJobFlowSteps
* @see AWS API Documentation
*/
default CompletableFuture addJobFlowSteps(AddJobFlowStepsRequest addJobFlowStepsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* AddJobFlowSteps adds new steps to a running cluster. A maximum of 256 steps are allowed in each job flow.
*
*
* If your cluster is long-running (such as a Hive data warehouse) or complex, you may require more than 256 steps
* to process your data. You can bypass the 256-step limitation in various ways, including using SSH to connect to
* the master node and submitting queries directly to the software running on the master node, such as Hive and
* Hadoop. For more information on how to do this, see Add More than 256 Steps to
* a Cluster in the Amazon EMR Management Guide.
*
*
* A step specifies the location of a JAR file stored either on the master node of the cluster or in Amazon S3. Each
* step is performed by the main function of the main class of the JAR file. The main class can be specified either
* in the manifest of the JAR or by using the MainFunction parameter of the step.
*
*
* Amazon EMR executes each step in the order listed. For a step to be considered complete, the main function must
* exit with a zero exit code and all Hadoop jobs started while the step was running must have completed and run
* successfully.
*
*
* You can only add steps to a cluster that is in one of the following states: STARTING, BOOTSTRAPPING, RUNNING, or
* WAITING.
*
*
*
* This is a convenience which creates an instance of the {@link AddJobFlowStepsRequest.Builder} avoiding the need
* to create one manually via {@link AddJobFlowStepsRequest#builder()}
*
*
* @param addJobFlowStepsRequest
* A {@link Consumer} that will call methods on {@link AddJobFlowStepsInput.Builder} to create a request. The
* input argument to the AddJobFlowSteps operation.
* @return A Java Future containing the result of the AddJobFlowSteps operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddJobFlowSteps
* @see AWS API Documentation
*/
default CompletableFuture addJobFlowSteps(
Consumer addJobFlowStepsRequest) {
return addJobFlowSteps(AddJobFlowStepsRequest.builder().applyMutation(addJobFlowStepsRequest).build());
}
/**
*
* Adds tags to an Amazon EMR resource. Tags make it easier to associate clusters in various ways, such as grouping
* clusters to track your Amazon EMR resource allocation costs. For more information, see Tag Clusters.
*
*
* @param addTagsRequest
* This input identifies a cluster and a list of tags to attach.
* @return A Java Future containing the result of the AddTags operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddTags
* @see AWS API
* Documentation
*/
default CompletableFuture addTags(AddTagsRequest addTagsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds tags to an Amazon EMR resource. Tags make it easier to associate clusters in various ways, such as grouping
* clusters to track your Amazon EMR resource allocation costs. For more information, see Tag Clusters.
*
*
*
* This is a convenience which creates an instance of the {@link AddTagsRequest.Builder} avoiding the need to create
* one manually via {@link AddTagsRequest#builder()}
*
*
* @param addTagsRequest
* A {@link Consumer} that will call methods on {@link AddTagsInput.Builder} to create a request. This input
* identifies a cluster and a list of tags to attach.
* @return A Java Future containing the result of the AddTags operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.AddTags
* @see AWS API
* Documentation
*/
default CompletableFuture addTags(Consumer addTagsRequest) {
return addTags(AddTagsRequest.builder().applyMutation(addTagsRequest).build());
}
/**
*
* Cancels a pending step or steps in a running cluster. Available only in Amazon EMR versions 4.8.0 and later,
* excluding version 5.0.0. A maximum of 256 steps are allowed in each CancelSteps request. CancelSteps is
* idempotent but asynchronous; it does not guarantee that a step will be canceled, even if the request is
* successfully submitted. You can only cancel steps that are in a PENDING state.
*
*
* @param cancelStepsRequest
* The input argument to the CancelSteps operation.
* @return A Java Future containing the result of the CancelSteps operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CancelSteps
* @see AWS
* API Documentation
*/
default CompletableFuture cancelSteps(CancelStepsRequest cancelStepsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Cancels a pending step or steps in a running cluster. Available only in Amazon EMR versions 4.8.0 and later,
* excluding version 5.0.0. A maximum of 256 steps are allowed in each CancelSteps request. CancelSteps is
* idempotent but asynchronous; it does not guarantee that a step will be canceled, even if the request is
* successfully submitted. You can only cancel steps that are in a PENDING state.
*
*
*
* This is a convenience which creates an instance of the {@link CancelStepsRequest.Builder} avoiding the need to
* create one manually via {@link CancelStepsRequest#builder()}
*
*
* @param cancelStepsRequest
* A {@link Consumer} that will call methods on {@link CancelStepsInput.Builder} to create a request. The
* input argument to the CancelSteps operation.
* @return A Java Future containing the result of the CancelSteps operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CancelSteps
* @see AWS
* API Documentation
*/
default CompletableFuture cancelSteps(Consumer cancelStepsRequest) {
return cancelSteps(CancelStepsRequest.builder().applyMutation(cancelStepsRequest).build());
}
/**
*
* Creates a security configuration, which is stored in the service and can be specified when a cluster is created.
*
*
* @param createSecurityConfigurationRequest
* @return A Java Future containing the result of the CreateSecurityConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CreateSecurityConfiguration
* @see AWS API Documentation
*/
default CompletableFuture createSecurityConfiguration(
CreateSecurityConfigurationRequest createSecurityConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a security configuration, which is stored in the service and can be specified when a cluster is created.
*
*
*
* This is a convenience which creates an instance of the {@link CreateSecurityConfigurationRequest.Builder}
* avoiding the need to create one manually via {@link CreateSecurityConfigurationRequest#builder()}
*
*
* @param createSecurityConfigurationRequest
* A {@link Consumer} that will call methods on {@link CreateSecurityConfigurationInput.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateSecurityConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CreateSecurityConfiguration
* @see AWS API Documentation
*/
default CompletableFuture createSecurityConfiguration(
Consumer createSecurityConfigurationRequest) {
return createSecurityConfiguration(CreateSecurityConfigurationRequest.builder()
.applyMutation(createSecurityConfigurationRequest).build());
}
/**
*
* Creates a new Amazon EMR Studio.
*
*
* @param createStudioRequest
* @return A Java Future containing the result of the CreateStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CreateStudio
* @see AWS
* API Documentation
*/
default CompletableFuture createStudio(CreateStudioRequest createStudioRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a new Amazon EMR Studio.
*
*
*
* This is a convenience which creates an instance of the {@link CreateStudioRequest.Builder} avoiding the need to
* create one manually via {@link CreateStudioRequest#builder()}
*
*
* @param createStudioRequest
* A {@link Consumer} that will call methods on {@link CreateStudioInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CreateStudio
* @see AWS
* API Documentation
*/
default CompletableFuture createStudio(Consumer createStudioRequest) {
return createStudio(CreateStudioRequest.builder().applyMutation(createStudioRequest).build());
}
/**
*
* Maps a user or group to the Amazon EMR Studio specified by StudioId, and applies a session policy to
* refine Studio permissions for that user or group.
*
*
* @param createStudioSessionMappingRequest
* @return A Java Future containing the result of the CreateStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CreateStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture createStudioSessionMapping(
CreateStudioSessionMappingRequest createStudioSessionMappingRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Maps a user or group to the Amazon EMR Studio specified by StudioId, and applies a session policy to
* refine Studio permissions for that user or group.
*
*
*
* This is a convenience which creates an instance of the {@link CreateStudioSessionMappingRequest.Builder} avoiding
* the need to create one manually via {@link CreateStudioSessionMappingRequest#builder()}
*
*
* @param createStudioSessionMappingRequest
* A {@link Consumer} that will call methods on {@link CreateStudioSessionMappingInput.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.CreateStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture createStudioSessionMapping(
Consumer createStudioSessionMappingRequest) {
return createStudioSessionMapping(CreateStudioSessionMappingRequest.builder()
.applyMutation(createStudioSessionMappingRequest).build());
}
/**
*
* Deletes a security configuration.
*
*
* @param deleteSecurityConfigurationRequest
* @return A Java Future containing the result of the DeleteSecurityConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DeleteSecurityConfiguration
* @see AWS API Documentation
*/
default CompletableFuture deleteSecurityConfiguration(
DeleteSecurityConfigurationRequest deleteSecurityConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a security configuration.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteSecurityConfigurationRequest.Builder}
* avoiding the need to create one manually via {@link DeleteSecurityConfigurationRequest#builder()}
*
*
* @param deleteSecurityConfigurationRequest
* A {@link Consumer} that will call methods on {@link DeleteSecurityConfigurationInput.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteSecurityConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DeleteSecurityConfiguration
* @see AWS API Documentation
*/
default CompletableFuture deleteSecurityConfiguration(
Consumer deleteSecurityConfigurationRequest) {
return deleteSecurityConfiguration(DeleteSecurityConfigurationRequest.builder()
.applyMutation(deleteSecurityConfigurationRequest).build());
}
/**
*
* Removes an Amazon EMR Studio from the Studio metadata store.
*
*
* @param deleteStudioRequest
* @return A Java Future containing the result of the DeleteStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DeleteStudio
* @see AWS
* API Documentation
*/
default CompletableFuture deleteStudio(DeleteStudioRequest deleteStudioRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes an Amazon EMR Studio from the Studio metadata store.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteStudioRequest.Builder} avoiding the need to
* create one manually via {@link DeleteStudioRequest#builder()}
*
*
* @param deleteStudioRequest
* A {@link Consumer} that will call methods on {@link DeleteStudioInput.Builder} to create a request.
* @return A Java Future containing the result of the DeleteStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DeleteStudio
* @see AWS
* API Documentation
*/
default CompletableFuture deleteStudio(Consumer deleteStudioRequest) {
return deleteStudio(DeleteStudioRequest.builder().applyMutation(deleteStudioRequest).build());
}
/**
*
* Removes a user or group from an Amazon EMR Studio.
*
*
* @param deleteStudioSessionMappingRequest
* @return A Java Future containing the result of the DeleteStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DeleteStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture deleteStudioSessionMapping(
DeleteStudioSessionMappingRequest deleteStudioSessionMappingRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes a user or group from an Amazon EMR Studio.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteStudioSessionMappingRequest.Builder} avoiding
* the need to create one manually via {@link DeleteStudioSessionMappingRequest#builder()}
*
*
* @param deleteStudioSessionMappingRequest
* A {@link Consumer} that will call methods on {@link DeleteStudioSessionMappingInput.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DeleteStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture deleteStudioSessionMapping(
Consumer deleteStudioSessionMappingRequest) {
return deleteStudioSessionMapping(DeleteStudioSessionMappingRequest.builder()
.applyMutation(deleteStudioSessionMappingRequest).build());
}
/**
*
* Provides cluster-level details including status, hardware and software configuration, VPC settings, and so on.
*
*
* @param describeClusterRequest
* This input determines which cluster to describe.
* @return A Java Future containing the result of the DescribeCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeCluster
* @see AWS API Documentation
*/
default CompletableFuture describeCluster(DescribeClusterRequest describeClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides cluster-level details including status, hardware and software configuration, VPC settings, and so on.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeClusterRequest.Builder} avoiding the need
* to create one manually via {@link DescribeClusterRequest#builder()}
*
*
* @param describeClusterRequest
* A {@link Consumer} that will call methods on {@link DescribeClusterInput.Builder} to create a request.
* This input determines which cluster to describe.
* @return A Java Future containing the result of the DescribeCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeCluster
* @see AWS API Documentation
*/
default CompletableFuture describeCluster(
Consumer describeClusterRequest) {
return describeCluster(DescribeClusterRequest.builder().applyMutation(describeClusterRequest).build());
}
/**
*
* Provides details of a notebook execution.
*
*
* @param describeNotebookExecutionRequest
* @return A Java Future containing the result of the DescribeNotebookExecution operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeNotebookExecution
* @see AWS API Documentation
*/
default CompletableFuture describeNotebookExecution(
DescribeNotebookExecutionRequest describeNotebookExecutionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides details of a notebook execution.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeNotebookExecutionRequest.Builder} avoiding
* the need to create one manually via {@link DescribeNotebookExecutionRequest#builder()}
*
*
* @param describeNotebookExecutionRequest
* A {@link Consumer} that will call methods on {@link DescribeNotebookExecutionInput.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeNotebookExecution operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeNotebookExecution
* @see AWS API Documentation
*/
default CompletableFuture describeNotebookExecution(
Consumer describeNotebookExecutionRequest) {
return describeNotebookExecution(DescribeNotebookExecutionRequest.builder()
.applyMutation(describeNotebookExecutionRequest).build());
}
/**
*
* Provides the details of a security configuration by returning the configuration JSON.
*
*
* @param describeSecurityConfigurationRequest
* @return A Java Future containing the result of the DescribeSecurityConfiguration operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeSecurityConfiguration
* @see AWS API Documentation
*/
default CompletableFuture describeSecurityConfiguration(
DescribeSecurityConfigurationRequest describeSecurityConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides the details of a security configuration by returning the configuration JSON.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeSecurityConfigurationRequest.Builder}
* avoiding the need to create one manually via {@link DescribeSecurityConfigurationRequest#builder()}
*
*
* @param describeSecurityConfigurationRequest
* A {@link Consumer} that will call methods on {@link DescribeSecurityConfigurationInput.Builder} to create
* a request.
* @return A Java Future containing the result of the DescribeSecurityConfiguration operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeSecurityConfiguration
* @see AWS API Documentation
*/
default CompletableFuture describeSecurityConfiguration(
Consumer describeSecurityConfigurationRequest) {
return describeSecurityConfiguration(DescribeSecurityConfigurationRequest.builder()
.applyMutation(describeSecurityConfigurationRequest).build());
}
/**
*
* Provides more detail about the cluster step.
*
*
* @param describeStepRequest
* This input determines which step to describe.
* @return A Java Future containing the result of the DescribeStep operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeStep
* @see AWS
* API Documentation
*/
default CompletableFuture describeStep(DescribeStepRequest describeStepRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides more detail about the cluster step.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeStepRequest.Builder} avoiding the need to
* create one manually via {@link DescribeStepRequest#builder()}
*
*
* @param describeStepRequest
* A {@link Consumer} that will call methods on {@link DescribeStepInput.Builder} to create a request. This
* input determines which step to describe.
* @return A Java Future containing the result of the DescribeStep operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeStep
* @see AWS
* API Documentation
*/
default CompletableFuture describeStep(Consumer describeStepRequest) {
return describeStep(DescribeStepRequest.builder().applyMutation(describeStepRequest).build());
}
/**
*
* Returns details for the specified Amazon EMR Studio including ID, Name, VPC, Studio access URL, and so on.
*
*
* @param describeStudioRequest
* @return A Java Future containing the result of the DescribeStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeStudio
* @see AWS API Documentation
*/
default CompletableFuture describeStudio(DescribeStudioRequest describeStudioRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns details for the specified Amazon EMR Studio including ID, Name, VPC, Studio access URL, and so on.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeStudioRequest.Builder} avoiding the need to
* create one manually via {@link DescribeStudioRequest#builder()}
*
*
* @param describeStudioRequest
* A {@link Consumer} that will call methods on {@link DescribeStudioInput.Builder} to create a request.
* @return A Java Future containing the result of the DescribeStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.DescribeStudio
* @see AWS API Documentation
*/
default CompletableFuture describeStudio(Consumer describeStudioRequest) {
return describeStudio(DescribeStudioRequest.builder().applyMutation(describeStudioRequest).build());
}
/**
*
* Returns the Amazon EMR block public access configuration for your AWS account in the current Region. For more
* information see Configure Block
* Public Access for Amazon EMR in the Amazon EMR Management Guide.
*
*
* @param getBlockPublicAccessConfigurationRequest
* @return A Java Future containing the result of the GetBlockPublicAccessConfiguration operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.GetBlockPublicAccessConfiguration
* @see AWS API Documentation
*/
default CompletableFuture getBlockPublicAccessConfiguration(
GetBlockPublicAccessConfigurationRequest getBlockPublicAccessConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the Amazon EMR block public access configuration for your AWS account in the current Region. For more
* information see Configure Block
* Public Access for Amazon EMR in the Amazon EMR Management Guide.
*
*
*
* This is a convenience which creates an instance of the {@link GetBlockPublicAccessConfigurationRequest.Builder}
* avoiding the need to create one manually via {@link GetBlockPublicAccessConfigurationRequest#builder()}
*
*
* @param getBlockPublicAccessConfigurationRequest
* A {@link Consumer} that will call methods on {@link GetBlockPublicAccessConfigurationInput.Builder} to
* create a request.
* @return A Java Future containing the result of the GetBlockPublicAccessConfiguration operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.GetBlockPublicAccessConfiguration
* @see AWS API Documentation
*/
default CompletableFuture getBlockPublicAccessConfiguration(
Consumer getBlockPublicAccessConfigurationRequest) {
return getBlockPublicAccessConfiguration(GetBlockPublicAccessConfigurationRequest.builder()
.applyMutation(getBlockPublicAccessConfigurationRequest).build());
}
/**
*
* Fetches the attached managed scaling policy for an Amazon EMR cluster.
*
*
* @param getManagedScalingPolicyRequest
* @return A Java Future containing the result of the GetManagedScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.GetManagedScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture getManagedScalingPolicy(
GetManagedScalingPolicyRequest getManagedScalingPolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Fetches the attached managed scaling policy for an Amazon EMR cluster.
*
*
*
* This is a convenience which creates an instance of the {@link GetManagedScalingPolicyRequest.Builder} avoiding
* the need to create one manually via {@link GetManagedScalingPolicyRequest#builder()}
*
*
* @param getManagedScalingPolicyRequest
* A {@link Consumer} that will call methods on {@link GetManagedScalingPolicyInput.Builder} to create a
* request.
* @return A Java Future containing the result of the GetManagedScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.GetManagedScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture getManagedScalingPolicy(
Consumer getManagedScalingPolicyRequest) {
return getManagedScalingPolicy(GetManagedScalingPolicyRequest.builder().applyMutation(getManagedScalingPolicyRequest)
.build());
}
/**
*
* Fetches mapping details for the specified Amazon EMR Studio and identity (user or group).
*
*
* @param getStudioSessionMappingRequest
* @return A Java Future containing the result of the GetStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.GetStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture getStudioSessionMapping(
GetStudioSessionMappingRequest getStudioSessionMappingRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Fetches mapping details for the specified Amazon EMR Studio and identity (user or group).
*
*
*
* This is a convenience which creates an instance of the {@link GetStudioSessionMappingRequest.Builder} avoiding
* the need to create one manually via {@link GetStudioSessionMappingRequest#builder()}
*
*
* @param getStudioSessionMappingRequest
* A {@link Consumer} that will call methods on {@link GetStudioSessionMappingInput.Builder} to create a
* request.
* @return A Java Future containing the result of the GetStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.GetStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture getStudioSessionMapping(
Consumer getStudioSessionMappingRequest) {
return getStudioSessionMapping(GetStudioSessionMappingRequest.builder().applyMutation(getStudioSessionMappingRequest)
.build());
}
/**
*
* Provides information about the bootstrap actions associated with a cluster.
*
*
* @param listBootstrapActionsRequest
* This input determines which bootstrap actions to retrieve.
* @return A Java Future containing the result of the ListBootstrapActions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListBootstrapActions
* @see AWS API Documentation
*/
default CompletableFuture listBootstrapActions(
ListBootstrapActionsRequest listBootstrapActionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides information about the bootstrap actions associated with a cluster.
*
*
*
* This is a convenience which creates an instance of the {@link ListBootstrapActionsRequest.Builder} avoiding the
* need to create one manually via {@link ListBootstrapActionsRequest#builder()}
*
*
* @param listBootstrapActionsRequest
* A {@link Consumer} that will call methods on {@link ListBootstrapActionsInput.Builder} to create a
* request. This input determines which bootstrap actions to retrieve.
* @return A Java Future containing the result of the ListBootstrapActions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListBootstrapActions
* @see AWS API Documentation
*/
default CompletableFuture listBootstrapActions(
Consumer listBootstrapActionsRequest) {
return listBootstrapActions(ListBootstrapActionsRequest.builder().applyMutation(listBootstrapActionsRequest).build());
}
/**
*
* Provides information about the bootstrap actions associated with a cluster.
*
*
*
* This is a variant of
* {@link #listBootstrapActions(software.amazon.awssdk.services.emr.model.ListBootstrapActionsRequest)} 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.emr.paginators.ListBootstrapActionsPublisher publisher = client.listBootstrapActionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListBootstrapActionsPublisher publisher = client.listBootstrapActionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListBootstrapActionsResponse 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 null 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 #listBootstrapActions(software.amazon.awssdk.services.emr.model.ListBootstrapActionsRequest)}
* operation.
*
*
* @param listBootstrapActionsRequest
* This input determines which bootstrap actions to retrieve.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListBootstrapActions
* @see AWS API Documentation
*/
default ListBootstrapActionsPublisher listBootstrapActionsPaginator(ListBootstrapActionsRequest listBootstrapActionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides information about the bootstrap actions associated with a cluster.
*
*
*
* This is a variant of
* {@link #listBootstrapActions(software.amazon.awssdk.services.emr.model.ListBootstrapActionsRequest)} 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.emr.paginators.ListBootstrapActionsPublisher publisher = client.listBootstrapActionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListBootstrapActionsPublisher publisher = client.listBootstrapActionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListBootstrapActionsResponse 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 null 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 #listBootstrapActions(software.amazon.awssdk.services.emr.model.ListBootstrapActionsRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListBootstrapActionsRequest.Builder} avoiding the
* need to create one manually via {@link ListBootstrapActionsRequest#builder()}
*
*
* @param listBootstrapActionsRequest
* A {@link Consumer} that will call methods on {@link ListBootstrapActionsInput.Builder} to create a
* request. This input determines which bootstrap actions to retrieve.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListBootstrapActions
* @see AWS API Documentation
*/
default ListBootstrapActionsPublisher listBootstrapActionsPaginator(
Consumer listBootstrapActionsRequest) {
return listBootstrapActionsPaginator(ListBootstrapActionsRequest.builder().applyMutation(listBootstrapActionsRequest)
.build());
}
/**
*
* Provides the status of all clusters visible to this AWS account. Allows you to filter the list of clusters based
* on certain criteria; for example, filtering by cluster creation date and time or by status. This call returns a
* maximum of 50 clusters per call, but returns a marker to track the paging of the cluster list across multiple
* ListClusters calls.
*
*
* @param listClustersRequest
* This input determines how the ListClusters action filters the list of clusters that it returns.
* @return A Java Future containing the result of the ListClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListClusters
* @see AWS
* API Documentation
*/
default CompletableFuture listClusters(ListClustersRequest listClustersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides the status of all clusters visible to this AWS account. Allows you to filter the list of clusters based
* on certain criteria; for example, filtering by cluster creation date and time or by status. This call returns a
* maximum of 50 clusters per call, but returns a marker to track the paging of the cluster list across multiple
* ListClusters calls.
*
*
*
* This is a convenience which creates an instance of the {@link ListClustersRequest.Builder} avoiding the need to
* create one manually via {@link ListClustersRequest#builder()}
*
*
* @param listClustersRequest
* A {@link Consumer} that will call methods on {@link ListClustersInput.Builder} to create a request. This
* input determines how the ListClusters action filters the list of clusters that it returns.
* @return A Java Future containing the result of the ListClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListClusters
* @see AWS
* API Documentation
*/
default CompletableFuture listClusters(Consumer listClustersRequest) {
return listClusters(ListClustersRequest.builder().applyMutation(listClustersRequest).build());
}
/**
*
* Provides the status of all clusters visible to this AWS account. Allows you to filter the list of clusters based
* on certain criteria; for example, filtering by cluster creation date and time or by status. This call returns a
* maximum of 50 clusters per call, but returns a marker to track the paging of the cluster list across multiple
* ListClusters calls.
*
*
* @return A Java Future containing the result of the ListClusters operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListClusters
* @see AWS
* API Documentation
*/
default CompletableFuture listClusters() {
return listClusters(ListClustersRequest.builder().build());
}
/**
*
* Provides the status of all clusters visible to this AWS account. Allows you to filter the list of clusters based
* on certain criteria; for example, filtering by cluster creation date and time or by status. This call returns a
* maximum of 50 clusters per call, but returns a marker to track the paging of the cluster list across multiple
* ListClusters calls.
*
*
*
* This is a variant of {@link #listClusters(software.amazon.awssdk.services.emr.model.ListClustersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@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.emr.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of null 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 #listClusters(software.amazon.awssdk.services.emr.model.ListClustersRequest)} 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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListClusters
* @see AWS
* API Documentation
*/
default ListClustersPublisher listClustersPaginator() {
return listClustersPaginator(ListClustersRequest.builder().build());
}
/**
*
* Provides the status of all clusters visible to this AWS account. Allows you to filter the list of clusters based
* on certain criteria; for example, filtering by cluster creation date and time or by status. This call returns a
* maximum of 50 clusters per call, but returns a marker to track the paging of the cluster list across multiple
* ListClusters calls.
*
*
*
* This is a variant of {@link #listClusters(software.amazon.awssdk.services.emr.model.ListClustersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@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.emr.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of null 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 #listClusters(software.amazon.awssdk.services.emr.model.ListClustersRequest)} operation.
*
*
* @param listClustersRequest
* This input determines how the ListClusters action filters the list of clusters that it returns.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListClusters
* @see AWS
* API Documentation
*/
default ListClustersPublisher listClustersPaginator(ListClustersRequest listClustersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides the status of all clusters visible to this AWS account. Allows you to filter the list of clusters based
* on certain criteria; for example, filtering by cluster creation date and time or by status. This call returns a
* maximum of 50 clusters per call, but returns a marker to track the paging of the cluster list across multiple
* ListClusters calls.
*
*
*
* This is a variant of {@link #listClusters(software.amazon.awssdk.services.emr.model.ListClustersRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@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.emr.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListClustersPublisher publisher = client.listClustersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListClustersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of null 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 #listClusters(software.amazon.awssdk.services.emr.model.ListClustersRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListClustersRequest.Builder} avoiding the need to
* create one manually via {@link ListClustersRequest#builder()}
*
*
* @param listClustersRequest
* A {@link Consumer} that will call methods on {@link ListClustersInput.Builder} to create a request. This
* input determines how the ListClusters action filters the list of clusters that it returns.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListClusters
* @see AWS
* API Documentation
*/
default ListClustersPublisher listClustersPaginator(Consumer listClustersRequest) {
return listClustersPaginator(ListClustersRequest.builder().applyMutation(listClustersRequest).build());
}
/**
*
* Lists all available details about the instance fleets in a cluster.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions.
*
*
*
* @param listInstanceFleetsRequest
* @return A Java Future containing the result of the ListInstanceFleets operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceFleets
* @see AWS API Documentation
*/
default CompletableFuture listInstanceFleets(ListInstanceFleetsRequest listInstanceFleetsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists all available details about the instance fleets in a cluster.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions.
*
*
*
* This is a convenience which creates an instance of the {@link ListInstanceFleetsRequest.Builder} avoiding the
* need to create one manually via {@link ListInstanceFleetsRequest#builder()}
*
*
* @param listInstanceFleetsRequest
* A {@link Consumer} that will call methods on {@link ListInstanceFleetsInput.Builder} to create a request.
* @return A Java Future containing the result of the ListInstanceFleets operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceFleets
* @see AWS API Documentation
*/
default CompletableFuture listInstanceFleets(
Consumer listInstanceFleetsRequest) {
return listInstanceFleets(ListInstanceFleetsRequest.builder().applyMutation(listInstanceFleetsRequest).build());
}
/**
*
* Lists all available details about the instance fleets in a cluster.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions.
*
*
*
* This is a variant of
* {@link #listInstanceFleets(software.amazon.awssdk.services.emr.model.ListInstanceFleetsRequest)} 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.emr.paginators.ListInstanceFleetsPublisher publisher = client.listInstanceFleetsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListInstanceFleetsPublisher publisher = client.listInstanceFleetsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListInstanceFleetsResponse 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 null 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 #listInstanceFleets(software.amazon.awssdk.services.emr.model.ListInstanceFleetsRequest)} operation.
*
*
* @param listInstanceFleetsRequest
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceFleets
* @see AWS API Documentation
*/
default ListInstanceFleetsPublisher listInstanceFleetsPaginator(ListInstanceFleetsRequest listInstanceFleetsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists all available details about the instance fleets in a cluster.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions.
*
*
*
* This is a variant of
* {@link #listInstanceFleets(software.amazon.awssdk.services.emr.model.ListInstanceFleetsRequest)} 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.emr.paginators.ListInstanceFleetsPublisher publisher = client.listInstanceFleetsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListInstanceFleetsPublisher publisher = client.listInstanceFleetsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListInstanceFleetsResponse 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 null 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 #listInstanceFleets(software.amazon.awssdk.services.emr.model.ListInstanceFleetsRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListInstanceFleetsRequest.Builder} avoiding the
* need to create one manually via {@link ListInstanceFleetsRequest#builder()}
*
*
* @param listInstanceFleetsRequest
* A {@link Consumer} that will call methods on {@link ListInstanceFleetsInput.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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceFleets
* @see AWS API Documentation
*/
default ListInstanceFleetsPublisher listInstanceFleetsPaginator(
Consumer listInstanceFleetsRequest) {
return listInstanceFleetsPaginator(ListInstanceFleetsRequest.builder().applyMutation(listInstanceFleetsRequest).build());
}
/**
*
* Provides all available details about the instance groups in a cluster.
*
*
* @param listInstanceGroupsRequest
* This input determines which instance groups to retrieve.
* @return A Java Future containing the result of the ListInstanceGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceGroups
* @see AWS API Documentation
*/
default CompletableFuture listInstanceGroups(ListInstanceGroupsRequest listInstanceGroupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides all available details about the instance groups in a cluster.
*
*
*
* This is a convenience which creates an instance of the {@link ListInstanceGroupsRequest.Builder} avoiding the
* need to create one manually via {@link ListInstanceGroupsRequest#builder()}
*
*
* @param listInstanceGroupsRequest
* A {@link Consumer} that will call methods on {@link ListInstanceGroupsInput.Builder} to create a request.
* This input determines which instance groups to retrieve.
* @return A Java Future containing the result of the ListInstanceGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceGroups
* @see AWS API Documentation
*/
default CompletableFuture listInstanceGroups(
Consumer listInstanceGroupsRequest) {
return listInstanceGroups(ListInstanceGroupsRequest.builder().applyMutation(listInstanceGroupsRequest).build());
}
/**
*
* Provides all available details about the instance groups in a cluster.
*
*
*
* This is a variant of
* {@link #listInstanceGroups(software.amazon.awssdk.services.emr.model.ListInstanceGroupsRequest)} 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.emr.paginators.ListInstanceGroupsPublisher publisher = client.listInstanceGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListInstanceGroupsPublisher publisher = client.listInstanceGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListInstanceGroupsResponse 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 null 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 #listInstanceGroups(software.amazon.awssdk.services.emr.model.ListInstanceGroupsRequest)} operation.
*
*
* @param listInstanceGroupsRequest
* This input determines which instance groups to retrieve.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceGroups
* @see AWS API Documentation
*/
default ListInstanceGroupsPublisher listInstanceGroupsPaginator(ListInstanceGroupsRequest listInstanceGroupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides all available details about the instance groups in a cluster.
*
*
*
* This is a variant of
* {@link #listInstanceGroups(software.amazon.awssdk.services.emr.model.ListInstanceGroupsRequest)} 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.emr.paginators.ListInstanceGroupsPublisher publisher = client.listInstanceGroupsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListInstanceGroupsPublisher publisher = client.listInstanceGroupsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListInstanceGroupsResponse 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 null 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 #listInstanceGroups(software.amazon.awssdk.services.emr.model.ListInstanceGroupsRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListInstanceGroupsRequest.Builder} avoiding the
* need to create one manually via {@link ListInstanceGroupsRequest#builder()}
*
*
* @param listInstanceGroupsRequest
* A {@link Consumer} that will call methods on {@link ListInstanceGroupsInput.Builder} to create a request.
* This input determines which instance groups to retrieve.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstanceGroups
* @see AWS API Documentation
*/
default ListInstanceGroupsPublisher listInstanceGroupsPaginator(
Consumer listInstanceGroupsRequest) {
return listInstanceGroupsPaginator(ListInstanceGroupsRequest.builder().applyMutation(listInstanceGroupsRequest).build());
}
/**
*
* Provides information for all active EC2 instances and EC2 instances terminated in the last 30 days, up to a
* maximum of 2,000. EC2 instances in any of the following states are considered active: AWAITING_FULFILLMENT,
* PROVISIONING, BOOTSTRAPPING, RUNNING.
*
*
* @param listInstancesRequest
* This input determines which instances to list.
* @return A Java Future containing the result of the ListInstances operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstances
* @see AWS API Documentation
*/
default CompletableFuture listInstances(ListInstancesRequest listInstancesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides information for all active EC2 instances and EC2 instances terminated in the last 30 days, up to a
* maximum of 2,000. EC2 instances in any of the following states are considered active: AWAITING_FULFILLMENT,
* PROVISIONING, BOOTSTRAPPING, RUNNING.
*
*
*
* This is a convenience which creates an instance of the {@link ListInstancesRequest.Builder} avoiding the need to
* create one manually via {@link ListInstancesRequest#builder()}
*
*
* @param listInstancesRequest
* A {@link Consumer} that will call methods on {@link ListInstancesInput.Builder} to create a request. This
* input determines which instances to list.
* @return A Java Future containing the result of the ListInstances operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstances
* @see AWS API Documentation
*/
default CompletableFuture listInstances(Consumer listInstancesRequest) {
return listInstances(ListInstancesRequest.builder().applyMutation(listInstancesRequest).build());
}
/**
*
* Provides information for all active EC2 instances and EC2 instances terminated in the last 30 days, up to a
* maximum of 2,000. EC2 instances in any of the following states are considered active: AWAITING_FULFILLMENT,
* PROVISIONING, BOOTSTRAPPING, RUNNING.
*
*
*
* This is a variant of {@link #listInstances(software.amazon.awssdk.services.emr.model.ListInstancesRequest)}
* 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.emr.paginators.ListInstancesPublisher publisher = client.listInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListInstancesPublisher publisher = client.listInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListInstancesResponse 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 null 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 #listInstances(software.amazon.awssdk.services.emr.model.ListInstancesRequest)} operation.
*
*
* @param listInstancesRequest
* This input determines which instances to list.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstances
* @see AWS API Documentation
*/
default ListInstancesPublisher listInstancesPaginator(ListInstancesRequest listInstancesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides information for all active EC2 instances and EC2 instances terminated in the last 30 days, up to a
* maximum of 2,000. EC2 instances in any of the following states are considered active: AWAITING_FULFILLMENT,
* PROVISIONING, BOOTSTRAPPING, RUNNING.
*
*
*
* This is a variant of {@link #listInstances(software.amazon.awssdk.services.emr.model.ListInstancesRequest)}
* 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.emr.paginators.ListInstancesPublisher publisher = client.listInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListInstancesPublisher publisher = client.listInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListInstancesResponse 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 null 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 #listInstances(software.amazon.awssdk.services.emr.model.ListInstancesRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListInstancesRequest.Builder} avoiding the need to
* create one manually via {@link ListInstancesRequest#builder()}
*
*
* @param listInstancesRequest
* A {@link Consumer} that will call methods on {@link ListInstancesInput.Builder} to create a request. This
* input determines which instances to list.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListInstances
* @see AWS API Documentation
*/
default ListInstancesPublisher listInstancesPaginator(Consumer listInstancesRequest) {
return listInstancesPaginator(ListInstancesRequest.builder().applyMutation(listInstancesRequest).build());
}
/**
*
* Provides summaries of all notebook executions. You can filter the list based on multiple criteria such as status,
* time range, and editor id. Returns a maximum of 50 notebook executions and a marker to track the paging of a
* longer notebook execution list across multiple ListNotebookExecution calls.
*
*
* @param listNotebookExecutionsRequest
* @return A Java Future containing the result of the ListNotebookExecutions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListNotebookExecutions
* @see AWS API Documentation
*/
default CompletableFuture listNotebookExecutions(
ListNotebookExecutionsRequest listNotebookExecutionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides summaries of all notebook executions. You can filter the list based on multiple criteria such as status,
* time range, and editor id. Returns a maximum of 50 notebook executions and a marker to track the paging of a
* longer notebook execution list across multiple ListNotebookExecution calls.
*
*
*
* This is a convenience which creates an instance of the {@link ListNotebookExecutionsRequest.Builder} avoiding the
* need to create one manually via {@link ListNotebookExecutionsRequest#builder()}
*
*
* @param listNotebookExecutionsRequest
* A {@link Consumer} that will call methods on {@link ListNotebookExecutionsInput.Builder} to create a
* request.
* @return A Java Future containing the result of the ListNotebookExecutions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListNotebookExecutions
* @see AWS API Documentation
*/
default CompletableFuture listNotebookExecutions(
Consumer listNotebookExecutionsRequest) {
return listNotebookExecutions(ListNotebookExecutionsRequest.builder().applyMutation(listNotebookExecutionsRequest)
.build());
}
/**
*
* Provides summaries of all notebook executions. You can filter the list based on multiple criteria such as status,
* time range, and editor id. Returns a maximum of 50 notebook executions and a marker to track the paging of a
* longer notebook execution list across multiple ListNotebookExecution calls.
*
*
*
* This is a variant of
* {@link #listNotebookExecutions(software.amazon.awssdk.services.emr.model.ListNotebookExecutionsRequest)}
* 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.emr.paginators.ListNotebookExecutionsPublisher publisher = client.listNotebookExecutionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListNotebookExecutionsPublisher publisher = client.listNotebookExecutionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListNotebookExecutionsResponse 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 null 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 #listNotebookExecutions(software.amazon.awssdk.services.emr.model.ListNotebookExecutionsRequest)}
* operation.
*
*
* @param listNotebookExecutionsRequest
* @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.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListNotebookExecutions
* @see AWS API Documentation
*/
default ListNotebookExecutionsPublisher listNotebookExecutionsPaginator(
ListNotebookExecutionsRequest listNotebookExecutionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides summaries of all notebook executions. You can filter the list based on multiple criteria such as status,
* time range, and editor id. Returns a maximum of 50 notebook executions and a marker to track the paging of a
* longer notebook execution list across multiple ListNotebookExecution calls.
*
*
*
* This is a variant of
* {@link #listNotebookExecutions(software.amazon.awssdk.services.emr.model.ListNotebookExecutionsRequest)}
* 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.emr.paginators.ListNotebookExecutionsPublisher publisher = client.listNotebookExecutionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListNotebookExecutionsPublisher publisher = client.listNotebookExecutionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListNotebookExecutionsResponse 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 null 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 #listNotebookExecutions(software.amazon.awssdk.services.emr.model.ListNotebookExecutionsRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListNotebookExecutionsRequest.Builder} avoiding the
* need to create one manually via {@link ListNotebookExecutionsRequest#builder()}
*
*
* @param listNotebookExecutionsRequest
* A {@link Consumer} that will call methods on {@link ListNotebookExecutionsInput.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.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListNotebookExecutions
* @see AWS API Documentation
*/
default ListNotebookExecutionsPublisher listNotebookExecutionsPaginator(
Consumer listNotebookExecutionsRequest) {
return listNotebookExecutionsPaginator(ListNotebookExecutionsRequest.builder()
.applyMutation(listNotebookExecutionsRequest).build());
}
/**
*
* Lists all the security configurations visible to this account, providing their creation dates and times, and
* their names. This call returns a maximum of 50 clusters per call, but returns a marker to track the paging of the
* cluster list across multiple ListSecurityConfigurations calls.
*
*
* @param listSecurityConfigurationsRequest
* @return A Java Future containing the result of the ListSecurityConfigurations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSecurityConfigurations
* @see AWS API Documentation
*/
default CompletableFuture listSecurityConfigurations(
ListSecurityConfigurationsRequest listSecurityConfigurationsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists all the security configurations visible to this account, providing their creation dates and times, and
* their names. This call returns a maximum of 50 clusters per call, but returns a marker to track the paging of the
* cluster list across multiple ListSecurityConfigurations calls.
*
*
*
* This is a convenience which creates an instance of the {@link ListSecurityConfigurationsRequest.Builder} avoiding
* the need to create one manually via {@link ListSecurityConfigurationsRequest#builder()}
*
*
* @param listSecurityConfigurationsRequest
* A {@link Consumer} that will call methods on {@link ListSecurityConfigurationsInput.Builder} to create a
* request.
* @return A Java Future containing the result of the ListSecurityConfigurations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSecurityConfigurations
* @see AWS API Documentation
*/
default CompletableFuture listSecurityConfigurations(
Consumer listSecurityConfigurationsRequest) {
return listSecurityConfigurations(ListSecurityConfigurationsRequest.builder()
.applyMutation(listSecurityConfigurationsRequest).build());
}
/**
*
* Lists all the security configurations visible to this account, providing their creation dates and times, and
* their names. This call returns a maximum of 50 clusters per call, but returns a marker to track the paging of the
* cluster list across multiple ListSecurityConfigurations calls.
*
*
* @return A Java Future containing the result of the ListSecurityConfigurations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSecurityConfigurations
* @see AWS API Documentation
*/
default CompletableFuture listSecurityConfigurations() {
return listSecurityConfigurations(ListSecurityConfigurationsRequest.builder().build());
}
/**
*
* Lists all the security configurations visible to this account, providing their creation dates and times, and
* their names. This call returns a maximum of 50 clusters per call, but returns a marker to track the paging of the
* cluster list across multiple ListSecurityConfigurations calls.
*
*
*
* This is a variant of
* {@link #listSecurityConfigurations(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsRequest)}
* 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.emr.paginators.ListSecurityConfigurationsPublisher publisher = client.listSecurityConfigurationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListSecurityConfigurationsPublisher publisher = client.listSecurityConfigurationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsResponse 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 null 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 #listSecurityConfigurations(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsRequest)}
* 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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSecurityConfigurations
* @see AWS API Documentation
*/
default ListSecurityConfigurationsPublisher listSecurityConfigurationsPaginator() {
return listSecurityConfigurationsPaginator(ListSecurityConfigurationsRequest.builder().build());
}
/**
*
* Lists all the security configurations visible to this account, providing their creation dates and times, and
* their names. This call returns a maximum of 50 clusters per call, but returns a marker to track the paging of the
* cluster list across multiple ListSecurityConfigurations calls.
*
*
*
* This is a variant of
* {@link #listSecurityConfigurations(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsRequest)}
* 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.emr.paginators.ListSecurityConfigurationsPublisher publisher = client.listSecurityConfigurationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListSecurityConfigurationsPublisher publisher = client.listSecurityConfigurationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsResponse 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 null 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 #listSecurityConfigurations(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsRequest)}
* operation.
*
*
* @param listSecurityConfigurationsRequest
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSecurityConfigurations
* @see AWS API Documentation
*/
default ListSecurityConfigurationsPublisher listSecurityConfigurationsPaginator(
ListSecurityConfigurationsRequest listSecurityConfigurationsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists all the security configurations visible to this account, providing their creation dates and times, and
* their names. This call returns a maximum of 50 clusters per call, but returns a marker to track the paging of the
* cluster list across multiple ListSecurityConfigurations calls.
*
*
*
* This is a variant of
* {@link #listSecurityConfigurations(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsRequest)}
* 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.emr.paginators.ListSecurityConfigurationsPublisher publisher = client.listSecurityConfigurationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListSecurityConfigurationsPublisher publisher = client.listSecurityConfigurationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsResponse 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 null 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 #listSecurityConfigurations(software.amazon.awssdk.services.emr.model.ListSecurityConfigurationsRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListSecurityConfigurationsRequest.Builder} avoiding
* the need to create one manually via {@link ListSecurityConfigurationsRequest#builder()}
*
*
* @param listSecurityConfigurationsRequest
* A {@link Consumer} that will call methods on {@link ListSecurityConfigurationsInput.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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSecurityConfigurations
* @see AWS API Documentation
*/
default ListSecurityConfigurationsPublisher listSecurityConfigurationsPaginator(
Consumer listSecurityConfigurationsRequest) {
return listSecurityConfigurationsPaginator(ListSecurityConfigurationsRequest.builder()
.applyMutation(listSecurityConfigurationsRequest).build());
}
/**
*
* Provides a list of steps for the cluster in reverse order unless you specify stepIds with the
* request of filter by StepStates. You can specify a maximum of 10 stepIDs.
*
*
* @param listStepsRequest
* This input determines which steps to list.
* @return A Java Future containing the result of the ListSteps operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSteps
* @see AWS
* API Documentation
*/
default CompletableFuture listSteps(ListStepsRequest listStepsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides a list of steps for the cluster in reverse order unless you specify stepIds with the
* request of filter by StepStates. You can specify a maximum of 10 stepIDs.
*
*
*
* This is a convenience which creates an instance of the {@link ListStepsRequest.Builder} avoiding the need to
* create one manually via {@link ListStepsRequest#builder()}
*
*
* @param listStepsRequest
* A {@link Consumer} that will call methods on {@link ListStepsInput.Builder} to create a request. This
* input determines which steps to list.
* @return A Java Future containing the result of the ListSteps operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSteps
* @see AWS
* API Documentation
*/
default CompletableFuture listSteps(Consumer listStepsRequest) {
return listSteps(ListStepsRequest.builder().applyMutation(listStepsRequest).build());
}
/**
*
* Provides a list of steps for the cluster in reverse order unless you specify stepIds with the
* request of filter by StepStates. You can specify a maximum of 10 stepIDs.
*
*
*
* This is a variant of {@link #listSteps(software.amazon.awssdk.services.emr.model.ListStepsRequest)} 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.emr.paginators.ListStepsPublisher publisher = client.listStepsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListStepsPublisher publisher = client.listStepsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListStepsResponse 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 null 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 #listSteps(software.amazon.awssdk.services.emr.model.ListStepsRequest)} operation.
*
*
* @param listStepsRequest
* This input determines which steps to list.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSteps
* @see AWS
* API Documentation
*/
default ListStepsPublisher listStepsPaginator(ListStepsRequest listStepsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Provides a list of steps for the cluster in reverse order unless you specify stepIds with the
* request of filter by StepStates. You can specify a maximum of 10 stepIDs.
*
*
*
* This is a variant of {@link #listSteps(software.amazon.awssdk.services.emr.model.ListStepsRequest)} 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.emr.paginators.ListStepsPublisher publisher = client.listStepsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListStepsPublisher publisher = client.listStepsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListStepsResponse 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 null 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 #listSteps(software.amazon.awssdk.services.emr.model.ListStepsRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListStepsRequest.Builder} avoiding the need to
* create one manually via {@link ListStepsRequest#builder()}
*
*
* @param listStepsRequest
* A {@link Consumer} that will call methods on {@link ListStepsInput.Builder} to create a request. This
* input determines which steps to list.
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListSteps
* @see AWS
* API Documentation
*/
default ListStepsPublisher listStepsPaginator(Consumer listStepsRequest) {
return listStepsPaginator(ListStepsRequest.builder().applyMutation(listStepsRequest).build());
}
/**
*
* Returns a list of all user or group session mappings for the Amazon EMR Studio specified by StudioId
* .
*
*
* @param listStudioSessionMappingsRequest
* @return A Java Future containing the result of the ListStudioSessionMappings operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudioSessionMappings
* @see AWS API Documentation
*/
default CompletableFuture listStudioSessionMappings(
ListStudioSessionMappingsRequest listStudioSessionMappingsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of all user or group session mappings for the Amazon EMR Studio specified by StudioId
* .
*
*
*
* This is a convenience which creates an instance of the {@link ListStudioSessionMappingsRequest.Builder} avoiding
* the need to create one manually via {@link ListStudioSessionMappingsRequest#builder()}
*
*
* @param listStudioSessionMappingsRequest
* A {@link Consumer} that will call methods on {@link ListStudioSessionMappingsInput.Builder} to create a
* request.
* @return A Java Future containing the result of the ListStudioSessionMappings operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudioSessionMappings
* @see AWS API Documentation
*/
default CompletableFuture listStudioSessionMappings(
Consumer listStudioSessionMappingsRequest) {
return listStudioSessionMappings(ListStudioSessionMappingsRequest.builder()
.applyMutation(listStudioSessionMappingsRequest).build());
}
/**
*
* Returns a list of all user or group session mappings for the Amazon EMR Studio specified by StudioId
* .
*
*
*
* This is a variant of
* {@link #listStudioSessionMappings(software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsRequest)}
* 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.emr.paginators.ListStudioSessionMappingsPublisher publisher = client.listStudioSessionMappingsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListStudioSessionMappingsPublisher publisher = client.listStudioSessionMappingsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsResponse 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 null 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 #listStudioSessionMappings(software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsRequest)}
* operation.
*
*
* @param listStudioSessionMappingsRequest
* @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.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudioSessionMappings
* @see AWS API Documentation
*/
default ListStudioSessionMappingsPublisher listStudioSessionMappingsPaginator(
ListStudioSessionMappingsRequest listStudioSessionMappingsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of all user or group session mappings for the Amazon EMR Studio specified by StudioId
* .
*
*
*
* This is a variant of
* {@link #listStudioSessionMappings(software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsRequest)}
* 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.emr.paginators.ListStudioSessionMappingsPublisher publisher = client.listStudioSessionMappingsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListStudioSessionMappingsPublisher publisher = client.listStudioSessionMappingsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsResponse 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 null 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 #listStudioSessionMappings(software.amazon.awssdk.services.emr.model.ListStudioSessionMappingsRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListStudioSessionMappingsRequest.Builder} avoiding
* the need to create one manually via {@link ListStudioSessionMappingsRequest#builder()}
*
*
* @param listStudioSessionMappingsRequest
* A {@link Consumer} that will call methods on {@link ListStudioSessionMappingsInput.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.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudioSessionMappings
* @see AWS API Documentation
*/
default ListStudioSessionMappingsPublisher listStudioSessionMappingsPaginator(
Consumer listStudioSessionMappingsRequest) {
return listStudioSessionMappingsPaginator(ListStudioSessionMappingsRequest.builder()
.applyMutation(listStudioSessionMappingsRequest).build());
}
/**
*
* Returns a list of all Amazon EMR Studios associated with the AWS account. The list includes details such as ID,
* Studio Access URL, and creation time for each Studio.
*
*
* @param listStudiosRequest
* @return A Java Future containing the result of the ListStudios operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudios
* @see AWS
* API Documentation
*/
default CompletableFuture listStudios(ListStudiosRequest listStudiosRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of all Amazon EMR Studios associated with the AWS account. The list includes details such as ID,
* Studio Access URL, and creation time for each Studio.
*
*
*
* This is a convenience which creates an instance of the {@link ListStudiosRequest.Builder} avoiding the need to
* create one manually via {@link ListStudiosRequest#builder()}
*
*
* @param listStudiosRequest
* A {@link Consumer} that will call methods on {@link ListStudiosInput.Builder} to create a request.
* @return A Java Future containing the result of the ListStudios operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudios
* @see AWS
* API Documentation
*/
default CompletableFuture listStudios(Consumer listStudiosRequest) {
return listStudios(ListStudiosRequest.builder().applyMutation(listStudiosRequest).build());
}
/**
*
* Returns a list of all Amazon EMR Studios associated with the AWS account. The list includes details such as ID,
* Studio Access URL, and creation time for each Studio.
*
*
*
* This is a variant of {@link #listStudios(software.amazon.awssdk.services.emr.model.ListStudiosRequest)}
* 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.emr.paginators.ListStudiosPublisher publisher = client.listStudiosPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListStudiosPublisher publisher = client.listStudiosPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListStudiosResponse 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 null 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 #listStudios(software.amazon.awssdk.services.emr.model.ListStudiosRequest)} operation.
*
*
* @param listStudiosRequest
* @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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudios
* @see AWS
* API Documentation
*/
default ListStudiosPublisher listStudiosPaginator(ListStudiosRequest listStudiosRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of all Amazon EMR Studios associated with the AWS account. The list includes details such as ID,
* Studio Access URL, and creation time for each Studio.
*
*
*
* This is a variant of {@link #listStudios(software.amazon.awssdk.services.emr.model.ListStudiosRequest)}
* 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.emr.paginators.ListStudiosPublisher publisher = client.listStudiosPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.emr.paginators.ListStudiosPublisher publisher = client.listStudiosPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.emr.model.ListStudiosResponse 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 null 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 #listStudios(software.amazon.awssdk.services.emr.model.ListStudiosRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListStudiosRequest.Builder} avoiding the need to
* create one manually via {@link ListStudiosRequest#builder()}
*
*
* @param listStudiosRequest
* A {@link Consumer} that will call methods on {@link ListStudiosInput.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.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ListStudios
* @see AWS
* API Documentation
*/
default ListStudiosPublisher listStudiosPaginator(Consumer listStudiosRequest) {
return listStudiosPaginator(ListStudiosRequest.builder().applyMutation(listStudiosRequest).build());
}
/**
*
* Modifies the number of steps that can be executed concurrently for the cluster specified using ClusterID.
*
*
* @param modifyClusterRequest
* @return A Java Future containing the result of the ModifyCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ModifyCluster
* @see AWS API Documentation
*/
default CompletableFuture modifyCluster(ModifyClusterRequest modifyClusterRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Modifies the number of steps that can be executed concurrently for the cluster specified using ClusterID.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyClusterRequest.Builder} avoiding the need to
* create one manually via {@link ModifyClusterRequest#builder()}
*
*
* @param modifyClusterRequest
* A {@link Consumer} that will call methods on {@link ModifyClusterInput.Builder} to create a request.
* @return A Java Future containing the result of the ModifyCluster operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ModifyCluster
* @see AWS API Documentation
*/
default CompletableFuture modifyCluster(Consumer modifyClusterRequest) {
return modifyCluster(ModifyClusterRequest.builder().applyMutation(modifyClusterRequest).build());
}
/**
*
* Modifies the target On-Demand and target Spot capacities for the instance fleet with the specified
* InstanceFleetID within the cluster specified using ClusterID. The call either succeeds or fails atomically.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions.
*
*
*
* @param modifyInstanceFleetRequest
* @return A Java Future containing the result of the ModifyInstanceFleet operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ModifyInstanceFleet
* @see AWS API Documentation
*/
default CompletableFuture modifyInstanceFleet(
ModifyInstanceFleetRequest modifyInstanceFleetRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Modifies the target On-Demand and target Spot capacities for the instance fleet with the specified
* InstanceFleetID within the cluster specified using ClusterID. The call either succeeds or fails atomically.
*
*
*
* The instance fleet configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyInstanceFleetRequest.Builder} avoiding the
* need to create one manually via {@link ModifyInstanceFleetRequest#builder()}
*
*
* @param modifyInstanceFleetRequest
* A {@link Consumer} that will call methods on {@link ModifyInstanceFleetInput.Builder} to create a request.
* @return A Java Future containing the result of the ModifyInstanceFleet operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ModifyInstanceFleet
* @see AWS API Documentation
*/
default CompletableFuture modifyInstanceFleet(
Consumer modifyInstanceFleetRequest) {
return modifyInstanceFleet(ModifyInstanceFleetRequest.builder().applyMutation(modifyInstanceFleetRequest).build());
}
/**
*
* ModifyInstanceGroups modifies the number of nodes and configuration settings of an instance group. The input
* parameters include the new target instance count for the group and the instance group ID. The call will either
* succeed or fail atomically.
*
*
* @param modifyInstanceGroupsRequest
* Change the size of some instance groups.
* @return A Java Future containing the result of the ModifyInstanceGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ModifyInstanceGroups
* @see AWS API Documentation
*/
default CompletableFuture modifyInstanceGroups(
ModifyInstanceGroupsRequest modifyInstanceGroupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* ModifyInstanceGroups modifies the number of nodes and configuration settings of an instance group. The input
* parameters include the new target instance count for the group and the instance group ID. The call will either
* succeed or fail atomically.
*
*
*
* This is a convenience which creates an instance of the {@link ModifyInstanceGroupsRequest.Builder} avoiding the
* need to create one manually via {@link ModifyInstanceGroupsRequest#builder()}
*
*
* @param modifyInstanceGroupsRequest
* A {@link Consumer} that will call methods on {@link ModifyInstanceGroupsInput.Builder} to create a
* request. Change the size of some instance groups.
* @return A Java Future containing the result of the ModifyInstanceGroups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.ModifyInstanceGroups
* @see AWS API Documentation
*/
default CompletableFuture modifyInstanceGroups(
Consumer modifyInstanceGroupsRequest) {
return modifyInstanceGroups(ModifyInstanceGroupsRequest.builder().applyMutation(modifyInstanceGroupsRequest).build());
}
/**
*
* Creates or updates an automatic scaling policy for a core instance group or task instance group in an Amazon EMR
* cluster. The automatic scaling policy defines how an instance group dynamically adds and terminates EC2 instances
* in response to the value of a CloudWatch metric.
*
*
* @param putAutoScalingPolicyRequest
* @return A Java Future containing the result of the PutAutoScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.PutAutoScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture putAutoScalingPolicy(
PutAutoScalingPolicyRequest putAutoScalingPolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates or updates an automatic scaling policy for a core instance group or task instance group in an Amazon EMR
* cluster. The automatic scaling policy defines how an instance group dynamically adds and terminates EC2 instances
* in response to the value of a CloudWatch metric.
*
*
*
* This is a convenience which creates an instance of the {@link PutAutoScalingPolicyRequest.Builder} avoiding the
* need to create one manually via {@link PutAutoScalingPolicyRequest#builder()}
*
*
* @param putAutoScalingPolicyRequest
* A {@link Consumer} that will call methods on {@link PutAutoScalingPolicyInput.Builder} to create a
* request.
* @return A Java Future containing the result of the PutAutoScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.PutAutoScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture putAutoScalingPolicy(
Consumer putAutoScalingPolicyRequest) {
return putAutoScalingPolicy(PutAutoScalingPolicyRequest.builder().applyMutation(putAutoScalingPolicyRequest).build());
}
/**
*
* Creates or updates an Amazon EMR block public access configuration for your AWS account in the current Region.
* For more information see Configure Block
* Public Access for Amazon EMR in the Amazon EMR Management Guide.
*
*
* @param putBlockPublicAccessConfigurationRequest
* @return A Java Future containing the result of the PutBlockPublicAccessConfiguration operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.PutBlockPublicAccessConfiguration
* @see AWS API Documentation
*/
default CompletableFuture putBlockPublicAccessConfiguration(
PutBlockPublicAccessConfigurationRequest putBlockPublicAccessConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates or updates an Amazon EMR block public access configuration for your AWS account in the current Region.
* For more information see Configure Block
* Public Access for Amazon EMR in the Amazon EMR Management Guide.
*
*
*
* This is a convenience which creates an instance of the {@link PutBlockPublicAccessConfigurationRequest.Builder}
* avoiding the need to create one manually via {@link PutBlockPublicAccessConfigurationRequest#builder()}
*
*
* @param putBlockPublicAccessConfigurationRequest
* A {@link Consumer} that will call methods on {@link PutBlockPublicAccessConfigurationInput.Builder} to
* create a request.
* @return A Java Future containing the result of the PutBlockPublicAccessConfiguration operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.PutBlockPublicAccessConfiguration
* @see AWS API Documentation
*/
default CompletableFuture putBlockPublicAccessConfiguration(
Consumer putBlockPublicAccessConfigurationRequest) {
return putBlockPublicAccessConfiguration(PutBlockPublicAccessConfigurationRequest.builder()
.applyMutation(putBlockPublicAccessConfigurationRequest).build());
}
/**
*
* Creates or updates a managed scaling policy for an Amazon EMR cluster. The managed scaling policy defines the
* limits for resources, such as EC2 instances that can be added or terminated from a cluster. The policy only
* applies to the core and task nodes. The master node cannot be scaled after initial configuration.
*
*
* @param putManagedScalingPolicyRequest
* @return A Java Future containing the result of the PutManagedScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.PutManagedScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture putManagedScalingPolicy(
PutManagedScalingPolicyRequest putManagedScalingPolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates or updates a managed scaling policy for an Amazon EMR cluster. The managed scaling policy defines the
* limits for resources, such as EC2 instances that can be added or terminated from a cluster. The policy only
* applies to the core and task nodes. The master node cannot be scaled after initial configuration.
*
*
*
* This is a convenience which creates an instance of the {@link PutManagedScalingPolicyRequest.Builder} avoiding
* the need to create one manually via {@link PutManagedScalingPolicyRequest#builder()}
*
*
* @param putManagedScalingPolicyRequest
* A {@link Consumer} that will call methods on {@link PutManagedScalingPolicyInput.Builder} to create a
* request.
* @return A Java Future containing the result of the PutManagedScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.PutManagedScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture putManagedScalingPolicy(
Consumer putManagedScalingPolicyRequest) {
return putManagedScalingPolicy(PutManagedScalingPolicyRequest.builder().applyMutation(putManagedScalingPolicyRequest)
.build());
}
/**
*
* Removes an automatic scaling policy from a specified instance group within an EMR cluster.
*
*
* @param removeAutoScalingPolicyRequest
* @return A Java Future containing the result of the RemoveAutoScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RemoveAutoScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture removeAutoScalingPolicy(
RemoveAutoScalingPolicyRequest removeAutoScalingPolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes an automatic scaling policy from a specified instance group within an EMR cluster.
*
*
*
* This is a convenience which creates an instance of the {@link RemoveAutoScalingPolicyRequest.Builder} avoiding
* the need to create one manually via {@link RemoveAutoScalingPolicyRequest#builder()}
*
*
* @param removeAutoScalingPolicyRequest
* A {@link Consumer} that will call methods on {@link RemoveAutoScalingPolicyInput.Builder} to create a
* request.
* @return A Java Future containing the result of the RemoveAutoScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RemoveAutoScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture removeAutoScalingPolicy(
Consumer removeAutoScalingPolicyRequest) {
return removeAutoScalingPolicy(RemoveAutoScalingPolicyRequest.builder().applyMutation(removeAutoScalingPolicyRequest)
.build());
}
/**
*
* Removes a managed scaling policy from a specified EMR cluster.
*
*
* @param removeManagedScalingPolicyRequest
* @return A Java Future containing the result of the RemoveManagedScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RemoveManagedScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture removeManagedScalingPolicy(
RemoveManagedScalingPolicyRequest removeManagedScalingPolicyRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes a managed scaling policy from a specified EMR cluster.
*
*
*
* This is a convenience which creates an instance of the {@link RemoveManagedScalingPolicyRequest.Builder} avoiding
* the need to create one manually via {@link RemoveManagedScalingPolicyRequest#builder()}
*
*
* @param removeManagedScalingPolicyRequest
* A {@link Consumer} that will call methods on {@link RemoveManagedScalingPolicyInput.Builder} to create a
* request.
* @return A Java Future containing the result of the RemoveManagedScalingPolicy operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RemoveManagedScalingPolicy
* @see AWS API Documentation
*/
default CompletableFuture removeManagedScalingPolicy(
Consumer removeManagedScalingPolicyRequest) {
return removeManagedScalingPolicy(RemoveManagedScalingPolicyRequest.builder()
.applyMutation(removeManagedScalingPolicyRequest).build());
}
/**
*
* Removes tags from an Amazon EMR resource. Tags make it easier to associate clusters in various ways, such as
* grouping clusters to track your Amazon EMR resource allocation costs. For more information, see Tag Clusters.
*
*
* The following example removes the stack tag with value Prod from a cluster:
*
*
* @param removeTagsRequest
* This input identifies a cluster and a list of tags to remove.
* @return A Java Future containing the result of the RemoveTags operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RemoveTags
* @see AWS
* API Documentation
*/
default CompletableFuture removeTags(RemoveTagsRequest removeTagsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes tags from an Amazon EMR resource. Tags make it easier to associate clusters in various ways, such as
* grouping clusters to track your Amazon EMR resource allocation costs. For more information, see Tag Clusters.
*
*
* The following example removes the stack tag with value Prod from a cluster:
*
*
*
* This is a convenience which creates an instance of the {@link RemoveTagsRequest.Builder} avoiding the need to
* create one manually via {@link RemoveTagsRequest#builder()}
*
*
* @param removeTagsRequest
* A {@link Consumer} that will call methods on {@link RemoveTagsInput.Builder} to create a request. This
* input identifies a cluster and a list of tags to remove.
* @return A Java Future containing the result of the RemoveTags operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RemoveTags
* @see AWS
* API Documentation
*/
default CompletableFuture removeTags(Consumer removeTagsRequest) {
return removeTags(RemoveTagsRequest.builder().applyMutation(removeTagsRequest).build());
}
/**
*
* RunJobFlow creates and starts running a new cluster (job flow). The cluster runs the steps specified. After the
* steps complete, the cluster stops and the HDFS partition is lost. To prevent loss of data, configure the last
* step of the job flow to store results in Amazon S3. If the JobFlowInstancesConfig
* KeepJobFlowAliveWhenNoSteps parameter is set to TRUE, the cluster transitions to the
* WAITING state rather than shutting down after the steps have completed.
*
*
* For additional protection, you can set the JobFlowInstancesConfig TerminationProtected
* parameter to TRUE to lock the cluster and prevent it from being terminated by API call, user
* intervention, or in the event of a job flow error.
*
*
* A maximum of 256 steps are allowed in each job flow.
*
*
* If your cluster is long-running (such as a Hive data warehouse) or complex, you may require more than 256 steps
* to process your data. You can bypass the 256-step limitation in various ways, including using the SSH shell to
* connect to the master node and submitting queries directly to the software running on the master node, such as
* Hive and Hadoop. For more information on how to do this, see Add More than 256 Steps to
* a Cluster in the Amazon EMR Management Guide.
*
*
* For long running clusters, we recommend that you periodically store your results.
*
*
*
* The instance fleets configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions. The RunJobFlow request can contain InstanceFleets parameters or InstanceGroups parameters, but not
* both.
*
*
*
* @param runJobFlowRequest
* Input to the RunJobFlow operation.
* @return A Java Future containing the result of the RunJobFlow operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RunJobFlow
* @see AWS
* API Documentation
*/
default CompletableFuture runJobFlow(RunJobFlowRequest runJobFlowRequest) {
throw new UnsupportedOperationException();
}
/**
*
* RunJobFlow creates and starts running a new cluster (job flow). The cluster runs the steps specified. After the
* steps complete, the cluster stops and the HDFS partition is lost. To prevent loss of data, configure the last
* step of the job flow to store results in Amazon S3. If the JobFlowInstancesConfig
* KeepJobFlowAliveWhenNoSteps parameter is set to TRUE, the cluster transitions to the
* WAITING state rather than shutting down after the steps have completed.
*
*
* For additional protection, you can set the JobFlowInstancesConfig TerminationProtected
* parameter to TRUE to lock the cluster and prevent it from being terminated by API call, user
* intervention, or in the event of a job flow error.
*
*
* A maximum of 256 steps are allowed in each job flow.
*
*
* If your cluster is long-running (such as a Hive data warehouse) or complex, you may require more than 256 steps
* to process your data. You can bypass the 256-step limitation in various ways, including using the SSH shell to
* connect to the master node and submitting queries directly to the software running on the master node, such as
* Hive and Hadoop. For more information on how to do this, see Add More than 256 Steps to
* a Cluster in the Amazon EMR Management Guide.
*
*
* For long running clusters, we recommend that you periodically store your results.
*
*
*
* The instance fleets configuration is available only in Amazon EMR versions 4.8.0 and later, excluding 5.0.x
* versions. The RunJobFlow request can contain InstanceFleets parameters or InstanceGroups parameters, but not
* both.
*
*
*
* This is a convenience which creates an instance of the {@link RunJobFlowRequest.Builder} avoiding the need to
* create one manually via {@link RunJobFlowRequest#builder()}
*
*
* @param runJobFlowRequest
* A {@link Consumer} that will call methods on {@link RunJobFlowInput.Builder} to create a request. Input to
* the RunJobFlow operation.
* @return A Java Future containing the result of the RunJobFlow operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.RunJobFlow
* @see AWS
* API Documentation
*/
default CompletableFuture runJobFlow(Consumer runJobFlowRequest) {
return runJobFlow(RunJobFlowRequest.builder().applyMutation(runJobFlowRequest).build());
}
/**
*
* SetTerminationProtection locks a cluster (job flow) so the EC2 instances in the cluster cannot be terminated by
* user intervention, an API call, or in the event of a job-flow error. The cluster still terminates upon successful
* completion of the job flow. Calling SetTerminationProtection on a cluster is similar to calling the
* Amazon EC2 DisableAPITermination API on all EC2 instances in a cluster.
*
*
* SetTerminationProtection is used to prevent accidental termination of a cluster and to ensure that
* in the event of an error, the instances persist so that you can recover any data stored in their ephemeral
* instance storage.
*
*
* To terminate a cluster that has been locked by setting SetTerminationProtection to true
* , you must first unlock the job flow by a subsequent call to SetTerminationProtection in which you
* set the value to false.
*
*
* For more information, seeManaging
* Cluster Termination in the Amazon EMR Management Guide.
*
*
* @param setTerminationProtectionRequest
* The input argument to the TerminationProtection operation.
* @return A Java Future containing the result of the SetTerminationProtection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.SetTerminationProtection
* @see AWS API Documentation
*/
default CompletableFuture setTerminationProtection(
SetTerminationProtectionRequest setTerminationProtectionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* SetTerminationProtection locks a cluster (job flow) so the EC2 instances in the cluster cannot be terminated by
* user intervention, an API call, or in the event of a job-flow error. The cluster still terminates upon successful
* completion of the job flow. Calling SetTerminationProtection on a cluster is similar to calling the
* Amazon EC2 DisableAPITermination API on all EC2 instances in a cluster.
*
*
* SetTerminationProtection is used to prevent accidental termination of a cluster and to ensure that
* in the event of an error, the instances persist so that you can recover any data stored in their ephemeral
* instance storage.
*
*
* To terminate a cluster that has been locked by setting SetTerminationProtection to true
* , you must first unlock the job flow by a subsequent call to SetTerminationProtection in which you
* set the value to false.
*
*
* For more information, seeManaging
* Cluster Termination in the Amazon EMR Management Guide.
*
*
*
* This is a convenience which creates an instance of the {@link SetTerminationProtectionRequest.Builder} avoiding
* the need to create one manually via {@link SetTerminationProtectionRequest#builder()}
*
*
* @param setTerminationProtectionRequest
* A {@link Consumer} that will call methods on {@link SetTerminationProtectionInput.Builder} to create a
* request. The input argument to the TerminationProtection operation.
* @return A Java Future containing the result of the SetTerminationProtection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.SetTerminationProtection
* @see AWS API Documentation
*/
default CompletableFuture setTerminationProtection(
Consumer setTerminationProtectionRequest) {
return setTerminationProtection(SetTerminationProtectionRequest.builder().applyMutation(setTerminationProtectionRequest)
.build());
}
/**
*
* Sets the Cluster$VisibleToAllUsers value, which determines whether the cluster is visible to all IAM
* users of the AWS account associated with the cluster. Only the IAM user who created the cluster or the AWS
* account root user can call this action. The default value, true, indicates that all IAM users in the
* AWS account can perform cluster actions if they have the proper IAM policy permissions. If set to
* false, only the IAM user that created the cluster can perform actions. This action works on running
* clusters. You can override the default true setting when you create a cluster by using the
* VisibleToAllUsers parameter with RunJobFlow.
*
*
* @param setVisibleToAllUsersRequest
* The input to the SetVisibleToAllUsers action.
* @return A Java Future containing the result of the SetVisibleToAllUsers operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.SetVisibleToAllUsers
* @see AWS API Documentation
*/
default CompletableFuture setVisibleToAllUsers(
SetVisibleToAllUsersRequest setVisibleToAllUsersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Sets the Cluster$VisibleToAllUsers value, which determines whether the cluster is visible to all IAM
* users of the AWS account associated with the cluster. Only the IAM user who created the cluster or the AWS
* account root user can call this action. The default value, true, indicates that all IAM users in the
* AWS account can perform cluster actions if they have the proper IAM policy permissions. If set to
* false, only the IAM user that created the cluster can perform actions. This action works on running
* clusters. You can override the default true setting when you create a cluster by using the
* VisibleToAllUsers parameter with RunJobFlow.
*
*
*
* This is a convenience which creates an instance of the {@link SetVisibleToAllUsersRequest.Builder} avoiding the
* need to create one manually via {@link SetVisibleToAllUsersRequest#builder()}
*
*
* @param setVisibleToAllUsersRequest
* A {@link Consumer} that will call methods on {@link SetVisibleToAllUsersInput.Builder} to create a
* request. The input to the SetVisibleToAllUsers action.
* @return A Java Future containing the result of the SetVisibleToAllUsers operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.SetVisibleToAllUsers
* @see AWS API Documentation
*/
default CompletableFuture setVisibleToAllUsers(
Consumer setVisibleToAllUsersRequest) {
return setVisibleToAllUsers(SetVisibleToAllUsersRequest.builder().applyMutation(setVisibleToAllUsersRequest).build());
}
/**
*
* Starts a notebook execution.
*
*
* @param startNotebookExecutionRequest
* @return A Java Future containing the result of the StartNotebookExecution operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.StartNotebookExecution
* @see AWS API Documentation
*/
default CompletableFuture startNotebookExecution(
StartNotebookExecutionRequest startNotebookExecutionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Starts a notebook execution.
*
*
*
* This is a convenience which creates an instance of the {@link StartNotebookExecutionRequest.Builder} avoiding the
* need to create one manually via {@link StartNotebookExecutionRequest#builder()}
*
*
* @param startNotebookExecutionRequest
* A {@link Consumer} that will call methods on {@link StartNotebookExecutionInput.Builder} to create a
* request.
* @return A Java Future containing the result of the StartNotebookExecution operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.StartNotebookExecution
* @see AWS API Documentation
*/
default CompletableFuture startNotebookExecution(
Consumer startNotebookExecutionRequest) {
return startNotebookExecution(StartNotebookExecutionRequest.builder().applyMutation(startNotebookExecutionRequest)
.build());
}
/**
*
* Stops a notebook execution.
*
*
* @param stopNotebookExecutionRequest
* @return A Java Future containing the result of the StopNotebookExecution operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.StopNotebookExecution
* @see AWS API Documentation
*/
default CompletableFuture stopNotebookExecution(
StopNotebookExecutionRequest stopNotebookExecutionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Stops a notebook execution.
*
*
*
* This is a convenience which creates an instance of the {@link StopNotebookExecutionRequest.Builder} avoiding the
* need to create one manually via {@link StopNotebookExecutionRequest#builder()}
*
*
* @param stopNotebookExecutionRequest
* A {@link Consumer} that will call methods on {@link StopNotebookExecutionInput.Builder} to create a
* request.
* @return A Java Future containing the result of the StopNotebookExecution operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.StopNotebookExecution
* @see AWS API Documentation
*/
default CompletableFuture stopNotebookExecution(
Consumer stopNotebookExecutionRequest) {
return stopNotebookExecution(StopNotebookExecutionRequest.builder().applyMutation(stopNotebookExecutionRequest).build());
}
/**
*
* TerminateJobFlows shuts a list of clusters (job flows) down. When a job flow is shut down, any step not yet
* completed is canceled and the EC2 instances on which the cluster is running are stopped. Any log files not
* already saved are uploaded to Amazon S3 if a LogUri was specified when the cluster was created.
*
*
* The maximum number of clusters allowed is 10. The call to TerminateJobFlows is asynchronous.
* Depending on the configuration of the cluster, it may take up to 1-5 minutes for the cluster to completely
* terminate and release allocated resources, such as Amazon EC2 instances.
*
*
* @param terminateJobFlowsRequest
* Input to the TerminateJobFlows operation.
* @return A Java Future containing the result of the TerminateJobFlows operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.TerminateJobFlows
* @see AWS API Documentation
*/
default CompletableFuture terminateJobFlows(TerminateJobFlowsRequest terminateJobFlowsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* TerminateJobFlows shuts a list of clusters (job flows) down. When a job flow is shut down, any step not yet
* completed is canceled and the EC2 instances on which the cluster is running are stopped. Any log files not
* already saved are uploaded to Amazon S3 if a LogUri was specified when the cluster was created.
*
*
* The maximum number of clusters allowed is 10. The call to TerminateJobFlows is asynchronous.
* Depending on the configuration of the cluster, it may take up to 1-5 minutes for the cluster to completely
* terminate and release allocated resources, such as Amazon EC2 instances.
*
*
*
* This is a convenience which creates an instance of the {@link TerminateJobFlowsRequest.Builder} avoiding the need
* to create one manually via {@link TerminateJobFlowsRequest#builder()}
*
*
* @param terminateJobFlowsRequest
* A {@link Consumer} that will call methods on {@link TerminateJobFlowsInput.Builder} to create a request.
* Input to the TerminateJobFlows operation.
* @return A Java Future containing the result of the TerminateJobFlows operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.TerminateJobFlows
* @see AWS API Documentation
*/
default CompletableFuture terminateJobFlows(
Consumer terminateJobFlowsRequest) {
return terminateJobFlows(TerminateJobFlowsRequest.builder().applyMutation(terminateJobFlowsRequest).build());
}
/**
*
* Updates an Amazon EMR Studio configuration, including attributes such as name, description, and subnets.
*
*
* @param updateStudioRequest
* @return A Java Future containing the result of the UpdateStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.UpdateStudio
* @see AWS
* API Documentation
*/
default CompletableFuture updateStudio(UpdateStudioRequest updateStudioRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates an Amazon EMR Studio configuration, including attributes such as name, description, and subnets.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateStudioRequest.Builder} avoiding the need to
* create one manually via {@link UpdateStudioRequest#builder()}
*
*
* @param updateStudioRequest
* A {@link Consumer} that will call methods on {@link UpdateStudioInput.Builder} to create a request.
* @return A Java Future containing the result of the UpdateStudio operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerException This exception occurs when there is an internal failure in the Amazon EMR
* service.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.UpdateStudio
* @see AWS
* API Documentation
*/
default CompletableFuture updateStudio(Consumer updateStudioRequest) {
return updateStudio(UpdateStudioRequest.builder().applyMutation(updateStudioRequest).build());
}
/**
*
* Updates the session policy attached to the user or group for the specified Amazon EMR Studio.
*
*
* @param updateStudioSessionMappingRequest
* @return A Java Future containing the result of the UpdateStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.UpdateStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture updateStudioSessionMapping(
UpdateStudioSessionMappingRequest updateStudioSessionMappingRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates the session policy attached to the user or group for the specified Amazon EMR Studio.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateStudioSessionMappingRequest.Builder} avoiding
* the need to create one manually via {@link UpdateStudioSessionMappingRequest#builder()}
*
*
* @param updateStudioSessionMappingRequest
* A {@link Consumer} that will call methods on {@link UpdateStudioSessionMappingInput.Builder} to create a
* request.
* @return A Java Future containing the result of the UpdateStudioSessionMapping operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException Indicates that an error occurred while processing the request and that
* the request was not completed.
* - InvalidRequestException This exception occurs when there is something wrong with user input.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - EmrException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample EmrAsyncClient.UpdateStudioSessionMapping
* @see AWS API Documentation
*/
default CompletableFuture updateStudioSessionMapping(
Consumer updateStudioSessionMappingRequest) {
return updateStudioSessionMapping(UpdateStudioSessionMappingRequest.builder()
.applyMutation(updateStudioSessionMappingRequest).build());
}
/**
* Create an instance of {@link EmrAsyncWaiter} 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 EmrAsyncWaiter}
*/
default EmrAsyncWaiter waiter() {
throw new UnsupportedOperationException();
}
}