terraconstructs 0.0.11 → 0.0.13

package/lib/aws/compute/subnet-v2.js

@@ -0,0 +1,405 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubnetV2 = exports.IpCidr = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/subnet-v2.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+// import { Lazy } from "cdktf";
+const constructs_1 = require("constructs");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+const network_acl_1 = require("./network-acl");
+const aws_construct_1 = require("../aws-construct");
+const ec2_util_v2_1 = require("./ec2-util-v2");
+const route_1 = require("./route");
+const vpc_1 = require("./vpc");
+const aws_stack_1 = require("../aws-stack");
+/**
+ * IPv4 or IPv6 CIDR range for the subnet
+ */
+class IpCidr {
+    constructor(props) {
+        this.cidr = props;
+    }
+}
+exports.IpCidr = IpCidr;
+_a = JSII_RTTI_SYMBOL_1;
+IpCidr[_a] = { fqn: "terraconstructs.aws.compute.alpha.IpCidr", version: "0.0.13" };
+/**
+ * Name tag constant
+ */
+const NAME_TAG = "Name";
+/**
+ * VPC Name tag constant
+ */
+const VPCNAME_TAG = "VpcName";
+/**
+ * The SubnetV2 class represents a subnet within a VPC (Virtual Private Cloud) in AWS.
+ * It extends the Resource class and implements the ISubnet interface.
+ *
+ * Instances of this class can be used to create and manage subnets within a VpcV2 instance.
+ * Subnets can be configured with specific IP address ranges (IPv4 and IPv6), availability zones,
+ * and subnet types (e.g., public, private, isolated).
+ *
+ * @resource AWS::EC2::Subnet
+ *
+ */
+class SubnetV2 extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import an existing subnet to the VPC
+     */
+    static fromSubnetV2Attributes(scope, id, attrs) {
+        /**
+         * Class to define an import for an existing subnet
+         * @resource AWS::EC2::Subnet
+         */
+        class ImportedSubnetV2 extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                /**
+                 * The IPv6 CIDR Block assigned to this subnet
+                 */
+                this.ipv6CidrBlock = attrs.ipv6CidrBlock;
+                /**
+                 * The type of subnet (eg. public or private) that this subnet represents.
+                 */
+                this.subnetType = attrs.subnetType;
+                /**
+                 * The Availability Zone in which subnet is located
+                 */
+                this.availabilityZone = attrs.availabilityZone;
+                /**
+                 * The subnetId for this particular subnet
+                 * Refers to the physical ID created
+                 */
+                this.subnetId = attrs.subnetId;
+                /**
+                 * Dependable that can be depended upon to force internet connectivity established on the VPC
+                 */
+                this.internetConnectivityEstablished = new constructs_1.DependencyGroup();
+                /**
+                 * The IPv4 CIDR block assigned to this subnet
+                 */
+                this.ipv4CidrBlock = attrs.ipv4CidrBlock;
+                /**
+                 *  Current route table associated with this subnet
+                 */
+                this.routeTable = {
+                    routeTableId: attrs.routeTableId,
+                };
+                this.subnetOutputs = {
+                    subnetId: this.subnetId,
+                    ipv4CidrBlock: this.ipv4CidrBlock,
+                    routeTableId: this.routeTable.routeTableId,
+                };
+            }
+            get outputs() {
+                return this.subnetOutputs;
+            }
+            /**
+             * Associate a Network ACL with this subnet
+             * Required here since it is implemented in the ISubnetV2
+             */
+            associateNetworkAcl(aclId, networkAcl) {
+                const aclScope = networkAcl instanceof constructs_1.Construct ? networkAcl : this;
+                const other = networkAcl instanceof constructs_1.Construct ? this : networkAcl;
+                new network_acl_1.SubnetNetworkAclAssociation(aclScope, aclId + aws_stack_1.AwsStack.uniqueId(other), {
+                    networkAcl,
+                    subnet: this,
+                });
+            }
+        }
+        return new ImportedSubnetV2(scope, id);
+    }
+    get subnetOutputs() {
+        return {
+            subnetId: this.subnetId,
+            ipv4CidrBlock: this.ipv4CidrBlock,
+            routeTableId: this.routeTable.routeTableId,
+        };
+    }
+    get outputs() {
+        return this.subnetOutputs;
+    }
+    /**
+     * Constructs a new SubnetV2 instance.
+     * @param scope The parent Construct that this resource will be part of.
+     * @param id The unique identifier for this resource.
+     * @param props The configuration properties for the subnet.
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        /**
+         * The variable name `internetConnectivityEstablished` does not reflect what it actually is.
+         * The naming is enforced by ISubnet. We need to keep it to maintain compatibility.
+         * It exposes the RouteTable-Subnet association so that other resources can depend on it.
+         * E.g. Resources in a subnet, when being deleted, may need the RouteTable to exist in order to delete properly
+         */
+        this._internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        const subnetName = props.subnetName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+                maxLength: 128,
+                allowedSpecialCharacters: "_",
+            });
+        // Lazy.string({
+        //   produce: () =>
+        //     Names.uniqueResourceName(this, {
+        //       maxLength: 128,
+        //       allowedSpecialCharacters: "_",
+        //     }),
+        // }),
+        const ipv4CidrBlock = props.ipv4CidrBlock.cidr;
+        const ipv6CidrBlock = props.ipv6CidrBlock?.cidr;
+        if (!checkCidrRanges(props.vpc, props.ipv4CidrBlock.cidr)) {
+            throw new Error("CIDR block should be within the range of VPC");
+        }
+        let overlap = false;
+        let overlapIpv6 = false;
+        overlap = validateOverlappingCidrRanges(props.vpc, props.ipv4CidrBlock.cidr);
+        //check whether VPC supports ipv6
+        if (props.ipv6CidrBlock?.cidr) {
+            validateSupportIpv6(props.vpc);
+            overlapIpv6 = validateOverlappingCidrRangesipv6(props.vpc, props.ipv6CidrBlock?.cidr);
+        }
+        if (overlap || overlapIpv6) {
+            throw new Error("CIDR block should not overlap with existing subnet blocks");
+        }
+        if (props.assignIpv6AddressOnCreation && !props.ipv6CidrBlock) {
+            throw new Error("IPv6 CIDR block is required when assigning IPv6 address on creation");
+        }
+        this.resource = new provider_aws_1.subnet.Subnet(this, "Resource", {
+            vpcId: props.vpc.vpcId,
+            cidrBlock: ipv4CidrBlock,
+            ipv6CidrBlock: ipv6CidrBlock,
+            availabilityZone: props.availabilityZone,
+            assignIpv6AddressOnCreation: props.assignIpv6AddressOnCreation ?? false,
+        });
+        this.node.defaultChild = this.resource;
+        this.ipv4CidrBlock = props.ipv4CidrBlock.cidr;
+        this.ipv6CidrBlock = props.ipv6CidrBlock?.cidr;
+        this.subnetId = this.resource.id;
+        this.availabilityZone = props.availabilityZone;
+        // Terraform subnet does not provide the default ACL NetworkAclAssociationId attribute
+        // this._networkAcl = NetworkAcl.fromNetworkAclId(
+        //   this,
+        //   "Acl",
+        //   this.resource.NetworkAclAssociationId,
+        // );
+        if (props.subnetName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, subnetName);
+        }
+        if (props.vpc.vpcName) {
+            aws_tags_1.Tags.of(this).add(VPCNAME_TAG, props.vpc.vpcName);
+        }
+        if (props.routeTable) {
+            this._routeTable = props.routeTable;
+        }
+        else {
+            // Assigning a default route table
+            this._routeTable = new route_1.RouteTable(this, "RouteTable", {
+                vpc: props.vpc,
+                routeTableName: "DefaultCDKRouteTable",
+            });
+        }
+        const routeAssoc = new provider_aws_1.routeTableAssociation.RouteTableAssociation(this, "RouteTableAssociation", {
+            subnetId: this.subnetId,
+            routeTableId: this.routeTable.routeTableId,
+        });
+        this._internetConnectivityEstablished.add(routeAssoc);
+        this.internetConnectivityEstablished =
+            this._internetConnectivityEstablished;
+        this.subnetType = props.subnetType;
+        storeSubnetToVpcByType(props.vpc, this, props.subnetType);
+    }
+    /**
+     * Associate a Network ACL with this subnet
+     *
+     * @param id The unique identifier for this association.
+     * @param networkAcl The Network ACL to associate with this subnet.
+     * This allows controlling inbound and outbound traffic for instances in this subnet.
+     */
+    associateNetworkAcl(id, networkAcl) {
+        this._networkAcl = networkAcl;
+        const scope = networkAcl instanceof constructs_1.Construct ? networkAcl : this;
+        const other = networkAcl instanceof constructs_1.Construct ? this : networkAcl;
+        new network_acl_1.SubnetNetworkAclAssociation(scope, id + aws_stack_1.AwsStack.uniqueId(other.node), {
+            networkAcl,
+            subnet: this,
+        });
+    }
+    /**
+     * Return the Route Table associated with this subnet
+     */
+    get routeTable() {
+        return this._routeTable;
+    }
+    /**
+     * Returns the Network ACL associated with this subnet.
+     */
+    get networkAcl() {
+        // TODO: should this rerturn from DataSource if undefined?
+        // https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/network_acls
+        return this._networkAcl;
+    }
+}
+exports.SubnetV2 = SubnetV2;
+_b = JSII_RTTI_SYMBOL_1;
+SubnetV2[_b] = { fqn: "terraconstructs.aws.compute.alpha.SubnetV2", version: "0.0.13" };
+const subnetTypeMap = {
+    [vpc_1.SubnetType.PRIVATE_ISOLATED]: (vpc, subnet) => vpc.isolatedSubnets.push(subnet),
+    [vpc_1.SubnetType.PUBLIC]: (vpc, subnet) => vpc.publicSubnets.push(subnet),
+    [vpc_1.SubnetType.PRIVATE_WITH_EGRESS]: (vpc, subnet) => vpc.privateSubnets.push(subnet),
+    [vpc_1.SubnetType.ISOLATED]: (vpc, subnet) => vpc.isolatedSubnets.push(subnet),
+    [vpc_1.SubnetType.PRIVATE]: (vpc, subnet) => vpc.privateSubnets.push(subnet),
+    [vpc_1.SubnetType.PRIVATE_WITH_NAT]: (vpc, subnet) => vpc.privateSubnets.push(subnet),
+};
+/**
+ * Stores the provided subnet in the VPC's collection of subnets based on the specified subnet type.
+ *
+ * @param vpc The VPC instance to which the subnet belongs.
+ * @param subnet The subnet instance to be stored.
+ * @param type The type of the subnet (e.g., public, private, isolated).
+ * @internal
+ */
+function storeSubnetToVpcByType(vpc, subnet, type) {
+    const findFunctionType = subnetTypeMap[type];
+    if (findFunctionType) {
+        findFunctionType(vpc, subnet);
+    }
+    else {
+        throw new Error(`Unsupported subnet type: ${type}`);
+    }
+    /**
+     * Need to set explicit dependency as during stack deletion,
+     * the cidr blocks may get deleted first and will fail as the subnets are still using the cidr blocks
+     */
+    if (vpc.secondaryCidrBlock) {
+        for (const cidr of vpc.secondaryCidrBlock) {
+            subnet.node.addDependency(cidr);
+        }
+    }
+}
+/**
+ * Validates whether the provided VPC supports IPv6 addresses.
+ *
+ * @param vpc The VPC instance to be validated.
+ * @throws Error if the VPC does not support IPv6 addresses.
+ * @returns True if the VPC supports IPv6 addresses, false otherwise.
+ * @internal
+ */
+function validateSupportIpv6(vpc) {
+    if (vpc.secondaryCidrBlock) {
+        if (vpc.secondaryCidrBlock.some((secondaryAddress) => secondaryAddress.amazonProvidedIpv6CidrBlock === true ||
+            secondaryAddress.ipv6IpamPoolId != undefined)) {
+            return true;
+        }
+        else {
+            throw new Error("To use IPv6, the VPC must enable IPv6 support.");
+        }
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Checks if the provided CIDR range falls within the IP address ranges of the given VPC.
+ *
+ * @param vpc The VPC instance to check against.
+ * @param cidrRange The CIDR range to be checked.
+ * @returns True if the CIDR range falls within the VPC's IP address ranges, false otherwise.
+ * @internal
+ */
+function checkCidrRanges(vpc, cidrRange) {
+    const vpcCidrBlock = [vpc.ipv4CidrBlock];
+    const subnetCidrBlock = new ec2_util_v2_1.CidrBlock(cidrRange);
+    const allCidrs = [];
+    // Secondary IP addresses assoicated using user defined IPv4 range
+    if (vpc.secondaryCidrBlock) {
+        for (const ipAddress of vpc.secondaryCidrBlock) {
+            if (ipAddress.cidrBlock) {
+                vpcCidrBlock.push(ipAddress.cidrBlock);
+            }
+        }
+        const cidrs = vpcCidrBlock.map((cidr) => new ec2_util_v2_1.CidrBlock(cidr));
+        allCidrs.push(...cidrs);
+    }
+    // Secondary IP addresses assoicated using IPAM IPv4 range
+    if (vpc.ipv4IpamProvisionedCidrs) {
+        const cidrs = vpc.ipv4IpamProvisionedCidrs.map((cidr) => new ec2_util_v2_1.CidrBlock(cidr));
+        allCidrs.push(...cidrs);
+    }
+    // If no IPv4 is assigned as secondary address
+    if (allCidrs.length === 0) {
+        throw new Error("No secondary IP address attached to VPC");
+    }
+    return allCidrs.some((c) => c.containsCidr(subnetCidrBlock));
+}
+/**
+ * Validates if the provided IPv4 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.
+ *
+ * @param vpc The VPC instance to check against.
+ * @param ipv4CidrBlock The IPv4 CIDR block to be validated.
+ * @returns True if the IPv4 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.
+ * @internal
+ */
+function validateOverlappingCidrRanges(vpc, ipv4CidrBlock) {
+    let allSubnets;
+    try {
+        allSubnets = vpc.selectSubnets().subnets;
+    }
+    catch (e) {
+        ("No subnets in VPC");
+        return false;
+    }
+    const ipMap = new Array();
+    const inputRange = new ec2_util_v2_1.CidrBlock(ipv4CidrBlock);
+    const inputIpMap = [inputRange.minIp(), inputRange.maxIp()];
+    for (const subnet of allSubnets) {
+        const cidrBlock = new ec2_util_v2_1.CidrBlock(subnet.ipv4CidrBlock);
+        ipMap.push([cidrBlock.minIp(), cidrBlock.maxIp()]);
+    }
+    for (const range of ipMap) {
+        if (inputRange.rangesOverlap(range, inputIpMap)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Validates if the provided IPv6 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.
+ *
+ * @param vpc The VPC instance to check against.
+ * @param ipv6CidrBlock The IPv6 CIDR block to be validated.
+ * @returns True if the IPv6 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.
+ * @throws Error if no subnets are found in the VPC.
+ * @internal
+ */
+function validateOverlappingCidrRangesipv6(vpc, ipv6CidrBlock) {
+    let allSubnets;
+    try {
+        allSubnets = vpc.selectSubnets().subnets;
+    }
+    catch (e) {
+        ("No subnets in VPC");
+        return false;
+    }
+    const ipv6Map = [];
+    const inputRange = new ec2_util_v2_1.CidrBlockIpv6(ipv6CidrBlock);
+    let result = false;
+    for (const subnet of allSubnets) {
+        if (subnet.ipv6CidrBlock) {
+            const cidrBlock = new ec2_util_v2_1.CidrBlockIpv6(subnet.ipv6CidrBlock);
+            ipv6Map.push(cidrBlock.cidr);
+        }
+    }
+    for (const range of ipv6Map) {
+        if (inputRange.rangesOverlap(range, inputRange.cidr)) {
+            result = true;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subnet-v2.js","sourceRoot":"","sources":["../../../src/aws/compute/subnet-v2.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/subnet-v2.ts\n\nimport {\n  subnet as tfSubnet,\n  routeTableAssociation as tfRouteTableAssociation,\n} from \"@cdktf/provider-aws\";\n// import { Lazy } from \"cdktf\";\nimport { Construct, DependencyGroup, IDependable } from \"constructs\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\nimport {\n  // NetworkAcl,\n  SubnetNetworkAclAssociation,\n  INetworkAcl,\n} from \"./network-acl\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { CidrBlock, CidrBlockIpv6 } from \"./ec2-util-v2\";\nimport { RouteTable } from \"./route\";\nimport { IRouteTable, ISubnet, SubnetOutputs, SubnetType } from \"./vpc\";\nimport { IVpcV2 } from \"./vpc-v2-base\";\nimport { AwsStack } from \"../aws-stack\";\n\n/**\n * Interface to define subnet CIDR\n */\ninterface ICidr {\n  readonly cidr: string;\n}\n\n/**\n * IPv4 or IPv6 CIDR range for the subnet\n */\nexport class IpCidr implements ICidr {\n  /**\n   * IPv6 CIDR range for the subnet\n   * Allowed only if IPv6 is enabled on VPc\n   */\n  public readonly cidr: string;\n  constructor(props: string) {\n    this.cidr = props;\n  }\n}\n\n/**\n * Name tag constant\n */\nconst NAME_TAG: string = \"Name\";\n\n/**\n * VPC Name tag constant\n */\nconst VPCNAME_TAG: string = \"VpcName\";\n\n/**\n * Properties to define subnet for VPC.\n */\nexport interface SubnetV2Props extends AwsConstructProps {\n  /**\n   * VPC Prop\n   */\n  readonly vpc: IVpcV2;\n\n  /**\n   * ipv4 cidr to assign to this subnet.\n   * See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-cidrblock\n   */\n  readonly ipv4CidrBlock: IpCidr;\n\n  /**\n   * Ipv6 CIDR Range for subnet\n   *\n   * @default - No Ipv6 address\n   */\n  readonly ipv6CidrBlock?: IpCidr;\n\n  /**\n   * Custom AZ for the subnet\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * Custom Route for subnet\n   *\n   * @default - a default route table created\n   */\n  readonly routeTable?: IRouteTable;\n\n  /**\n   * The type of Subnet to configure.\n   *\n   * The Subnet type will control the ability to route and connect to the\n   * Internet.\n   *\n   * TODO: Add validation check `subnetType` when adding resources (e.g. cannot add NatGateway to private)\n   */\n  readonly subnetType: SubnetType;\n\n  /**\n   * Subnet name\n   *\n   * @default - provisioned with an autogenerated name by CDK\n   */\n  readonly subnetName?: string;\n\n  /**\n   * Indicates whether a network interface created in this subnet receives an IPv6 address.\n   * If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.\n   *\n   * @default - undefined in case not provided as an input\n   */\n  readonly assignIpv6AddressOnCreation?: boolean;\n}\n\n/**\n * Interface with additional properties for SubnetV2\n */\nexport interface ISubnetV2 extends ISubnet {\n  /**\n   * The IPv6 CIDR block for this subnet\n   */\n  readonly ipv6CidrBlock?: string;\n\n  /**\n   * The type of subnet (public or private) that this subnet represents.\n   *\n   * @attribute SubnetType\n   */\n  readonly subnetType?: SubnetType;\n}\n\n/**\n * The SubnetV2 class represents a subnet within a VPC (Virtual Private Cloud) in AWS.\n * It extends the Resource class and implements the ISubnet interface.\n *\n * Instances of this class can be used to create and manage subnets within a VpcV2 instance.\n * Subnets can be configured with specific IP address ranges (IPv4 and IPv6), availability zones,\n * and subnet types (e.g., public, private, isolated).\n *\n * @resource AWS::EC2::Subnet\n *\n */\nexport class SubnetV2 extends AwsConstructBase implements ISubnetV2 {\n  /**\n   * Import an existing subnet to the VPC\n   */\n  public static fromSubnetV2Attributes(\n    scope: Construct,\n    id: string,\n    attrs: SubnetV2Attributes,\n  ): ISubnetV2 {\n    /**\n     * Class to define an import for an existing subnet\n     * @resource AWS::EC2::Subnet\n     */\n    class ImportedSubnetV2 extends AwsConstructBase implements ISubnetV2 {\n      /**\n       * The IPv6 CIDR Block assigned to this subnet\n       */\n      public readonly ipv6CidrBlock?: string = attrs.ipv6CidrBlock;\n\n      /**\n       * The type of subnet (eg. public or private) that this subnet represents.\n       */\n      public readonly subnetType?: SubnetType = attrs.subnetType;\n\n      /**\n       * The Availability Zone in which subnet is located\n       */\n      public readonly availabilityZone: string = attrs.availabilityZone;\n\n      /**\n       * The subnetId for this particular subnet\n       * Refers to the physical ID created\n       */\n      public readonly subnetId: string = attrs.subnetId;\n\n      /**\n       * Dependable that can be depended upon to force internet connectivity established on the VPC\n       */\n      public readonly internetConnectivityEstablished: IDependable =\n        new DependencyGroup();\n\n      /**\n       * The IPv4 CIDR block assigned to this subnet\n       */\n      public readonly ipv4CidrBlock: string = attrs.ipv4CidrBlock;\n\n      /**\n       *  Current route table associated with this subnet\n       */\n      public readonly routeTable: IRouteTable = {\n        routeTableId: attrs.routeTableId!,\n      };\n\n      public subnetOutputs: SubnetOutputs = {\n        subnetId: this.subnetId,\n        ipv4CidrBlock: this.ipv4CidrBlock,\n        routeTableId: this.routeTable.routeTableId,\n      };\n      public get outputs(): Record<string, any> {\n        return this.subnetOutputs;\n      }\n      /**\n       * Associate a Network ACL with this subnet\n       * Required here since it is implemented in the ISubnetV2\n       */\n      public associateNetworkAcl(aclId: string, networkAcl: INetworkAcl) {\n        const aclScope = networkAcl instanceof Construct ? networkAcl : this;\n        const other = networkAcl instanceof Construct ? this : networkAcl;\n        new SubnetNetworkAclAssociation(\n          aclScope,\n          aclId + AwsStack.uniqueId(other),\n          {\n            networkAcl,\n            subnet: this,\n          },\n        );\n      }\n    }\n    return new ImportedSubnetV2(scope, id);\n  }\n\n  public get subnetOutputs(): SubnetOutputs {\n    return {\n      subnetId: this.subnetId,\n      ipv4CidrBlock: this.ipv4CidrBlock,\n      routeTableId: this.routeTable.routeTableId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.subnetOutputs;\n  }\n\n  /**\n   * The Availability Zone the subnet is located in\n   */\n  public readonly availabilityZone: string;\n\n  /**\n   * The subnetId for this particular subnet\n   * @attribute\n   */\n  public readonly subnetId: string;\n\n  /**\n   *  Dependencies for internet connectivity\n   * This Property exposes the RouteTable-Subnet association so that other resources can depend on it.\n   */\n  public readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * The variable name `internetConnectivityEstablished` does not reflect what it actually is.\n   * The naming is enforced by ISubnet. We need to keep it to maintain compatibility.\n   * It exposes the RouteTable-Subnet association so that other resources can depend on it.\n   * E.g. Resources in a subnet, when being deleted, may need the RouteTable to exist in order to delete properly\n   */\n  private readonly _internetConnectivityEstablished = new DependencyGroup();\n\n  /**\n   * The IPv4 CIDR block for this subnet\n   */\n  public readonly ipv4CidrBlock: string;\n\n  /**\n   * The IPv6 CIDR Block for this subnet\n   */\n  public readonly ipv6CidrBlock?: string;\n\n  /**\n   * The type of subnet (public or private) that this subnet represents.\n   * @attribute SubnetType\n   */\n  public readonly subnetType?: SubnetType;\n\n  private _networkAcl?: INetworkAcl;\n  public resource: tfSubnet.Subnet;\n\n  private _routeTable: IRouteTable;\n\n  /**\n   * Constructs a new SubnetV2 instance.\n   * @param scope The parent Construct that this resource will be part of.\n   * @param id The unique identifier for this resource.\n   * @param props The configuration properties for the subnet.\n   */\n  constructor(scope: Construct, id: string, props: SubnetV2Props) {\n    super(scope, id, props);\n    const subnetName =\n      props.subnetName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        maxLength: 128,\n        allowedSpecialCharacters: \"_\",\n      });\n    // Lazy.string({\n    //   produce: () =>\n    //     Names.uniqueResourceName(this, {\n    //       maxLength: 128,\n    //       allowedSpecialCharacters: \"_\",\n    //     }),\n    // }),\n\n    const ipv4CidrBlock = props.ipv4CidrBlock.cidr;\n    const ipv6CidrBlock = props.ipv6CidrBlock?.cidr;\n\n    if (!checkCidrRanges(props.vpc, props.ipv4CidrBlock.cidr)) {\n      throw new Error(\"CIDR block should be within the range of VPC\");\n    }\n\n    let overlap: boolean = false;\n    let overlapIpv6: boolean = false;\n\n    overlap = validateOverlappingCidrRanges(\n      props.vpc,\n      props.ipv4CidrBlock.cidr,\n    );\n\n    //check whether VPC supports ipv6\n    if (props.ipv6CidrBlock?.cidr) {\n      validateSupportIpv6(props.vpc);\n      overlapIpv6 = validateOverlappingCidrRangesipv6(\n        props.vpc,\n        props.ipv6CidrBlock?.cidr,\n      );\n    }\n\n    if (overlap || overlapIpv6) {\n      throw new Error(\n        \"CIDR block should not overlap with existing subnet blocks\",\n      );\n    }\n\n    if (props.assignIpv6AddressOnCreation && !props.ipv6CidrBlock) {\n      throw new Error(\n        \"IPv6 CIDR block is required when assigning IPv6 address on creation\",\n      );\n    }\n\n    this.resource = new tfSubnet.Subnet(this, \"Resource\", {\n      vpcId: props.vpc.vpcId,\n      cidrBlock: ipv4CidrBlock,\n      ipv6CidrBlock: ipv6CidrBlock,\n      availabilityZone: props.availabilityZone,\n      assignIpv6AddressOnCreation: props.assignIpv6AddressOnCreation ?? false,\n    });\n\n    this.node.defaultChild = this.resource;\n    this.ipv4CidrBlock = props.ipv4CidrBlock.cidr;\n    this.ipv6CidrBlock = props.ipv6CidrBlock?.cidr;\n    this.subnetId = this.resource.id;\n    this.availabilityZone = props.availabilityZone;\n\n    // Terraform subnet does not provide the default ACL NetworkAclAssociationId attribute\n    // this._networkAcl = NetworkAcl.fromNetworkAclId(\n    //   this,\n    //   \"Acl\",\n    //   this.resource.NetworkAclAssociationId,\n    // );\n\n    if (props.subnetName) {\n      Tags.of(this).add(NAME_TAG, subnetName);\n    }\n\n    if (props.vpc.vpcName) {\n      Tags.of(this).add(VPCNAME_TAG, props.vpc.vpcName);\n    }\n\n    if (props.routeTable) {\n      this._routeTable = props.routeTable;\n    } else {\n      // Assigning a default route table\n      this._routeTable = new RouteTable(this, \"RouteTable\", {\n        vpc: props.vpc,\n        routeTableName: \"DefaultCDKRouteTable\",\n      });\n    }\n\n    const routeAssoc = new tfRouteTableAssociation.RouteTableAssociation(\n      this,\n      \"RouteTableAssociation\",\n      {\n        subnetId: this.subnetId,\n        routeTableId: this.routeTable.routeTableId,\n      },\n    );\n\n    this._internetConnectivityEstablished.add(routeAssoc);\n\n    this.internetConnectivityEstablished =\n      this._internetConnectivityEstablished;\n\n    this.subnetType = props.subnetType;\n    storeSubnetToVpcByType(props.vpc, this, props.subnetType);\n  }\n\n  /**\n   * Associate a Network ACL with this subnet\n   *\n   * @param id The unique identifier for this association.\n   * @param networkAcl The Network ACL to associate with this subnet.\n   * This allows controlling inbound and outbound traffic for instances in this subnet.\n   */\n  public associateNetworkAcl(id: string, networkAcl: INetworkAcl) {\n    this._networkAcl = networkAcl;\n\n    const scope = networkAcl instanceof Construct ? networkAcl : this;\n    const other = networkAcl instanceof Construct ? this : networkAcl;\n    new SubnetNetworkAclAssociation(scope, id + AwsStack.uniqueId(other.node), {\n      networkAcl,\n      subnet: this,\n    });\n  }\n\n  /**\n   * Return the Route Table associated with this subnet\n   */\n  public get routeTable(): IRouteTable {\n    return this._routeTable;\n  }\n\n  /**\n   * Returns the Network ACL associated with this subnet.\n   */\n\n  public get networkAcl(): INetworkAcl | undefined {\n    // TODO: should this rerturn from DataSource if undefined?\n    // https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/network_acls\n    return this._networkAcl;\n  }\n}\n\n/**\n * Properties required to import a subnet\n */\nexport interface SubnetV2Attributes {\n  /**\n   * The Availability Zone this subnet is located in\n   *\n   * @default - No AZ information, cannot use AZ selection features\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * The IPv4 CIDR block associated with the subnet\n   *\n   * @default - No CIDR information, cannot use CIDR filter features\n   */\n  readonly ipv4CidrBlock: string;\n\n  /**\n   * The IPv4 CIDR block associated with the subnet\n   *\n   * @default - No CIDR information, cannot use CIDR filter features\n   */\n  readonly ipv6CidrBlock?: string;\n\n  /**\n   * The ID of the route table for this particular subnet\n   *\n   * @default - No route table information, cannot create VPC endpoints\n   */\n  readonly routeTableId?: string;\n\n  /**\n   * The subnetId for this particular subnet\n   */\n  readonly subnetId: string;\n\n  /**\n   * The type of subnet (public or private) that this subnet represents.\n   */\n  readonly subnetType: SubnetType;\n\n  /**\n   * Name of the given subnet\n   *\n   * @default - no subnet name\n   */\n  readonly subnetName?: string;\n}\n\nconst subnetTypeMap = {\n  [SubnetType.PRIVATE_ISOLATED]: (vpc: IVpcV2, subnet: SubnetV2) =>\n    vpc.isolatedSubnets.push(subnet),\n  [SubnetType.PUBLIC]: (vpc: IVpcV2, subnet: SubnetV2) =>\n    vpc.publicSubnets.push(subnet),\n  [SubnetType.PRIVATE_WITH_EGRESS]: (vpc: IVpcV2, subnet: SubnetV2) =>\n    vpc.privateSubnets.push(subnet),\n  [SubnetType.ISOLATED]: (vpc: IVpcV2, subnet: SubnetV2) =>\n    vpc.isolatedSubnets.push(subnet),\n  [SubnetType.PRIVATE]: (vpc: IVpcV2, subnet: SubnetV2) =>\n    vpc.privateSubnets.push(subnet),\n  [SubnetType.PRIVATE_WITH_NAT]: (vpc: IVpcV2, subnet: SubnetV2) =>\n    vpc.privateSubnets.push(subnet),\n};\n\n/**\n * Stores the provided subnet in the VPC's collection of subnets based on the specified subnet type.\n *\n * @param vpc The VPC instance to which the subnet belongs.\n * @param subnet The subnet instance to be stored.\n * @param type The type of the subnet (e.g., public, private, isolated).\n * @internal\n */\nfunction storeSubnetToVpcByType(\n  vpc: IVpcV2,\n  subnet: SubnetV2,\n  type: SubnetType,\n) {\n  const findFunctionType = subnetTypeMap[type];\n  if (findFunctionType) {\n    findFunctionType(vpc, subnet);\n  } else {\n    throw new Error(`Unsupported subnet type: ${type}`);\n  }\n\n  /**\n   * Need to set explicit dependency as during stack deletion,\n   * the cidr blocks may get deleted first and will fail as the subnets are still using the cidr blocks\n   */\n  if (vpc.secondaryCidrBlock) {\n    for (const cidr of vpc.secondaryCidrBlock) {\n      subnet.node.addDependency(cidr);\n    }\n  }\n}\n\n/**\n * Validates whether the provided VPC supports IPv6 addresses.\n *\n * @param vpc The VPC instance to be validated.\n * @throws Error if the VPC does not support IPv6 addresses.\n * @returns True if the VPC supports IPv6 addresses, false otherwise.\n * @internal\n */\nfunction validateSupportIpv6(vpc: IVpcV2) {\n  if (vpc.secondaryCidrBlock) {\n    if (\n      vpc.secondaryCidrBlock.some(\n        (secondaryAddress) =>\n          secondaryAddress.amazonProvidedIpv6CidrBlock === true ||\n          secondaryAddress.ipv6IpamPoolId != undefined,\n      )\n    ) {\n      return true;\n    } else {\n      throw new Error(\"To use IPv6, the VPC must enable IPv6 support.\");\n    }\n  } else {\n    return false;\n  }\n}\n\n/**\n * Checks if the provided CIDR range falls within the IP address ranges of the given VPC.\n *\n * @param vpc The VPC instance to check against.\n * @param cidrRange The CIDR range to be checked.\n * @returns True if the CIDR range falls within the VPC's IP address ranges, false otherwise.\n * @internal\n */\nfunction checkCidrRanges(vpc: IVpcV2, cidrRange: string) {\n  const vpcCidrBlock = [vpc.ipv4CidrBlock];\n  const subnetCidrBlock = new CidrBlock(cidrRange);\n  const allCidrs: CidrBlock[] = [];\n\n  // Secondary IP addresses assoicated using user defined IPv4 range\n  if (vpc.secondaryCidrBlock) {\n    for (const ipAddress of vpc.secondaryCidrBlock) {\n      if (ipAddress.cidrBlock) {\n        vpcCidrBlock.push(ipAddress.cidrBlock);\n      }\n    }\n    const cidrs = vpcCidrBlock.map((cidr) => new CidrBlock(cidr));\n    allCidrs.push(...cidrs);\n  }\n\n  // Secondary IP addresses assoicated using IPAM IPv4 range\n  if (vpc.ipv4IpamProvisionedCidrs) {\n    const cidrs = vpc.ipv4IpamProvisionedCidrs.map(\n      (cidr) => new CidrBlock(cidr),\n    );\n    allCidrs.push(...cidrs);\n  }\n\n  // If no IPv4 is assigned as secondary address\n  if (allCidrs.length === 0) {\n    throw new Error(\"No secondary IP address attached to VPC\");\n  }\n\n  return allCidrs.some((c) => c.containsCidr(subnetCidrBlock));\n}\n\n/**\n * Validates if the provided IPv4 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.\n *\n * @param vpc The VPC instance to check against.\n * @param ipv4CidrBlock The IPv4 CIDR block to be validated.\n * @returns True if the IPv4 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.\n * @internal\n */\n\nfunction validateOverlappingCidrRanges(\n  vpc: IVpcV2,\n  ipv4CidrBlock: string,\n): boolean {\n  let allSubnets: ISubnetV2[];\n  try {\n    allSubnets = vpc.selectSubnets().subnets;\n  } catch (e) {\n    (\"No subnets in VPC\");\n    return false;\n  }\n\n  const ipMap: [string, string][] = new Array();\n\n  const inputRange = new CidrBlock(ipv4CidrBlock);\n\n  const inputIpMap: [string, string] = [inputRange.minIp(), inputRange.maxIp()];\n\n  for (const subnet of allSubnets) {\n    const cidrBlock = new CidrBlock(subnet.ipv4CidrBlock);\n    ipMap.push([cidrBlock.minIp(), cidrBlock.maxIp()]);\n  }\n\n  for (const range of ipMap) {\n    if (inputRange.rangesOverlap(range, inputIpMap)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Validates if the provided IPv6 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.\n *\n * @param vpc The VPC instance to check against.\n * @param ipv6CidrBlock The IPv6 CIDR block to be validated.\n * @returns True if the IPv6 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.\n * @throws Error if no subnets are found in the VPC.\n * @internal\n */\nfunction validateOverlappingCidrRangesipv6(\n  vpc: IVpcV2,\n  ipv6CidrBlock: string,\n): boolean {\n  let allSubnets: ISubnetV2[];\n  try {\n    allSubnets = vpc.selectSubnets().subnets;\n  } catch (e) {\n    (\"No subnets in VPC\");\n    return false;\n  }\n\n  const ipv6Map: string[] = [];\n\n  const inputRange = new CidrBlockIpv6(ipv6CidrBlock);\n\n  let result: boolean = false;\n\n  for (const subnet of allSubnets) {\n    if (subnet.ipv6CidrBlock) {\n      const cidrBlock = new CidrBlockIpv6(subnet.ipv6CidrBlock);\n      ipv6Map.push(cidrBlock.cidr);\n    }\n  }\n\n  for (const range of ipv6Map) {\n    if (inputRange.rangesOverlap(range, inputRange.cidr)) {\n      result = true;\n    }\n  }\n\n  return result;\n}\n"]}

package/lib/aws/compute/subnet.d.ts

@@ -0,0 +1,37 @@
+import { ISubnet } from "./vpc";
+/**
+ * Contains logic which chooses a set of subnets from a larger list, in conjunction
+ * with SubnetSelection, to determine where to place AWS resources such as VPC
+ * endpoints, EC2 instances, etc.
+ */
+export declare abstract class SubnetFilter {
+    /**
+     * Chooses subnets by id.
+     */
+    static byIds(subnetIds: string[]): SubnetFilter;
+    /**
+     * Chooses subnets which are in one of the given availability zones.
+     */
+    static availabilityZones(availabilityZones: string[]): SubnetFilter;
+    /**
+     * Chooses subnets such that there is at most one per availability zone.
+     */
+    static onePerAz(): SubnetFilter;
+    /**
+     * Chooses subnets which contain any of the specified IP addresses.
+     */
+    static containsIpAddresses(ipv4addrs: string[]): SubnetFilter;
+    /**
+     * Chooses subnets which have the provided CIDR netmask.
+     */
+    static byCidrMask(mask: number): SubnetFilter;
+    /**
+     * Chooses subnets which are inside any of the specified CIDR range.
+     * @param cidrs List of CIDR ranges to filter subnets from
+     */
+    static byCidrRanges(cidrs: string[]): SubnetFilter;
+    /**
+     * Executes the subnet filtering logic, returning a filtered set of subnets.
+     */
+    selectSubnets(_subnets: ISubnet[]): ISubnet[];
+}