/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace EMR { /** *

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 Amazon * Web Services services to do tasks such as web indexing, data mining, log file * analysis, machine learning, scientific simulation, and data warehouse * management.

*/ class AWS_EMR_API EMRClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef EMRClientConfiguration ClientConfigurationType; typedef EMREndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EMRClient(const Aws::EMR::EMRClientConfiguration& clientConfiguration = Aws::EMR::EMRClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EMRClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::EMR::EMRClientConfiguration& clientConfiguration = Aws::EMR::EMRClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ EMRClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::EMR::EMRClientConfiguration& clientConfiguration = Aws::EMR::EMRClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EMRClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EMRClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ EMRClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~EMRClient(); /** *

Adds an instance fleet to a running cluster.

The instance fleet * configuration is available only in Amazon EMR releases 4.8.0 and later, * excluding 5.0.x.

See Also:

AWS * API Reference

*/ virtual Model::AddInstanceFleetOutcome AddInstanceFleet(const Model::AddInstanceFleetRequest& request) const; /** * A Callable wrapper for AddInstanceFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddInstanceFleetOutcomeCallable AddInstanceFleetCallable(const AddInstanceFleetRequestT& request) const { return SubmitCallable(&EMRClient::AddInstanceFleet, request); } /** * An Async wrapper for AddInstanceFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddInstanceFleetAsync(const AddInstanceFleetRequestT& request, const AddInstanceFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::AddInstanceFleet, request, handler, context); } /** *

Adds one or more instance groups to a running cluster.

See * Also:

AWS * API Reference

*/ virtual Model::AddInstanceGroupsOutcome AddInstanceGroups(const Model::AddInstanceGroupsRequest& request) const; /** * A Callable wrapper for AddInstanceGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddInstanceGroupsOutcomeCallable AddInstanceGroupsCallable(const AddInstanceGroupsRequestT& request) const { return SubmitCallable(&EMRClient::AddInstanceGroups, request); } /** * An Async wrapper for AddInstanceGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddInstanceGroupsAsync(const AddInstanceGroupsRequestT& request, const AddInstanceGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::AddInstanceGroups, request, handler, context); } /** *

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.

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.

The string values * passed into HadoopJarStep object cannot exceed a total of 10240 * characters.

See Also:

AWS * API Reference

*/ virtual Model::AddJobFlowStepsOutcome AddJobFlowSteps(const Model::AddJobFlowStepsRequest& request) const; /** * A Callable wrapper for AddJobFlowSteps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddJobFlowStepsOutcomeCallable AddJobFlowStepsCallable(const AddJobFlowStepsRequestT& request) const { return SubmitCallable(&EMRClient::AddJobFlowSteps, request); } /** * An Async wrapper for AddJobFlowSteps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddJobFlowStepsAsync(const AddJobFlowStepsRequestT& request, const AddJobFlowStepsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::AddJobFlowSteps, request, handler, context); } /** *

Adds tags to an Amazon EMR resource, such as a cluster or an Amazon EMR * Studio. Tags make it easier to associate resources in various ways, such as * grouping clusters to track your Amazon EMR resource allocation costs. For more * information, see Tag * Clusters.

See Also:

AWS * API Reference

*/ virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const; /** * A Callable wrapper for AddTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const { return SubmitCallable(&EMRClient::AddTags, request); } /** * An Async wrapper for AddTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::AddTags, request, handler, context); } /** *

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. When you use Amazon EMR releases 5.28.0 and * later, you can cancel steps that are in a PENDING or * RUNNING state. In earlier versions of Amazon EMR, you can only * cancel steps that are in a PENDING state.

See Also:

* AWS * API Reference

*/ virtual Model::CancelStepsOutcome CancelSteps(const Model::CancelStepsRequest& request) const; /** * A Callable wrapper for CancelSteps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelStepsOutcomeCallable CancelStepsCallable(const CancelStepsRequestT& request) const { return SubmitCallable(&EMRClient::CancelSteps, request); } /** * An Async wrapper for CancelSteps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelStepsAsync(const CancelStepsRequestT& request, const CancelStepsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::CancelSteps, request, handler, context); } /** *

Creates a security configuration, which is stored in the service and can be * specified when a cluster is created.

See Also:

AWS * API Reference

*/ virtual Model::CreateSecurityConfigurationOutcome CreateSecurityConfiguration(const Model::CreateSecurityConfigurationRequest& request) const; /** * A Callable wrapper for CreateSecurityConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSecurityConfigurationOutcomeCallable CreateSecurityConfigurationCallable(const CreateSecurityConfigurationRequestT& request) const { return SubmitCallable(&EMRClient::CreateSecurityConfiguration, request); } /** * An Async wrapper for CreateSecurityConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSecurityConfigurationAsync(const CreateSecurityConfigurationRequestT& request, const CreateSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::CreateSecurityConfiguration, request, handler, context); } /** *

Creates a new Amazon EMR Studio.

See Also:

AWS * API Reference

*/ virtual Model::CreateStudioOutcome CreateStudio(const Model::CreateStudioRequest& request) const; /** * A Callable wrapper for CreateStudio that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStudioOutcomeCallable CreateStudioCallable(const CreateStudioRequestT& request) const { return SubmitCallable(&EMRClient::CreateStudio, request); } /** * An Async wrapper for CreateStudio that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStudioAsync(const CreateStudioRequestT& request, const CreateStudioResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::CreateStudio, request, handler, context); } /** *

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. Use CreateStudioSessionMapping to assign * users to a Studio when you use IAM Identity Center authentication. For * instructions on how to assign users to a Studio when you use IAM authentication, * see Assign * a user or group to your EMR Studio.

See Also:

AWS * API Reference

*/ virtual Model::CreateStudioSessionMappingOutcome CreateStudioSessionMapping(const Model::CreateStudioSessionMappingRequest& request) const; /** * A Callable wrapper for CreateStudioSessionMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStudioSessionMappingOutcomeCallable CreateStudioSessionMappingCallable(const CreateStudioSessionMappingRequestT& request) const { return SubmitCallable(&EMRClient::CreateStudioSessionMapping, request); } /** * An Async wrapper for CreateStudioSessionMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStudioSessionMappingAsync(const CreateStudioSessionMappingRequestT& request, const CreateStudioSessionMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::CreateStudioSessionMapping, request, handler, context); } /** *

Deletes a security configuration.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSecurityConfigurationOutcome DeleteSecurityConfiguration(const Model::DeleteSecurityConfigurationRequest& request) const; /** * A Callable wrapper for DeleteSecurityConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSecurityConfigurationOutcomeCallable DeleteSecurityConfigurationCallable(const DeleteSecurityConfigurationRequestT& request) const { return SubmitCallable(&EMRClient::DeleteSecurityConfiguration, request); } /** * An Async wrapper for DeleteSecurityConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSecurityConfigurationAsync(const DeleteSecurityConfigurationRequestT& request, const DeleteSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DeleteSecurityConfiguration, request, handler, context); } /** *

Removes an Amazon EMR Studio from the Studio metadata store.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteStudioOutcome DeleteStudio(const Model::DeleteStudioRequest& request) const; /** * A Callable wrapper for DeleteStudio that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStudioOutcomeCallable DeleteStudioCallable(const DeleteStudioRequestT& request) const { return SubmitCallable(&EMRClient::DeleteStudio, request); } /** * An Async wrapper for DeleteStudio that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStudioAsync(const DeleteStudioRequestT& request, const DeleteStudioResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DeleteStudio, request, handler, context); } /** *

Removes a user or group from an Amazon EMR Studio.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteStudioSessionMappingOutcome DeleteStudioSessionMapping(const Model::DeleteStudioSessionMappingRequest& request) const; /** * A Callable wrapper for DeleteStudioSessionMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStudioSessionMappingOutcomeCallable DeleteStudioSessionMappingCallable(const DeleteStudioSessionMappingRequestT& request) const { return SubmitCallable(&EMRClient::DeleteStudioSessionMapping, request); } /** * An Async wrapper for DeleteStudioSessionMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStudioSessionMappingAsync(const DeleteStudioSessionMappingRequestT& request, const DeleteStudioSessionMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DeleteStudioSessionMapping, request, handler, context); } /** *

Provides cluster-level details including status, hardware and software * configuration, VPC settings, and so on.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const; /** * A Callable wrapper for DescribeCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const { return SubmitCallable(&EMRClient::DescribeCluster, request); } /** * An Async wrapper for DescribeCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DescribeCluster, request, handler, context); } /** *

Provides details of a notebook execution.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNotebookExecutionOutcome DescribeNotebookExecution(const Model::DescribeNotebookExecutionRequest& request) const; /** * A Callable wrapper for DescribeNotebookExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNotebookExecutionOutcomeCallable DescribeNotebookExecutionCallable(const DescribeNotebookExecutionRequestT& request) const { return SubmitCallable(&EMRClient::DescribeNotebookExecution, request); } /** * An Async wrapper for DescribeNotebookExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNotebookExecutionAsync(const DescribeNotebookExecutionRequestT& request, const DescribeNotebookExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DescribeNotebookExecution, request, handler, context); } /** *

Provides Amazon EMR release label details, such as the releases available the * Region where the API request is run, and the available applications for a * specific Amazon EMR release label. Can also list Amazon EMR releases that * support a specified version of Spark.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReleaseLabelOutcome DescribeReleaseLabel(const Model::DescribeReleaseLabelRequest& request) const; /** * A Callable wrapper for DescribeReleaseLabel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReleaseLabelOutcomeCallable DescribeReleaseLabelCallable(const DescribeReleaseLabelRequestT& request) const { return SubmitCallable(&EMRClient::DescribeReleaseLabel, request); } /** * An Async wrapper for DescribeReleaseLabel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReleaseLabelAsync(const DescribeReleaseLabelRequestT& request, const DescribeReleaseLabelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DescribeReleaseLabel, request, handler, context); } /** *

Provides the details of a security configuration by returning the * configuration JSON.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSecurityConfigurationOutcome DescribeSecurityConfiguration(const Model::DescribeSecurityConfigurationRequest& request) const; /** * A Callable wrapper for DescribeSecurityConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSecurityConfigurationOutcomeCallable DescribeSecurityConfigurationCallable(const DescribeSecurityConfigurationRequestT& request) const { return SubmitCallable(&EMRClient::DescribeSecurityConfiguration, request); } /** * An Async wrapper for DescribeSecurityConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSecurityConfigurationAsync(const DescribeSecurityConfigurationRequestT& request, const DescribeSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DescribeSecurityConfiguration, request, handler, context); } /** *

Provides more detail about the cluster step.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStepOutcome DescribeStep(const Model::DescribeStepRequest& request) const; /** * A Callable wrapper for DescribeStep that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStepOutcomeCallable DescribeStepCallable(const DescribeStepRequestT& request) const { return SubmitCallable(&EMRClient::DescribeStep, request); } /** * An Async wrapper for DescribeStep that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStepAsync(const DescribeStepRequestT& request, const DescribeStepResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DescribeStep, request, handler, context); } /** *

Returns details for the specified Amazon EMR Studio including ID, Name, VPC, * Studio access URL, and so on.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStudioOutcome DescribeStudio(const Model::DescribeStudioRequest& request) const; /** * A Callable wrapper for DescribeStudio that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStudioOutcomeCallable DescribeStudioCallable(const DescribeStudioRequestT& request) const { return SubmitCallable(&EMRClient::DescribeStudio, request); } /** * An Async wrapper for DescribeStudio that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStudioAsync(const DescribeStudioRequestT& request, const DescribeStudioResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::DescribeStudio, request, handler, context); } /** *

Returns the auto-termination policy for an Amazon EMR cluster.

See * Also:

AWS * API Reference

*/ virtual Model::GetAutoTerminationPolicyOutcome GetAutoTerminationPolicy(const Model::GetAutoTerminationPolicyRequest& request) const; /** * A Callable wrapper for GetAutoTerminationPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAutoTerminationPolicyOutcomeCallable GetAutoTerminationPolicyCallable(const GetAutoTerminationPolicyRequestT& request) const { return SubmitCallable(&EMRClient::GetAutoTerminationPolicy, request); } /** * An Async wrapper for GetAutoTerminationPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAutoTerminationPolicyAsync(const GetAutoTerminationPolicyRequestT& request, const GetAutoTerminationPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::GetAutoTerminationPolicy, request, handler, context); } /** *

Returns the Amazon EMR block public access configuration for your Amazon Web * Services account in the current Region. For more information see Configure * Block Public Access for Amazon EMR in the Amazon EMR Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetBlockPublicAccessConfigurationOutcome GetBlockPublicAccessConfiguration(const Model::GetBlockPublicAccessConfigurationRequest& request) const; /** * A Callable wrapper for GetBlockPublicAccessConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBlockPublicAccessConfigurationOutcomeCallable GetBlockPublicAccessConfigurationCallable(const GetBlockPublicAccessConfigurationRequestT& request) const { return SubmitCallable(&EMRClient::GetBlockPublicAccessConfiguration, request); } /** * An Async wrapper for GetBlockPublicAccessConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBlockPublicAccessConfigurationAsync(const GetBlockPublicAccessConfigurationRequestT& request, const GetBlockPublicAccessConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::GetBlockPublicAccessConfiguration, request, handler, context); } /** *

Provides temporary, HTTP basic credentials that are associated with a given * runtime IAM role and used by a cluster with fine-grained access control * activated. You can use these credentials to connect to cluster endpoints that * support username and password authentication.

See Also:

AWS * API Reference

*/ virtual Model::GetClusterSessionCredentialsOutcome GetClusterSessionCredentials(const Model::GetClusterSessionCredentialsRequest& request) const; /** * A Callable wrapper for GetClusterSessionCredentials that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetClusterSessionCredentialsOutcomeCallable GetClusterSessionCredentialsCallable(const GetClusterSessionCredentialsRequestT& request) const { return SubmitCallable(&EMRClient::GetClusterSessionCredentials, request); } /** * An Async wrapper for GetClusterSessionCredentials that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetClusterSessionCredentialsAsync(const GetClusterSessionCredentialsRequestT& request, const GetClusterSessionCredentialsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::GetClusterSessionCredentials, request, handler, context); } /** *

Fetches the attached managed scaling policy for an Amazon EMR cluster. *

See Also:

AWS * API Reference

*/ virtual Model::GetManagedScalingPolicyOutcome GetManagedScalingPolicy(const Model::GetManagedScalingPolicyRequest& request) const; /** * A Callable wrapper for GetManagedScalingPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetManagedScalingPolicyOutcomeCallable GetManagedScalingPolicyCallable(const GetManagedScalingPolicyRequestT& request) const { return SubmitCallable(&EMRClient::GetManagedScalingPolicy, request); } /** * An Async wrapper for GetManagedScalingPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetManagedScalingPolicyAsync(const GetManagedScalingPolicyRequestT& request, const GetManagedScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::GetManagedScalingPolicy, request, handler, context); } /** *

Fetches mapping details for the specified Amazon EMR Studio and identity * (user or group).

See Also:

AWS * API Reference

*/ virtual Model::GetStudioSessionMappingOutcome GetStudioSessionMapping(const Model::GetStudioSessionMappingRequest& request) const; /** * A Callable wrapper for GetStudioSessionMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStudioSessionMappingOutcomeCallable GetStudioSessionMappingCallable(const GetStudioSessionMappingRequestT& request) const { return SubmitCallable(&EMRClient::GetStudioSessionMapping, request); } /** * An Async wrapper for GetStudioSessionMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStudioSessionMappingAsync(const GetStudioSessionMappingRequestT& request, const GetStudioSessionMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::GetStudioSessionMapping, request, handler, context); } /** *

Provides information about the bootstrap actions associated with a * cluster.

See Also:

AWS * API Reference

*/ virtual Model::ListBootstrapActionsOutcome ListBootstrapActions(const Model::ListBootstrapActionsRequest& request) const; /** * A Callable wrapper for ListBootstrapActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBootstrapActionsOutcomeCallable ListBootstrapActionsCallable(const ListBootstrapActionsRequestT& request) const { return SubmitCallable(&EMRClient::ListBootstrapActions, request); } /** * An Async wrapper for ListBootstrapActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBootstrapActionsAsync(const ListBootstrapActionsRequestT& request, const ListBootstrapActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListBootstrapActions, request, handler, context); } /** *

Provides the status of all clusters visible to this Amazon Web Services * 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 in unsorted order per call, but returns a * marker to track the paging of the cluster list across multiple ListClusters * calls.

See Also:

AWS * API Reference

*/ virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request) const; /** * A Callable wrapper for ListClusters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request) const { return SubmitCallable(&EMRClient::ListClusters, request); } /** * An Async wrapper for ListClusters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListClustersAsync(const ListClustersRequestT& request, const ListClustersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListClusters, request, handler, context); } /** *

Lists all available details about the instance fleets in a cluster.

*

The instance fleet configuration is available only in Amazon EMR * releases 4.8.0 and later, excluding 5.0.x versions.

See * Also:

AWS * API Reference

*/ virtual Model::ListInstanceFleetsOutcome ListInstanceFleets(const Model::ListInstanceFleetsRequest& request) const; /** * A Callable wrapper for ListInstanceFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInstanceFleetsOutcomeCallable ListInstanceFleetsCallable(const ListInstanceFleetsRequestT& request) const { return SubmitCallable(&EMRClient::ListInstanceFleets, request); } /** * An Async wrapper for ListInstanceFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInstanceFleetsAsync(const ListInstanceFleetsRequestT& request, const ListInstanceFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListInstanceFleets, request, handler, context); } /** *

Provides all available details about the instance groups in a * cluster.

See Also:

AWS * API Reference

*/ virtual Model::ListInstanceGroupsOutcome ListInstanceGroups(const Model::ListInstanceGroupsRequest& request) const; /** * A Callable wrapper for ListInstanceGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInstanceGroupsOutcomeCallable ListInstanceGroupsCallable(const ListInstanceGroupsRequestT& request) const { return SubmitCallable(&EMRClient::ListInstanceGroups, request); } /** * An Async wrapper for ListInstanceGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInstanceGroupsAsync(const ListInstanceGroupsRequestT& request, const ListInstanceGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListInstanceGroups, request, handler, context); } /** *

Provides information for all active Amazon EC2 instances and Amazon EC2 * instances terminated in the last 30 days, up to a maximum of 2,000. Amazon EC2 * instances in any of the following states are considered active: * AWAITING_FULFILLMENT, PROVISIONING, BOOTSTRAPPING, RUNNING.

See * Also:

AWS * API Reference

*/ virtual Model::ListInstancesOutcome ListInstances(const Model::ListInstancesRequest& request) const; /** * A Callable wrapper for ListInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInstancesOutcomeCallable ListInstancesCallable(const ListInstancesRequestT& request) const { return SubmitCallable(&EMRClient::ListInstances, request); } /** * An Async wrapper for ListInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInstancesAsync(const ListInstancesRequestT& request, const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListInstances, request, handler, context); } /** *

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 ListNotebookExecutions * calls.

See Also:

AWS * API Reference

*/ virtual Model::ListNotebookExecutionsOutcome ListNotebookExecutions(const Model::ListNotebookExecutionsRequest& request) const; /** * A Callable wrapper for ListNotebookExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNotebookExecutionsOutcomeCallable ListNotebookExecutionsCallable(const ListNotebookExecutionsRequestT& request) const { return SubmitCallable(&EMRClient::ListNotebookExecutions, request); } /** * An Async wrapper for ListNotebookExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNotebookExecutionsAsync(const ListNotebookExecutionsRequestT& request, const ListNotebookExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListNotebookExecutions, request, handler, context); } /** *

Retrieves release labels of Amazon EMR services in the Region where the API * is called.

See Also:

AWS * API Reference

*/ virtual Model::ListReleaseLabelsOutcome ListReleaseLabels(const Model::ListReleaseLabelsRequest& request) const; /** * A Callable wrapper for ListReleaseLabels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListReleaseLabelsOutcomeCallable ListReleaseLabelsCallable(const ListReleaseLabelsRequestT& request) const { return SubmitCallable(&EMRClient::ListReleaseLabels, request); } /** * An Async wrapper for ListReleaseLabels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListReleaseLabelsAsync(const ListReleaseLabelsRequestT& request, const ListReleaseLabelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListReleaseLabels, request, handler, context); } /** *

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.

See Also:

* AWS * API Reference

*/ virtual Model::ListSecurityConfigurationsOutcome ListSecurityConfigurations(const Model::ListSecurityConfigurationsRequest& request) const; /** * A Callable wrapper for ListSecurityConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSecurityConfigurationsOutcomeCallable ListSecurityConfigurationsCallable(const ListSecurityConfigurationsRequestT& request) const { return SubmitCallable(&EMRClient::ListSecurityConfigurations, request); } /** * An Async wrapper for ListSecurityConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSecurityConfigurationsAsync(const ListSecurityConfigurationsRequestT& request, const ListSecurityConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListSecurityConfigurations, request, handler, context); } /** *

Provides a list of steps for the cluster in reverse order unless you specify * stepIds with the request or filter by StepStates. You * can specify a maximum of 10 stepIDs. The CLI automatically * paginates results to return a list greater than 50 steps. To return more than 50 * steps using the CLI, specify a Marker, which is a pagination token * that indicates the next set of steps to retrieve.

See Also:

AWS * API Reference

*/ virtual Model::ListStepsOutcome ListSteps(const Model::ListStepsRequest& request) const; /** * A Callable wrapper for ListSteps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStepsOutcomeCallable ListStepsCallable(const ListStepsRequestT& request) const { return SubmitCallable(&EMRClient::ListSteps, request); } /** * An Async wrapper for ListSteps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStepsAsync(const ListStepsRequestT& request, const ListStepsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListSteps, request, handler, context); } /** *

Returns a list of all user or group session mappings for the Amazon EMR * Studio specified by StudioId.

See Also:

AWS * API Reference

*/ virtual Model::ListStudioSessionMappingsOutcome ListStudioSessionMappings(const Model::ListStudioSessionMappingsRequest& request) const; /** * A Callable wrapper for ListStudioSessionMappings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStudioSessionMappingsOutcomeCallable ListStudioSessionMappingsCallable(const ListStudioSessionMappingsRequestT& request) const { return SubmitCallable(&EMRClient::ListStudioSessionMappings, request); } /** * An Async wrapper for ListStudioSessionMappings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStudioSessionMappingsAsync(const ListStudioSessionMappingsRequestT& request, const ListStudioSessionMappingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListStudioSessionMappings, request, handler, context); } /** *

Returns a list of all Amazon EMR Studios associated with the Amazon Web * Services account. The list includes details such as ID, Studio Access URL, and * creation time for each Studio.

See Also:

AWS * API Reference

*/ virtual Model::ListStudiosOutcome ListStudios(const Model::ListStudiosRequest& request) const; /** * A Callable wrapper for ListStudios that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStudiosOutcomeCallable ListStudiosCallable(const ListStudiosRequestT& request) const { return SubmitCallable(&EMRClient::ListStudios, request); } /** * An Async wrapper for ListStudios that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStudiosAsync(const ListStudiosRequestT& request, const ListStudiosResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListStudios, request, handler, context); } /** *

A list of the instance types that Amazon EMR supports. You can filter the * list by Amazon Web Services Region and Amazon EMR release.

See * Also:

AWS * API Reference

*/ virtual Model::ListSupportedInstanceTypesOutcome ListSupportedInstanceTypes(const Model::ListSupportedInstanceTypesRequest& request) const; /** * A Callable wrapper for ListSupportedInstanceTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSupportedInstanceTypesOutcomeCallable ListSupportedInstanceTypesCallable(const ListSupportedInstanceTypesRequestT& request) const { return SubmitCallable(&EMRClient::ListSupportedInstanceTypes, request); } /** * An Async wrapper for ListSupportedInstanceTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSupportedInstanceTypesAsync(const ListSupportedInstanceTypesRequestT& request, const ListSupportedInstanceTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ListSupportedInstanceTypes, request, handler, context); } /** *

Modifies the number of steps that can be executed concurrently for the * cluster specified using ClusterID.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClusterOutcome ModifyCluster(const Model::ModifyClusterRequest& request) const; /** * A Callable wrapper for ModifyCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterOutcomeCallable ModifyClusterCallable(const ModifyClusterRequestT& request) const { return SubmitCallable(&EMRClient::ModifyCluster, request); } /** * An Async wrapper for ModifyCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterAsync(const ModifyClusterRequestT& request, const ModifyClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ModifyCluster, request, handler, context); } /** *

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 releases 4.8.0 and * later, excluding 5.0.x versions.

See Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceFleetOutcome ModifyInstanceFleet(const Model::ModifyInstanceFleetRequest& request) const; /** * A Callable wrapper for ModifyInstanceFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceFleetOutcomeCallable ModifyInstanceFleetCallable(const ModifyInstanceFleetRequestT& request) const { return SubmitCallable(&EMRClient::ModifyInstanceFleet, request); } /** * An Async wrapper for ModifyInstanceFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceFleetAsync(const ModifyInstanceFleetRequestT& request, const ModifyInstanceFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ModifyInstanceFleet, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceGroupsOutcome ModifyInstanceGroups(const Model::ModifyInstanceGroupsRequest& request) const; /** * A Callable wrapper for ModifyInstanceGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceGroupsOutcomeCallable ModifyInstanceGroupsCallable(const ModifyInstanceGroupsRequestT& request) const { return SubmitCallable(&EMRClient::ModifyInstanceGroups, request); } /** * An Async wrapper for ModifyInstanceGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceGroupsAsync(const ModifyInstanceGroupsRequestT& request, const ModifyInstanceGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::ModifyInstanceGroups, request, handler, context); } /** *

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 Amazon EC2 * instances in response to the value of a CloudWatch metric.

See * Also:

AWS * API Reference

*/ virtual Model::PutAutoScalingPolicyOutcome PutAutoScalingPolicy(const Model::PutAutoScalingPolicyRequest& request) const; /** * A Callable wrapper for PutAutoScalingPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAutoScalingPolicyOutcomeCallable PutAutoScalingPolicyCallable(const PutAutoScalingPolicyRequestT& request) const { return SubmitCallable(&EMRClient::PutAutoScalingPolicy, request); } /** * An Async wrapper for PutAutoScalingPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAutoScalingPolicyAsync(const PutAutoScalingPolicyRequestT& request, const PutAutoScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::PutAutoScalingPolicy, request, handler, context); } /** *

Auto-termination is supported in Amazon EMR releases 5.30.0 and 6.1.0 * and later. For more information, see Using * an auto-termination policy.

Creates or updates an * auto-termination policy for an Amazon EMR cluster. An auto-termination policy * defines the amount of idle time in seconds after which a cluster automatically * terminates. For alternative cluster termination options, see Control * cluster termination.

See Also:

AWS * API Reference

*/ virtual Model::PutAutoTerminationPolicyOutcome PutAutoTerminationPolicy(const Model::PutAutoTerminationPolicyRequest& request) const; /** * A Callable wrapper for PutAutoTerminationPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAutoTerminationPolicyOutcomeCallable PutAutoTerminationPolicyCallable(const PutAutoTerminationPolicyRequestT& request) const { return SubmitCallable(&EMRClient::PutAutoTerminationPolicy, request); } /** * An Async wrapper for PutAutoTerminationPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAutoTerminationPolicyAsync(const PutAutoTerminationPolicyRequestT& request, const PutAutoTerminationPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::PutAutoTerminationPolicy, request, handler, context); } /** *

Creates or updates an Amazon EMR block public access configuration for your * Amazon Web Services account in the current Region. For more information see Configure * Block Public Access for Amazon EMR in the Amazon EMR Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::PutBlockPublicAccessConfigurationOutcome PutBlockPublicAccessConfiguration(const Model::PutBlockPublicAccessConfigurationRequest& request) const; /** * A Callable wrapper for PutBlockPublicAccessConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBlockPublicAccessConfigurationOutcomeCallable PutBlockPublicAccessConfigurationCallable(const PutBlockPublicAccessConfigurationRequestT& request) const { return SubmitCallable(&EMRClient::PutBlockPublicAccessConfiguration, request); } /** * An Async wrapper for PutBlockPublicAccessConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBlockPublicAccessConfigurationAsync(const PutBlockPublicAccessConfigurationRequestT& request, const PutBlockPublicAccessConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::PutBlockPublicAccessConfiguration, request, handler, context); } /** *

Creates or updates a managed scaling policy for an Amazon EMR cluster. The * managed scaling policy defines the limits for resources, such as Amazon 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.

See Also:

AWS * API Reference

*/ virtual Model::PutManagedScalingPolicyOutcome PutManagedScalingPolicy(const Model::PutManagedScalingPolicyRequest& request) const; /** * A Callable wrapper for PutManagedScalingPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutManagedScalingPolicyOutcomeCallable PutManagedScalingPolicyCallable(const PutManagedScalingPolicyRequestT& request) const { return SubmitCallable(&EMRClient::PutManagedScalingPolicy, request); } /** * An Async wrapper for PutManagedScalingPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutManagedScalingPolicyAsync(const PutManagedScalingPolicyRequestT& request, const PutManagedScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::PutManagedScalingPolicy, request, handler, context); } /** *

Removes an automatic scaling policy from a specified instance group within an * Amazon EMR cluster.

See Also:

AWS * API Reference

*/ virtual Model::RemoveAutoScalingPolicyOutcome RemoveAutoScalingPolicy(const Model::RemoveAutoScalingPolicyRequest& request) const; /** * A Callable wrapper for RemoveAutoScalingPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveAutoScalingPolicyOutcomeCallable RemoveAutoScalingPolicyCallable(const RemoveAutoScalingPolicyRequestT& request) const { return SubmitCallable(&EMRClient::RemoveAutoScalingPolicy, request); } /** * An Async wrapper for RemoveAutoScalingPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveAutoScalingPolicyAsync(const RemoveAutoScalingPolicyRequestT& request, const RemoveAutoScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::RemoveAutoScalingPolicy, request, handler, context); } /** *

Removes an auto-termination policy from an Amazon EMR cluster.

See * Also:

AWS * API Reference

*/ virtual Model::RemoveAutoTerminationPolicyOutcome RemoveAutoTerminationPolicy(const Model::RemoveAutoTerminationPolicyRequest& request) const; /** * A Callable wrapper for RemoveAutoTerminationPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveAutoTerminationPolicyOutcomeCallable RemoveAutoTerminationPolicyCallable(const RemoveAutoTerminationPolicyRequestT& request) const { return SubmitCallable(&EMRClient::RemoveAutoTerminationPolicy, request); } /** * An Async wrapper for RemoveAutoTerminationPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveAutoTerminationPolicyAsync(const RemoveAutoTerminationPolicyRequestT& request, const RemoveAutoTerminationPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::RemoveAutoTerminationPolicy, request, handler, context); } /** *

Removes a managed scaling policy from a specified Amazon EMR cluster. *

See Also:

AWS * API Reference

*/ virtual Model::RemoveManagedScalingPolicyOutcome RemoveManagedScalingPolicy(const Model::RemoveManagedScalingPolicyRequest& request) const; /** * A Callable wrapper for RemoveManagedScalingPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveManagedScalingPolicyOutcomeCallable RemoveManagedScalingPolicyCallable(const RemoveManagedScalingPolicyRequestT& request) const { return SubmitCallable(&EMRClient::RemoveManagedScalingPolicy, request); } /** * An Async wrapper for RemoveManagedScalingPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveManagedScalingPolicyAsync(const RemoveManagedScalingPolicyRequestT& request, const RemoveManagedScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::RemoveManagedScalingPolicy, request, handler, context); } /** *

Removes tags from an Amazon EMR resource, such as a cluster or Amazon EMR * Studio. Tags make it easier to associate resources 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:

See Also:

AWS * API Reference

*/ virtual Model::RemoveTagsOutcome RemoveTags(const Model::RemoveTagsRequest& request) const; /** * A Callable wrapper for RemoveTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveTagsOutcomeCallable RemoveTagsCallable(const RemoveTagsRequestT& request) const { return SubmitCallable(&EMRClient::RemoveTags, request); } /** * An Async wrapper for RemoveTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveTagsAsync(const RemoveTagsRequestT& request, const RemoveTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::RemoveTags, request, handler, context); } /** *

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 long-running clusters, we recommend that you * periodically store your results.

The instance fleets configuration * is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x * versions. The RunJobFlow request can contain InstanceFleets parameters or * InstanceGroups parameters, but not both.

See Also:

AWS * API Reference

*/ virtual Model::RunJobFlowOutcome RunJobFlow(const Model::RunJobFlowRequest& request) const; /** * A Callable wrapper for RunJobFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RunJobFlowOutcomeCallable RunJobFlowCallable(const RunJobFlowRequestT& request) const { return SubmitCallable(&EMRClient::RunJobFlow, request); } /** * An Async wrapper for RunJobFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RunJobFlowAsync(const RunJobFlowRequestT& request, const RunJobFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::RunJobFlow, request, handler, context); } /** *

SetTerminationProtection locks a cluster (job flow) so the Amazon 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 Amazon 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. *

See Also:

AWS * API Reference

*/ virtual Model::SetTerminationProtectionOutcome SetTerminationProtection(const Model::SetTerminationProtectionRequest& request) const; /** * A Callable wrapper for SetTerminationProtection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetTerminationProtectionOutcomeCallable SetTerminationProtectionCallable(const SetTerminationProtectionRequestT& request) const { return SubmitCallable(&EMRClient::SetTerminationProtection, request); } /** * An Async wrapper for SetTerminationProtection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetTerminationProtectionAsync(const SetTerminationProtectionRequestT& request, const SetTerminationProtectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::SetTerminationProtection, request, handler, context); } /** *

The SetVisibleToAllUsers parameter is no longer supported. Your * cluster may be visible to all users in your account. To restrict cluster access * using an IAM policy, see Identity * and Access Management for Amazon EMR.

Sets the * Cluster$VisibleToAllUsers value for an Amazon EMR cluster. When * true, IAM principals in the Amazon Web Services account can perform * Amazon EMR cluster actions that their IAM policies allow. When * false, only the IAM principal that created the cluster and the * Amazon Web Services account root user can perform Amazon EMR actions on the * cluster, regardless of IAM permissions policies attached to other IAM * principals.

This action works on running clusters. When you create a * cluster, use the RunJobFlowInput$VisibleToAllUsers parameter.

For * more information, see Understanding * the Amazon EMR Cluster VisibleToAllUsers Setting in the Amazon EMR * Management Guide.

See Also:

AWS * API Reference

*/ virtual Model::SetVisibleToAllUsersOutcome SetVisibleToAllUsers(const Model::SetVisibleToAllUsersRequest& request) const; /** * A Callable wrapper for SetVisibleToAllUsers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetVisibleToAllUsersOutcomeCallable SetVisibleToAllUsersCallable(const SetVisibleToAllUsersRequestT& request) const { return SubmitCallable(&EMRClient::SetVisibleToAllUsers, request); } /** * An Async wrapper for SetVisibleToAllUsers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetVisibleToAllUsersAsync(const SetVisibleToAllUsersRequestT& request, const SetVisibleToAllUsersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::SetVisibleToAllUsers, request, handler, context); } /** *

Starts a notebook execution.

See Also:

AWS * API Reference

*/ virtual Model::StartNotebookExecutionOutcome StartNotebookExecution(const Model::StartNotebookExecutionRequest& request) const; /** * A Callable wrapper for StartNotebookExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartNotebookExecutionOutcomeCallable StartNotebookExecutionCallable(const StartNotebookExecutionRequestT& request) const { return SubmitCallable(&EMRClient::StartNotebookExecution, request); } /** * An Async wrapper for StartNotebookExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartNotebookExecutionAsync(const StartNotebookExecutionRequestT& request, const StartNotebookExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::StartNotebookExecution, request, handler, context); } /** *

Stops a notebook execution.

See Also:

AWS * API Reference

*/ virtual Model::StopNotebookExecutionOutcome StopNotebookExecution(const Model::StopNotebookExecutionRequest& request) const; /** * A Callable wrapper for StopNotebookExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopNotebookExecutionOutcomeCallable StopNotebookExecutionCallable(const StopNotebookExecutionRequestT& request) const { return SubmitCallable(&EMRClient::StopNotebookExecution, request); } /** * An Async wrapper for StopNotebookExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopNotebookExecutionAsync(const StopNotebookExecutionRequestT& request, const StopNotebookExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::StopNotebookExecution, request, handler, context); } /** *

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 Amazon 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.

See Also:

AWS * API Reference

*/ virtual Model::TerminateJobFlowsOutcome TerminateJobFlows(const Model::TerminateJobFlowsRequest& request) const; /** * A Callable wrapper for TerminateJobFlows that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TerminateJobFlowsOutcomeCallable TerminateJobFlowsCallable(const TerminateJobFlowsRequestT& request) const { return SubmitCallable(&EMRClient::TerminateJobFlows, request); } /** * An Async wrapper for TerminateJobFlows that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TerminateJobFlowsAsync(const TerminateJobFlowsRequestT& request, const TerminateJobFlowsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::TerminateJobFlows, request, handler, context); } /** *

Updates an Amazon EMR Studio configuration, including attributes such as * name, description, and subnets.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStudioOutcome UpdateStudio(const Model::UpdateStudioRequest& request) const; /** * A Callable wrapper for UpdateStudio that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStudioOutcomeCallable UpdateStudioCallable(const UpdateStudioRequestT& request) const { return SubmitCallable(&EMRClient::UpdateStudio, request); } /** * An Async wrapper for UpdateStudio that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStudioAsync(const UpdateStudioRequestT& request, const UpdateStudioResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::UpdateStudio, request, handler, context); } /** *

Updates the session policy attached to the user or group for the specified * Amazon EMR Studio.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStudioSessionMappingOutcome UpdateStudioSessionMapping(const Model::UpdateStudioSessionMappingRequest& request) const; /** * A Callable wrapper for UpdateStudioSessionMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStudioSessionMappingOutcomeCallable UpdateStudioSessionMappingCallable(const UpdateStudioSessionMappingRequestT& request) const { return SubmitCallable(&EMRClient::UpdateStudioSessionMapping, request); } /** * An Async wrapper for UpdateStudioSessionMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStudioSessionMappingAsync(const UpdateStudioSessionMappingRequestT& request, const UpdateStudioSessionMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EMRClient::UpdateStudioSessionMapping, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const EMRClientConfiguration& clientConfiguration); EMRClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace EMR } // namespace Aws