agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-fsx/.jsiirc.json

@@ -0,0 +1,13 @@
+{
+  "targets": {
+    "java": {
+      "package": "software.amazon.awscdk.services.fsx"
+    },
+    "dotnet": {
+      "namespace": "Amazon.CDK.AWS.FSx"
+    },
+    "python": {
+      "module": "aws_cdk.aws_fsx"
+    }
+  }
+}

cdk/node_modules/aws-cdk-lib/aws-fsx/README.md

@@ -0,0 +1,281 @@
+# Amazon FSx Construct Library
+
+[Amazon FSx](https://docs.aws.amazon.com/fsx/?id=docs_gateway) provides fully managed third-party file systems with the
+native compatibility and feature sets for workloads such as Microsoft Windows–based storage, high-performance computing,
+machine learning, and electronic design automation.
+
+Amazon FSx supports two file system types: [Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/index.html) and
+[Windows](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/index.html) File Server.
+
+## FSx for Lustre
+
+Amazon FSx for Lustre makes it easy and cost-effective to launch and run the popular, high-performance Lustre file
+system. You use Lustre for workloads where speed matters, such as machine learning, high performance computing (HPC),
+video processing, and financial modeling.
+
+The open-source Lustre file system is designed for applications that require fast storage—where you want your storage
+to keep up with your compute. Lustre was built to solve the problem of quickly and cheaply processing the world's
+ever-growing datasets. It's a widely used file system designed for the fastest computers in the world. It provides
+submillisecond latencies, up to hundreds of GBps of throughput, and up to millions of IOPS. For more information on
+Lustre, see the [Lustre website](http://lustre.org/).
+
+As a fully managed service, Amazon FSx makes it easier for you to use Lustre for workloads where storage speed matters.
+Amazon FSx for Lustre eliminates the traditional complexity of setting up and managing Lustre file systems, enabling
+you to spin up and run a battle-tested high-performance file system in minutes. It also provides multiple deployment
+options so you can optimize cost for your needs.
+
+Amazon FSx for Lustre is POSIX-compliant, so you can use your current Linux-based applications without having to make
+any changes. Amazon FSx for Lustre provides a native file system interface and works as any file system does with your
+Linux operating system. It also provides read-after-write consistency and supports file locking.
+
+### Installation
+
+Import to your project:
+
+```ts nofixture
+import * as fsx from 'aws-cdk-lib/aws-fsx';
+```
+
+### Basic Usage
+
+Setup required properties and create:
+
+```ts
+declare const vpc: ec2.Vpc;
+
+const fileSystem = new fsx.LustreFileSystem(this, 'FsxLustreFileSystem', {
+  lustreConfiguration: { deploymentType: fsx.LustreDeploymentType.SCRATCH_2 },
+  storageCapacityGiB: 1200,
+  vpc,
+  vpcSubnet: vpc.privateSubnets[0],
+});
+```
+
+### File System Type Version
+
+You can set [the Lustre version for the file system](https://docs.aws.amazon.com/ja_jp/AWSCloudFormation/latest/UserGuide/aws-resource-fsx-filesystem.html#cfn-fsx-filesystem-filesystemtypeversion). To do this, use the `fileSystemTypeVersion` property:
+
+```ts
+declare const vpc: ec2.Vpc;
+
+const fileSystem = new fsx.LustreFileSystem(this, 'FsxLustreFileSystem', {
+lustreConfiguration: { deploymentType: fsx.LustreDeploymentType.SCRATCH_2 },
+  storageCapacityGiB: 1200,
+  vpc,
+  vpcSubnet: vpc.privateSubnets[0],
+  fileSystemTypeVersion: fsx.FileSystemTypeVersion.V_2_15,
+});
+```
+
+**Note**: The `fileSystemTypeVersion` has a restrictions on the values that can be set based on the `deploymentType`.
+
+- `V_2_10` is supported by the Scratch and `PERSISTENT_1` deployment types.
+- `V_2_12` is supported by all Lustre deployment types.
+- `V_2_15` is supported by all Lustre deployment types and is recommended for all new file systems.
+
+**Note**: The default value of `fileSystemTypeVersion` is `V_2_10` except for `PERSISTENT_2` deployment type where the default value is `V_2_12`.
+
+### Connecting
+
+To control who can access the file system, use the `.connections` attribute. FSx has a fixed default port, so you don't
+need to specify the port. This example allows an EC2 instance to connect to a file system:
+
+```ts
+declare const fileSystem: fsx.LustreFileSystem;
+declare const instance: ec2.Instance;
+
+fileSystem.connections.allowDefaultPortFrom(instance);
+```
+
+### Mounting
+
+The LustreFileSystem Construct exposes both the DNS name of the file system as well as its mount name, which can be
+used to mount the file system on an EC2 instance. The following example shows how to bring up a file system and EC2
+instance, and then use User Data to mount the file system on the instance at start-up:
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+
+declare const vpc: ec2.Vpc;
+const lustreConfiguration = {
+  deploymentType: fsx.LustreDeploymentType.SCRATCH_2,
+};
+
+const fs = new fsx.LustreFileSystem(this, 'FsxLustreFileSystem', {
+  lustreConfiguration,
+  storageCapacityGiB: 1200,
+  vpc,
+  vpcSubnet: vpc.privateSubnets[0],
+});
+
+const inst = new ec2.Instance(this, 'inst', {
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.LARGE),
+  machineImage: new ec2.AmazonLinuxImage({
+    generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,
+  }),
+  vpc,
+  vpcSubnets: {
+    subnetType: ec2.SubnetType.PUBLIC,
+  },
+});
+fs.connections.allowDefaultPortFrom(inst);
+
+// Need to give the instance access to read information about FSx to determine the file system's mount name.
+inst.role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonFSxReadOnlyAccess'));
+
+const mountPath = '/mnt/fsx';
+const dnsName = fs.dnsName;
+const mountName = fs.mountName;
+
+inst.userData.addCommands(
+  'set -eux',
+  'yum update -y',
+  'amazon-linux-extras install -y lustre2.10',
+  // Set up the directory to mount the file system to and change the owner to the AL2 default ec2-user.
+  `mkdir -p ${mountPath}`,
+  `chmod 777 ${mountPath}`,
+  `chown ec2-user:ec2-user ${mountPath}`,
+  // Set the file system up to mount automatically on start up and mount it.
+  `echo "${dnsName}@tcp:/${mountName} ${mountPath} lustre defaults,noatime,flock,_netdev 0 0" >> /etc/fstab`,
+  'mount -a',
+);
+```
+
+### Importing an existing Lustre filesystem
+
+An FSx for Lustre file system can be imported with `fromLustreFileSystemAttributes(this, id, attributes)`. The
+following example lays out how you could import the SecurityGroup a file system belongs to, use that to import the file
+system, and then also import the VPC the file system is in and add an EC2 instance to it, giving it access to the file
+system.
+
+```ts
+const sg = ec2.SecurityGroup.fromSecurityGroupId(this, 'FsxSecurityGroup', '{SECURITY-GROUP-ID}');
+const fs = fsx.LustreFileSystem.fromLustreFileSystemAttributes(this, 'FsxLustreFileSystem', {
+  dnsName: '{FILE-SYSTEM-DNS-NAME}',
+  fileSystemId: '{FILE-SYSTEM-ID}',
+  securityGroup: sg,
+});
+
+const vpc = ec2.Vpc.fromVpcAttributes(this, 'Vpc', {
+  availabilityZones: ['us-west-2a', 'us-west-2b'],
+  publicSubnetIds: ['{US-WEST-2A-SUBNET-ID}', '{US-WEST-2B-SUBNET-ID}'],
+  vpcId: '{VPC-ID}',
+});
+
+const inst = new ec2.Instance(this, 'inst', {
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.LARGE),
+  machineImage: new ec2.AmazonLinuxImage({
+    generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,
+  }),
+  vpc,
+  vpcSubnets: {
+    subnetType: ec2.SubnetType.PUBLIC,
+  },
+});
+
+fs.connections.allowDefaultPortFrom(inst);
+```
+
+### Lustre Data Repository Association support
+
+The LustreFilesystem Construct supports one [Data Repository Association](https://docs.aws.amazon.com/fsx/latest/LustreGuide/fsx-data-repositories.html) (DRA) to an S3 bucket.  This allows Lustre hierarchical storage management to S3 buckets, which in turn makes it possible to use S3 as a permanent backing store, and use FSx for Lustre as a temporary high performance cache.
+
+Note: CloudFormation does not currently support for `PERSISTENT_2` filesystems, and so neither does CDK.
+
+The following example illustrates setting up a DRA to an S3 bucket, including automated metadata import whenever a file is changed, created or deleted in the S3 bucket:
+
+```ts
+import { aws_s3 as s3 } from 'aws-cdk-lib';
+
+declare const vpc: ec2.Vpc;
+declare const bucket: s3.Bucket;
+
+const lustreConfiguration = {
+  deploymentType: fsx.LustreDeploymentType.SCRATCH_2,
+  exportPath: bucket.s3UrlForObject(),
+  importPath: bucket.s3UrlForObject(),
+  autoImportPolicy: fsx.LustreAutoImportPolicy.NEW_CHANGED_DELETED,
+};
+
+const fs = new fsx.LustreFileSystem(this, "FsxLustreFileSystem", {
+  vpc: vpc,
+  vpcSubnet: vpc.privateSubnets[0],
+  storageCapacityGiB: 1200,
+  lustreConfiguration,
+});
+```
+
+### Compression
+
+By default, transparent compression of data within FSx for Lustre is switched off.  To enable it, add the following to your `lustreConfiguration`:
+
+```ts
+const lustreConfiguration = {
+  // ...
+  dataCompressionType: fsx.LustreDataCompressionType.LZ4,
+  // ...
+}
+```
+
+When you turn data compression on for an existing file system, only newly written files are compressed.  Existing files are not compressed. For more information, see [Compressing previously written files](https://docs.aws.amazon.com/fsx/latest/LustreGuide/data-compression.html#migrate-compression).
+
+### Backups
+
+You can take daily automatic backups by setting `automaticBackupRetention` to a non-zero day in the `lustreConfiguration`.
+
+Additionally, you can set the backup window by specifying the `dailyAutomaticBackupStartTime`.
+
+```ts
+import * as cdk from 'aws-cdk-lib';
+
+const lustreConfiguration = {
+  // ...
+  automaticBackupRetention: cdk.Duration.days(3), // backup retention
+  copyTagsToBackups: true, // if true, tags are copied to backups
+  dailyAutomaticBackupStartTime: new fsx.DailyAutomaticBackupStartTime({ hour: 11, minute: 30 }),  // backup window
+  // ...
+}
+```
+
+For more information, see [Working with backups
+](https://docs.aws.amazon.com/fsx/latest/LustreGuide/using-backups-fsx.html).
+
+### Storage Type
+
+By default, FSx for Lustre uses SSD storage. To use HDD storage, specify `storageType`:
+
+```ts
+declare const vpc: ec2.Vpc;
+
+const fileSystem = new fsx.LustreFileSystem(this, 'FsxLustreFileSystem', {
+  lustreConfiguration: { deploymentType: fsx.LustreDeploymentType.PERSISTENT_1 },
+  storageCapacityGiB: 1200,
+  vpc,
+  vpcSubnet: vpc.privateSubnets[0],
+  storageType: fsx.StorageType.HDD,
+});
+```
+
+**Note:** The HDD storage type is only supported for `PERSISTENT_1` deployment types.
+
+To improve the performance of frequently accessed files by caching up to 20% of the total storage capacity of the file system, set `driveCacheType` to `READ`:
+
+```ts
+declare const vpc: ec2.Vpc;
+
+const fileSystem = new fsx.LustreFileSystem(this, 'FsxLustreFileSystem', {
+  lustreConfiguration: {
+    deploymentType: fsx.LustreDeploymentType.PERSISTENT_1,
+    driveCacheType: fsx.DriveCacheType.READ,
+    },
+  storageCapacityGiB: 1200,
+  vpc,
+  vpcSubnet: vpc.privateSubnets[0],
+  storageType: fsx.StorageType.HDD,
+});
+```
+
+## FSx for Windows File Server
+
+The L2 construct for the FSx for Windows File Server has not yet been implemented. To instantiate an FSx for Windows
+file system, the L1 constructs can be used as defined by CloudFormation.

cdk/node_modules/aws-cdk-lib/aws-fsx/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/daily-automatic-backup-start-time.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Properties required for setting up a daily automatic backup time.
+ */
+export interface DailyAutomaticBackupStartTimeProps {
+    /**
+     * The hour of the day (from 0-23) for automatic backup starts.
+     */
+    readonly hour: number;
+    /**
+     * The minute of the hour (from 0-59) for automatic backup starts.
+     */
+    readonly minute: number;
+}
+/**
+ * Class for scheduling a daily automatic backup time.
+ */
+export declare class DailyAutomaticBackupStartTime {
+    /**
+     * The start hour of the automatic backup time in Coordinated Universal Time (UTC), using 24-hour time.
+     * For example, 17 refers to 5:00 P.M. UTC.
+     *
+     * @default - 22
+     */
+    private readonly hour;
+    /**
+     * The start minute of the automatic backup time, in UTC.
+     *
+     * @default - 0
+     */
+    private readonly minute;
+    constructor(props: DailyAutomaticBackupStartTimeProps);
+    /**
+     * Converts an hour, and minute into HH:MM string.
+     */
+    toTimestamp(): string;
+    /**
+     * Pad an integer so that it always contains at least 2 digits. Assumes the number is a positive integer.
+     */
+    private getTwoDigitString;
+    /**
+     * Validation needed for the values of the daily automatic backup time.
+     */
+    private validate;
+}

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/daily-automatic-backup-start-time.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DailyAutomaticBackupStartTime=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};class DailyAutomaticBackupStartTime{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_fsx.DailyAutomaticBackupStartTime",version:"2.252.0"};hour;minute;constructor(props){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_fsx_DailyAutomaticBackupStartTimeProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,DailyAutomaticBackupStartTime),error}this.validate(props.hour,props.minute),this.hour=this.getTwoDigitString(props.hour),this.minute=this.getTwoDigitString(props.minute)}toTimestamp(){return`${this.hour}:${this.minute}`}getTwoDigitString(n){const numberString=n.toString();return numberString.length===1?`0${n}`:numberString}validate(hour,minute){if(!Number.isInteger(hour)||hour<0||hour>23)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`DailyAutomaticBackupStartTimeHourMustBeInteger`,`dailyAutomaticBackupStartTime hour must be an integer between 0 and 24. received: ${hour}`);if(!Number.isInteger(minute)||minute<0||minute>59)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`DailyAutomaticBackupStartTimeMinuteMustBeInteger`,`dailyAutomaticBackupStartTime minute must be an integer between 0 and 59. received: ${minute}`)}}exports.DailyAutomaticBackupStartTime=DailyAutomaticBackupStartTime;

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/file-system.d.ts

@@ -0,0 +1,120 @@
+import type { Connections, IConnectable, ISecurityGroup, IVpc } from '../../aws-ec2';
+import type { IKeyRef } from '../../aws-kms';
+import type { RemovalPolicy } from '../../core';
+import { Resource } from '../../core';
+/**
+ * The storage type for the file system.
+ */
+export declare enum StorageType {
+    /**
+     * Solid State Drive storage
+     */
+    SSD = "SSD",
+    /**
+     * Hard Disk Drive storage
+     */
+    HDD = "HDD",
+    /**
+     * Intelligent Tiering storage
+     */
+    INTELLIGENT_TIERING = "INTELLIGENT_TIERING"
+}
+/**
+ * Interface to implement FSx File Systems.
+ */
+export interface IFileSystem extends IConnectable {
+    /**
+     * The ID of the file system, assigned by Amazon FSx.
+     * @attribute
+     */
+    readonly fileSystemId: string;
+}
+/**
+ * Properties for the FSx file system
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-fsx-filesystem.html
+ */
+export interface FileSystemProps {
+    /**
+     * The VPC to launch the file system in.
+     */
+    readonly vpc: IVpc;
+    /**
+     * The ID of the backup. Specifies the backup to use if you're creating a file system from an existing backup.
+     *
+     * @default - no backup will be used.
+     */
+    readonly backupId?: string;
+    /**
+     * The KMS key used for encryption to protect your data at rest.
+     *
+     * @default - the aws/fsx default KMS key for the AWS account being deployed into.
+     */
+    readonly kmsKey?: IKeyRef;
+    /**
+     * Security Group to assign to this file system.
+     *
+     * @default - creates new security group which allows all outbound traffic.
+     */
+    readonly securityGroup?: ISecurityGroup;
+    /**
+     * The storage capacity of the file system being created.
+     *
+     * For Windows file systems, valid values are 32 GiB to 65,536 GiB.
+     * For SCRATCH_1 deployment types, valid values are 1,200, 2,400, 3,600, then continuing in increments of 3,600 GiB.
+     * For SCRATCH_2, PERSISTENT_2 and PERSISTENT_1 deployment types using SSD storage type, the valid values are 1200 GiB, 2400 GiB, and increments of 2400 GiB.
+     * For PERSISTENT_1 HDD file systems, valid values are increments of 6000 GiB for 12 MB/s/TiB file systems and increments of 1800 GiB for 40 MB/s/TiB file systems.
+     */
+    readonly storageCapacityGiB: number;
+    /**
+     * Policy to apply when the file system is removed from the stack
+     *
+     * @default RemovalPolicy.RETAIN
+     */
+    readonly removalPolicy?: RemovalPolicy;
+    /**
+     * The storage type for the file system that you're creating.
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-fsx-filesystem.html#cfn-fsx-filesystem-storagetype
+     *
+     * @default StorageType.SSD
+     */
+    readonly storageType?: StorageType;
+}
+/**
+ * A new or imported FSx file system.
+ */
+export declare abstract class FileSystemBase extends Resource implements IFileSystem {
+    /**
+     * The security groups/rules used to allow network connections to the file system.
+     * @attribute
+     */
+    abstract readonly connections: Connections;
+    /**
+     * The DNS name assigned to this file system.
+     * @attribute
+     */
+    abstract readonly dnsName: string;
+    /**
+     * The ID of the file system, assigned by Amazon FSx.
+     * @attribute
+     */
+    abstract readonly fileSystemId: string;
+}
+/**
+ * Properties that describe an existing FSx file system.
+ */
+export interface FileSystemAttributes {
+    /**
+     * The DNS name assigned to this file system.
+     */
+    readonly dnsName: string;
+    /**
+     * The ID of the file system, assigned by Amazon FSx.
+     */
+    readonly fileSystemId: string;
+    /**
+     * The security group of the file system.
+     */
+    readonly securityGroup: ISecurityGroup;
+}

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/file-system.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.FileSystemBase=exports.StorageType=void 0;const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},StorageType;(function(StorageType2){StorageType2.SSD="SSD",StorageType2.HDD="HDD",StorageType2.INTELLIGENT_TIERING="INTELLIGENT_TIERING"})(StorageType||(exports.StorageType=StorageType={}));class FileSystemBase extends core_1().Resource{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_fsx.FileSystemBase",version:"2.252.0"}}exports.FileSystemBase=FileSystemBase;

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/fsx-canned-metrics.generated.d.ts

@@ -0,0 +1,88 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class FSxMetrics {
+    static clientConnectionsSampleCount(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static cpuUtilizationAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static dataReadBytesSum(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static dataReadOperationsSum(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static dataWriteBytesSum(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static dataWriteOperationsSum(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static diskThroughputBalanceAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static diskThroughputUtilizationAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static fileServerDiskIopsBalanceAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static fileServerDiskIopsUtilizationAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static fileServerDiskThroughputUtilizationAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static freeDataStorageCapacitySum(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static freeStorageCapacityAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static memoryUtilizationAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static metadataOperationsSum(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+    static networkThroughputUtilizationAverage(this: void, dimensions: {
+        FileSystemId: string;
+    }): MetricWithDims<{
+        FileSystemId: string;
+    }>;
+}

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/fsx-canned-metrics.generated.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.FSxMetrics=void 0;class FSxMetrics{static clientConnectionsSampleCount(dimensions){return{namespace:"AWS/FSx",metricName:"ClientConnections",dimensionsMap:dimensions,statistic:"SampleCount"}}static cpuUtilizationAverage(dimensions){return{namespace:"AWS/FSx",metricName:"CPUUtilization",dimensionsMap:dimensions,statistic:"Average"}}static dataReadBytesSum(dimensions){return{namespace:"AWS/FSx",metricName:"DataReadBytes",dimensionsMap:dimensions,statistic:"Sum"}}static dataReadOperationsSum(dimensions){return{namespace:"AWS/FSx",metricName:"DataReadOperations",dimensionsMap:dimensions,statistic:"Sum"}}static dataWriteBytesSum(dimensions){return{namespace:"AWS/FSx",metricName:"DataWriteBytes",dimensionsMap:dimensions,statistic:"Sum"}}static dataWriteOperationsSum(dimensions){return{namespace:"AWS/FSx",metricName:"DataWriteOperations",dimensionsMap:dimensions,statistic:"Sum"}}static diskThroughputBalanceAverage(dimensions){return{namespace:"AWS/FSx",metricName:"DiskThroughputBalance",dimensionsMap:dimensions,statistic:"Average"}}static diskThroughputUtilizationAverage(dimensions){return{namespace:"AWS/FSx",metricName:"DiskThroughputUtilization",dimensionsMap:dimensions,statistic:"Average"}}static fileServerDiskIopsBalanceAverage(dimensions){return{namespace:"AWS/FSx",metricName:"FileServerDiskIopsBalance",dimensionsMap:dimensions,statistic:"Average"}}static fileServerDiskIopsUtilizationAverage(dimensions){return{namespace:"AWS/FSx",metricName:"FileServerDiskIopsUtilization",dimensionsMap:dimensions,statistic:"Average"}}static fileServerDiskThroughputUtilizationAverage(dimensions){return{namespace:"AWS/FSx",metricName:"FileServerDiskThroughputUtilization",dimensionsMap:dimensions,statistic:"Average"}}static freeDataStorageCapacitySum(dimensions){return{namespace:"AWS/FSx",metricName:"FreeDataStorageCapacity",dimensionsMap:dimensions,statistic:"Sum"}}static freeStorageCapacityAverage(dimensions){return{namespace:"AWS/FSx",metricName:"FreeStorageCapacity",dimensionsMap:dimensions,statistic:"Average"}}static memoryUtilizationAverage(dimensions){return{namespace:"AWS/FSx",metricName:"MemoryUtilization",dimensionsMap:dimensions,statistic:"Average"}}static metadataOperationsSum(dimensions){return{namespace:"AWS/FSx",metricName:"MetadataOperations",dimensionsMap:dimensions,statistic:"Sum"}}static networkThroughputUtilizationAverage(dimensions){return{namespace:"AWS/FSx",metricName:"NetworkThroughputUtilization",dimensionsMap:dimensions,statistic:"Average"}}}exports.FSxMetrics=FSxMetrics;

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './daily-automatic-backup-start-time';
+export * from './file-system';
+export * from './fsx.generated';
+export * from './lustre-file-system';
+export * from './maintenance-time';

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/lustre-file-system.d.ts

@@ -0,0 +1,325 @@
+import type { Construct } from 'constructs';
+import type { DailyAutomaticBackupStartTime } from './daily-automatic-backup-start-time';
+import type { FileSystemAttributes, FileSystemProps, IFileSystem } from './file-system';
+import { FileSystemBase } from './file-system';
+import type { LustreMaintenanceTime } from './maintenance-time';
+import type { ISubnet } from '../../aws-ec2';
+import { Connections } from '../../aws-ec2';
+import { Duration } from '../../core';
+/**
+ * The Lustre version for the file system.
+ */
+export declare enum FileSystemTypeVersion {
+    /**
+     * Version 2.10
+     */
+    V_2_10 = "2.10",
+    /**
+     * Version 2.12
+     */
+    V_2_12 = "2.12",
+    /**
+     * Version 2.15
+     */
+    V_2_15 = "2.15"
+}
+/**
+ * The different kinds of file system deployments used by Lustre.
+ */
+export declare enum LustreDeploymentType {
+    /**
+     * Original type for shorter term data processing. Data is not replicated and does not persist on server fail.
+     */
+    SCRATCH_1 = "SCRATCH_1",
+    /**
+     * Newer type for shorter term data processing. Data is not replicated and does not persist on server fail.
+     * Provides better support for spiky workloads.
+     */
+    SCRATCH_2 = "SCRATCH_2",
+    /**
+     * Long term storage. Data is replicated and file servers are replaced if they fail.
+     */
+    PERSISTENT_1 = "PERSISTENT_1",
+    /**
+     * Newer type of long term storage with higher throughput tiers.
+     * Data is replicated and file servers are replaced if they fail.
+     */
+    PERSISTENT_2 = "PERSISTENT_2"
+}
+/**
+ * The different auto import policies which are allowed
+ */
+export declare enum LustreAutoImportPolicy {
+    /**
+     * AutoImport is off. Amazon FSx only updates file and directory listings from the linked S3 bucket when the file system is created. FSx does not update file and directory listings for any new or changed objects after choosing this option.
+     */
+    NONE = "NONE",
+    /**
+     * AutoImport is on. Amazon FSx automatically imports directory listings of any new objects added to the linked S3 bucket that do not currently exist in the FSx file system.
+     */
+    NEW = "NEW",
+    /**
+     * AutoImport is on. Amazon FSx automatically imports file and directory listings of any new objects added to the S3 bucket and any existing objects that are changed in the S3 bucket after you choose this option.
+     */
+    NEW_CHANGED = "NEW_CHANGED",
+    /**
+     * AutoImport is on. Amazon FSx automatically imports file and directory listings of any new objects added to the S3 bucket, any existing objects that are changed in the S3 bucket, and any objects that were deleted in the S3 bucket.
+     * */
+    NEW_CHANGED_DELETED = "NEW_CHANGED_DELETED"
+}
+/**
+ * The type of drive cache used by PERSISTENT_1 file systems that are provisioned with HDD storage devices.
+ */
+export declare enum DriveCacheType {
+    /**
+     * The Lustre file system is configured with no data cache.
+     */
+    NONE = "NONE",
+    /**
+     * The Lustre file system is configured with a read cache.
+     */
+    READ = "READ"
+}
+/**
+ * The permitted Lustre data compression algorithms
+ */
+export declare enum LustreDataCompressionType {
+    /**
+     *
+     * `NONE` - (Default) Data compression is turned off when the file system is created.
+     */
+    NONE = "NONE",
+    /**
+     * `LZ4` - Data compression is turned on with the LZ4 algorithm.  Note: When you turn data compression on for an existing file system, only newly written files are compressed. Existing files are not compressed.
+     */
+    LZ4 = "LZ4"
+}
+/**
+ * The configuration for the Amazon FSx for Lustre file system.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-lustreconfiguration.html
+ */
+export interface LustreConfiguration {
+    /**
+     * The type of backing file system deployment used by FSx.
+     */
+    readonly deploymentType: LustreDeploymentType;
+    /**
+     * The path in Amazon S3 where the root of your Amazon FSx file system is exported. The path must use the same
+     * Amazon S3 bucket as specified in ImportPath. If you only specify a bucket name, such as s3://import-bucket, you
+     * get a 1:1 mapping of file system objects to S3 bucket objects. This mapping means that the input data in S3 is
+     * overwritten on export. If you provide a custom prefix in the export path, such as
+     * s3://import-bucket/[custom-optional-prefix], Amazon FSx exports the contents of your file system to that export
+     * prefix in the Amazon S3 bucket.
+     *
+     * @default s3://import-bucket/FSxLustre[creation-timestamp]
+     */
+    readonly exportPath?: string;
+    /**
+     * For files imported from a data repository, this value determines the stripe count and maximum amount of data per
+     * file (in MiB) stored on a single physical disk. Allowed values are between 1 and 512,000.
+     *
+     * @default 1024
+     */
+    readonly importedFileChunkSizeMiB?: number;
+    /**
+     * The path to the Amazon S3 bucket (including the optional prefix) that you're using as the data repository for
+     * your Amazon FSx for Lustre file system. Must be of the format "s3://{bucketName}/optional-prefix" and cannot
+     * exceed 900 characters.
+     *
+     * @default - no bucket is imported
+     */
+    readonly importPath?: string;
+    /**
+     * Available with `Scratch` and `Persistent_1` deployment types. When you create your file system, your existing S3 objects appear as file and directory listings. Use this property to choose how Amazon FSx keeps your file and directory listings up to date as you add or modify objects in your linked S3 bucket. `AutoImportPolicy` can have the following values:
+     *
+     * For more information, see [Automatically import updates from your S3 bucket](https://docs.aws.amazon.com/fsx/latest/LustreGuide/autoimport-data-repo.html) .
+     *
+     * > This parameter is not supported for Lustre file systems using the `Persistent_2` deployment type.
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-lustreconfiguration.html#cfn-fsx-filesystem-lustreconfiguration-autoimportpolicy
+     * @default - no import policy
+     */
+    readonly autoImportPolicy?: LustreAutoImportPolicy;
+    /**
+     * Sets the data compression configuration for the file system.
+     * For more information, see [Lustre data compression](https://docs.aws.amazon.com/fsx/latest/LustreGuide/data-compression.html) in the *Amazon FSx for Lustre User Guide* .
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-lustreconfiguration.html#cfn-fsx-filesystem-lustreconfiguration-datacompressiontype
+     * @default - no compression
+     */
+    readonly dataCompressionType?: LustreDataCompressionType;
+    /**
+     * Provisions the amount of read and write throughput for each 1 tebibyte (TiB) of file system storage capacity, in MB/s/TiB.
+     * Required with PERSISTENT_1 and PERSISTENT_2 deployment types.
+     *
+     * Valid values:
+     * - For PERSISTENT_1 SSD storage: 50, 100, 200 MB/s/TiB.
+     * - For PERSISTENT_1 HDD storage: 12, 40 MB/s/TiB.
+     * - For PERSISTENT_2 SSD storage: 125, 250, 500, 1000 MB/s/TiB.
+     *
+     * @default - no default, conditionally required for PERSISTENT_1 and PERSISTENT_2 deployment type
+     */
+    readonly perUnitStorageThroughput?: number;
+    /**
+     * The preferred day and time to perform weekly maintenance. The first digit is the day of the week, starting at 1
+     * for Monday, then the following are hours and minutes in the UTC time zone, 24 hour clock. For example: '2:20:30'
+     * is Tuesdays at 20:30.
+     *
+     * @default - no preference
+     */
+    readonly weeklyMaintenanceStartTime?: LustreMaintenanceTime;
+    /**
+     * The number of days to retain automatic backups.
+     * Setting this property to 0 disables automatic backups.
+     * You can retain automatic backups for a maximum of 90 days.
+     *
+     * Automatic Backups is not supported on scratch file systems.
+     *
+     * @default Duration.days(0)
+     */
+    readonly automaticBackupRetention?: Duration;
+    /**
+     * A boolean flag indicating whether tags for the file system should be copied to backups.
+     *
+     * @default - false
+     */
+    readonly copyTagsToBackups?: boolean;
+    /**
+     * Start time for 30-minute daily automatic backup window in Coordinated Universal Time (UTC).
+     *
+     * @default - no backup window
+     */
+    readonly dailyAutomaticBackupStartTime?: DailyAutomaticBackupStartTime;
+    /**
+     * The type of drive cache used by PERSISTENT_1 file systems that are provisioned with HDD storage devices.
+     *
+     * @default - no drive cache
+     */
+    readonly driveCacheType?: DriveCacheType;
+}
+/**
+ * Properties specific to the Lustre version of the FSx file system.
+ */
+export interface LustreFileSystemProps extends FileSystemProps {
+    /**
+     * Additional configuration for FSx specific to Lustre.
+     */
+    readonly lustreConfiguration: LustreConfiguration;
+    /**
+     * The Lustre version for the file system.
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-fsx-filesystem.html#cfn-fsx-filesystem-filesystemtypeversion
+     *
+     * @default - V_2_10, except for PERSISTENT_2 deployment type, where it is V_2_12 without metadata configuration mode and V_2_15 with metadata configuration mode.
+     */
+    readonly fileSystemTypeVersion?: FileSystemTypeVersion;
+    /**
+     * The subnet that the file system will be accessible from.
+     */
+    readonly vpcSubnet: ISubnet;
+}
+/**
+ * The FSx for Lustre File System implementation of IFileSystem.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-fsx-filesystem.html
+ *
+ * @resource AWS::FSx::FileSystem
+ */
+export declare class LustreFileSystem extends FileSystemBase {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing FSx for Lustre file system from the given properties.
+     */
+    static fromLustreFileSystemAttributes(scope: Construct, id: string, attrs: FileSystemAttributes): IFileSystem;
+    /**
+     * The default FSx file system type used by FSx for Lustre.
+     */
+    private static readonly DEFAULT_FILE_SYSTEM_TYPE;
+    /**
+     * The default ports the file system listens on. Actual port list is: [988, 1021, 1022, 1023]
+     */
+    private static readonly DEFAULT_PORT_RANGE;
+    /**
+     * Configures a Connections object with all the ports required by FSx for Lustre
+     */
+    private static configureConnections;
+    /**
+     * The security groups/rules used to allow network connections to the file system.
+     */
+    readonly connections: Connections;
+    /**
+     * The DNS name assigned to this file system.
+     */
+    readonly dnsName: string;
+    /**
+     * The ID that AWS assigns to the file system.
+     */
+    readonly fileSystemId: string;
+    /**
+     * The mount name of the file system, generated by FSx
+     *
+     * @attribute LustreMountName
+     */
+    readonly mountName: string;
+    /**
+     * The encapsulated L1 file system.
+     */
+    private readonly fileSystem;
+    constructor(scope: Construct, id: string, props: LustreFileSystemProps);
+    /**
+     * Validates the props provided for a new FSx for Lustre file system.
+     */
+    private validateProps;
+    /**
+     * Validates the drive cache type is only set for the PERSISTENT_1 deployment type and HDD storage type.
+     */
+    private validateDriveCacheType;
+    /**
+     * Validates if the storage type corresponds to the appropriate deployment type.
+     */
+    private validateStorageType;
+    /**
+     * Validates the file system type version
+     */
+    private validateFiileSystemTypeVersion;
+    /**
+     * Validates the auto import policy
+     */
+    private validateAutoImportPolicy;
+    /**
+     * Validates the export path is in the correct format and matches the import path.
+     */
+    private validateExportPath;
+    /**
+     * Validates the importedFileChunkSize is in the correct range.
+     */
+    private validateImportedFileChunkSize;
+    /**
+     * Validates the import path is the correct format.
+     */
+    private validateImportPath;
+    /**
+     * Validates the perUnitStorageThroughput is defined correctly for the given deploymentType.
+     *
+     * @see https://docs.aws.amazon.com/fsx/latest/LustreGuide/managing-throughput-capacity.html
+     */
+    private validatePerUnitStorageThroughput;
+    /**
+     * Validates the storage capacity is an acceptable value for the deployment type.
+     *
+     * @see https://docs.aws.amazon.com/fsx/latest/LustreGuide/increase-storage-capacity.html
+     */
+    private validateStorageCapacity;
+    /**
+     * Validates the automaticBackupRetention with a non-scratch deployment class and an acceptable day value.
+     */
+    private validateAutomaticBackupRetention;
+    /**
+     * Validates the dailyAutomaticBackupStartTime is set with a non-zero day automaticBackupRetention.
+     */
+    private validateDailyAutomaticBackupStartTime;
+}

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/maintenance-time.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Enum for representing all the days of the week
+ */
+export declare enum Weekday {
+    /**
+     * Monday
+     */
+    MONDAY = "1",
+    /**
+     * Tuesday
+     */
+    TUESDAY = "2",
+    /**
+     * Wednesday
+     */
+    WEDNESDAY = "3",
+    /**
+     * Thursday
+     */
+    THURSDAY = "4",
+    /**
+     * Friday
+     */
+    FRIDAY = "5",
+    /**
+     * Saturday
+     */
+    SATURDAY = "6",
+    /**
+     * Sunday
+     */
+    SUNDAY = "7"
+}
+/**
+ * Properties required for setting up a weekly maintenance time
+ */
+export interface LustreMaintenanceTimeProps {
+    /**
+     * The day of the week for maintenance to be performed.
+     */
+    readonly day: Weekday;
+    /**
+     * The hour of the day (from 0-23) for maintenance to be performed.
+     */
+    readonly hour: number;
+    /**
+     * The minute of the hour (from 0-59) for maintenance to be performed.
+     */
+    readonly minute: number;
+}
+/**
+ * Class for scheduling a weekly maintenance time.
+ */
+export declare class LustreMaintenanceTime {
+    /**
+     * The day of the week for maintenance to be performed.
+     */
+    private readonly day;
+    /**
+     * The hour of the day (from 00-23) for maintenance to be performed.
+     */
+    private readonly hour;
+    /**
+     * The minute of the hour (from 00-59) for maintenance to be performed.
+     */
+    private readonly minute;
+    constructor(props: LustreMaintenanceTimeProps);
+    /**
+     * Converts a day, hour, and minute into a timestamp as used by FSx for Lustre's weeklyMaintenanceStartTime field.
+     */
+    toTimestamp(): string;
+    /**
+     * Pad an integer so that it always contains at least 2 digits. Assumes the number is a positive integer.
+     */
+    private getTwoDigitString;
+    /**
+     * Validation needed for the values of the maintenance time.
+     */
+    private validate;
+}

cdk/node_modules/aws-cdk-lib/aws-fsx/lib/maintenance-time.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LustreMaintenanceTime=exports.Weekday=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp},Weekday;(function(Weekday2){Weekday2.MONDAY="1",Weekday2.TUESDAY="2",Weekday2.WEDNESDAY="3",Weekday2.THURSDAY="4",Weekday2.FRIDAY="5",Weekday2.SATURDAY="6",Weekday2.SUNDAY="7"})(Weekday||(exports.Weekday=Weekday={}));class LustreMaintenanceTime{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_fsx.LustreMaintenanceTime",version:"2.252.0"};day;hour;minute;constructor(props){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_fsx_LustreMaintenanceTimeProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,LustreMaintenanceTime),error}this.validate(props.hour,props.minute),this.day=props.day,this.hour=this.getTwoDigitString(props.hour),this.minute=this.getTwoDigitString(props.minute)}toTimestamp(){return`${this.day.valueOf()}:${this.hour}:${this.minute}`}getTwoDigitString(n){const numberString=n.toString();return numberString.length===1?`0${n}`:numberString}validate(hour,minute){if(!Number.isInteger(hour)||hour<0||hour>23)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`MaintenanceTimeHourMustBeInteger`,"Maintenance time hour must be an integer between 0 and 23");if(!Number.isInteger(minute)||minute<0||minute>59)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`MaintenanceTimeMinuteMustBeInteger`,"Maintenance time minute must be an integer between 0 and 59")}}exports.LustreMaintenanceTime=LustreMaintenanceTime;