/** * 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 DataSync { /** * DataSync

DataSync is an online data movement and * discovery service that simplifies data migration and helps you quickly, easily, * and securely transfer your file or object data to, from, and between Amazon Web * Services storage services.

This API interface reference includes * documentation for using DataSync programmatically. For complete information, see * the DataSync * User Guide .

*/ class AWS_DATASYNC_API DataSyncClient : 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 DataSyncClientConfiguration ClientConfigurationType; typedef DataSyncEndpointProvider 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. */ DataSyncClient(const Aws::DataSync::DataSyncClientConfiguration& clientConfiguration = Aws::DataSync::DataSyncClientConfiguration(), 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. */ DataSyncClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::DataSync::DataSyncClientConfiguration& clientConfiguration = Aws::DataSync::DataSyncClientConfiguration()); /** * 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 */ DataSyncClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::DataSync::DataSyncClientConfiguration& clientConfiguration = Aws::DataSync::DataSyncClientConfiguration()); /* 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. */ DataSyncClient(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. */ DataSyncClient(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 */ DataSyncClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~DataSyncClient(); /** *

Creates an Amazon Web Services resource for an on-premises storage system * that you want DataSync Discovery to collect information about.

See * Also:

AWS * API Reference

*/ virtual Model::AddStorageSystemOutcome AddStorageSystem(const Model::AddStorageSystemRequest& request) const; /** * A Callable wrapper for AddStorageSystem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddStorageSystemOutcomeCallable AddStorageSystemCallable(const AddStorageSystemRequestT& request) const { return SubmitCallable(&DataSyncClient::AddStorageSystem, request); } /** * An Async wrapper for AddStorageSystem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddStorageSystemAsync(const AddStorageSystemRequestT& request, const AddStorageSystemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::AddStorageSystem, request, handler, context); } /** *

Stops an DataSync task execution that's in progress. The transfer of some * files are abruptly interrupted. File contents that're transferred to the * destination might be incomplete or inconsistent with the source files.

*

However, if you start a new task execution using the same task and allow it * to finish, file content on the destination will be complete and consistent. This * applies to other unexpected failures that interrupt a task execution. In all of * these cases, DataSync successfully completes the transfer when you start the * next task execution.

See Also:

AWS * API Reference

*/ virtual Model::CancelTaskExecutionOutcome CancelTaskExecution(const Model::CancelTaskExecutionRequest& request) const; /** * A Callable wrapper for CancelTaskExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelTaskExecutionOutcomeCallable CancelTaskExecutionCallable(const CancelTaskExecutionRequestT& request) const { return SubmitCallable(&DataSyncClient::CancelTaskExecution, request); } /** * An Async wrapper for CancelTaskExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelTaskExecutionAsync(const CancelTaskExecutionRequestT& request, const CancelTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CancelTaskExecution, request, handler, context); } /** *

Activates an DataSync agent that you've deployed in your storage environment. * The activation process associates the agent with your Amazon Web Services * account.

If you haven't deployed an agent yet, see the following topics * to learn more:

If you're transferring between Amazon * Web Services storage services, you don't need a DataSync agent.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateAgentOutcome CreateAgent(const Model::CreateAgentRequest& request) const; /** * A Callable wrapper for CreateAgent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAgentOutcomeCallable CreateAgentCallable(const CreateAgentRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateAgent, request); } /** * An Async wrapper for CreateAgent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAgentAsync(const CreateAgentRequestT& request, const CreateAgentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateAgent, request, handler, context); } /** *

Creates an endpoint for a Microsoft Azure Blob Storage container that * DataSync can use as a transfer source or destination.

Before you begin, * make sure you know how * DataSync accesses Azure Blob Storage and works with access * tiers and blob * types. You also need a DataSync * agent that can connect to your container.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationAzureBlobOutcome CreateLocationAzureBlob(const Model::CreateLocationAzureBlobRequest& request) const; /** * A Callable wrapper for CreateLocationAzureBlob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationAzureBlobOutcomeCallable CreateLocationAzureBlobCallable(const CreateLocationAzureBlobRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationAzureBlob, request); } /** * An Async wrapper for CreateLocationAzureBlob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationAzureBlobAsync(const CreateLocationAzureBlobRequestT& request, const CreateLocationAzureBlobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationAzureBlob, request, handler, context); } /** *

Creates an endpoint for an Amazon EFS file system that DataSync can access * for a transfer. For more information, see Creating * a location for Amazon EFS.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationEfsOutcome CreateLocationEfs(const Model::CreateLocationEfsRequest& request) const; /** * A Callable wrapper for CreateLocationEfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationEfsOutcomeCallable CreateLocationEfsCallable(const CreateLocationEfsRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationEfs, request); } /** * An Async wrapper for CreateLocationEfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationEfsAsync(const CreateLocationEfsRequestT& request, const CreateLocationEfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationEfs, request, handler, context); } /** *

Creates an endpoint for an Amazon FSx for Lustre file system.

See * Also:

AWS * API Reference

*/ virtual Model::CreateLocationFsxLustreOutcome CreateLocationFsxLustre(const Model::CreateLocationFsxLustreRequest& request) const; /** * A Callable wrapper for CreateLocationFsxLustre that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationFsxLustreOutcomeCallable CreateLocationFsxLustreCallable(const CreateLocationFsxLustreRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationFsxLustre, request); } /** * An Async wrapper for CreateLocationFsxLustre that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationFsxLustreAsync(const CreateLocationFsxLustreRequestT& request, const CreateLocationFsxLustreResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationFsxLustre, request, handler, context); } /** *

Creates an endpoint for an Amazon FSx for NetApp ONTAP file system that * DataSync can access for a transfer. For more information, see Creating * a location for FSx for ONTAP.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationFsxOntapOutcome CreateLocationFsxOntap(const Model::CreateLocationFsxOntapRequest& request) const; /** * A Callable wrapper for CreateLocationFsxOntap that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationFsxOntapOutcomeCallable CreateLocationFsxOntapCallable(const CreateLocationFsxOntapRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationFsxOntap, request); } /** * An Async wrapper for CreateLocationFsxOntap that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationFsxOntapAsync(const CreateLocationFsxOntapRequestT& request, const CreateLocationFsxOntapResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationFsxOntap, request, handler, context); } /** *

Creates an endpoint for an Amazon FSx for OpenZFS file system that DataSync * can access for a transfer. For more information, see Creating * a location for FSx for OpenZFS.

Request parameters related to * SMB aren't supported with the CreateLocationFsxOpenZfs * operation.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationFsxOpenZfsOutcome CreateLocationFsxOpenZfs(const Model::CreateLocationFsxOpenZfsRequest& request) const; /** * A Callable wrapper for CreateLocationFsxOpenZfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationFsxOpenZfsOutcomeCallable CreateLocationFsxOpenZfsCallable(const CreateLocationFsxOpenZfsRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationFsxOpenZfs, request); } /** * An Async wrapper for CreateLocationFsxOpenZfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationFsxOpenZfsAsync(const CreateLocationFsxOpenZfsRequestT& request, const CreateLocationFsxOpenZfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationFsxOpenZfs, request, handler, context); } /** *

Creates an endpoint for an Amazon FSx for Windows File Server file * system.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationFsxWindowsOutcome CreateLocationFsxWindows(const Model::CreateLocationFsxWindowsRequest& request) const; /** * A Callable wrapper for CreateLocationFsxWindows that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationFsxWindowsOutcomeCallable CreateLocationFsxWindowsCallable(const CreateLocationFsxWindowsRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationFsxWindows, request); } /** * An Async wrapper for CreateLocationFsxWindows that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationFsxWindowsAsync(const CreateLocationFsxWindowsRequestT& request, const CreateLocationFsxWindowsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationFsxWindows, request, handler, context); } /** *

Creates an endpoint for a Hadoop Distributed File System (HDFS). *

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationHdfsOutcome CreateLocationHdfs(const Model::CreateLocationHdfsRequest& request) const; /** * A Callable wrapper for CreateLocationHdfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationHdfsOutcomeCallable CreateLocationHdfsCallable(const CreateLocationHdfsRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationHdfs, request); } /** * An Async wrapper for CreateLocationHdfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationHdfsAsync(const CreateLocationHdfsRequestT& request, const CreateLocationHdfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationHdfs, request, handler, context); } /** *

Creates an endpoint for an Network File System (NFS) file server that * DataSync can use for a data transfer.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationNfsOutcome CreateLocationNfs(const Model::CreateLocationNfsRequest& request) const; /** * A Callable wrapper for CreateLocationNfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationNfsOutcomeCallable CreateLocationNfsCallable(const CreateLocationNfsRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationNfs, request); } /** * An Async wrapper for CreateLocationNfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationNfsAsync(const CreateLocationNfsRequestT& request, const CreateLocationNfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationNfs, request, handler, context); } /** *

Creates an endpoint for an object storage system that DataSync can access for * a transfer. For more information, see Creating * a location for object storage.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationObjectStorageOutcome CreateLocationObjectStorage(const Model::CreateLocationObjectStorageRequest& request) const; /** * A Callable wrapper for CreateLocationObjectStorage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationObjectStorageOutcomeCallable CreateLocationObjectStorageCallable(const CreateLocationObjectStorageRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationObjectStorage, request); } /** * An Async wrapper for CreateLocationObjectStorage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationObjectStorageAsync(const CreateLocationObjectStorageRequestT& request, const CreateLocationObjectStorageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationObjectStorage, request, handler, context); } /** *

A location is an endpoint for an Amazon S3 bucket. DataSync can use * the location as a source or destination for copying data.

*

Before you create your location, make sure that you read the following * sections:

For * more information, see Creating * an Amazon S3 location.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationS3Outcome CreateLocationS3(const Model::CreateLocationS3Request& request) const; /** * A Callable wrapper for CreateLocationS3 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationS3OutcomeCallable CreateLocationS3Callable(const CreateLocationS3RequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationS3, request); } /** * An Async wrapper for CreateLocationS3 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationS3Async(const CreateLocationS3RequestT& request, const CreateLocationS3ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationS3, request, handler, context); } /** *

Creates an endpoint for a Server Message Block (SMB) file server that * DataSync can use for a data transfer.

Before you begin, make sure that * you understand how DataSync accesses * an SMB file server.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocationSmbOutcome CreateLocationSmb(const Model::CreateLocationSmbRequest& request) const; /** * A Callable wrapper for CreateLocationSmb that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocationSmbOutcomeCallable CreateLocationSmbCallable(const CreateLocationSmbRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateLocationSmb, request); } /** * An Async wrapper for CreateLocationSmb that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocationSmbAsync(const CreateLocationSmbRequestT& request, const CreateLocationSmbResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateLocationSmb, request, handler, context); } /** *

Configures a task, which defines where and how DataSync transfers your * data.

A task includes a source location, a destination location, and the * preferences for how and when you want to transfer your data (such as bandwidth * limits, scheduling, among other options).

If you're planning * to transfer data to or from an Amazon S3 location, review how * DataSync can affect your S3 request charges and the DataSync pricing page before * you begin.

See Also:

AWS * API Reference

*/ virtual Model::CreateTaskOutcome CreateTask(const Model::CreateTaskRequest& request) const; /** * A Callable wrapper for CreateTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTaskOutcomeCallable CreateTaskCallable(const CreateTaskRequestT& request) const { return SubmitCallable(&DataSyncClient::CreateTask, request); } /** * An Async wrapper for CreateTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTaskAsync(const CreateTaskRequestT& request, const CreateTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::CreateTask, request, handler, context); } /** *

Deletes an agent. To specify which agent to delete, use the Amazon Resource * Name (ARN) of the agent in your request. The operation disassociates the agent * from your Amazon Web Services account. However, it doesn't delete the agent * virtual machine (VM) from your on-premises environment.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteAgentOutcome DeleteAgent(const Model::DeleteAgentRequest& request) const; /** * A Callable wrapper for DeleteAgent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAgentOutcomeCallable DeleteAgentCallable(const DeleteAgentRequestT& request) const { return SubmitCallable(&DataSyncClient::DeleteAgent, request); } /** * An Async wrapper for DeleteAgent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAgentAsync(const DeleteAgentRequestT& request, const DeleteAgentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DeleteAgent, request, handler, context); } /** *

Deletes the configuration of a location used by DataSync.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteLocationOutcome DeleteLocation(const Model::DeleteLocationRequest& request) const; /** * A Callable wrapper for DeleteLocation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLocationOutcomeCallable DeleteLocationCallable(const DeleteLocationRequestT& request) const { return SubmitCallable(&DataSyncClient::DeleteLocation, request); } /** * An Async wrapper for DeleteLocation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLocationAsync(const DeleteLocationRequestT& request, const DeleteLocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DeleteLocation, request, handler, context); } /** *

Deletes an DataSync task.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTaskOutcome DeleteTask(const Model::DeleteTaskRequest& request) const; /** * A Callable wrapper for DeleteTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTaskOutcomeCallable DeleteTaskCallable(const DeleteTaskRequestT& request) const { return SubmitCallable(&DataSyncClient::DeleteTask, request); } /** * An Async wrapper for DeleteTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTaskAsync(const DeleteTaskRequestT& request, const DeleteTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DeleteTask, request, handler, context); } /** *

Returns metadata about an DataSync agent, such as its name, endpoint type, * and status.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAgentOutcome DescribeAgent(const Model::DescribeAgentRequest& request) const; /** * A Callable wrapper for DescribeAgent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAgentOutcomeCallable DescribeAgentCallable(const DescribeAgentRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeAgent, request); } /** * An Async wrapper for DescribeAgent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAgentAsync(const DescribeAgentRequestT& request, const DescribeAgentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeAgent, request, handler, context); } /** *

Returns information about a DataSync discovery job.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeDiscoveryJobOutcome DescribeDiscoveryJob(const Model::DescribeDiscoveryJobRequest& request) const; /** * A Callable wrapper for DescribeDiscoveryJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDiscoveryJobOutcomeCallable DescribeDiscoveryJobCallable(const DescribeDiscoveryJobRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeDiscoveryJob, request); } /** * An Async wrapper for DescribeDiscoveryJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDiscoveryJobAsync(const DescribeDiscoveryJobRequestT& request, const DescribeDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeDiscoveryJob, request, handler, context); } /** *

Provides details about how an DataSync transfer location for Microsoft Azure * Blob Storage is configured.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationAzureBlobOutcome DescribeLocationAzureBlob(const Model::DescribeLocationAzureBlobRequest& request) const; /** * A Callable wrapper for DescribeLocationAzureBlob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationAzureBlobOutcomeCallable DescribeLocationAzureBlobCallable(const DescribeLocationAzureBlobRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationAzureBlob, request); } /** * An Async wrapper for DescribeLocationAzureBlob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationAzureBlobAsync(const DescribeLocationAzureBlobRequestT& request, const DescribeLocationAzureBlobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationAzureBlob, request, handler, context); } /** *

Returns metadata about your DataSync location for an Amazon EFS file * system.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationEfsOutcome DescribeLocationEfs(const Model::DescribeLocationEfsRequest& request) const; /** * A Callable wrapper for DescribeLocationEfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationEfsOutcomeCallable DescribeLocationEfsCallable(const DescribeLocationEfsRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationEfs, request); } /** * An Async wrapper for DescribeLocationEfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationEfsAsync(const DescribeLocationEfsRequestT& request, const DescribeLocationEfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationEfs, request, handler, context); } /** *

Provides details about how an DataSync location for an Amazon FSx for Lustre * file system is configured.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationFsxLustreOutcome DescribeLocationFsxLustre(const Model::DescribeLocationFsxLustreRequest& request) const; /** * A Callable wrapper for DescribeLocationFsxLustre that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationFsxLustreOutcomeCallable DescribeLocationFsxLustreCallable(const DescribeLocationFsxLustreRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationFsxLustre, request); } /** * An Async wrapper for DescribeLocationFsxLustre that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationFsxLustreAsync(const DescribeLocationFsxLustreRequestT& request, const DescribeLocationFsxLustreResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationFsxLustre, request, handler, context); } /** *

Provides details about how an DataSync location for an Amazon FSx for NetApp * ONTAP file system is configured.

If your location uses SMB, the * DescribeLocationFsxOntap operation doesn't actually return a * Password.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationFsxOntapOutcome DescribeLocationFsxOntap(const Model::DescribeLocationFsxOntapRequest& request) const; /** * A Callable wrapper for DescribeLocationFsxOntap that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationFsxOntapOutcomeCallable DescribeLocationFsxOntapCallable(const DescribeLocationFsxOntapRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationFsxOntap, request); } /** * An Async wrapper for DescribeLocationFsxOntap that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationFsxOntapAsync(const DescribeLocationFsxOntapRequestT& request, const DescribeLocationFsxOntapResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationFsxOntap, request, handler, context); } /** *

Provides details about how an DataSync location for an Amazon FSx for OpenZFS * file system is configured.

Response elements related to * SMB aren't supported with the * DescribeLocationFsxOpenZfs operation.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeLocationFsxOpenZfsOutcome DescribeLocationFsxOpenZfs(const Model::DescribeLocationFsxOpenZfsRequest& request) const; /** * A Callable wrapper for DescribeLocationFsxOpenZfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationFsxOpenZfsOutcomeCallable DescribeLocationFsxOpenZfsCallable(const DescribeLocationFsxOpenZfsRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationFsxOpenZfs, request); } /** * An Async wrapper for DescribeLocationFsxOpenZfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationFsxOpenZfsAsync(const DescribeLocationFsxOpenZfsRequestT& request, const DescribeLocationFsxOpenZfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationFsxOpenZfs, request, handler, context); } /** *

Returns metadata about an Amazon FSx for Windows File Server location, such * as information about its path.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationFsxWindowsOutcome DescribeLocationFsxWindows(const Model::DescribeLocationFsxWindowsRequest& request) const; /** * A Callable wrapper for DescribeLocationFsxWindows that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationFsxWindowsOutcomeCallable DescribeLocationFsxWindowsCallable(const DescribeLocationFsxWindowsRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationFsxWindows, request); } /** * An Async wrapper for DescribeLocationFsxWindows that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationFsxWindowsAsync(const DescribeLocationFsxWindowsRequestT& request, const DescribeLocationFsxWindowsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationFsxWindows, request, handler, context); } /** *

Returns metadata, such as the authentication information about the Hadoop * Distributed File System (HDFS) location.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationHdfsOutcome DescribeLocationHdfs(const Model::DescribeLocationHdfsRequest& request) const; /** * A Callable wrapper for DescribeLocationHdfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationHdfsOutcomeCallable DescribeLocationHdfsCallable(const DescribeLocationHdfsRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationHdfs, request); } /** * An Async wrapper for DescribeLocationHdfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationHdfsAsync(const DescribeLocationHdfsRequestT& request, const DescribeLocationHdfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationHdfs, request, handler, context); } /** *

Returns metadata, such as the path information, about an NFS * location.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationNfsOutcome DescribeLocationNfs(const Model::DescribeLocationNfsRequest& request) const; /** * A Callable wrapper for DescribeLocationNfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationNfsOutcomeCallable DescribeLocationNfsCallable(const DescribeLocationNfsRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationNfs, request); } /** * An Async wrapper for DescribeLocationNfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationNfsAsync(const DescribeLocationNfsRequestT& request, const DescribeLocationNfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationNfs, request, handler, context); } /** *

Returns metadata about your DataSync location for an object storage * system.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationObjectStorageOutcome DescribeLocationObjectStorage(const Model::DescribeLocationObjectStorageRequest& request) const; /** * A Callable wrapper for DescribeLocationObjectStorage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationObjectStorageOutcomeCallable DescribeLocationObjectStorageCallable(const DescribeLocationObjectStorageRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationObjectStorage, request); } /** * An Async wrapper for DescribeLocationObjectStorage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationObjectStorageAsync(const DescribeLocationObjectStorageRequestT& request, const DescribeLocationObjectStorageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationObjectStorage, request, handler, context); } /** *

Returns metadata, such as bucket name, about an Amazon S3 bucket * location.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationS3Outcome DescribeLocationS3(const Model::DescribeLocationS3Request& request) const; /** * A Callable wrapper for DescribeLocationS3 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationS3OutcomeCallable DescribeLocationS3Callable(const DescribeLocationS3RequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationS3, request); } /** * An Async wrapper for DescribeLocationS3 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationS3Async(const DescribeLocationS3RequestT& request, const DescribeLocationS3ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationS3, request, handler, context); } /** *

Returns metadata, such as the path and user information about an SMB * location.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationSmbOutcome DescribeLocationSmb(const Model::DescribeLocationSmbRequest& request) const; /** * A Callable wrapper for DescribeLocationSmb that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocationSmbOutcomeCallable DescribeLocationSmbCallable(const DescribeLocationSmbRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeLocationSmb, request); } /** * An Async wrapper for DescribeLocationSmb that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocationSmbAsync(const DescribeLocationSmbRequestT& request, const DescribeLocationSmbResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeLocationSmb, request, handler, context); } /** *

Returns information about an on-premises storage system that you're using * with DataSync Discovery.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStorageSystemOutcome DescribeStorageSystem(const Model::DescribeStorageSystemRequest& request) const; /** * A Callable wrapper for DescribeStorageSystem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStorageSystemOutcomeCallable DescribeStorageSystemCallable(const DescribeStorageSystemRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeStorageSystem, request); } /** * An Async wrapper for DescribeStorageSystem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStorageSystemAsync(const DescribeStorageSystemRequestT& request, const DescribeStorageSystemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeStorageSystem, request, handler, context); } /** *

Returns information, including performance data and capacity usage, which * DataSync Discovery collects about a specific resource in your-premises storage * system.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStorageSystemResourceMetricsOutcome DescribeStorageSystemResourceMetrics(const Model::DescribeStorageSystemResourceMetricsRequest& request) const; /** * A Callable wrapper for DescribeStorageSystemResourceMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStorageSystemResourceMetricsOutcomeCallable DescribeStorageSystemResourceMetricsCallable(const DescribeStorageSystemResourceMetricsRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeStorageSystemResourceMetrics, request); } /** * An Async wrapper for DescribeStorageSystemResourceMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStorageSystemResourceMetricsAsync(const DescribeStorageSystemResourceMetricsRequestT& request, const DescribeStorageSystemResourceMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeStorageSystemResourceMetrics, request, handler, context); } /** *

Returns information that DataSync Discovery collects about resources in your * on-premises storage system.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStorageSystemResourcesOutcome DescribeStorageSystemResources(const Model::DescribeStorageSystemResourcesRequest& request) const; /** * A Callable wrapper for DescribeStorageSystemResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStorageSystemResourcesOutcomeCallable DescribeStorageSystemResourcesCallable(const DescribeStorageSystemResourcesRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeStorageSystemResources, request); } /** * An Async wrapper for DescribeStorageSystemResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStorageSystemResourcesAsync(const DescribeStorageSystemResourcesRequestT& request, const DescribeStorageSystemResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeStorageSystemResources, request, handler, context); } /** *

Provides information about an DataSync transfer task.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTaskOutcome DescribeTask(const Model::DescribeTaskRequest& request) const; /** * A Callable wrapper for DescribeTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTaskOutcomeCallable DescribeTaskCallable(const DescribeTaskRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeTask, request); } /** * An Async wrapper for DescribeTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTaskAsync(const DescribeTaskRequestT& request, const DescribeTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeTask, request, handler, context); } /** *

Provides information about an DataSync transfer task that's * running.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTaskExecutionOutcome DescribeTaskExecution(const Model::DescribeTaskExecutionRequest& request) const; /** * A Callable wrapper for DescribeTaskExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTaskExecutionOutcomeCallable DescribeTaskExecutionCallable(const DescribeTaskExecutionRequestT& request) const { return SubmitCallable(&DataSyncClient::DescribeTaskExecution, request); } /** * An Async wrapper for DescribeTaskExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTaskExecutionAsync(const DescribeTaskExecutionRequestT& request, const DescribeTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::DescribeTaskExecution, request, handler, context); } /** *

Creates recommendations about where to migrate your data to in Amazon Web * Services. Recommendations are generated based on information that DataSync * Discovery collects about your on-premises storage system's resources. For more * information, see Recommendations * provided by DataSync Discovery.

Once generated, you can view your * recommendations by using the DescribeStorageSystemResources * operation.

If your discovery * job completes successfully, you don't need to use this operation. DataSync * Discovery generates the recommendations for you automatically.

*

See Also:

AWS * API Reference

*/ virtual Model::GenerateRecommendationsOutcome GenerateRecommendations(const Model::GenerateRecommendationsRequest& request) const; /** * A Callable wrapper for GenerateRecommendations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GenerateRecommendationsOutcomeCallable GenerateRecommendationsCallable(const GenerateRecommendationsRequestT& request) const { return SubmitCallable(&DataSyncClient::GenerateRecommendations, request); } /** * An Async wrapper for GenerateRecommendations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GenerateRecommendationsAsync(const GenerateRecommendationsRequestT& request, const GenerateRecommendationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::GenerateRecommendations, request, handler, context); } /** *

Returns a list of DataSync agents that belong to an Amazon Web Services * account in the Amazon Web Services Region specified in the request.

With * pagination, you can reduce the number of agents returned in a response. If you * get a truncated list of agents in a response, the response contains a marker * that you can specify in your next request to fetch the next page of agents.

*

ListAgents is eventually consistent. This means the result of * running the operation might not reflect that you just created or deleted an * agent. For example, if you create an agent with CreateAgent * and then immediately run ListAgents, that agent might not show up * in the list right away. In situations like this, you can always confirm whether * an agent has been created (or deleted) by using DescribeAgent.

See * Also:

AWS * API Reference

*/ virtual Model::ListAgentsOutcome ListAgents(const Model::ListAgentsRequest& request) const; /** * A Callable wrapper for ListAgents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAgentsOutcomeCallable ListAgentsCallable(const ListAgentsRequestT& request) const { return SubmitCallable(&DataSyncClient::ListAgents, request); } /** * An Async wrapper for ListAgents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAgentsAsync(const ListAgentsRequestT& request, const ListAgentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::ListAgents, request, handler, context); } /** *

Provides a list of the existing discovery jobs in the Amazon Web Services * Region and Amazon Web Services account where you're using DataSync * Discovery.

See Also:

AWS * API Reference

*/ virtual Model::ListDiscoveryJobsOutcome ListDiscoveryJobs(const Model::ListDiscoveryJobsRequest& request) const; /** * A Callable wrapper for ListDiscoveryJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDiscoveryJobsOutcomeCallable ListDiscoveryJobsCallable(const ListDiscoveryJobsRequestT& request) const { return SubmitCallable(&DataSyncClient::ListDiscoveryJobs, request); } /** * An Async wrapper for ListDiscoveryJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDiscoveryJobsAsync(const ListDiscoveryJobsRequestT& request, const ListDiscoveryJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::ListDiscoveryJobs, request, handler, context); } /** *

Returns a list of source and destination locations.

If you have more * locations than are returned in a response (that is, the response returns only a * truncated list of your agents), the response contains a token that you can * specify in your next request to fetch the next page of locations.

See * Also:

AWS * API Reference

*/ virtual Model::ListLocationsOutcome ListLocations(const Model::ListLocationsRequest& request) const; /** * A Callable wrapper for ListLocations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListLocationsOutcomeCallable ListLocationsCallable(const ListLocationsRequestT& request) const { return SubmitCallable(&DataSyncClient::ListLocations, request); } /** * An Async wrapper for ListLocations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListLocationsAsync(const ListLocationsRequestT& request, const ListLocationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::ListLocations, request, handler, context); } /** *

Lists the on-premises storage systems that you're using with DataSync * Discovery.

See Also:

AWS * API Reference

*/ virtual Model::ListStorageSystemsOutcome ListStorageSystems(const Model::ListStorageSystemsRequest& request) const; /** * A Callable wrapper for ListStorageSystems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStorageSystemsOutcomeCallable ListStorageSystemsCallable(const ListStorageSystemsRequestT& request) const { return SubmitCallable(&DataSyncClient::ListStorageSystems, request); } /** * An Async wrapper for ListStorageSystems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStorageSystemsAsync(const ListStorageSystemsRequestT& request, const ListStorageSystemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::ListStorageSystems, request, handler, context); } /** *

Returns all the tags associated with an Amazon Web Services * resource.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&DataSyncClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::ListTagsForResource, request, handler, context); } /** *

Returns a list of executed tasks.

See Also:

AWS * API Reference

*/ virtual Model::ListTaskExecutionsOutcome ListTaskExecutions(const Model::ListTaskExecutionsRequest& request) const; /** * A Callable wrapper for ListTaskExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTaskExecutionsOutcomeCallable ListTaskExecutionsCallable(const ListTaskExecutionsRequestT& request) const { return SubmitCallable(&DataSyncClient::ListTaskExecutions, request); } /** * An Async wrapper for ListTaskExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTaskExecutionsAsync(const ListTaskExecutionsRequestT& request, const ListTaskExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::ListTaskExecutions, request, handler, context); } /** *

Returns a list of the DataSync tasks you created.

See Also:

* AWS * API Reference

*/ virtual Model::ListTasksOutcome ListTasks(const Model::ListTasksRequest& request) const; /** * A Callable wrapper for ListTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTasksOutcomeCallable ListTasksCallable(const ListTasksRequestT& request) const { return SubmitCallable(&DataSyncClient::ListTasks, request); } /** * An Async wrapper for ListTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTasksAsync(const ListTasksRequestT& request, const ListTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::ListTasks, request, handler, context); } /** *

Permanently removes a storage system resource from DataSync Discovery, * including the associated discovery jobs, collected data, and * recommendations.

See Also:

AWS * API Reference

*/ virtual Model::RemoveStorageSystemOutcome RemoveStorageSystem(const Model::RemoveStorageSystemRequest& request) const; /** * A Callable wrapper for RemoveStorageSystem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveStorageSystemOutcomeCallable RemoveStorageSystemCallable(const RemoveStorageSystemRequestT& request) const { return SubmitCallable(&DataSyncClient::RemoveStorageSystem, request); } /** * An Async wrapper for RemoveStorageSystem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveStorageSystemAsync(const RemoveStorageSystemRequestT& request, const RemoveStorageSystemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::RemoveStorageSystem, request, handler, context); } /** *

Runs a DataSync discovery job on your on-premises storage system. If you * haven't added the storage system to DataSync Discovery yet, do this first by * using the AddStorageSystem * operation.

See Also:

AWS * API Reference

*/ virtual Model::StartDiscoveryJobOutcome StartDiscoveryJob(const Model::StartDiscoveryJobRequest& request) const; /** * A Callable wrapper for StartDiscoveryJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartDiscoveryJobOutcomeCallable StartDiscoveryJobCallable(const StartDiscoveryJobRequestT& request) const { return SubmitCallable(&DataSyncClient::StartDiscoveryJob, request); } /** * An Async wrapper for StartDiscoveryJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartDiscoveryJobAsync(const StartDiscoveryJobRequestT& request, const StartDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::StartDiscoveryJob, request, handler, context); } /** *

Starts an DataSync task. For each task, you can only run one task execution * at a time.

There are several phases to a task execution. For more * information, see Task * execution statuses.

If you're planning to transfer data * to or from an Amazon S3 location, review how * DataSync can affect your S3 request charges and the DataSync pricing page before * you begin.

See Also:

AWS * API Reference

*/ virtual Model::StartTaskExecutionOutcome StartTaskExecution(const Model::StartTaskExecutionRequest& request) const; /** * A Callable wrapper for StartTaskExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartTaskExecutionOutcomeCallable StartTaskExecutionCallable(const StartTaskExecutionRequestT& request) const { return SubmitCallable(&DataSyncClient::StartTaskExecution, request); } /** * An Async wrapper for StartTaskExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartTaskExecutionAsync(const StartTaskExecutionRequestT& request, const StartTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::StartTaskExecution, request, handler, context); } /** *

Stops a running DataSync discovery job.

You can stop a discovery job * anytime. A job that's stopped before it's scheduled to end likely will provide * you some information about your on-premises storage system resources. To get * recommendations for a stopped job, you must use the GenerateRecommendations * operation.

See Also:

AWS * API Reference

*/ virtual Model::StopDiscoveryJobOutcome StopDiscoveryJob(const Model::StopDiscoveryJobRequest& request) const; /** * A Callable wrapper for StopDiscoveryJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopDiscoveryJobOutcomeCallable StopDiscoveryJobCallable(const StopDiscoveryJobRequestT& request) const { return SubmitCallable(&DataSyncClient::StopDiscoveryJob, request); } /** * An Async wrapper for StopDiscoveryJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopDiscoveryJobAsync(const StopDiscoveryJobRequestT& request, const StopDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::StopDiscoveryJob, request, handler, context); } /** *

Applies a tag to an Amazon Web Services resource. Tags are key-value * pairs that can help you manage, filter, and search for your resources.

*

These include DataSync resources, such as locations, tasks, and task * executions.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&DataSyncClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::TagResource, request, handler, context); } /** *

Removes tags from an Amazon Web Services resource.

See Also:

* AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&DataSyncClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UntagResource, request, handler, context); } /** *

Updates the name of an agent.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAgentOutcome UpdateAgent(const Model::UpdateAgentRequest& request) const; /** * A Callable wrapper for UpdateAgent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAgentOutcomeCallable UpdateAgentCallable(const UpdateAgentRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateAgent, request); } /** * An Async wrapper for UpdateAgent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAgentAsync(const UpdateAgentRequestT& request, const UpdateAgentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateAgent, request, handler, context); } /** *

Edits a DataSync discovery job configuration.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDiscoveryJobOutcome UpdateDiscoveryJob(const Model::UpdateDiscoveryJobRequest& request) const; /** * A Callable wrapper for UpdateDiscoveryJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDiscoveryJobOutcomeCallable UpdateDiscoveryJobCallable(const UpdateDiscoveryJobRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateDiscoveryJob, request); } /** * An Async wrapper for UpdateDiscoveryJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDiscoveryJobAsync(const UpdateDiscoveryJobRequestT& request, const UpdateDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateDiscoveryJob, request, handler, context); } /** *

Modifies some configurations of the Microsoft Azure Blob Storage transfer * location that you're using with DataSync.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLocationAzureBlobOutcome UpdateLocationAzureBlob(const Model::UpdateLocationAzureBlobRequest& request) const; /** * A Callable wrapper for UpdateLocationAzureBlob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateLocationAzureBlobOutcomeCallable UpdateLocationAzureBlobCallable(const UpdateLocationAzureBlobRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateLocationAzureBlob, request); } /** * An Async wrapper for UpdateLocationAzureBlob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateLocationAzureBlobAsync(const UpdateLocationAzureBlobRequestT& request, const UpdateLocationAzureBlobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateLocationAzureBlob, request, handler, context); } /** *

Updates some parameters of a previously created location for a Hadoop * Distributed File System cluster.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLocationHdfsOutcome UpdateLocationHdfs(const Model::UpdateLocationHdfsRequest& request) const; /** * A Callable wrapper for UpdateLocationHdfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateLocationHdfsOutcomeCallable UpdateLocationHdfsCallable(const UpdateLocationHdfsRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateLocationHdfs, request); } /** * An Async wrapper for UpdateLocationHdfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateLocationHdfsAsync(const UpdateLocationHdfsRequestT& request, const UpdateLocationHdfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateLocationHdfs, request, handler, context); } /** *

Updates some of the parameters of a previously created location for Network * File System (NFS) access. For information about creating an NFS location, see Creating * a location for NFS.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLocationNfsOutcome UpdateLocationNfs(const Model::UpdateLocationNfsRequest& request) const; /** * A Callable wrapper for UpdateLocationNfs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateLocationNfsOutcomeCallable UpdateLocationNfsCallable(const UpdateLocationNfsRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateLocationNfs, request); } /** * An Async wrapper for UpdateLocationNfs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateLocationNfsAsync(const UpdateLocationNfsRequestT& request, const UpdateLocationNfsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateLocationNfs, request, handler, context); } /** *

Updates some parameters of an existing object storage location that DataSync * accesses for a transfer. For information about creating a self-managed object * storage location, see Creating * a location for object storage.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLocationObjectStorageOutcome UpdateLocationObjectStorage(const Model::UpdateLocationObjectStorageRequest& request) const; /** * A Callable wrapper for UpdateLocationObjectStorage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateLocationObjectStorageOutcomeCallable UpdateLocationObjectStorageCallable(const UpdateLocationObjectStorageRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateLocationObjectStorage, request); } /** * An Async wrapper for UpdateLocationObjectStorage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateLocationObjectStorageAsync(const UpdateLocationObjectStorageRequestT& request, const UpdateLocationObjectStorageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateLocationObjectStorage, request, handler, context); } /** *

Updates some of the parameters of a previously created location for Server * Message Block (SMB) file system access. For information about creating an SMB * location, see Creating * a location for SMB.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLocationSmbOutcome UpdateLocationSmb(const Model::UpdateLocationSmbRequest& request) const; /** * A Callable wrapper for UpdateLocationSmb that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateLocationSmbOutcomeCallable UpdateLocationSmbCallable(const UpdateLocationSmbRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateLocationSmb, request); } /** * An Async wrapper for UpdateLocationSmb that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateLocationSmbAsync(const UpdateLocationSmbRequestT& request, const UpdateLocationSmbResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateLocationSmb, request, handler, context); } /** *

Modifies some configurations of an on-premises storage system resource that * you're using with DataSync Discovery.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStorageSystemOutcome UpdateStorageSystem(const Model::UpdateStorageSystemRequest& request) const; /** * A Callable wrapper for UpdateStorageSystem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStorageSystemOutcomeCallable UpdateStorageSystemCallable(const UpdateStorageSystemRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateStorageSystem, request); } /** * An Async wrapper for UpdateStorageSystem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStorageSystemAsync(const UpdateStorageSystemRequestT& request, const UpdateStorageSystemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateStorageSystem, request, handler, context); } /** *

Updates the metadata associated with a task.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTaskOutcome UpdateTask(const Model::UpdateTaskRequest& request) const; /** * A Callable wrapper for UpdateTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTaskOutcomeCallable UpdateTaskCallable(const UpdateTaskRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateTask, request); } /** * An Async wrapper for UpdateTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTaskAsync(const UpdateTaskRequestT& request, const UpdateTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateTask, request, handler, context); } /** *

Modifies a running DataSync task.

Currently, the only * Option that you can modify with UpdateTaskExecution is * BytesPerSecond * , which throttles bandwidth for a running or queued task.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateTaskExecutionOutcome UpdateTaskExecution(const Model::UpdateTaskExecutionRequest& request) const; /** * A Callable wrapper for UpdateTaskExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTaskExecutionOutcomeCallable UpdateTaskExecutionCallable(const UpdateTaskExecutionRequestT& request) const { return SubmitCallable(&DataSyncClient::UpdateTaskExecution, request); } /** * An Async wrapper for UpdateTaskExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTaskExecutionAsync(const UpdateTaskExecutionRequestT& request, const UpdateTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DataSyncClient::UpdateTaskExecution, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const DataSyncClientConfiguration& clientConfiguration); DataSyncClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace DataSync } // namespace Aws