@aws-cdk/aws-ec2-alpha 2.156.0-alpha.0

package/lib/vpc-v2.js

@@ -0,0 +1,303 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VpcV2 = exports.IpAddresses = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const core_1 = require("aws-cdk-lib/core");
+const constructs_1 = require("constructs");
+const vpc_v2_base_1 = require("./vpc-v2-base");
+/**
+ * IpAddress options to define VPC V2
+ */
+class IpAddresses {
+    /**
+     * An IPv4 CIDR Range
+     */
+    static ipv4(ipv4Cidr, props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_ec2_alpha_SecondaryAddressProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ipv4);
+            }
+            throw error;
+        }
+        return new ipv4CidrAllocation(ipv4Cidr, props);
+    }
+    /**
+     * An Ipv4 Ipam Pool
+     */
+    static ipv4Ipam(ipv4IpamOptions) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_ec2_alpha_IpamOptions(ipv4IpamOptions);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ipv4Ipam);
+            }
+            throw error;
+        }
+        return new IpamIpv4(ipv4IpamOptions);
+    }
+    /**
+     * An Ipv6 Ipam Pool
+     */
+    static ipv6Ipam(ipv6IpamOptions) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_ec2_alpha_IpamOptions(ipv6IpamOptions);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ipv6Ipam);
+            }
+            throw error;
+        }
+        return new IpamIpv6(ipv6IpamOptions);
+    }
+    /**
+     * Amazon Provided Ipv6 range
+     */
+    static amazonProvidedIpv6(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_ec2_alpha_SecondaryAddressProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.amazonProvidedIpv6);
+            }
+            throw error;
+        }
+        return new AmazonProvided(props);
+    }
+}
+exports.IpAddresses = IpAddresses;
+_a = JSII_RTTI_SYMBOL_1;
+IpAddresses[_a] = { fqn: "@aws-cdk/aws-ec2-alpha.IpAddresses", version: "2.156.0-alpha.0" };
+/**
+ * This class provides a foundation for creating and configuring a VPC with advanced features such as IPAM (IP Address Management) and IPv6 support.
+ *
+ * For more information, see the {@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html|AWS CDK Documentation on VPCs}.
+ *
+ * @resource AWS::EC2::VPC
+ */
+class VpcV2 extends vpc_v2_base_1.VpcV2Base {
+    constructor(scope, id, props = {}) {
+        super(scope, id, {
+            physicalName: props.vpcName ?? core_1.Lazy.string({
+                produce: () => core_1.Names.uniqueResourceName(this, { maxLength: 128, allowedSpecialCharacters: '_' }),
+            }),
+        });
+        /**
+         * To define dependency on internet connectivity
+         */
+        this._internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        /**
+       * reference to all secondary blocks attached
+       */
+        this.secondaryCidrBlock = new Array;
+        /**
+         * For validation to define IPv6 subnets, set to true in case of
+         * Amazon Provided IPv6 cidr range
+         * IPv6 addresses can be attached to the subnets
+         * @default false
+         */
+        this.useIpv6 = false;
+        this.ipv4CidrBlock = '';
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_ec2_alpha_VpcV2Props(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, VpcV2);
+            }
+            throw error;
+        }
+        this.ipAddresses = props.primaryAddressBlock ?? IpAddresses.ipv4('10.0.0.0/16');
+        const vpcOptions = this.ipAddresses.allocateVpcCidr();
+        this.dnsHostnamesEnabled = props.enableDnsHostnames == null ? true : props.enableDnsHostnames;
+        this.dnsSupportEnabled = props.enableDnsSupport == null ? true : props.enableDnsSupport;
+        const instanceTenancy = props.defaultInstanceTenancy || 'default';
+        this.resource = new aws_ec2_1.CfnVPC(this, 'Resource', {
+            cidrBlock: vpcOptions.ipv4CidrBlock, //for Ipv4 addresses CIDR block
+            enableDnsHostnames: this.dnsHostnamesEnabled,
+            enableDnsSupport: this.dnsSupportEnabled,
+            ipv4IpamPoolId: vpcOptions.ipv4IpamPool?.ipamPoolId, // for Ipv4 ipam option
+            ipv4NetmaskLength: vpcOptions.ipv4NetmaskLength, // for Ipv4 ipam option
+            instanceTenancy: instanceTenancy,
+        });
+        this.node.defaultChild = this.resource;
+        this.vpcCidrBlock = this.resource.attrCidrBlock;
+        if (vpcOptions.ipv4CidrBlock) {
+            this.ipv4CidrBlock = vpcOptions.ipv4CidrBlock;
+        }
+        this.ipv6CidrBlocks = this.resource.attrIpv6CidrBlocks;
+        this.vpcId = this.resource.attrVpcId;
+        this.vpcArn = core_1.Arn.format({
+            service: 'ec2',
+            resource: 'vpc',
+            resourceName: this.vpcId,
+        }, this.stack);
+        if (props.secondaryAddressBlocks) {
+            const secondaryAddressBlocks = props.secondaryAddressBlocks;
+            for (const secondaryAddressBlock of secondaryAddressBlocks) {
+                const secondaryVpcOptions = secondaryAddressBlock.allocateVpcCidr();
+                if (!secondaryVpcOptions.cidrBlockName) {
+                    throw new Error('Cidr Block Name is required to create secondary IP address');
+                }
+                if (secondaryVpcOptions.amazonProvided || secondaryVpcOptions.ipv6IpamPool) {
+                    this.useIpv6 = true;
+                }
+                //validate CIDR ranges per RFC 1918
+                if (secondaryVpcOptions.ipv4CidrBlock) {
+                    const ret = validateIpv4address(secondaryVpcOptions.ipv4CidrBlock, this.resource.cidrBlock);
+                    if (ret === false) {
+                        throw new Error('CIDR block should be in the same RFC 1918 range in the VPC');
+                    }
+                }
+                const cfnVpcCidrBlock = new aws_ec2_1.CfnVPCCidrBlock(this, secondaryVpcOptions.cidrBlockName, {
+                    vpcId: this.vpcId,
+                    cidrBlock: secondaryVpcOptions.ipv4CidrBlock,
+                    ipv4IpamPoolId: secondaryVpcOptions.ipv4IpamPool?.ipamPoolId,
+                    ipv4NetmaskLength: secondaryVpcOptions.ipv4NetmaskLength,
+                    ipv6NetmaskLength: secondaryVpcOptions.ipv6NetmaskLength,
+                    ipv6IpamPoolId: secondaryVpcOptions.ipv6IpamPool?.ipamPoolId,
+                    amazonProvidedIpv6CidrBlock: secondaryVpcOptions.amazonProvided,
+                });
+                if (secondaryVpcOptions.dependencies) {
+                    for (const dep of secondaryVpcOptions.dependencies) {
+                        cfnVpcCidrBlock.addDependency(dep);
+                    }
+                }
+                //Create secondary blocks for Ipv4 and Ipv6
+                this.secondaryCidrBlock.push(cfnVpcCidrBlock);
+            }
+        }
+        /**
+         * Empty array for isolated subnets
+         */
+        this.isolatedSubnets = new Array;
+        /**
+         * Empty array for public subnets
+         */
+        this.publicSubnets = new Array;
+        /**
+         * Empty array for private subnets
+         */
+        this.privateSubnets = new Array;
+        /**
+         * Dependable that can be depended upon to force internet connectivity established on the VPC
+         * Add igw to this if its a public subnet
+         */
+        this.internetConnectivityEstablished = this._internetConnectivityEstablished;
+    }
+}
+exports.VpcV2 = VpcV2;
+_b = JSII_RTTI_SYMBOL_1;
+VpcV2[_b] = { fqn: "@aws-cdk/aws-ec2-alpha.VpcV2", version: "2.156.0-alpha.0" };
+/**
+ * Supports assigning IPv4 address to VPC
+ */
+class ipv4CidrAllocation {
+    constructor(cidrBlock, props) {
+        this.cidrBlock = cidrBlock;
+        this.props = props;
+    }
+    /**
+     * @returns CIDR block provided by the user to set IPv4
+     */
+    allocateVpcCidr() {
+        return {
+            ipv4CidrBlock: this.cidrBlock,
+            cidrBlockName: this.props?.cidrBlockName,
+        };
+    }
+}
+/**
+ * Supports Amazon Provided Ipv6 ranges
+ */
+class AmazonProvided {
+    /**
+     * Represents an Amazon-provided IPv6 CIDR range for a VPC.
+     *
+     * This class implements the IIpAddresses interface and is used to allocate an Amazon-provided
+     * IPv6 CIDR range for a VPC. When an instance of this class is used to allocate the VPC CIDR,
+     * Amazon will automatically assign an IPv6 CIDR range from its pool of available addresses.
+     */
+    constructor(props) {
+        this.props = props;
+    }
+    ;
+    allocateVpcCidr() {
+        return {
+            amazonProvided: true,
+            cidrBlockName: this.props.cidrBlockName,
+        };
+    }
+}
+/**
+ * Represents an IPv4 address range managed by AWS IP Address Manager (IPAM).
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html
+ */
+class IpamIpv6 {
+    constructor(props) {
+        this.props = props;
+    }
+    allocateVpcCidr() {
+        return {
+            ipv6NetmaskLength: this.props.netmaskLength,
+            ipv6IpamPool: this.props.ipamPool,
+            dependencies: this.props.ipamPool?.ipamCidrs.map(c => c),
+            cidrBlockName: this.props.cidrBlockName,
+        };
+    }
+}
+/**
+ * Represents an IPv4 address range managed by AWS IP Address Manager (IPAM).
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html
+ */
+class IpamIpv4 {
+    constructor(props) {
+        this.props = props;
+    }
+    allocateVpcCidr() {
+        return {
+            ipv4NetmaskLength: this.props.netmaskLength,
+            ipv4IpamPool: this.props.ipamPool,
+            cidrBlockName: this.props?.cidrBlockName,
+        };
+    }
+}
+/**
+ * Validates whether a secondary IPv4 address is within the same private IP address range as the primary IPv4 address.
+ *
+ * @param cidr1 The secondary IPv4 CIDR block to be validated.
+ * @param cidr2 The primary IPv4 CIDR block to validate against.
+ * @returns True if the secondary IPv4 CIDR block is within the same private IP address range as the primary IPv4 CIDR block, false otherwise.
+ * @internal
+ * The private IP address ranges are defined by RFC 1918 as 10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16.
+ */
+function validateIpv4address(cidr1, cidr2) {
+    if (!cidr1 || !cidr2) {
+        return false; // Handle cases where CIDR ranges are not provided
+    }
+    const octetsCidr1 = cidr1.split('.').map(octet => parseInt(octet, 10));
+    const octetsCidr2 = cidr2.split('.').map(octet => parseInt(octet, 10));
+    if (octetsCidr1.length !== 4 || octetsCidr2.length !== 4) {
+        return false; // Handle invalid CIDR ranges
+    }
+    const ip1 = {
+        octet1: octetsCidr1[0],
+        octet2: octetsCidr1[1],
+    };
+    const ip2 = {
+        octet1: octetsCidr2[0],
+        octet2: octetsCidr2[1],
+    };
+    return (ip1.octet1 === 10 && ip2.octet1 === 10) ||
+        (ip1.octet1 === 192 && ip1.octet2 === 168 && ip2.octet1 === 192 && ip2.octet2 === 168) ||
+        (ip1.octet1 === 172 && ip1.octet2 === 16 && ip2.octet1 === 172 && ip2.octet2 === 16); // CIDR ranges belong to same private IP address ranges
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-v2.js","sourceRoot":"","sources":["vpc-v2.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnVPC, CfnVPCCidrBlock, DefaultInstanceTenancy, ISubnet } from 'aws-cdk-lib/aws-ec2';\nimport { Arn, CfnResource, Lazy, Names } from 'aws-cdk-lib/core';\nimport { Construct, DependencyGroup, IDependable } from 'constructs';\nimport { IpamOptions, IIpamPool } from './ipam';\nimport { VpcV2Base } from './vpc-v2-base';\n\n/**\n * Additional props needed for secondary Address\n */\nexport interface SecondaryAddressProps {\n  /**\n   * Required to set Secondary cidr block resource name\n   * in order to generate unique logical id for the resource.\n   */\n  readonly cidrBlockName: string;\n}\n\n/**\n * IpAddress options to define VPC V2\n */\nexport class IpAddresses {\n\n  /**\n   * An IPv4 CIDR Range\n   */\n  public static ipv4(ipv4Cidr: string, props?: SecondaryAddressProps): IIpAddresses {\n    return new ipv4CidrAllocation(ipv4Cidr, props);\n  }\n\n  /**\n   * An Ipv4 Ipam Pool\n   */\n  public static ipv4Ipam(ipv4IpamOptions: IpamOptions): IIpAddresses {\n    return new IpamIpv4(ipv4IpamOptions);\n  }\n\n  /**\n   * An Ipv6 Ipam Pool\n   */\n  public static ipv6Ipam(ipv6IpamOptions: IpamOptions): IIpAddresses {\n    return new IpamIpv6(ipv6IpamOptions);\n  }\n\n  /**\n   * Amazon Provided Ipv6 range\n   */\n  public static amazonProvidedIpv6(props: SecondaryAddressProps) : IIpAddresses {\n    return new AmazonProvided(props);\n  }\n}\n\n/**\n * Consolidated return parameters to pass to VPC construct\n */\nexport interface VpcCidrOptions {\n\n  /**\n   * IPv4 CIDR Block\n   * @default - '10.0.0.0/16'\n   */\n  readonly ipv4CidrBlock?: string;\n\n  /**\n   * CIDR Mask for Vpc\n   *\n   * @default - Only required when using IPAM Ipv4\n   */\n  readonly ipv4NetmaskLength?: number;\n\n  /**\n   * Ipv4 IPAM Pool\n   *\n   * @default - Only required when using IPAM Ipv4\n   */\n  readonly ipv4IpamPool?: IIpamPool;\n\n  /**\n   * Implementing Ipv6\n   * @default - No ipv6 address\n   */\n  readonly ipv6CidrBlock?: string;\n\n  /**\n   * CIDR Mask for Vpc\n   *\n   * @default - Only required when using AWS Ipam\n   */\n  readonly ipv6NetmaskLength?: number;\n\n  /**\n   * Ipv6 IPAM pool id for VPC range, can only be defined\n   * under public scope\n   *\n   * @default - no pool id\n   */\n  readonly ipv6IpamPool?: IIpamPool;\n\n  /**\n   * Use amazon provided IP range\n   * @default false\n   */\n  readonly amazonProvided?: boolean;\n\n  /**\n   * Dependency to associate Ipv6 CIDR block\n   * @default - No dependency\n   */\n  readonly dependencies?: CfnResource[];\n\n  /**\n   * Required to set Secondary cidr block resource name\n   * in order to generate unique logical id for the resource.\n   * @default : no name for primary addresses\n   */\n  readonly cidrBlockName?: string;\n}\n\n/**\n * Implements ip address allocation according to the IPAdress type\n */\nexport interface IIpAddresses {\n\n  /**\n   * Method to define the implementation logic of\n   * IP address allocation\n   */\n  allocateVpcCidr() : VpcCidrOptions;\n\n}\n\n/**\n * Properties to define VPC\n * [disable-awslint:from-method]\n */\nexport interface VpcV2Props {\n\n  /** A must IPv4 CIDR block for the VPC\n   * https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html\n   * @default - Ipv4 CIDR Block ('10.0.0.0/16')\n  */\n  readonly primaryAddressBlock?: IIpAddresses;\n\n  /**\n   * The secondary CIDR blocks associated with the VPC.\n   * Can be  IPv4 or IPv6, two IPv4 ranges must follow RFC#1918 convention\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-resize}.\n   * @default - No secondary IP address\n  */\n  readonly secondaryAddressBlocks?: IIpAddresses[];\n\n  /**\n   * Indicates whether the instances launched in the VPC get DNS hostnames\n   * @default true\n   */\n  readonly enableDnsHostnames?: boolean;\n\n  /**\n   * Indicates whether the DNS resolution is supported for the VPC.\n   * @default true\n   */\n  readonly enableDnsSupport?: boolean;\n\n  /**\n   * The default tenancy of instances launched into the VPC.\n   *\n   * By setting this to dedicated tenancy, instances will be launched on\n   * hardware dedicated to a single AWS customer, unless specifically specified\n   * at instance launch time. Please note, not all instance types are usable\n   * with Dedicated tenancy.\n   *\n   * @default DefaultInstanceTenancy.Default (shared) tenancy\n   */\n  readonly defaultInstanceTenancy?: DefaultInstanceTenancy;\n\n  /**\n   * Physical name for the VPC\n   * @default: autogenerated by CDK\n   */\n  readonly vpcName?: string;\n}\n\n/**\n * This class provides a foundation for creating and configuring a VPC with advanced features such as IPAM (IP Address Management) and IPv6 support.\n *\n * For more information, see the {@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html|AWS CDK Documentation on VPCs}.\n *\n * @resource AWS::EC2::VPC\n */\nexport class VpcV2 extends VpcV2Base {\n\n  /**\n   * Identifier for this VPC\n   */\n  public readonly vpcId: string;\n\n  /**\n  * @attribute\n  */\n  public readonly vpcArn: string;\n\n  /**\n   * @attribute\n  */\n  public readonly vpcCidrBlock: string;\n  /**\n   * The IPv6 CIDR blocks for the VPC.\n   *\n   * See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#aws-resource-ec2-vpc-return-values\n   */\n  public readonly ipv6CidrBlocks: string[];\n\n  /**\n   * The provider of ipv4 addresses\n   */\n  public readonly ipAddresses: IIpAddresses;\n\n  /**\n   * The AWS CloudFormation resource representing the VPC.\n   */\n  public readonly resource: CfnVPC;\n\n  /**\n   * Indicates if instances launched in this VPC will have public DNS hostnames.\n   */\n  public readonly dnsHostnamesEnabled: boolean;\n\n  /**\n  * Indicates if DNS support is enabled for this VPC.\n  */\n  public readonly dnsSupportEnabled: boolean;\n\n  /**\n   * Isolated Subnets that are part of this VPC.\n   */\n  public readonly isolatedSubnets: ISubnet[];\n\n  /**\n   * Public Subnets that are part of this VPC.\n   */\n  public readonly publicSubnets: ISubnet[];\n\n  /**\n   * Pbulic Subnets that are part of this VPC.\n   */\n  public readonly privateSubnets: ISubnet[];\n\n  /**\n   * To define dependency on internet connectivity\n   */\n  public readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * To define dependency on internet connectivity\n   */\n  private readonly _internetConnectivityEstablished = new DependencyGroup();\n\n  /**\n * reference to all secondary blocks attached\n */\n  public readonly secondaryCidrBlock = new Array<CfnVPCCidrBlock>;\n\n  /**\n   * For validation to define IPv6 subnets, set to true in case of\n   * Amazon Provided IPv6 cidr range\n   * IPv6 addresses can be attached to the subnets\n   * @default false\n   */\n  public readonly useIpv6: boolean = false;\n\n  public readonly ipv4CidrBlock: string = '';\n\n  constructor(scope: Construct, id: string, props: VpcV2Props = {}) {\n    super(scope, id, {\n      physicalName: props.vpcName ?? Lazy.string({\n        produce: () => Names.uniqueResourceName(this, { maxLength: 128, allowedSpecialCharacters: '_' }),\n      }),\n    });\n\n    this.ipAddresses = props.primaryAddressBlock ?? IpAddresses.ipv4('10.0.0.0/16');\n    const vpcOptions = this.ipAddresses.allocateVpcCidr();\n\n    this.dnsHostnamesEnabled = props.enableDnsHostnames == null ? true : props.enableDnsHostnames;\n    this.dnsSupportEnabled = props.enableDnsSupport == null ? true : props.enableDnsSupport;\n    const instanceTenancy = props.defaultInstanceTenancy || 'default';\n    this.resource = new CfnVPC(this, 'Resource', {\n      cidrBlock: vpcOptions.ipv4CidrBlock, //for Ipv4 addresses CIDR block\n      enableDnsHostnames: this.dnsHostnamesEnabled,\n      enableDnsSupport: this.dnsSupportEnabled,\n      ipv4IpamPoolId: vpcOptions.ipv4IpamPool?.ipamPoolId, // for Ipv4 ipam option\n      ipv4NetmaskLength: vpcOptions.ipv4NetmaskLength, // for Ipv4 ipam option\n      instanceTenancy: instanceTenancy,\n    });\n\n    this.node.defaultChild = this.resource;\n    this.vpcCidrBlock = this.resource.attrCidrBlock;\n    if (vpcOptions.ipv4CidrBlock) {\n      this.ipv4CidrBlock = vpcOptions.ipv4CidrBlock;\n    }\n    this.ipv6CidrBlocks = this.resource.attrIpv6CidrBlocks;\n    this.vpcId = this.resource.attrVpcId;\n    this.vpcArn = Arn.format({\n      service: 'ec2',\n      resource: 'vpc',\n      resourceName: this.vpcId,\n    }, this.stack);\n\n    if (props.secondaryAddressBlocks) {\n      const secondaryAddressBlocks: IIpAddresses[] = props.secondaryAddressBlocks;\n\n      for (const secondaryAddressBlock of secondaryAddressBlocks) {\n\n        const secondaryVpcOptions: VpcCidrOptions = secondaryAddressBlock.allocateVpcCidr();\n        if (!secondaryVpcOptions.cidrBlockName) {\n          throw new Error('Cidr Block Name is required to create secondary IP address');\n        }\n\n        if (secondaryVpcOptions.amazonProvided || secondaryVpcOptions.ipv6IpamPool) {\n          this.useIpv6 = true;\n        }\n        //validate CIDR ranges per RFC 1918\n        if (secondaryVpcOptions.ipv4CidrBlock!) {\n          const ret = validateIpv4address(secondaryVpcOptions.ipv4CidrBlock, this.resource.cidrBlock);\n          if (ret === false) {\n            throw new Error('CIDR block should be in the same RFC 1918 range in the VPC');\n          }\n        }\n        const cfnVpcCidrBlock = new CfnVPCCidrBlock(this, secondaryVpcOptions.cidrBlockName, {\n          vpcId: this.vpcId,\n          cidrBlock: secondaryVpcOptions.ipv4CidrBlock,\n          ipv4IpamPoolId: secondaryVpcOptions.ipv4IpamPool?.ipamPoolId,\n          ipv4NetmaskLength: secondaryVpcOptions.ipv4NetmaskLength,\n          ipv6NetmaskLength: secondaryVpcOptions.ipv6NetmaskLength,\n          ipv6IpamPoolId: secondaryVpcOptions.ipv6IpamPool?.ipamPoolId,\n          amazonProvidedIpv6CidrBlock: secondaryVpcOptions.amazonProvided,\n        });\n        if (secondaryVpcOptions.dependencies) {\n          for (const dep of secondaryVpcOptions.dependencies) {\n            cfnVpcCidrBlock.addDependency(dep);\n          }\n        }\n        //Create secondary blocks for Ipv4 and Ipv6\n        this.secondaryCidrBlock.push(cfnVpcCidrBlock);\n      }\n    }\n\n    /**\n     * Empty array for isolated subnets\n     */\n    this.isolatedSubnets = new Array<ISubnet>;\n\n    /**\n     * Empty array for public subnets\n     */\n    this.publicSubnets = new Array<ISubnet>;\n\n    /**\n     * Empty array for private subnets\n     */\n    this.privateSubnets = new Array<ISubnet>;\n\n    /**\n     * Dependable that can be depended upon to force internet connectivity established on the VPC\n     * Add igw to this if its a public subnet\n     */\n    this.internetConnectivityEstablished = this._internetConnectivityEstablished;\n  }\n}\n/**\n * Supports assigning IPv4 address to VPC\n */\nclass ipv4CidrAllocation implements IIpAddresses {\n\n  constructor(private readonly cidrBlock: string, private readonly props?: { cidrBlockName: string}) {\n  }\n\n  /**\n   * @returns CIDR block provided by the user to set IPv4\n   */\n  allocateVpcCidr(): VpcCidrOptions {\n    return {\n      ipv4CidrBlock: this.cidrBlock,\n      cidrBlockName: this.props?.cidrBlockName,\n    };\n  }\n}\n\n/**\n * Supports Amazon Provided Ipv6 ranges\n */\nclass AmazonProvided implements IIpAddresses {\n  /**\n   * Represents an Amazon-provided IPv6 CIDR range for a VPC.\n   *\n   * This class implements the IIpAddresses interface and is used to allocate an Amazon-provided\n   * IPv6 CIDR range for a VPC. When an instance of this class is used to allocate the VPC CIDR,\n   * Amazon will automatically assign an IPv6 CIDR range from its pool of available addresses.\n   */\n\n  constructor(private readonly props: { cidrBlockName: string}) {};\n\n  allocateVpcCidr(): VpcCidrOptions {\n    return {\n      amazonProvided: true,\n      cidrBlockName: this.props.cidrBlockName,\n    };\n  }\n\n}\n\n/**\n * Represents an IPv4 address range managed by AWS IP Address Manager (IPAM).\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html\n */\nclass IpamIpv6 implements IIpAddresses {\n\n  constructor(private readonly props: IpamOptions) {\n  }\n\n  allocateVpcCidr(): VpcCidrOptions {\n    return {\n      ipv6NetmaskLength: this.props.netmaskLength,\n      ipv6IpamPool: this.props.ipamPool,\n      dependencies: this.props.ipamPool?.ipamCidrs.map(c => c as CfnResource),\n      cidrBlockName: this.props.cidrBlockName,\n    };\n  }\n}\n\n/**\n * Represents an IPv4 address range managed by AWS IP Address Manager (IPAM).\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html\n */\nclass IpamIpv4 implements IIpAddresses {\n\n  constructor(private readonly props: IpamOptions) {\n  }\n  allocateVpcCidr(): VpcCidrOptions {\n\n    return {\n      ipv4NetmaskLength: this.props.netmaskLength,\n      ipv4IpamPool: this.props.ipamPool,\n      cidrBlockName: this.props?.cidrBlockName,\n    };\n  }\n}\n\n//@internal First two Octet to verify RFC 1918\ninterface IPaddressConfig {\n  octet1: number;\n  octet2: number;\n}\n\n/**\n * Validates whether a secondary IPv4 address is within the same private IP address range as the primary IPv4 address.\n *\n * @param cidr1 The secondary IPv4 CIDR block to be validated.\n * @param cidr2 The primary IPv4 CIDR block to validate against.\n * @returns True if the secondary IPv4 CIDR block is within the same private IP address range as the primary IPv4 CIDR block, false otherwise.\n * @internal\n * The private IP address ranges are defined by RFC 1918 as 10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16.\n */\nfunction validateIpv4address(cidr1?: string, cidr2?: string): boolean {\n  if (!cidr1 || !cidr2) {\n    return false; // Handle cases where CIDR ranges are not provided\n  }\n\n  const octetsCidr1: number[] = cidr1.split('.').map(octet => parseInt(octet, 10));\n  const octetsCidr2: number[] = cidr2.split('.').map(octet => parseInt(octet, 10));\n\n  if (octetsCidr1.length !== 4 || octetsCidr2.length !== 4) {\n    return false; // Handle invalid CIDR ranges\n  }\n\n  const ip1: IPaddressConfig = {\n    octet1: octetsCidr1[0],\n    octet2: octetsCidr1[1],\n  };\n\n  const ip2: IPaddressConfig = {\n    octet1: octetsCidr2[0],\n    octet2: octetsCidr2[1],\n  };\n\n  return (ip1.octet1 === 10 && ip2.octet1 === 10) ||\n    (ip1.octet1 === 192 && ip1.octet2 === 168 && ip2.octet1 === 192 && ip2.octet2 === 168) ||\n    (ip1.octet1 === 172 && ip1.octet2 === 16 && ip2.octet1 === 172 && ip2.octet2 === 16); // CIDR ranges belong to same private IP address ranges\n}"]}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@aws-cdk/aws-ec2-alpha",
+  "private": false,
+  "version": "2.156.0-alpha.0",
+  "description": "The CDK construct library for VPC V2",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {
+      "java": {
+        "package": "software.amazon.awscdk.services.ec2.alpha",
+        "maven": {
+          "groupId": "software.amazon.awscdk",
+          "artifactId": "ec2-alpha"
+        }
+      },
+      "dotnet": {
+        "namespace": "Amazon.CDK.AWS.ec2.Alpha",
+        "packageId": "Amazon.CDK.AWS.ec2.Alpha",
+        "iconUrl": "https://raw.githubusercontent.com/aws/aws-cdk/main/logo/default-256-dark.png"
+      },
+      "python": {
+        "distName": "aws-cdk.aws-ec2-alpha",
+        "module": "aws_cdk.aws_ec2_alpha",
+        "classifiers": [
+          "Framework :: AWS CDK",
+          "Framework :: AWS CDK :: 2"
+        ]
+      },
+      "go": {
+        "moduleName": "github.com/aws/aws-cdk-go",
+        "packageName": "awsec2alpha"
+      }
+    },
+    "projectReferences": true,
+    "metadata": {
+      "jsii": {
+        "rosetta": {
+          "strict": true
+        }
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/aws-cdk.git",
+    "directory": "packages/@aws-cdk/aws-ec2-alpha"
+  },
+  "scripts": {
+    "build": "cdk-build",
+    "watch": "cdk-watch",
+    "lint": "cdk-lint",
+    "test": "cdk-test",
+    "integ": "integ-runner --language javascript",
+    "pkglint": "pkglint -f",
+    "awslint": "cdk-awslint",
+    "package": "cdk-package",
+    "build+test": "yarn build && yarn test",
+    "build+test+package": "yarn build+test && yarn package",
+    "compat": "cdk-compat",
+    "rosetta:extract": "yarn --silent jsii-rosetta extract",
+    "build+extract": "yarn build && yarn rosetta:extract",
+    "build+test+extract": "yarn build+test && yarn rosetta:extract"
+  },
+  "keywords": [
+    "aws",
+    "cdk",
+    "example",
+    "construct",
+    "library"
+  ],
+  "author": {
+    "name": "Amazon Web Services",
+    "url": "https://aws.amazon.com",
+    "organization": true
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@aws-cdk/cdk-build-tools": "2.156.0-alpha.0",
+    "@aws-cdk/integ-runner": "2.156.0-alpha.0",
+    "@aws-cdk/integ-tests-alpha": "^2.156.0-alpha.0",
+    "@aws-cdk/pkglint": "2.156.0-alpha.0",
+    "@types/jest": "^29.5.12",
+    "aws-cdk-lib": "2.156.0",
+    "jest": "^29.7.0"
+  },
+  "homepage": "https://github.com/aws/aws-cdk",
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.156.0",
+    "constructs": "^10.0.0"
+  },
+  "separate-module": false,
+  "engines": {
+    "node": ">= 14.15.0"
+  },
+  "stability": "experimental",
+  "maturity": "experimental",
+  "awscdkio": {
+    "announce": false
+  },
+  "cdk-build": {
+    "env": {
+      "AWSLINT_BASE_CONSTRUCT": true
+    }
+  },
+  "publishConfig": {
+    "tag": "latest"
+  }
+}

package/rosetta/_generated.ts-fixture

@@ -0,0 +1,6 @@
+import { Construct } from "constructs";
+class MyConstruct extends Construct {
+constructor(scope: Construct, id: string) {
+super(scope, id);
+/// here
+} }

package/rosetta/default.ts-fixture

@@ -0,0 +1,15 @@
+// Fixture with packages imported, but nothing else
+import { Construct } from 'constructs';
+import { Stack, App, Fn } from 'aws-cdk-lib';
+import * as vpc_v2 from '@aws-cdk/aws-ec2-alpha';
+import { Ipam, AwsServiceName, IpCidr } from '@aws-cdk/aws-ec2-alpha';
+import { NatConnectivityType } from '@aws-cdk/aws-ec2-alpha'
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+class Fixture extends Stack {
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    /// here
+  }
+}