terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/network-acl.js

@@ -0,0 +1,207 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubnetNetworkAclAssociation = exports.NetworkAclEntry = exports.TrafficDirection = exports.Action = exports.NetworkAcl = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/network-acl.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+/**
+ * Name tag constant
+ */
+const NAME_TAG = "Name";
+/**
+ * A NetworkAclBase that is not created in this template
+ *
+ *
+ */
+class NetworkAclBase extends aws_construct_1.AwsConstructBase {
+    get networkAclOutputs() {
+        return {
+            networkAclId: this.networkAclId,
+        };
+    }
+    get outputs() {
+        return this.networkAclOutputs;
+    }
+    /**
+     * Add a new entry to the ACL
+     */
+    addEntry(id, options) {
+        return new NetworkAclEntry(this, id, {
+            networkAcl: this,
+            ...options,
+        });
+    }
+}
+/**
+ * Define a new custom network ACL
+ *
+ * By default, will deny all inbound and outbound traffic unless entries are
+ * added explicitly allowing it.
+ *
+ *
+ */
+class NetworkAcl extends NetworkAclBase {
+    /**
+     * Import an existing NetworkAcl into this app.
+     */
+    static fromNetworkAclId(scope, id, networkAclId) {
+        class Import extends NetworkAclBase {
+            constructor() {
+                super(...arguments);
+                this.networkAclId = networkAclId;
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.vpc = props.vpc;
+        aws_tags_1.Tags.of(this).add(NAME_TAG, props.networkAclName || this.node.path);
+        this.networkAcl = new provider_aws_1.networkAcl.NetworkAcl(this, "Resource", {
+            vpcId: props.vpc.vpcId,
+        });
+        this.networkAclId = this.networkAcl.id;
+        this.networkAclVpcId = this.networkAcl.vpcId;
+        if (props.subnetSelection !== undefined) {
+            this.associateWithSubnet("DefaultAssociation", props.subnetSelection);
+        }
+    }
+    /**
+     * Associate the ACL with a given set of subnets
+     */
+    associateWithSubnet(id, selection) {
+        const subnets = this.vpc.selectSubnets(selection);
+        for (const subnet of subnets.subnets) {
+            subnet.associateNetworkAcl(id, this);
+        }
+    }
+}
+exports.NetworkAcl = NetworkAcl;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkAcl[_a] = { fqn: "terraconstructs.aws.compute.NetworkAcl", version: "0.0.12" };
+/**
+ * What action to apply to traffic matching the ACL
+ *
+ *
+ */
+var Action;
+(function (Action) {
+    /**
+     * Allow the traffic
+     */
+    Action["ALLOW"] = "allow";
+    /**
+     * Deny the traffic
+     */
+    Action["DENY"] = "deny";
+})(Action || (exports.Action = Action = {}));
+/**
+ * Base class for NetworkAclEntries
+ *
+ *
+ */
+class NetworkAclEntryBase extends aws_construct_1.AwsConstructBase {
+    get networkAclEntryOutputs() {
+        return {
+            networkAclId: this.networkAcl.networkAclId,
+        };
+    }
+    get outputs() {
+        return this.networkAclEntryOutputs;
+    }
+}
+/**
+ * Direction of traffic the AclEntry applies to
+ *
+ *
+ */
+var TrafficDirection;
+(function (TrafficDirection) {
+    /**
+     * Traffic leaving the subnet
+     */
+    TrafficDirection[TrafficDirection["EGRESS"] = 0] = "EGRESS";
+    /**
+     * Traffic entering the subnet
+     */
+    TrafficDirection[TrafficDirection["INGRESS"] = 1] = "INGRESS";
+})(TrafficDirection || (exports.TrafficDirection = TrafficDirection = {}));
+/**
+ * Define an entry in a Network ACL table
+ *
+ *
+ */
+class NetworkAclEntry extends NetworkAclEntryBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        // const networkAclEntryName =
+        //   props.networkAclEntryName ||
+        //   this.stack.uniqueResourceName(this, {
+        //     prefix: this.gridUUID,
+        //   });
+        this.networkAcl = props.networkAcl;
+        this.resource = new provider_aws_1.networkAclRule.NetworkAclRule(this, "Resource", {
+            networkAclId: this.networkAcl.networkAclId,
+            ruleNumber: props.ruleNumber,
+            ruleAction: props.ruleAction ?? Action.ALLOW,
+            egress: props.direction !== undefined
+                ? props.direction === TrafficDirection.EGRESS
+                : undefined,
+            ...props.traffic.toTfTrafficConfig(),
+            ...props.cidr.toCidrConfig(),
+        });
+    }
+}
+exports.NetworkAclEntry = NetworkAclEntry;
+_b = JSII_RTTI_SYMBOL_1;
+NetworkAclEntry[_b] = { fqn: "terraconstructs.aws.compute.NetworkAclEntry", version: "0.0.12" };
+/**
+ * Associate a network ACL with a subnet
+ *
+ *
+ */
+class SubnetNetworkAclAssociationBase extends aws_construct_1.AwsConstructBase {
+    get subnetNetworkAclAssociationOutputs() {
+        return {
+            subnetNetworkAclAssociationAssociationId: this.subnetNetworkAclAssociationAssociationId,
+        };
+    }
+    get outputs() {
+        return this.subnetNetworkAclAssociationOutputs;
+    }
+}
+class SubnetNetworkAclAssociation extends SubnetNetworkAclAssociationBase {
+    static fromSubnetNetworkAclAssociationAssociationId(scope, id, subnetNetworkAclAssociationAssociationId) {
+        class Import extends SubnetNetworkAclAssociationBase {
+            constructor() {
+                super(...arguments);
+                this.subnetNetworkAclAssociationAssociationId = subnetNetworkAclAssociationAssociationId;
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        // const subnetNetworkAclAssociationName =
+        //   props.subnetNetworkAclAssociationName ||
+        //   this.stack.uniqueResourceName(this, {
+        //     prefix: this.gridUUID,
+        //   });
+        this.association = new provider_aws_1.networkAclAssociation.NetworkAclAssociation(this, "Resource", {
+            networkAclId: props.networkAcl.networkAclId,
+            subnetId: props.subnet.subnetId,
+        });
+        this.networkAcl = props.networkAcl;
+        this.subnet = props.subnet;
+        this.subnetNetworkAclAssociationAssociationId = this.association.id;
+    }
+}
+exports.SubnetNetworkAclAssociation = SubnetNetworkAclAssociation;
+_c = JSII_RTTI_SYMBOL_1;
+SubnetNetworkAclAssociation[_c] = { fqn: "terraconstructs.aws.compute.SubnetNetworkAclAssociation", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-acl.js","sourceRoot":"","sources":["../../../src/aws/compute/network-acl.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/network-acl.ts\n\nimport {\n  networkAcl as tfNetworkAcl,\n  networkAclRule as tfNetworkAclRule,\n  networkAclAssociation as tfNetworkAclAssociation,\n} from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { AclCidr, AclTraffic } from \"./network-acl-types\";\nimport { ISubnet, IVpc, SubnetSelection } from \"./vpc\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\n\n/**\n * Name tag constant\n */\nconst NAME_TAG: string = \"Name\";\n\nexport interface NetworkAclOutputs {\n  /**\n   * The ID of the NetworkACL\n   */\n  readonly networkAclId: string;\n}\n\n/**\n * A NetworkAcl\n *\n *\n */\nexport interface INetworkAcl extends IAwsConstruct {\n  readonly networkAclOutputs: NetworkAclOutputs;\n  /**\n   * ID for the current Network ACL\n   * @attribute\n   */\n  readonly networkAclId: string;\n\n  /**\n   * Add a new entry to the ACL\n   */\n  addEntry(id: string, options: CommonNetworkAclEntryOptions): NetworkAclEntry;\n}\n\n/**\n * A NetworkAclBase that is not created in this template\n *\n *\n */\nabstract class NetworkAclBase extends AwsConstructBase implements INetworkAcl {\n  public get networkAclOutputs(): NetworkAclOutputs {\n    return {\n      networkAclId: this.networkAclId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.networkAclOutputs;\n  }\n  public abstract readonly networkAclId: string;\n\n  /**\n   * Add a new entry to the ACL\n   */\n  public addEntry(\n    id: string,\n    options: CommonNetworkAclEntryOptions,\n  ): NetworkAclEntry {\n    return new NetworkAclEntry(this, id, {\n      networkAcl: this,\n      ...options,\n    });\n  }\n}\n\n/**\n * Properties to create NetworkAcl\n *\n *\n */\nexport interface NetworkAclProps {\n  /**\n   * The name of the NetworkAcl.\n   *\n   * Since the NetworkAcl resource doesn't support providing a physical name, the value provided here will be recorded in the `Name` tag.\n   *\n   * @default CDK generated name\n   */\n  readonly networkAclName?: string;\n\n  /**\n   * The VPC in which to create the NetworkACL.\n   */\n  readonly vpc: IVpc;\n\n  /**\n   * Subnets in the given VPC to associate the ACL with\n   *\n   * More subnets can always be added later by calling\n   * `associateWithSubnets()`.\n   *\n   * @default - No subnets associated\n   */\n  readonly subnetSelection?: SubnetSelection;\n}\n\n/**\n * Define a new custom network ACL\n *\n * By default, will deny all inbound and outbound traffic unless entries are\n * added explicitly allowing it.\n *\n *\n */\nexport class NetworkAcl extends NetworkAclBase {\n  /**\n   * Import an existing NetworkAcl into this app.\n   */\n  public static fromNetworkAclId(\n    scope: Construct,\n    id: string,\n    networkAclId: string,\n  ): INetworkAcl {\n    class Import extends NetworkAclBase {\n      public readonly networkAclId = networkAclId;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The ID of the NetworkACL\n   *\n   * @attribute\n   */\n  public readonly networkAclId: string;\n\n  /**\n   * The VPC ID for this NetworkACL\n   *\n   * @attribute\n   */\n  public readonly networkAclVpcId: string;\n\n  private readonly networkAcl: tfNetworkAcl.NetworkAcl;\n  private readonly vpc: IVpc;\n\n  constructor(scope: Construct, id: string, props: NetworkAclProps) {\n    super(scope, id);\n\n    this.vpc = props.vpc;\n\n    Tags.of(this).add(NAME_TAG, props.networkAclName || this.node.path);\n\n    this.networkAcl = new tfNetworkAcl.NetworkAcl(this, \"Resource\", {\n      vpcId: props.vpc.vpcId,\n    });\n\n    this.networkAclId = this.networkAcl.id;\n    this.networkAclVpcId = this.networkAcl.vpcId;\n\n    if (props.subnetSelection !== undefined) {\n      this.associateWithSubnet(\"DefaultAssociation\", props.subnetSelection);\n    }\n  }\n\n  /**\n   * Associate the ACL with a given set of subnets\n   */\n  public associateWithSubnet(id: string, selection: SubnetSelection) {\n    const subnets = this.vpc.selectSubnets(selection);\n    for (const subnet of subnets.subnets) {\n      subnet.associateNetworkAcl(id, this);\n    }\n  }\n}\n\n/**\n * What action to apply to traffic matching the ACL\n *\n *\n */\nexport enum Action {\n  /**\n   * Allow the traffic\n   */\n  ALLOW = \"allow\",\n\n  /**\n   * Deny the traffic\n   */\n  DENY = \"deny\",\n}\n\nexport interface NetworkAclEntryOutputs {\n  /**\n   * The ID of the NetworkACL\n   */\n  readonly networkAclId: string;\n}\n\n/**\n * A NetworkAclEntry\n *\n *\n */\nexport interface INetworkAclEntry extends IAwsConstruct {\n  readonly networkAclEntryOutputs: NetworkAclEntryOutputs;\n  /**\n   * The network ACL.\n   */\n  readonly networkAcl: INetworkAcl;\n}\n\n/**\n * Base class for NetworkAclEntries\n *\n *\n */\nabstract class NetworkAclEntryBase\n  extends AwsConstructBase\n  implements INetworkAclEntry\n{\n  public get networkAclEntryOutputs(): NetworkAclEntryOutputs {\n    return {\n      networkAclId: this.networkAcl.networkAclId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.networkAclEntryOutputs;\n  }\n  public abstract readonly networkAcl: INetworkAcl;\n}\n\n/**\n * Direction of traffic the AclEntry applies to\n *\n *\n */\nexport enum TrafficDirection {\n  /**\n   * Traffic leaving the subnet\n   */\n  EGRESS,\n\n  /**\n   * Traffic entering the subnet\n   */\n  INGRESS,\n}\n\n/**\n * Basic NetworkACL entry props\n *\n *\n */\nexport interface CommonNetworkAclEntryOptions {\n  // /**\n  //  * The name of the NetworkAclEntry.\n  //  *\n  //  * It is not recommended to use an explicit group name.\n  //  *\n  //  * @default If you don't specify a NetworkAclName, AWS CloudFormation generates a\n  //  * unique physical ID and uses that ID for the group name.\n  //  */\n  // readonly networkAclEntryName?: string;\n\n  /**\n   * The CIDR range to allow or deny.\n   */\n  readonly cidr: AclCidr;\n\n  /**\n   * What kind of traffic this ACL rule applies to\n   */\n  readonly traffic: AclTraffic;\n\n  /**\n   * Traffic direction, with respect to the subnet, this rule applies to\n   *\n   * @default TrafficDirection.INGRESS\n   */\n  readonly direction?: TrafficDirection;\n\n  /**\n   * Whether to allow or deny traffic that matches the rule; valid values are \"allow\" or \"deny\".\n   *\n   * Any traffic that is not explicitly allowed is automatically denied in a custom\n   * ACL, all traffic is automatically allowed in a default ACL.\n   *\n   * @default ALLOW\n   */\n  readonly ruleAction?: Action;\n\n  /**\n   * Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number.\n   * Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.\n   */\n  readonly ruleNumber: number;\n}\n\n/**\n * Properties to create NetworkAclEntry\n *\n *\n */\nexport interface NetworkAclEntryProps\n  extends CommonNetworkAclEntryOptions,\n    AwsConstructProps {\n  /**\n   * The network ACL this entry applies to.\n   */\n  readonly networkAcl: INetworkAcl;\n}\n\n/**\n * Define an entry in a Network ACL table\n *\n *\n */\nexport class NetworkAclEntry extends NetworkAclEntryBase {\n  public readonly networkAcl: INetworkAcl;\n  public resource: tfNetworkAclRule.NetworkAclRule;\n\n  constructor(scope: Construct, id: string, props: NetworkAclEntryProps) {\n    super(scope, id, props);\n    // const networkAclEntryName =\n    //   props.networkAclEntryName ||\n    //   this.stack.uniqueResourceName(this, {\n    //     prefix: this.gridUUID,\n    //   });\n\n    this.networkAcl = props.networkAcl;\n\n    this.resource = new tfNetworkAclRule.NetworkAclRule(this, \"Resource\", {\n      networkAclId: this.networkAcl.networkAclId,\n      ruleNumber: props.ruleNumber,\n      ruleAction: props.ruleAction ?? Action.ALLOW,\n      egress:\n        props.direction !== undefined\n          ? props.direction === TrafficDirection.EGRESS\n          : undefined,\n      ...props.traffic.toTfTrafficConfig(),\n      ...props.cidr.toCidrConfig(),\n    });\n  }\n}\n\nexport interface SubnetNetworkAclAssociationOutputs {\n  /**\n   * The ID of the SubnetNetworkAclAssociation\n   */\n  readonly subnetNetworkAclAssociationAssociationId: string;\n}\n\n/**\n * A SubnetNetworkAclAssociation\n *\n *\n */\nexport interface ISubnetNetworkAclAssociation extends IAwsConstruct {\n  readonly subnetNetworkAclAssociationOutputs: SubnetNetworkAclAssociationOutputs;\n  /**\n   * ID for the current SubnetNetworkAclAssociation\n   * @attribute\n   */\n  readonly subnetNetworkAclAssociationAssociationId: string;\n}\n\n/**\n * Properties to create a SubnetNetworkAclAssociation\n *\n *\n */\nexport interface SubnetNetworkAclAssociationProps extends AwsConstructProps {\n  // /**\n  //  * The name of the SubnetNetworkAclAssociation.\n  //  *\n  //  * It is not recommended to use an explicit name.\n  //  *\n  //  * @default If you don't specify a SubnetNetworkAclAssociationName, AWS CloudFormation generates a\n  //  * unique physical ID and uses that ID for the group name.\n  //  */\n  // readonly subnetNetworkAclAssociationName?: string;\n\n  /**\n   * The Network ACL this association is defined for\n   *\n   * @attribute\n   */\n  readonly networkAcl: INetworkAcl;\n\n  /**\n   * ID of the Subnet\n   * @attribute\n   */\n  readonly subnet: ISubnet;\n}\n\n/**\n * Associate a network ACL with a subnet\n *\n *\n */\nabstract class SubnetNetworkAclAssociationBase\n  extends AwsConstructBase\n  implements ISubnetNetworkAclAssociation\n{\n  public get subnetNetworkAclAssociationOutputs(): SubnetNetworkAclAssociationOutputs {\n    return {\n      subnetNetworkAclAssociationAssociationId:\n        this.subnetNetworkAclAssociationAssociationId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.subnetNetworkAclAssociationOutputs;\n  }\n  public abstract readonly subnetNetworkAclAssociationAssociationId: string;\n}\nexport class SubnetNetworkAclAssociation extends SubnetNetworkAclAssociationBase {\n  public static fromSubnetNetworkAclAssociationAssociationId(\n    scope: Construct,\n    id: string,\n    subnetNetworkAclAssociationAssociationId: string,\n  ): ISubnetNetworkAclAssociation {\n    class Import extends SubnetNetworkAclAssociationBase {\n      public readonly subnetNetworkAclAssociationAssociationId =\n        subnetNetworkAclAssociationAssociationId;\n    }\n\n    return new Import(scope, id);\n  }\n  /**\n   * ID for the current SubnetNetworkAclAssociation\n   * @attribute\n   */\n  public readonly subnetNetworkAclAssociationAssociationId: string;\n\n  /**\n   * ID for the current Network ACL\n   * @attribute\n   */\n  public readonly networkAcl: INetworkAcl;\n\n  /**\n   * ID of the Subnet\n   * @attribute\n   */\n  public readonly subnet: ISubnet;\n\n  private association: tfNetworkAclAssociation.NetworkAclAssociation;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: SubnetNetworkAclAssociationProps,\n  ) {\n    super(scope, id, props);\n    // const subnetNetworkAclAssociationName =\n    //   props.subnetNetworkAclAssociationName ||\n    //   this.stack.uniqueResourceName(this, {\n    //     prefix: this.gridUUID,\n    //   });\n\n    this.association = new tfNetworkAclAssociation.NetworkAclAssociation(\n      this,\n      \"Resource\",\n      {\n        networkAclId: props.networkAcl.networkAclId,\n        subnetId: props.subnet.subnetId,\n      },\n    );\n\n    this.networkAcl = props.networkAcl;\n    this.subnet = props.subnet;\n    this.subnetNetworkAclAssociationAssociationId = this.association.id;\n  }\n}\n"]}

package/lib/aws/compute/network-util.d.ts

@@ -0,0 +1,116 @@
+/**
+ * InvalidCidrRangeError is thrown when attempting to perform operations on a CIDR
+ * range that is either not valid, or outside of the VPC size limits.
+ */
+export declare class InvalidCidrRangeError extends Error {
+    constructor(cidr: string);
+}
+/**
+ * NetworkUtils contains helpers to work with network constructs (subnets/ranges)
+ */
+export declare class NetworkUtils {
+    /**
+     * Validates an IPv4 string
+     *
+     * returns true of the string contains 4 numbers between 0-255 delimited by
+     * a `.` character
+     */
+    static validIp(ipAddress: string): boolean;
+    /**
+     * Converts a string IPv4 to a number
+     *
+     * takes an IP Address (e.g. 174.66.173.168) and converts to a number
+     * (e.g 2923605416); currently only supports IPv4
+     *
+     * Uses the formula:
+     * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +
+     * (fourth octet)
+     *
+     * @param  {string} the IP address (e.g. 174.66.173.168)
+     * @returns {number} the integer value of the IP address (e.g 2923605416)
+     */
+    static ipToNum(ipAddress: string): number;
+    /**
+     * Takes number and converts it to IPv4 address string
+     *
+     * Takes a number (e.g 2923605416) and converts it to an IPv4 address string
+     * currently only supports IPv4
+     *
+     * @param  {number} the integer value of the IP address (e.g 2923605416)
+     * @returns {string} the IPv4 address (e.g. 174.66.173.168)
+     */
+    static numToIp(ipNum: number): string;
+}
+/**
+ * Creates a network based on a CIDR Block to build contained subnets
+ */
+export declare class NetworkBuilder {
+    /**
+     * The CIDR range used when creating the network
+     */
+    readonly networkCidr: CidrBlock;
+    /**
+     * The list of CIDR blocks for subnets within this network
+     */
+    private readonly subnetCidrs;
+    /**
+     * The next available IP address as a number
+     */
+    private nextAvailableIp;
+    /**
+     * Create a network using the provided CIDR block
+     *
+     * No subnets are allocated in the constructor, the maxIpConsumed is set one
+     * less than the first IP in the network
+     *
+     */
+    constructor(cidr: string);
+    /**
+     * Add a subnet to the network and update the maxIpConsumed
+     */
+    addSubnet(mask: number): string;
+    /**
+     * Add {count} number of subnets to the network and update the maxIpConsumed
+     */
+    addSubnets(mask: number, count?: number): string[];
+    /**
+     * return the CIDR notation strings for all subnets in the network
+     */
+    get cidrStrings(): string[];
+    /**
+     * Calculates the largest subnet to create of the given count from the
+     * remaining IP space
+     */
+    maskForRemainingSubnets(subnetCount: number): number;
+}
+/**
+ * A block of IP address space with a given bit prefix
+ */
+export declare class CidrBlock {
+    /**
+     * Calculates the netmask for a given CIDR mask
+     *
+     * For example:
+     * CidrBlock.calculateNetmask(24) returns '255.255.255.0'
+     */
+    static calculateNetmask(mask: number): string;
+    /**
+     * Calculates the number IP addresses in a CIDR Mask
+     *
+     * For example:
+     * CidrBlock.calculateNetsize(24) returns 256
+     */
+    static calculateNetsize(mask: number): number;
+    readonly cidr: string;
+    readonly mask: number;
+    readonly networkSize: number;
+    private readonly networkAddress;
+    constructor(cidr: string);
+    constructor(ipAddress: number, mask: number);
+    maxIp(): string;
+    minIp(): string;
+    minAddress(): number;
+    maxAddress(): number;
+    nextBlock(): CidrBlock;
+    containsCidr(other: CidrBlock): boolean;
+}

package/lib/aws/compute/network-util.js

@@ -0,0 +1,241 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/network-util.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CidrBlock = exports.NetworkBuilder = exports.NetworkUtils = exports.InvalidCidrRangeError = void 0;
+// TODO: Fix duplicates from https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/util.ts
+// classes overlap and seem identical: CidrBlock, NetworkUtils in ./util.ts
+/**
+ * InvalidCidrRangeError is thrown when attempting to perform operations on a CIDR
+ * range that is either not valid, or outside of the VPC size limits.
+ */
+class InvalidCidrRangeError extends Error {
+    constructor(cidr) {
+        super(cidr +
+            " is not a valid VPC CIDR range. VPCs must be between /16 and /28 and the minimum subnet size is /28.");
+        // The following line is required for type checking of custom errors, and must be called right after super()
+        // https://stackoverflow.com/questions/31626231/custom-error-class-in-typescript
+        Object.setPrototypeOf(this, InvalidCidrRangeError.prototype);
+    }
+}
+exports.InvalidCidrRangeError = InvalidCidrRangeError;
+/**
+ * NetworkUtils contains helpers to work with network constructs (subnets/ranges)
+ */
+class NetworkUtils {
+    /**
+     * Validates an IPv4 string
+     *
+     * returns true of the string contains 4 numbers between 0-255 delimited by
+     * a `.` character
+     */
+    static validIp(ipAddress) {
+        const octets = ipAddress.split(".");
+        if (octets.length !== 4) {
+            return false;
+        }
+        return (octets
+            .map((octet) => parseInt(octet, 10))
+            .filter((octet) => octet >= 0 && octet <= 255).length === 4);
+    }
+    /**
+     * Converts a string IPv4 to a number
+     *
+     * takes an IP Address (e.g. 174.66.173.168) and converts to a number
+     * (e.g 2923605416); currently only supports IPv4
+     *
+     * Uses the formula:
+     * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +
+     * (fourth octet)
+     *
+     * @param  {string} the IP address (e.g. 174.66.173.168)
+     * @returns {number} the integer value of the IP address (e.g 2923605416)
+     */
+    static ipToNum(ipAddress) {
+        if (!this.validIp(ipAddress)) {
+            throw new Error(`${ipAddress} is not valid`);
+        }
+        return ipAddress
+            .split(".")
+            .reduce((p, c, i) => p + parseInt(c, 10) * 256 ** (3 - i), 0);
+    }
+    /**
+     * Takes number and converts it to IPv4 address string
+     *
+     * Takes a number (e.g 2923605416) and converts it to an IPv4 address string
+     * currently only supports IPv4
+     *
+     * @param  {number} the integer value of the IP address (e.g 2923605416)
+     * @returns {string} the IPv4 address (e.g. 174.66.173.168)
+     */
+    static numToIp(ipNum) {
+        // this all because bitwise math is signed
+        let remaining = ipNum;
+        const address = new Array();
+        for (let i = 0; i < 4; i++) {
+            if (remaining !== 0) {
+                address.push(Math.floor(remaining / 256 ** (3 - i)));
+                remaining = remaining % 256 ** (3 - i);
+            }
+            else {
+                address.push(0);
+            }
+        }
+        const ipAddress = address.join(".");
+        if (!this.validIp(ipAddress)) {
+            throw new Error(`${ipAddress} is not a valid IP Address`);
+        }
+        return ipAddress;
+    }
+}
+exports.NetworkUtils = NetworkUtils;
+/**
+ * Creates a network based on a CIDR Block to build contained subnets
+ */
+class NetworkBuilder {
+    /**
+     * Create a network using the provided CIDR block
+     *
+     * No subnets are allocated in the constructor, the maxIpConsumed is set one
+     * less than the first IP in the network
+     *
+     */
+    constructor(cidr) {
+        /**
+         * The list of CIDR blocks for subnets within this network
+         */
+        this.subnetCidrs = [];
+        this.networkCidr = new CidrBlock(cidr);
+        this.subnetCidrs = [];
+        this.nextAvailableIp = this.networkCidr.minAddress();
+    }
+    /**
+     * Add a subnet to the network and update the maxIpConsumed
+     */
+    addSubnet(mask) {
+        return this.addSubnets(mask, 1)[0];
+    }
+    /**
+     * Add {count} number of subnets to the network and update the maxIpConsumed
+     */
+    addSubnets(mask, count = 1) {
+        if (mask < 16 || mask > 28) {
+            throw new InvalidCidrRangeError(`x.x.x.x/${mask}`);
+        }
+        const maxIp = this.nextAvailableIp + CidrBlock.calculateNetsize(mask) * count;
+        if (this.networkCidr.maxAddress() < maxIp - 1) {
+            throw new Error(`${count} of /${mask} exceeds remaining space of ${this.networkCidr.cidr}`);
+        }
+        const subnets = [];
+        for (let i = 0; i < count; i++) {
+            const subnet = new CidrBlock(this.nextAvailableIp, mask);
+            this.nextAvailableIp = subnet.nextBlock().minAddress();
+            this.subnetCidrs.push(subnet);
+            subnets.push(subnet);
+        }
+        return subnets.map((subnet) => subnet.cidr);
+    }
+    /**
+     * return the CIDR notation strings for all subnets in the network
+     */
+    get cidrStrings() {
+        return this.subnetCidrs.map((subnet) => subnet.cidr);
+    }
+    /**
+     * Calculates the largest subnet to create of the given count from the
+     * remaining IP space
+     */
+    maskForRemainingSubnets(subnetCount) {
+        const remaining = this.networkCidr.maxAddress() - this.nextAvailableIp + 1;
+        const ipsPerSubnet = Math.floor(remaining / subnetCount);
+        return 32 - Math.floor(Math.log2(ipsPerSubnet));
+    }
+}
+exports.NetworkBuilder = NetworkBuilder;
+/**
+ * A block of IP address space with a given bit prefix
+ */
+class CidrBlock {
+    /**
+     * Calculates the netmask for a given CIDR mask
+     *
+     * For example:
+     * CidrBlock.calculateNetmask(24) returns '255.255.255.0'
+     */
+    static calculateNetmask(mask) {
+        return NetworkUtils.numToIp(2 ** 32 - 2 ** (32 - mask));
+    }
+    /**
+     * Calculates the number IP addresses in a CIDR Mask
+     *
+     * For example:
+     * CidrBlock.calculateNetsize(24) returns 256
+     */
+    static calculateNetsize(mask) {
+        return 2 ** (32 - mask);
+    }
+    constructor(ipAddressOrCidr, mask) {
+        if (typeof ipAddressOrCidr === "string") {
+            this.mask = parseInt(ipAddressOrCidr.split("/")[1], 10);
+            this.networkAddress =
+                NetworkUtils.ipToNum(ipAddressOrCidr.split("/")[0]) +
+                    CidrBlock.calculateNetsize(this.mask) -
+                    1;
+        }
+        else {
+            if (typeof mask === "number") {
+                this.mask = mask;
+            }
+            else {
+                // this should be impossible
+                this.mask = 16;
+            }
+            this.networkAddress =
+                ipAddressOrCidr + CidrBlock.calculateNetsize(this.mask) - 1;
+            this.networkSize = 2 ** (32 - this.mask);
+        }
+        this.networkSize = 2 ** (32 - this.mask);
+        this.cidr = `${this.minIp()}/${this.mask}`;
+    }
+    /*
+     * The maximum IP in the CIDR Block e.g. '10.0.8.255'
+     */
+    maxIp() {
+        // min + (2^(32-mask)) - 1 [zero needs to count]
+        return NetworkUtils.numToIp(this.maxAddress());
+    }
+    /*
+     * The minimum IP in the CIDR Block e.g. '10.0.0.0'
+     */
+    minIp() {
+        return NetworkUtils.numToIp(this.minAddress());
+    }
+    /*
+     * Returns the number representation for the minimum IPv4 address
+     */
+    minAddress() {
+        const div = this.networkAddress % this.networkSize;
+        return this.networkAddress - div;
+    }
+    /*
+     * Returns the number representation for the maximum IPv4 address
+     */
+    maxAddress() {
+        // min + (2^(32-mask)) - 1 [zero needs to count]
+        return this.minAddress() + this.networkSize - 1;
+    }
+    /*
+     * Returns the next CIDR Block of the same mask size
+     */
+    nextBlock() {
+        return new CidrBlock(this.maxAddress() + 1, this.mask);
+    }
+    /*
+     * Returns true if this CidrBlock fully contains the provided CidrBlock
+     */
+    containsCidr(other) {
+        return (this.maxAddress() >= other.maxAddress() &&
+            this.minAddress() <= other.minAddress());
+    }
+}
+exports.CidrBlock = CidrBlock;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-util.js","sourceRoot":"","sources":["../../../src/aws/compute/network-util.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/network-util.ts\n\n// TODO: Fix duplicates from https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/util.ts\n// classes overlap and seem identical: CidrBlock, NetworkUtils in ./util.ts\n\n/**\n * InvalidCidrRangeError is thrown when attempting to perform operations on a CIDR\n * range that is either not valid, or outside of the VPC size limits.\n */\nexport class InvalidCidrRangeError extends Error {\n  constructor(cidr: string) {\n    super(\n      cidr +\n        \" is not a valid VPC CIDR range. VPCs must be between /16 and /28 and the minimum subnet size is /28.\",\n    );\n    // The following line is required for type checking of custom errors, and must be called right after super()\n    // https://stackoverflow.com/questions/31626231/custom-error-class-in-typescript\n    Object.setPrototypeOf(this, InvalidCidrRangeError.prototype);\n  }\n}\n\n/**\n * NetworkUtils contains helpers to work with network constructs (subnets/ranges)\n */\nexport class NetworkUtils {\n  /**\n   * Validates an IPv4 string\n   *\n   * returns true of the string contains 4 numbers between 0-255 delimited by\n   * a `.` character\n   */\n  public static validIp(ipAddress: string): boolean {\n    const octets = ipAddress.split(\".\");\n    if (octets.length !== 4) {\n      return false;\n    }\n    return (\n      octets\n        .map((octet: string) => parseInt(octet, 10))\n        .filter((octet: number) => octet >= 0 && octet <= 255).length === 4\n    );\n  }\n\n  /**\n   * Converts a string IPv4 to a number\n   *\n   * takes an IP Address (e.g. 174.66.173.168) and converts to a number\n   * (e.g 2923605416); currently only supports IPv4\n   *\n   * Uses the formula:\n   * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +\n   * (fourth octet)\n   *\n   * @param  {string} the IP address (e.g. 174.66.173.168)\n   * @returns {number} the integer value of the IP address (e.g 2923605416)\n   */\n  public static ipToNum(ipAddress: string): number {\n    if (!this.validIp(ipAddress)) {\n      throw new Error(`${ipAddress} is not valid`);\n    }\n\n    return ipAddress\n      .split(\".\")\n      .reduce(\n        (p: number, c: string, i: number) =>\n          p + parseInt(c, 10) * 256 ** (3 - i),\n        0,\n      );\n  }\n\n  /**\n   * Takes number and converts it to IPv4 address string\n   *\n   * Takes a number (e.g 2923605416) and converts it to an IPv4 address string\n   * currently only supports IPv4\n   *\n   * @param  {number} the integer value of the IP address (e.g 2923605416)\n   * @returns {string} the IPv4 address (e.g. 174.66.173.168)\n   */\n  public static numToIp(ipNum: number): string {\n    // this all because bitwise math is signed\n    let remaining = ipNum;\n    const address = new Array<number>();\n    for (let i = 0; i < 4; i++) {\n      if (remaining !== 0) {\n        address.push(Math.floor(remaining / 256 ** (3 - i)));\n        remaining = remaining % 256 ** (3 - i);\n      } else {\n        address.push(0);\n      }\n    }\n    const ipAddress: string = address.join(\".\");\n    if (!this.validIp(ipAddress)) {\n      throw new Error(`${ipAddress} is not a valid IP Address`);\n    }\n    return ipAddress;\n  }\n}\n\n/**\n * Creates a network based on a CIDR Block to build contained subnets\n */\nexport class NetworkBuilder {\n  /**\n   * The CIDR range used when creating the network\n   */\n  public readonly networkCidr: CidrBlock;\n\n  /**\n   * The list of CIDR blocks for subnets within this network\n   */\n  private readonly subnetCidrs: CidrBlock[] = [];\n\n  /**\n   * The next available IP address as a number\n   */\n  private nextAvailableIp: number;\n\n  /**\n   * Create a network using the provided CIDR block\n   *\n   * No subnets are allocated in the constructor, the maxIpConsumed is set one\n   * less than the first IP in the network\n   *\n   */\n  constructor(cidr: string) {\n    this.networkCidr = new CidrBlock(cidr);\n    this.subnetCidrs = [];\n    this.nextAvailableIp = this.networkCidr.minAddress();\n  }\n\n  /**\n   * Add a subnet to the network and update the maxIpConsumed\n   */\n  public addSubnet(mask: number): string {\n    return this.addSubnets(mask, 1)[0];\n  }\n\n  /**\n   * Add {count} number of subnets to the network and update the maxIpConsumed\n   */\n  public addSubnets(mask: number, count: number = 1): string[] {\n    if (mask < 16 || mask > 28) {\n      throw new InvalidCidrRangeError(`x.x.x.x/${mask}`);\n    }\n    const maxIp =\n      this.nextAvailableIp + CidrBlock.calculateNetsize(mask) * count;\n    if (this.networkCidr.maxAddress() < maxIp - 1) {\n      throw new Error(\n        `${count} of /${mask} exceeds remaining space of ${this.networkCidr.cidr}`,\n      );\n    }\n    const subnets: CidrBlock[] = [];\n    for (let i = 0; i < count; i++) {\n      const subnet: CidrBlock = new CidrBlock(this.nextAvailableIp, mask);\n      this.nextAvailableIp = subnet.nextBlock().minAddress();\n      this.subnetCidrs.push(subnet);\n      subnets.push(subnet);\n    }\n    return subnets.map((subnet) => subnet.cidr);\n  }\n\n  /**\n   * return the CIDR notation strings for all subnets in the network\n   */\n  public get cidrStrings(): string[] {\n    return this.subnetCidrs.map((subnet) => subnet.cidr);\n  }\n\n  /**\n   * Calculates the largest subnet to create of the given count from the\n   * remaining IP space\n   */\n  public maskForRemainingSubnets(subnetCount: number): number {\n    const remaining: number =\n      this.networkCidr.maxAddress() - this.nextAvailableIp + 1;\n    const ipsPerSubnet: number = Math.floor(remaining / subnetCount);\n    return 32 - Math.floor(Math.log2(ipsPerSubnet));\n  }\n}\n\n/**\n * A block of IP address space with a given bit prefix\n */\nexport class CidrBlock {\n  /**\n   * Calculates the netmask for a given CIDR mask\n   *\n   * For example:\n   * CidrBlock.calculateNetmask(24) returns '255.255.255.0'\n   */\n  public static calculateNetmask(mask: number): string {\n    return NetworkUtils.numToIp(2 ** 32 - 2 ** (32 - mask));\n  }\n\n  /**\n   * Calculates the number IP addresses in a CIDR Mask\n   *\n   * For example:\n   * CidrBlock.calculateNetsize(24) returns 256\n   */\n  public static calculateNetsize(mask: number): number {\n    return 2 ** (32 - mask);\n  }\n\n  /*\n   * The CIDR Block represented as a string e.g. '10.0.0.0/21'\n   */\n  public readonly cidr: string;\n\n  /*\n   * The CIDR mask e.g. for CIDR '10.0.0.0/21' returns 21\n   */\n  public readonly mask: number;\n\n  /*\n   * The total number of IP addresses in the CIDR\n   */\n  public readonly networkSize: number;\n\n  /*\n   * The network address provided in CIDR creation offset by the Netsize -1\n   */\n  private readonly networkAddress: number;\n\n  /*\n   * Parses either CIDR notation String or two numbers representing the IP\n   * space\n   *\n   * cidr expects a string '10.0.0.0/16'\n   * ipAddress expects a number\n   * mask expects a number\n   *\n   * If the given `cidr` or `ipAddress` is not the beginning of the block,\n   * then the next available block will be returned. For example, if\n   * `10.0.3.1/28` is given the returned block will represent `10.0.3.16/28`.\n   */\n  constructor(cidr: string);\n  constructor(ipAddress: number, mask: number);\n  constructor(ipAddressOrCidr: string | number, mask?: number) {\n    if (typeof ipAddressOrCidr === \"string\") {\n      this.mask = parseInt(ipAddressOrCidr.split(\"/\")[1], 10);\n      this.networkAddress =\n        NetworkUtils.ipToNum(ipAddressOrCidr.split(\"/\")[0]) +\n        CidrBlock.calculateNetsize(this.mask) -\n        1;\n    } else {\n      if (typeof mask === \"number\") {\n        this.mask = mask;\n      } else {\n        // this should be impossible\n        this.mask = 16;\n      }\n      this.networkAddress =\n        ipAddressOrCidr + CidrBlock.calculateNetsize(this.mask) - 1;\n      this.networkSize = 2 ** (32 - this.mask);\n    }\n    this.networkSize = 2 ** (32 - this.mask);\n    this.cidr = `${this.minIp()}/${this.mask}`;\n  }\n\n  /*\n   * The maximum IP in the CIDR Block e.g. '10.0.8.255'\n   */\n  public maxIp(): string {\n    // min + (2^(32-mask)) - 1 [zero needs to count]\n    return NetworkUtils.numToIp(this.maxAddress());\n  }\n\n  /*\n   * The minimum IP in the CIDR Block e.g. '10.0.0.0'\n   */\n  public minIp(): string {\n    return NetworkUtils.numToIp(this.minAddress());\n  }\n\n  /*\n   * Returns the number representation for the minimum IPv4 address\n   */\n  public minAddress(): number {\n    const div = this.networkAddress % this.networkSize;\n    return this.networkAddress - div;\n  }\n\n  /*\n   * Returns the number representation for the maximum IPv4 address\n   */\n  public maxAddress(): number {\n    // min + (2^(32-mask)) - 1 [zero needs to count]\n    return this.minAddress() + this.networkSize - 1;\n  }\n\n  /*\n   * Returns the next CIDR Block of the same mask size\n   */\n  public nextBlock(): CidrBlock {\n    return new CidrBlock(this.maxAddress() + 1, this.mask);\n  }\n\n  /*\n   * Returns true if this CidrBlock fully contains the provided CidrBlock\n   */\n  public containsCidr(other: CidrBlock): boolean {\n    return (\n      this.maxAddress() >= other.maxAddress() &&\n      this.minAddress() <= other.minAddress()\n    );\n  }\n}\n"]}