feat(client-fsx): This release adds support for Amazon File Cache.

Author: awstools

clients/client-fsx/src/FSx.ts

@@ -71,6 +71,7 @@ import {
   CreateDataRepositoryTaskCommandInput,
   CreateDataRepositoryTaskCommandOutput,
 } from "./commands/CreateDataRepositoryTaskCommand";
+import { CreateFileCacheCommandInput, CreateFileCacheCommandOutput } from "./commands/CreateFileCacheCommand";
 import { CreateFileSystemCommandInput, CreateFileSystemCommandOutput } from "./commands/CreateFileSystemCommand";
 import {
   CreateFileSystemFromBackupCommandInput,
@@ -91,6 +92,7 @@ import {
   DeleteDataRepositoryAssociationCommandInput,
   DeleteDataRepositoryAssociationCommandOutput,
 } from "./commands/DeleteDataRepositoryAssociationCommand";
+import { DeleteFileCacheCommandInput, DeleteFileCacheCommandOutput } from "./commands/DeleteFileCacheCommand";
 import { DeleteFileSystemCommandInput, DeleteFileSystemCommandOutput } from "./commands/DeleteFileSystemCommand";
 import { DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput } from "./commands/DeleteSnapshotCommand";
 import {
@@ -107,6 +109,7 @@ import {
   DescribeDataRepositoryTasksCommandInput,
   DescribeDataRepositoryTasksCommandOutput,
 } from "./commands/DescribeDataRepositoryTasksCommand";
+import { DescribeFileCachesCommandInput, DescribeFileCachesCommandOutput } from "./commands/DescribeFileCachesCommand";
 import {
   DescribeFileSystemAliasesCommandInput,
   DescribeFileSystemAliasesCommandOutput,
@@ -143,6 +146,7 @@ import {
   UpdateDataRepositoryAssociationCommandInput,
   UpdateDataRepositoryAssociationCommandOutput,
 } from "./commands/UpdateDataRepositoryAssociationCommand";
+import { UpdateFileCacheCommandInput, UpdateFileCacheCommandOutput } from "./commands/UpdateFileCacheCommand";
 import { UpdateFileSystemCommandInput, UpdateFileSystemCommandOutput } from "./commands/UpdateFileSystemCommand";
 import { UpdateSnapshotCommandInput, UpdateSnapshotCommandOutput } from "./commands/UpdateSnapshotCommand";
 import {
@@ -159,6 +163,7 @@ export type ServiceInputTypes =
   | CreateBackupCommandInput
   | CreateDataRepositoryAssociationCommandInput
   | CreateDataRepositoryTaskCommandInput
+  | CreateFileCacheCommandInput
   | CreateFileSystemCommandInput
   | CreateFileSystemFromBackupCommandInput
   | CreateSnapshotCommandInput
@@ -167,13 +172,15 @@ export type ServiceInputTypes =
   | CreateVolumeFromBackupCommandInput
   | DeleteBackupCommandInput
   | DeleteDataRepositoryAssociationCommandInput
+  | DeleteFileCacheCommandInput
   | DeleteFileSystemCommandInput
   | DeleteSnapshotCommandInput
   | DeleteStorageVirtualMachineCommandInput
   | DeleteVolumeCommandInput
   | DescribeBackupsCommandInput
   | DescribeDataRepositoryAssociationsCommandInput
   | DescribeDataRepositoryTasksCommandInput
+  | DescribeFileCachesCommandInput
   | DescribeFileSystemAliasesCommandInput
   | DescribeFileSystemsCommandInput
   | DescribeSnapshotsCommandInput
@@ -186,6 +193,7 @@ export type ServiceInputTypes =
   | TagResourceCommandInput
   | UntagResourceCommandInput
   | UpdateDataRepositoryAssociationCommandInput
+  | UpdateFileCacheCommandInput
   | UpdateFileSystemCommandInput
   | UpdateSnapshotCommandInput
   | UpdateStorageVirtualMachineCommandInput
@@ -198,6 +206,7 @@ export type ServiceOutputTypes =
   | CreateBackupCommandOutput
   | CreateDataRepositoryAssociationCommandOutput
   | CreateDataRepositoryTaskCommandOutput
+  | CreateFileCacheCommandOutput
   | CreateFileSystemCommandOutput
   | CreateFileSystemFromBackupCommandOutput
   | CreateSnapshotCommandOutput
@@ -206,13 +215,15 @@ export type ServiceOutputTypes =
   | CreateVolumeFromBackupCommandOutput
   | DeleteBackupCommandOutput
   | DeleteDataRepositoryAssociationCommandOutput
+  | DeleteFileCacheCommandOutput
   | DeleteFileSystemCommandOutput
   | DeleteSnapshotCommandOutput
   | DeleteStorageVirtualMachineCommandOutput
   | DeleteVolumeCommandOutput
   | DescribeBackupsCommandOutput
   | DescribeDataRepositoryAssociationsCommandOutput
   | DescribeDataRepositoryTasksCommandOutput
+  | DescribeFileCachesCommandOutput
   | DescribeFileSystemAliasesCommandOutput
   | DescribeFileSystemsCommandOutput
   | DescribeSnapshotsCommandOutput
@@ -225,6 +236,7 @@ export type ServiceOutputTypes =
   | TagResourceCommandOutput
   | UntagResourceCommandOutput
   | UpdateDataRepositoryAssociationCommandOutput
+  | UpdateFileCacheCommandOutput
   | UpdateFileSystemCommandOutput
   | UpdateSnapshotCommandOutput
   | UpdateStorageVirtualMachineCommandOutput

clients/client-fsx/src/FSxClient.ts

@@ -41,6 +41,12 @@ export interface CreateDataRepositoryAssociationCommandOutput
  *             for automatic export only, or for both. To learn more about linking a
  *             data repository to your file system, see
  *             <a href="https://docs.aws.amazon.com/fsx/latest/LustreGuide/create-dra-linked-data-repo.html">Linking your file system to an S3 bucket</a>.</p>
+ *         <note>
+ *             <p>
+ *                <code>CreateDataRepositoryAssociation</code> isn't supported
+ *             on Amazon File Cache resources. To create a DRA on Amazon File Cache,
+ *             use the <code>CreateFileCache</code> operation.</p>
+ *         </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

clients/client-fsx/src/commands/CreateDataRepositoryAssociationCommand.ts

@@ -0,0 +1,124 @@
+// smithy-typescript generated code
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { FSxClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../FSxClient";
+import {
+  CreateFileCacheRequest,
+  CreateFileCacheRequestFilterSensitiveLog,
+  CreateFileCacheResponse,
+  CreateFileCacheResponseFilterSensitiveLog,
+} from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateFileCacheCommand,
+  serializeAws_json1_1CreateFileCacheCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateFileCacheCommandInput extends CreateFileCacheRequest {}
+export interface CreateFileCacheCommandOutput extends CreateFileCacheResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates a new Amazon File Cache resource.</p>
+ *         <p>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, <code>CreateFileCache</code> 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 <code>IncompatibleParameterError</code>.
+ *             If a file cache with the specified client request token doesn't exist,
+ *             <code>CreateFileCache</code> does the following: </p>
+ *         <ul>
+ *             <li>
+ *                 <p>Creates a new, empty Amazon File Cache resourcewith an assigned ID, and
+ *                     an initial lifecycle state of <code>CREATING</code>.</p>
+ *             </li>
+ *             <li>
+ *                 <p>Returns the description of the cache in JSON format.</p>
+ *             </li>
+ *          </ul>
+ *         <note>
+ *             <p>The <code>CreateFileCache</code> call returns while the cache's lifecycle
+ *                 state is still <code>CREATING</code>. You can check the cache creation status
+ *                 by calling the <a href="https://docs.aws.amazon.com/fsx/latest/APIReference/API_DescribeFileCaches.html">DescribeFileCaches</a> operation, which returns the cache state
+ *                 along with other information.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { FSxClient, CreateFileCacheCommand } from "@aws-sdk/client-fsx"; // ES Modules import
+ * // const { FSxClient, CreateFileCacheCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
+ * const client = new FSxClient(config);
+ * const command = new CreateFileCacheCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateFileCacheCommandInput} for command's `input` shape.
+ * @see {@link CreateFileCacheCommandOutput} for command's `response` shape.
+ * @see {@link FSxClientResolvedConfig | config} for FSxClient's `config` shape.
+ *
+ */
+export class CreateFileCacheCommand extends $Command<
+  CreateFileCacheCommandInput,
+  CreateFileCacheCommandOutput,
+  FSxClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateFileCacheCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: FSxClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateFileCacheCommandInput, CreateFileCacheCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "FSxClient";
+    const commandName = "CreateFileCacheCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateFileCacheRequestFilterSensitiveLog,
+      outputFilterSensitiveLog: CreateFileCacheResponseFilterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateFileCacheCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateFileCacheCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateFileCacheCommandOutput> {
+    return deserializeAws_json1_1CreateFileCacheCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

clients/client-fsx/src/commands/CreateFileCacheCommand.ts

@@ -68,16 +68,6 @@ export interface CreateFileSystemCommandOutput extends CreateFileSystemResponse,
  *                 <p>Returns the description of the file system in JSON format.</p>
  *             </li>
  *          </ul>
- *
- *         <p>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 <code>CreateFileSystem</code> 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 a success message as
- *             long as the parameters are the same.</p>
  *         <note>
  *             <p>The <code>CreateFileSystem</code> call returns while the file system's lifecycle
  *                 state is still <code>CREATING</code>. You can check the file-system creation status

clients/client-fsx/src/commands/CreateFileSystemCommand.ts

@@ -0,0 +1,114 @@
+// smithy-typescript generated code
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { FSxClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../FSxClient";
+import {
+  DeleteFileCacheRequest,
+  DeleteFileCacheRequestFilterSensitiveLog,
+  DeleteFileCacheResponse,
+  DeleteFileCacheResponseFilterSensitiveLog,
+} from "../models/models_0";
+import {
+  deserializeAws_json1_1DeleteFileCacheCommand,
+  serializeAws_json1_1DeleteFileCacheCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DeleteFileCacheCommandInput extends DeleteFileCacheRequest {}
+export interface DeleteFileCacheCommandOutput extends DeleteFileCacheResponse, __MetadataBearer {}
+
+/**
+ * <p>Deletes an Amazon File Cache resource. After deletion, the cache no longer exists, and its data
+ *             is gone.</p>
+ *
+ *         <p>The <code>DeleteFileCache</code> operation returns while the cache has the
+ *             <code>DELETING</code> status. You can check the cache deletion status by
+ *             calling the <a href="https://docs.aws.amazon.com/fsx/latest/APIReference/API_DescribeFileCaches.html">DescribeFileCaches</a> operation, which returns a list of caches in your
+ *             account. If you pass the cache ID for a deleted cache, the
+ *             <code>DescribeFileCaches</code> operation returns a <code>FileCacheNotFound</code>
+ *             error.</p>
+ *
+ *         <important>
+ *             <p>The data in a deleted cache is also deleted and can't be recovered by
+ *                 any means.</p>
+ *         </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { FSxClient, DeleteFileCacheCommand } from "@aws-sdk/client-fsx"; // ES Modules import
+ * // const { FSxClient, DeleteFileCacheCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
+ * const client = new FSxClient(config);
+ * const command = new DeleteFileCacheCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteFileCacheCommandInput} for command's `input` shape.
+ * @see {@link DeleteFileCacheCommandOutput} for command's `response` shape.
+ * @see {@link FSxClientResolvedConfig | config} for FSxClient's `config` shape.
+ *
+ */
+export class DeleteFileCacheCommand extends $Command<
+  DeleteFileCacheCommandInput,
+  DeleteFileCacheCommandOutput,
+  FSxClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DeleteFileCacheCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: FSxClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DeleteFileCacheCommandInput, DeleteFileCacheCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "FSxClient";
+    const commandName = "DeleteFileCacheCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DeleteFileCacheRequestFilterSensitiveLog,
+      outputFilterSensitiveLog: DeleteFileCacheResponseFilterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: DeleteFileCacheCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DeleteFileCacheCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteFileCacheCommandOutput> {
+    return deserializeAws_json1_1DeleteFileCacheCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}