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

Amazon FSx is a fully managed service that makes it easy for storage and * application administrators to launch and use shared file storage.

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

Use this action to associate one or more Domain Name Server (DNS) aliases * with an existing Amazon FSx for Windows File Server file system. A file system * can have a maximum of 50 DNS aliases associated with it at any one time. If you * try to associate a DNS alias that is already associated with the file system, * FSx takes no action on that alias in the request. For more information, see Working * with DNS Aliases and Walkthrough * 5: Using DNS aliases to access your file system, including additional steps * you must take to be able to access your file system using a DNS alias.

*

The system response shows the DNS aliases that Amazon FSx is attempting to * associate with the file system. Use the API operation to monitor the status of * the aliases Amazon FSx is associating with the file system.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateFileSystemAliasesOutcome AssociateFileSystemAliases(const Model::AssociateFileSystemAliasesRequest& request) const; /** * A Callable wrapper for AssociateFileSystemAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateFileSystemAliasesOutcomeCallable AssociateFileSystemAliasesCallable(const AssociateFileSystemAliasesRequestT& request) const { return SubmitCallable(&FSxClient::AssociateFileSystemAliases, request); } /** * An Async wrapper for AssociateFileSystemAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateFileSystemAliasesAsync(const AssociateFileSystemAliasesRequestT& request, const AssociateFileSystemAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::AssociateFileSystemAliases, request, handler, context); } /** *

Cancels an existing Amazon FSx for Lustre data repository task if that task * is in either the PENDING or EXECUTING state. When you * cancel a task, Amazon FSx does the following.

  • Any files that * FSx has already exported are not reverted.

  • FSx continues to * export any files that are "in-flight" when the cancel operation is received.

    *

  • FSx does not export any files that have not yet been exported.

    *

See Also:

AWS * API Reference

*/ virtual Model::CancelDataRepositoryTaskOutcome CancelDataRepositoryTask(const Model::CancelDataRepositoryTaskRequest& request) const; /** * A Callable wrapper for CancelDataRepositoryTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelDataRepositoryTaskOutcomeCallable CancelDataRepositoryTaskCallable(const CancelDataRepositoryTaskRequestT& request) const { return SubmitCallable(&FSxClient::CancelDataRepositoryTask, request); } /** * An Async wrapper for CancelDataRepositoryTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelDataRepositoryTaskAsync(const CancelDataRepositoryTaskRequestT& request, const CancelDataRepositoryTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CancelDataRepositoryTask, request, handler, context); } /** *

Copies an existing backup within the same Amazon Web Services account to * another Amazon Web Services Region (cross-Region copy) or within the same Amazon * Web Services Region (in-Region copy). You can have up to five backup copy * requests in progress to a single destination Region per account.

You can * use cross-Region backup copies for cross-Region disaster recovery. You can * periodically take backups and copy them to another Region so that in the event * of a disaster in the primary Region, you can restore from backup and recover * availability quickly in the other Region. You can make cross-Region copies only * within your Amazon Web Services partition. A partition is a grouping of Regions. * Amazon Web Services currently has three partitions: aws (Standard * Regions), aws-cn (China Regions), and aws-us-gov * (Amazon Web Services GovCloud [US] Regions).

You can also use backup * copies to clone your file dataset to another Region or within the same * Region.

You can use the SourceRegion parameter to specify * the Amazon Web Services Region from which the backup will be copied. For * example, if you make the call from the us-west-1 Region and want to * copy a backup from the us-east-2 Region, you specify * us-east-2 in the SourceRegion parameter to make a * cross-Region copy. If you don't specify a Region, the backup copy is created in * the same Region where the request is sent from (in-Region copy).

For more * information about creating backup copies, see * Copying backups in the Amazon FSx for Windows User Guide, Copying * backups in the Amazon FSx for Lustre User Guide, and Copying * backups in the Amazon FSx for OpenZFS User Guide.

See * Also:

AWS API * Reference

*/ virtual Model::CopyBackupOutcome CopyBackup(const Model::CopyBackupRequest& request) const; /** * A Callable wrapper for CopyBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyBackupOutcomeCallable CopyBackupCallable(const CopyBackupRequestT& request) const { return SubmitCallable(&FSxClient::CopyBackup, request); } /** * An Async wrapper for CopyBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyBackupAsync(const CopyBackupRequestT& request, const CopyBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CopyBackup, request, handler, context); } /** *

Creates a backup of an existing Amazon FSx for Windows File Server file * system, Amazon FSx for Lustre file system, Amazon FSx for NetApp ONTAP volume, * or Amazon FSx for OpenZFS file system. We recommend creating regular backups so * that you can restore a file system or volume from a backup if an issue arises * with the original file system or volume.

For Amazon FSx for Lustre file * systems, you can create a backup only for file systems that have the following * configuration:

  • A Persistent deployment type

  • *

    Are not linked to a data repository

For more * information about backups, see the following:

If a backup with the * specified client request token exists and the parameters match, this operation * returns the description of the existing backup. If a backup with the specified * client request token exists and the parameters don't match, this operation * returns IncompatibleParameterError. If a backup with the specified * client request token doesn't exist, CreateBackup does the * following:

  • Creates a new Amazon FSx backup with an assigned * ID, and an initial lifecycle state of CREATING.

  • *

    Returns the description of the backup.

By using the * idempotent operation, you can retry a CreateBackup operation * without the risk of creating an extra backup. This approach can be useful when * an initial call fails in a way that makes it unclear whether a backup was * created. If you use the same client request token and the initial call created a * backup, the operation returns a successful result because all the parameters are * the same.

The CreateBackup operation returns while the * backup's lifecycle state is still CREATING. You can check the * backup creation status by calling the DescribeBackups * operation, which returns the backup state along with other * information.

See Also:

AWS * API Reference

*/ virtual Model::CreateBackupOutcome CreateBackup(const Model::CreateBackupRequest& request) const; /** * A Callable wrapper for CreateBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBackupOutcomeCallable CreateBackupCallable(const CreateBackupRequestT& request) const { return SubmitCallable(&FSxClient::CreateBackup, request); } /** * An Async wrapper for CreateBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBackupAsync(const CreateBackupRequestT& request, const CreateBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateBackup, request, handler, context); } /** *

Creates an Amazon FSx for Lustre data repository association (DRA). A data * repository association is a link between a directory on the file system and an * Amazon S3 bucket or prefix. You can have a maximum of 8 data repository * associations on a file system. Data repository associations are supported on all * FSx for Lustre 2.12 and newer file systems, excluding scratch_1 * deployment type.

Each data repository association must have a unique * Amazon FSx file system directory and a unique S3 bucket or prefix associated * with it. You can configure a data repository association for automatic import * only, for automatic export only, or for both. To learn more about linking a data * repository to your file system, see Linking * your file system to an S3 bucket.

* CreateDataRepositoryAssociation isn't supported on Amazon File * Cache resources. To create a DRA on Amazon File Cache, use the * CreateFileCache operation.

See Also:

AWS * API Reference

*/ virtual Model::CreateDataRepositoryAssociationOutcome CreateDataRepositoryAssociation(const Model::CreateDataRepositoryAssociationRequest& request) const; /** * A Callable wrapper for CreateDataRepositoryAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDataRepositoryAssociationOutcomeCallable CreateDataRepositoryAssociationCallable(const CreateDataRepositoryAssociationRequestT& request) const { return SubmitCallable(&FSxClient::CreateDataRepositoryAssociation, request); } /** * An Async wrapper for CreateDataRepositoryAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDataRepositoryAssociationAsync(const CreateDataRepositoryAssociationRequestT& request, const CreateDataRepositoryAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateDataRepositoryAssociation, request, handler, context); } /** *

Creates an Amazon FSx for Lustre data repository task. You use data * repository tasks to perform bulk operations between your Amazon FSx file system * and its linked data repositories. An example of a data repository task is * exporting any data and metadata changes, including POSIX metadata, to files, * directories, and symbolic links (symlinks) from your FSx file system to a linked * data repository. A CreateDataRepositoryTask operation will fail if * a data repository is not linked to the FSx file system. To learn more about data * repository tasks, see Data * Repository Tasks. To learn more about linking a data repository to your file * system, see Linking * your file system to an S3 bucket.

See Also:

AWS * API Reference

*/ virtual Model::CreateDataRepositoryTaskOutcome CreateDataRepositoryTask(const Model::CreateDataRepositoryTaskRequest& request) const; /** * A Callable wrapper for CreateDataRepositoryTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDataRepositoryTaskOutcomeCallable CreateDataRepositoryTaskCallable(const CreateDataRepositoryTaskRequestT& request) const { return SubmitCallable(&FSxClient::CreateDataRepositoryTask, request); } /** * An Async wrapper for CreateDataRepositoryTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDataRepositoryTaskAsync(const CreateDataRepositoryTaskRequestT& request, const CreateDataRepositoryTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateDataRepositoryTask, request, handler, context); } /** *

Creates a new Amazon File Cache resource.

You can use this operation * with a client request token in the request that Amazon File Cache uses to ensure * idempotent creation. If a cache with the specified client request token exists * and the parameters match, CreateFileCache returns the description * of the existing cache. If a cache with the specified client request token exists * and the parameters don't match, this call returns * IncompatibleParameterError. If a file cache with the specified * client request token doesn't exist, CreateFileCache does the * following:

  • Creates a new, empty Amazon File Cache resourcewith * an assigned ID, and an initial lifecycle state of CREATING.

    *

  • Returns the description of the cache in JSON format.

    • *

The CreateFileCache call returns while the cache's * lifecycle state is still CREATING. You can check the cache creation * status by calling the DescribeFileCaches * operation, which returns the cache state along with other information.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateFileCacheOutcome CreateFileCache(const Model::CreateFileCacheRequest& request) const; /** * A Callable wrapper for CreateFileCache that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFileCacheOutcomeCallable CreateFileCacheCallable(const CreateFileCacheRequestT& request) const { return SubmitCallable(&FSxClient::CreateFileCache, request); } /** * An Async wrapper for CreateFileCache that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFileCacheAsync(const CreateFileCacheRequestT& request, const CreateFileCacheResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateFileCache, request, handler, context); } /** *

Creates a new, empty Amazon FSx file system. You can create the following * supported Amazon FSx file systems using the CreateFileSystem API * operation:

  • Amazon FSx for Lustre

  • Amazon FSx * for NetApp ONTAP

  • Amazon FSx for OpenZFS

  • *

    Amazon FSx for Windows File Server

This operation requires * a client request token in the request that Amazon FSx uses to ensure idempotent * creation. This means that calling the operation multiple times with the same * client request token has no effect. By using the idempotent operation, you can * retry a CreateFileSystem operation without the risk of creating an * extra file system. This approach can be useful when an initial call fails in a * way that makes it unclear whether a file system was created. Examples are if a * transport level timeout occurred, or your connection was reset. If you use the * same client request token and the initial call created a file system, the client * receives success as long as the parameters are the same.

If a file system * with the specified client request token exists and the parameters match, * CreateFileSystem returns the description of the existing file * system. If a file system with the specified client request token exists and the * parameters don't match, this call returns * IncompatibleParameterError. If a file system with the specified * client request token doesn't exist, CreateFileSystem does the * following:

  • Creates a new, empty Amazon FSx file system with an * assigned ID, and an initial lifecycle state of CREATING.

    • *

  • Returns the description of the file system in JSON format.

    • *

The CreateFileSystem call returns while the file * system's lifecycle state is still CREATING. You can check the * file-system creation status by calling the DescribeFileSystems * operation, which returns the file system state along with other information.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateFileSystemOutcome CreateFileSystem(const Model::CreateFileSystemRequest& request) const; /** * A Callable wrapper for CreateFileSystem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFileSystemOutcomeCallable CreateFileSystemCallable(const CreateFileSystemRequestT& request) const { return SubmitCallable(&FSxClient::CreateFileSystem, request); } /** * An Async wrapper for CreateFileSystem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFileSystemAsync(const CreateFileSystemRequestT& request, const CreateFileSystemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateFileSystem, request, handler, context); } /** *

Creates a new Amazon FSx for Lustre, Amazon FSx for Windows File Server, or * Amazon FSx for OpenZFS file system from an existing Amazon FSx backup.

If * a file system with the specified client request token exists and the parameters * match, this operation returns the description of the file system. If a file * system with the specified client request token exists but the parameters don't * match, this call returns IncompatibleParameterError. If a file * system with the specified client request token doesn't exist, this operation * does the following:

  • Creates a new Amazon FSx file system from * backup with an assigned ID, and an initial lifecycle state of * CREATING.

  • Returns the description of the file * system.

Parameters like the Active Directory, default share * name, automatic backup, and backup settings default to the parameters of the * file system that was backed up, unless overridden. You can explicitly supply * other settings.

By using the idempotent operation, you can retry a * CreateFileSystemFromBackup call without the risk of creating an * extra file system. This approach can be useful when an initial call fails in a * way that makes it unclear whether a file system was created. Examples are if a * transport level timeout occurred, or your connection was reset. If you use the * same client request token and the initial call created a file system, the client * receives a success message as long as the parameters are the same.

*

The CreateFileSystemFromBackup call returns while the file * system's lifecycle state is still CREATING. You can check the * file-system creation status by calling the * DescribeFileSystems operation, which returns the file system state along * with other information.

See Also:

AWS * API Reference

*/ virtual Model::CreateFileSystemFromBackupOutcome CreateFileSystemFromBackup(const Model::CreateFileSystemFromBackupRequest& request) const; /** * A Callable wrapper for CreateFileSystemFromBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFileSystemFromBackupOutcomeCallable CreateFileSystemFromBackupCallable(const CreateFileSystemFromBackupRequestT& request) const { return SubmitCallable(&FSxClient::CreateFileSystemFromBackup, request); } /** * An Async wrapper for CreateFileSystemFromBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFileSystemFromBackupAsync(const CreateFileSystemFromBackupRequestT& request, const CreateFileSystemFromBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateFileSystemFromBackup, request, handler, context); } /** *

Creates a snapshot of an existing Amazon FSx for OpenZFS volume. With * snapshots, you can easily undo file changes and compare file versions by * restoring the volume to a previous version.

If a snapshot with the * specified client request token exists, and the parameters match, this operation * returns the description of the existing snapshot. If a snapshot with the * specified client request token exists, and the parameters don't match, this * operation returns IncompatibleParameterError. If a snapshot with * the specified client request token doesn't exist, CreateSnapshot * does the following:

  • Creates a new OpenZFS snapshot with an * assigned ID, and an initial lifecycle state of CREATING.

    • *

  • Returns the description of the snapshot.

By using the * idempotent operation, you can retry a CreateSnapshot operation * without the risk of creating an extra snapshot. This approach can be useful when * an initial call fails in a way that makes it unclear whether a snapshot was * created. If you use the same client request token and the initial call created a * snapshot, the operation returns a successful result because all the parameters * are the same.

The CreateSnapshot operation returns while the * snapshot's lifecycle state is still CREATING. You can check the * snapshot creation status by calling the DescribeSnapshots * operation, which returns the snapshot state along with other * information.

See Also:

AWS * API Reference

*/ virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const; /** * A Callable wrapper for CreateSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const { return SubmitCallable(&FSxClient::CreateSnapshot, request); } /** * An Async wrapper for CreateSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateSnapshot, request, handler, context); } /** *

Creates a storage virtual machine (SVM) for an Amazon FSx for ONTAP file * system.

See Also:

AWS * API Reference

*/ virtual Model::CreateStorageVirtualMachineOutcome CreateStorageVirtualMachine(const Model::CreateStorageVirtualMachineRequest& request) const; /** * A Callable wrapper for CreateStorageVirtualMachine that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStorageVirtualMachineOutcomeCallable CreateStorageVirtualMachineCallable(const CreateStorageVirtualMachineRequestT& request) const { return SubmitCallable(&FSxClient::CreateStorageVirtualMachine, request); } /** * An Async wrapper for CreateStorageVirtualMachine that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStorageVirtualMachineAsync(const CreateStorageVirtualMachineRequestT& request, const CreateStorageVirtualMachineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateStorageVirtualMachine, request, handler, context); } /** *

Creates an FSx for ONTAP or Amazon FSx for OpenZFS storage * volume.

See Also:

AWS * API Reference

*/ virtual Model::CreateVolumeOutcome CreateVolume(const Model::CreateVolumeRequest& request) const; /** * A Callable wrapper for CreateVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVolumeOutcomeCallable CreateVolumeCallable(const CreateVolumeRequestT& request) const { return SubmitCallable(&FSxClient::CreateVolume, request); } /** * An Async wrapper for CreateVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVolumeAsync(const CreateVolumeRequestT& request, const CreateVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateVolume, request, handler, context); } /** *

Creates a new Amazon FSx for NetApp ONTAP volume from an existing Amazon FSx * volume backup.

See Also:

AWS * API Reference

*/ virtual Model::CreateVolumeFromBackupOutcome CreateVolumeFromBackup(const Model::CreateVolumeFromBackupRequest& request) const; /** * A Callable wrapper for CreateVolumeFromBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVolumeFromBackupOutcomeCallable CreateVolumeFromBackupCallable(const CreateVolumeFromBackupRequestT& request) const { return SubmitCallable(&FSxClient::CreateVolumeFromBackup, request); } /** * An Async wrapper for CreateVolumeFromBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVolumeFromBackupAsync(const CreateVolumeFromBackupRequestT& request, const CreateVolumeFromBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::CreateVolumeFromBackup, request, handler, context); } /** *

Deletes an Amazon FSx backup. After deletion, the backup no longer exists, * and its data is gone.

The DeleteBackup call returns * instantly. The backup won't show up in later DescribeBackups * calls.

The data in a deleted backup is also deleted and can't * be recovered by any means.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBackupOutcome DeleteBackup(const Model::DeleteBackupRequest& request) const; /** * A Callable wrapper for DeleteBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBackupOutcomeCallable DeleteBackupCallable(const DeleteBackupRequestT& request) const { return SubmitCallable(&FSxClient::DeleteBackup, request); } /** * An Async wrapper for DeleteBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBackupAsync(const DeleteBackupRequestT& request, const DeleteBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DeleteBackup, request, handler, context); } /** *

Deletes a data repository association on an Amazon FSx for Lustre file * system. Deleting the data repository association unlinks the file system from * the Amazon S3 bucket. When deleting a data repository association, you have the * option of deleting the data in the file system that corresponds to the data * repository association. Data repository associations are supported on all FSx * for Lustre 2.12 and newer file systems, excluding scratch_1 * deployment type.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDataRepositoryAssociationOutcome DeleteDataRepositoryAssociation(const Model::DeleteDataRepositoryAssociationRequest& request) const; /** * A Callable wrapper for DeleteDataRepositoryAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDataRepositoryAssociationOutcomeCallable DeleteDataRepositoryAssociationCallable(const DeleteDataRepositoryAssociationRequestT& request) const { return SubmitCallable(&FSxClient::DeleteDataRepositoryAssociation, request); } /** * An Async wrapper for DeleteDataRepositoryAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDataRepositoryAssociationAsync(const DeleteDataRepositoryAssociationRequestT& request, const DeleteDataRepositoryAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DeleteDataRepositoryAssociation, request, handler, context); } /** *

Deletes an Amazon File Cache resource. After deletion, the cache no longer * exists, and its data is gone.

The DeleteFileCache operation * returns while the cache has the DELETING status. You can check the * cache deletion status by calling the DescribeFileCaches * operation, which returns a list of caches in your account. If you pass the cache * ID for a deleted cache, the DescribeFileCaches operation returns a * FileCacheNotFound error.

The data in a deleted * cache is also deleted and can't be recovered by any means.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteFileCacheOutcome DeleteFileCache(const Model::DeleteFileCacheRequest& request) const; /** * A Callable wrapper for DeleteFileCache that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFileCacheOutcomeCallable DeleteFileCacheCallable(const DeleteFileCacheRequestT& request) const { return SubmitCallable(&FSxClient::DeleteFileCache, request); } /** * An Async wrapper for DeleteFileCache that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFileCacheAsync(const DeleteFileCacheRequestT& request, const DeleteFileCacheResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DeleteFileCache, request, handler, context); } /** *

Deletes a file system. After deletion, the file system no longer exists, and * its data is gone. Any existing automatic backups and snapshots are also * deleted.

To delete an Amazon FSx for NetApp ONTAP file system, first * delete all the volumes and storage virtual machines (SVMs) on the file system. * Then provide a FileSystemId value to the * DeleFileSystem operation.

By default, when you delete an * Amazon FSx for Windows File Server file system, a final backup is created upon * deletion. This final backup isn't subject to the file system's retention policy, * and must be manually deleted.

The DeleteFileSystem operation * returns while the file system has the DELETING status. You can * check the file system deletion status by calling the DescribeFileSystems * operation, which returns a list of file systems in your account. If you pass the * file system ID for a deleted file system, the DescribeFileSystems * operation returns a FileSystemNotFound error.

If a * data repository task is in a PENDING or EXECUTING * state, deleting an Amazon FSx for Lustre file system will fail with an HTTP * status code 400 (Bad Request).

The data in a deleted * file system is also deleted and can't be recovered by any means.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteFileSystemOutcome DeleteFileSystem(const Model::DeleteFileSystemRequest& request) const; /** * A Callable wrapper for DeleteFileSystem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFileSystemOutcomeCallable DeleteFileSystemCallable(const DeleteFileSystemRequestT& request) const { return SubmitCallable(&FSxClient::DeleteFileSystem, request); } /** * An Async wrapper for DeleteFileSystem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFileSystemAsync(const DeleteFileSystemRequestT& request, const DeleteFileSystemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DeleteFileSystem, request, handler, context); } /** *

Deletes an Amazon FSx for OpenZFS snapshot. After deletion, the snapshot no * longer exists, and its data is gone. Deleting a snapshot doesn't affect * snapshots stored in a file system backup.

The * DeleteSnapshot operation returns instantly. The snapshot appears * with the lifecycle status of DELETING until the deletion is * complete.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const; /** * A Callable wrapper for DeleteSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const { return SubmitCallable(&FSxClient::DeleteSnapshot, request); } /** * An Async wrapper for DeleteSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DeleteSnapshot, request, handler, context); } /** *

Deletes an existing Amazon FSx for ONTAP storage virtual machine (SVM). Prior * to deleting an SVM, you must delete all non-root volumes in the SVM, otherwise * the operation will fail.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStorageVirtualMachineOutcome DeleteStorageVirtualMachine(const Model::DeleteStorageVirtualMachineRequest& request) const; /** * A Callable wrapper for DeleteStorageVirtualMachine that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStorageVirtualMachineOutcomeCallable DeleteStorageVirtualMachineCallable(const DeleteStorageVirtualMachineRequestT& request) const { return SubmitCallable(&FSxClient::DeleteStorageVirtualMachine, request); } /** * An Async wrapper for DeleteStorageVirtualMachine that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStorageVirtualMachineAsync(const DeleteStorageVirtualMachineRequestT& request, const DeleteStorageVirtualMachineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DeleteStorageVirtualMachine, request, handler, context); } /** *

Deletes an Amazon FSx for NetApp ONTAP or Amazon FSx for OpenZFS * volume.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVolumeOutcome DeleteVolume(const Model::DeleteVolumeRequest& request) const; /** * A Callable wrapper for DeleteVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVolumeOutcomeCallable DeleteVolumeCallable(const DeleteVolumeRequestT& request) const { return SubmitCallable(&FSxClient::DeleteVolume, request); } /** * An Async wrapper for DeleteVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVolumeAsync(const DeleteVolumeRequestT& request, const DeleteVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DeleteVolume, request, handler, context); } /** *

Returns the description of a specific Amazon FSx backup, if a * BackupIds value is provided for that backup. Otherwise, it returns * all backups owned by your Amazon Web Services account in the Amazon Web Services * Region of the endpoint that you're calling.

When retrieving all backups, * you can optionally specify the MaxResults parameter to limit the * number of backups in a response. If more backups remain, Amazon FSx returns a * NextToken value in the response. In this case, send a later request * with the NextToken request parameter set to the value of the * NextToken value from the last response.

This operation is * used in an iterative process to retrieve a list of your backups. * DescribeBackups is called first without a NextToken * value. Then the operation continues to be called with the NextToken * parameter set to the value of the last NextToken value until a * response has no NextToken value.

When using this operation, * keep the following in mind:

  • The operation might return fewer * than the MaxResults value of backup descriptions while still * including a NextToken value.

  • The order of the * backups returned in the response of one DescribeBackups call and * the order of the backups returned across the responses of a multi-call iteration * is unspecified.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBackupsOutcome DescribeBackups(const Model::DescribeBackupsRequest& request) const; /** * A Callable wrapper for DescribeBackups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBackupsOutcomeCallable DescribeBackupsCallable(const DescribeBackupsRequestT& request) const { return SubmitCallable(&FSxClient::DescribeBackups, request); } /** * An Async wrapper for DescribeBackups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBackupsAsync(const DescribeBackupsRequestT& request, const DescribeBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeBackups, request, handler, context); } /** *

Returns the description of specific Amazon FSx for Lustre or Amazon File * Cache data repository associations, if one or more AssociationIds * values are provided in the request, or if filters are used in the request. Data * repository associations are supported on Amazon File Cache resources and all FSx * for Lustre 2.12 and newer file systems, excluding scratch_1 * deployment type.

You can use filters to narrow the response to include * just data repository associations for specific file systems (use the * file-system-id filter with the ID of the file system) or caches * (use the file-cache-id filter with the ID of the cache), or data * repository associations for a specific repository type (use the * data-repository-type filter with a value of S3 or * NFS). If you don't use filters, the response returns all data * repository associations owned by your Amazon Web Services account in the Amazon * Web Services Region of the endpoint that you're calling.

When retrieving * all data repository associations, you can paginate the response by using the * optional MaxResults parameter to limit the number of data * repository associations returned in a response. If more data repository * associations remain, a NextToken value is returned in the response. * In this case, send a later request with the NextToken request * parameter set to the value of NextToken from the last * response.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataRepositoryAssociationsOutcome DescribeDataRepositoryAssociations(const Model::DescribeDataRepositoryAssociationsRequest& request) const; /** * A Callable wrapper for DescribeDataRepositoryAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataRepositoryAssociationsOutcomeCallable DescribeDataRepositoryAssociationsCallable(const DescribeDataRepositoryAssociationsRequestT& request) const { return SubmitCallable(&FSxClient::DescribeDataRepositoryAssociations, request); } /** * An Async wrapper for DescribeDataRepositoryAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataRepositoryAssociationsAsync(const DescribeDataRepositoryAssociationsRequestT& request, const DescribeDataRepositoryAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeDataRepositoryAssociations, request, handler, context); } /** *

Returns the description of specific Amazon FSx for Lustre or Amazon File * Cache data repository tasks, if one or more TaskIds values are * provided in the request, or if filters are used in the request. You can use * filters to narrow the response to include just tasks for specific file systems * or caches, or tasks in a specific lifecycle state. Otherwise, it returns all * data repository tasks owned by your Amazon Web Services account in the Amazon * Web Services Region of the endpoint that you're calling.

When retrieving * all tasks, you can paginate the response by using the optional * MaxResults parameter to limit the number of tasks returned in a * response. If more tasks remain, a NextToken value is returned in * the response. In this case, send a later request with the NextToken * request parameter set to the value of NextToken from the last * response.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataRepositoryTasksOutcome DescribeDataRepositoryTasks(const Model::DescribeDataRepositoryTasksRequest& request) const; /** * A Callable wrapper for DescribeDataRepositoryTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataRepositoryTasksOutcomeCallable DescribeDataRepositoryTasksCallable(const DescribeDataRepositoryTasksRequestT& request) const { return SubmitCallable(&FSxClient::DescribeDataRepositoryTasks, request); } /** * An Async wrapper for DescribeDataRepositoryTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataRepositoryTasksAsync(const DescribeDataRepositoryTasksRequestT& request, const DescribeDataRepositoryTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeDataRepositoryTasks, request, handler, context); } /** *

Returns the description of a specific Amazon File Cache resource, if a * FileCacheIds value is provided for that cache. Otherwise, it * returns descriptions of all caches owned by your Amazon Web Services account in * the Amazon Web Services Region of the endpoint that you're calling.

When * retrieving all cache descriptions, you can optionally specify the * MaxResults parameter to limit the number of descriptions in a * response. If more cache descriptions remain, the operation returns a * NextToken value in the response. In this case, send a later request * with the NextToken request parameter set to the value of * NextToken from the last response.

This operation is used in * an iterative process to retrieve a list of your cache descriptions. * DescribeFileCaches is called first without a * NextTokenvalue. Then the operation continues to be called with the * NextToken parameter set to the value of the last * NextToken value until a response has no NextToken.

*

When using this operation, keep the following in mind:

  • The * implementation might return fewer than MaxResults cache * descriptions while still including a NextToken value.

    • *

  • The order of caches returned in the response of one * DescribeFileCaches call and the order of caches returned across the * responses of a multicall iteration is unspecified.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeFileCachesOutcome DescribeFileCaches(const Model::DescribeFileCachesRequest& request) const; /** * A Callable wrapper for DescribeFileCaches that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFileCachesOutcomeCallable DescribeFileCachesCallable(const DescribeFileCachesRequestT& request) const { return SubmitCallable(&FSxClient::DescribeFileCaches, request); } /** * An Async wrapper for DescribeFileCaches that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFileCachesAsync(const DescribeFileCachesRequestT& request, const DescribeFileCachesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeFileCaches, request, handler, context); } /** *

Returns the DNS aliases that are associated with the specified Amazon FSx for * Windows File Server file system. A history of all DNS aliases that have been * associated with and disassociated from the file system is available in the list * of AdministrativeAction provided in the DescribeFileSystems * operation response.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFileSystemAliasesOutcome DescribeFileSystemAliases(const Model::DescribeFileSystemAliasesRequest& request) const; /** * A Callable wrapper for DescribeFileSystemAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFileSystemAliasesOutcomeCallable DescribeFileSystemAliasesCallable(const DescribeFileSystemAliasesRequestT& request) const { return SubmitCallable(&FSxClient::DescribeFileSystemAliases, request); } /** * An Async wrapper for DescribeFileSystemAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFileSystemAliasesAsync(const DescribeFileSystemAliasesRequestT& request, const DescribeFileSystemAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeFileSystemAliases, request, handler, context); } /** *

Returns the description of specific Amazon FSx file systems, if a * FileSystemIds value is provided for that file system. Otherwise, it * returns descriptions of all file systems owned by your Amazon Web Services * account in the Amazon Web Services Region of the endpoint that you're * calling.

When retrieving all file system descriptions, you can optionally * specify the MaxResults parameter to limit the number of * descriptions in a response. If more file system descriptions remain, Amazon FSx * returns a NextToken value in the response. In this case, send a * later request with the NextToken request parameter set to the value * of NextToken from the last response.

This operation is used * in an iterative process to retrieve a list of your file system descriptions. * DescribeFileSystems is called first without a * NextTokenvalue. Then the operation continues to be called with the * NextToken parameter set to the value of the last * NextToken value until a response has no NextToken.

*

When using this operation, keep the following in mind:

  • The * implementation might return fewer than MaxResults file system * descriptions while still including a NextToken value.

    • *

  • The order of file systems returned in the response of one * DescribeFileSystems call and the order of file systems returned * across the responses of a multicall iteration is unspecified.

    • *

See Also:

AWS * API Reference

*/ virtual Model::DescribeFileSystemsOutcome DescribeFileSystems(const Model::DescribeFileSystemsRequest& request) const; /** * A Callable wrapper for DescribeFileSystems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFileSystemsOutcomeCallable DescribeFileSystemsCallable(const DescribeFileSystemsRequestT& request) const { return SubmitCallable(&FSxClient::DescribeFileSystems, request); } /** * An Async wrapper for DescribeFileSystems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFileSystemsAsync(const DescribeFileSystemsRequestT& request, const DescribeFileSystemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeFileSystems, request, handler, context); } /** *

Returns the description of specific Amazon FSx for OpenZFS snapshots, if a * SnapshotIds value is provided. Otherwise, this operation returns * all snapshots owned by your Amazon Web Services account in the Amazon Web * Services Region of the endpoint that you're calling.

When retrieving all * snapshots, you can optionally specify the MaxResults parameter to * limit the number of snapshots in a response. If more backups remain, Amazon FSx * returns a NextToken value in the response. In this case, send a * later request with the NextToken request parameter set to the value * of NextToken from the last response.

Use this operation in * an iterative process to retrieve a list of your snapshots. * DescribeSnapshots is called first without a NextToken * value. Then the operation continues to be called with the NextToken * parameter set to the value of the last NextToken value until a * response has no NextToken value.

When using this operation, * keep the following in mind:

  • The operation might return fewer * than the MaxResults value of snapshot descriptions while still * including a NextToken value.

  • The order of * snapshots returned in the response of one DescribeSnapshots call * and the order of backups returned across the responses of a multi-call iteration * is unspecified.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSnapshotsOutcome DescribeSnapshots(const Model::DescribeSnapshotsRequest& request) const; /** * A Callable wrapper for DescribeSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSnapshotsOutcomeCallable DescribeSnapshotsCallable(const DescribeSnapshotsRequestT& request) const { return SubmitCallable(&FSxClient::DescribeSnapshots, request); } /** * An Async wrapper for DescribeSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSnapshotsAsync(const DescribeSnapshotsRequestT& request, const DescribeSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeSnapshots, request, handler, context); } /** *

Describes one or more Amazon FSx for NetApp ONTAP storage virtual machines * (SVMs).

See Also:

AWS * API Reference

*/ virtual Model::DescribeStorageVirtualMachinesOutcome DescribeStorageVirtualMachines(const Model::DescribeStorageVirtualMachinesRequest& request) const; /** * A Callable wrapper for DescribeStorageVirtualMachines that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStorageVirtualMachinesOutcomeCallable DescribeStorageVirtualMachinesCallable(const DescribeStorageVirtualMachinesRequestT& request) const { return SubmitCallable(&FSxClient::DescribeStorageVirtualMachines, request); } /** * An Async wrapper for DescribeStorageVirtualMachines that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStorageVirtualMachinesAsync(const DescribeStorageVirtualMachinesRequestT& request, const DescribeStorageVirtualMachinesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeStorageVirtualMachines, request, handler, context); } /** *

Describes one or more Amazon FSx for NetApp ONTAP or Amazon FSx for OpenZFS * volumes.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVolumesOutcome DescribeVolumes(const Model::DescribeVolumesRequest& request) const; /** * A Callable wrapper for DescribeVolumes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVolumesOutcomeCallable DescribeVolumesCallable(const DescribeVolumesRequestT& request) const { return SubmitCallable(&FSxClient::DescribeVolumes, request); } /** * An Async wrapper for DescribeVolumes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVolumesAsync(const DescribeVolumesRequestT& request, const DescribeVolumesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DescribeVolumes, request, handler, context); } /** *

Use this action to disassociate, or remove, one or more Domain Name Service * (DNS) aliases from an Amazon FSx for Windows File Server file system. If you * attempt to disassociate a DNS alias that is not associated with the file system, * Amazon FSx responds with a 400 Bad Request. For more information, see Working * with DNS Aliases.

The system generated response showing the DNS * aliases that Amazon FSx is attempting to disassociate from the file system. Use * the API operation to monitor the status of the aliases Amazon FSx is * disassociating with the file system.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateFileSystemAliasesOutcome DisassociateFileSystemAliases(const Model::DisassociateFileSystemAliasesRequest& request) const; /** * A Callable wrapper for DisassociateFileSystemAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateFileSystemAliasesOutcomeCallable DisassociateFileSystemAliasesCallable(const DisassociateFileSystemAliasesRequestT& request) const { return SubmitCallable(&FSxClient::DisassociateFileSystemAliases, request); } /** * An Async wrapper for DisassociateFileSystemAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateFileSystemAliasesAsync(const DisassociateFileSystemAliasesRequestT& request, const DisassociateFileSystemAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::DisassociateFileSystemAliases, request, handler, context); } /** *

Lists tags for Amazon FSx resources.

When retrieving all tags, you can * optionally specify the MaxResults parameter to limit the number of * tags in a response. If more tags remain, Amazon FSx returns a * NextToken value in the response. In this case, send a later request * with the NextToken request parameter set to the value of * NextToken from the last response.

This action is used in an * iterative process to retrieve a list of your tags. * ListTagsForResource is called first without a * NextTokenvalue. Then the action continues to be called with the * NextToken parameter set to the value of the last * NextToken value until a response has no NextToken.

*

When using this action, keep the following in mind:

  • The * implementation might return fewer than MaxResults file system * descriptions while still including a NextToken value.

    • *

  • The order of tags returned in the response of one * ListTagsForResource call and the order of tags returned across the * responses of a multi-call iteration is unspecified.

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(&FSxClient::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(&FSxClient::ListTagsForResource, request, handler, context); } /** *

Releases the file system lock from an Amazon FSx for OpenZFS file * system.

See Also:

AWS * API Reference

*/ virtual Model::ReleaseFileSystemNfsV3LocksOutcome ReleaseFileSystemNfsV3Locks(const Model::ReleaseFileSystemNfsV3LocksRequest& request) const; /** * A Callable wrapper for ReleaseFileSystemNfsV3Locks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReleaseFileSystemNfsV3LocksOutcomeCallable ReleaseFileSystemNfsV3LocksCallable(const ReleaseFileSystemNfsV3LocksRequestT& request) const { return SubmitCallable(&FSxClient::ReleaseFileSystemNfsV3Locks, request); } /** * An Async wrapper for ReleaseFileSystemNfsV3Locks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReleaseFileSystemNfsV3LocksAsync(const ReleaseFileSystemNfsV3LocksRequestT& request, const ReleaseFileSystemNfsV3LocksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::ReleaseFileSystemNfsV3Locks, request, handler, context); } /** *

Returns an Amazon FSx for OpenZFS volume to the state saved by the specified * snapshot.

See Also:

AWS * API Reference

*/ virtual Model::RestoreVolumeFromSnapshotOutcome RestoreVolumeFromSnapshot(const Model::RestoreVolumeFromSnapshotRequest& request) const; /** * A Callable wrapper for RestoreVolumeFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreVolumeFromSnapshotOutcomeCallable RestoreVolumeFromSnapshotCallable(const RestoreVolumeFromSnapshotRequestT& request) const { return SubmitCallable(&FSxClient::RestoreVolumeFromSnapshot, request); } /** * An Async wrapper for RestoreVolumeFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreVolumeFromSnapshotAsync(const RestoreVolumeFromSnapshotRequestT& request, const RestoreVolumeFromSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::RestoreVolumeFromSnapshot, request, handler, context); } /** *

Tags an Amazon FSx resource.

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(&FSxClient::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(&FSxClient::TagResource, request, handler, context); } /** *

This action removes a tag from an Amazon FSx 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(&FSxClient::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(&FSxClient::UntagResource, request, handler, context); } /** *

Updates the configuration of an existing data repository association on an * Amazon FSx for Lustre file system. Data repository associations are supported on * all FSx for Lustre 2.12 and newer file systems, excluding scratch_1 * deployment type.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDataRepositoryAssociationOutcome UpdateDataRepositoryAssociation(const Model::UpdateDataRepositoryAssociationRequest& request) const; /** * A Callable wrapper for UpdateDataRepositoryAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDataRepositoryAssociationOutcomeCallable UpdateDataRepositoryAssociationCallable(const UpdateDataRepositoryAssociationRequestT& request) const { return SubmitCallable(&FSxClient::UpdateDataRepositoryAssociation, request); } /** * An Async wrapper for UpdateDataRepositoryAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDataRepositoryAssociationAsync(const UpdateDataRepositoryAssociationRequestT& request, const UpdateDataRepositoryAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::UpdateDataRepositoryAssociation, request, handler, context); } /** *

Updates the configuration of an existing Amazon File Cache resource. You can * update multiple properties in a single request.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFileCacheOutcome UpdateFileCache(const Model::UpdateFileCacheRequest& request) const; /** * A Callable wrapper for UpdateFileCache that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFileCacheOutcomeCallable UpdateFileCacheCallable(const UpdateFileCacheRequestT& request) const { return SubmitCallable(&FSxClient::UpdateFileCache, request); } /** * An Async wrapper for UpdateFileCache that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFileCacheAsync(const UpdateFileCacheRequestT& request, const UpdateFileCacheResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::UpdateFileCache, request, handler, context); } /** *

Use this operation to update the configuration of an existing Amazon FSx file * system. You can update multiple properties in a single request.

For FSx * for Windows File Server file systems, you can update the following * properties:

  • AuditLogConfiguration

  • *

    AutomaticBackupRetentionDays

  • * DailyAutomaticBackupStartTime

  • * SelfManagedActiveDirectoryConfiguration

  • * StorageCapacity

  • ThroughputCapacity *

  • WeeklyMaintenanceStartTime

*

For FSx for Lustre file systems, you can update the following properties:

*

  • AutoImportPolicy

  • * AutomaticBackupRetentionDays

  • * DailyAutomaticBackupStartTime

  • * DataCompressionType

  • * LogConfiguration

  • * LustreRootSquashConfiguration

  • * StorageCapacity

  • * WeeklyMaintenanceStartTime

For FSx for ONTAP * file systems, you can update the following properties:

  • * AddRouteTableIds

  • * AutomaticBackupRetentionDays

  • * DailyAutomaticBackupStartTime

  • * DiskIopsConfiguration

  • * FsxAdminPassword

  • * RemoveRouteTableIds

  • * StorageCapacity

  • ThroughputCapacity *

  • WeeklyMaintenanceStartTime

*

For FSx for OpenZFS file systems, you can update the following * properties:

  • AutomaticBackupRetentionDays

    *

  • CopyTagsToBackups

  • * CopyTagsToVolumes

  • * DailyAutomaticBackupStartTime

  • * DiskIopsConfiguration

  • * StorageCapacity

  • ThroughputCapacity *

  • WeeklyMaintenanceStartTime

    • *

See Also:

AWS * API Reference

*/ virtual Model::UpdateFileSystemOutcome UpdateFileSystem(const Model::UpdateFileSystemRequest& request) const; /** * A Callable wrapper for UpdateFileSystem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFileSystemOutcomeCallable UpdateFileSystemCallable(const UpdateFileSystemRequestT& request) const { return SubmitCallable(&FSxClient::UpdateFileSystem, request); } /** * An Async wrapper for UpdateFileSystem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFileSystemAsync(const UpdateFileSystemRequestT& request, const UpdateFileSystemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::UpdateFileSystem, request, handler, context); } /** *

Updates the name of an Amazon FSx for OpenZFS snapshot.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateSnapshotOutcome UpdateSnapshot(const Model::UpdateSnapshotRequest& request) const; /** * A Callable wrapper for UpdateSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSnapshotOutcomeCallable UpdateSnapshotCallable(const UpdateSnapshotRequestT& request) const { return SubmitCallable(&FSxClient::UpdateSnapshot, request); } /** * An Async wrapper for UpdateSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSnapshotAsync(const UpdateSnapshotRequestT& request, const UpdateSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::UpdateSnapshot, request, handler, context); } /** *

Updates an FSx for ONTAP storage virtual machine (SVM).

See * Also:

AWS * API Reference

*/ virtual Model::UpdateStorageVirtualMachineOutcome UpdateStorageVirtualMachine(const Model::UpdateStorageVirtualMachineRequest& request) const; /** * A Callable wrapper for UpdateStorageVirtualMachine that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStorageVirtualMachineOutcomeCallable UpdateStorageVirtualMachineCallable(const UpdateStorageVirtualMachineRequestT& request) const { return SubmitCallable(&FSxClient::UpdateStorageVirtualMachine, request); } /** * An Async wrapper for UpdateStorageVirtualMachine that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStorageVirtualMachineAsync(const UpdateStorageVirtualMachineRequestT& request, const UpdateStorageVirtualMachineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::UpdateStorageVirtualMachine, request, handler, context); } /** *

Updates the configuration of an Amazon FSx for NetApp ONTAP or Amazon FSx for * OpenZFS volume.

See Also:

AWS * API Reference

*/ virtual Model::UpdateVolumeOutcome UpdateVolume(const Model::UpdateVolumeRequest& request) const; /** * A Callable wrapper for UpdateVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVolumeOutcomeCallable UpdateVolumeCallable(const UpdateVolumeRequestT& request) const { return SubmitCallable(&FSxClient::UpdateVolume, request); } /** * An Async wrapper for UpdateVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVolumeAsync(const UpdateVolumeRequestT& request, const UpdateVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FSxClient::UpdateVolume, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const FSxClientConfiguration& clientConfiguration); FSxClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace FSx } // namespace Aws