terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/connections.js

@@ -0,0 +1,208 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connections = 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/connections.ts
+const peer_1 = require("./peer");
+/**
+ * Manage the allowed network connections for constructs with Security Groups.
+ *
+ * Security Groups can be thought of as a firewall for network-connected
+ * devices. This class makes it easy to allow network connections to and
+ * from security groups, and between security groups individually. When
+ * establishing connectivity between security groups, it will automatically
+ * add rules in both security groups
+ *
+ * This object can manage one or more security groups.
+ */
+class Connections {
+    constructor(props = {}) {
+        /**
+         * Underlying securityGroup for this Connections object, if present
+         *
+         * May be empty if this Connections object is not managing a SecurityGroup,
+         * but simply representing a Connectable peer.
+         */
+        this._securityGroups = new ReactiveList();
+        /**
+         * The rule that defines how to represent this peer in a security group
+         */
+        this._securityGroupRules = new ReactiveList();
+        /**
+         * When doing bidirectional grants between Connections, make sure we don't recursive infinitely
+         */
+        this.skip = false;
+        /**
+         * When doing bidirectional grants between Security Groups in different stacks, put the rule on the other SG
+         */
+        this.remoteRule = false;
+        this.connections = this;
+        this._securityGroups.push(...(props.securityGroups || []));
+        this._securityGroupRules.push(...this._securityGroups.asArray());
+        if (props.peer) {
+            this._securityGroupRules.push(props.peer);
+        }
+        this.defaultPort = props.defaultPort;
+    }
+    get securityGroups() {
+        return this._securityGroups.asArray();
+    }
+    /**
+     * Add a security group to the list of security groups managed by this object
+     */
+    addSecurityGroup(...securityGroups) {
+        for (const securityGroup of securityGroups) {
+            this._securityGroups.push(securityGroup);
+            this._securityGroupRules.push(securityGroup);
+        }
+    }
+    /**
+     * Allow connections to the peer on the given port
+     */
+    allowTo(other, portRange, description) {
+        if (this.skip) {
+            return;
+        }
+        const remoteRule = this.remoteRule; // Capture current value into local for callback to close over
+        this._securityGroups.forEachAndForever((securityGroup) => {
+            other.connections._securityGroupRules.forEachAndForever((rule) => {
+                securityGroup.addEgressRule(rule, portRange, description, remoteRule);
+            });
+        });
+        this.skip = true;
+        other.connections.remoteRule = true;
+        try {
+            other.connections.allowFrom(this, portRange, description);
+        }
+        finally {
+            this.skip = false;
+            other.connections.remoteRule = false;
+        }
+    }
+    /**
+     * Allow connections from the peer on the given port
+     */
+    allowFrom(other, portRange, description) {
+        if (this.skip) {
+            return;
+        }
+        const remoteRule = this.remoteRule; // Capture current value into local for callback to close over
+        this._securityGroups.forEachAndForever((securityGroup) => {
+            other.connections._securityGroupRules.forEachAndForever((rule) => {
+                securityGroup.addIngressRule(rule, portRange, description, remoteRule);
+            });
+        });
+        this.skip = true;
+        other.connections.remoteRule = true;
+        try {
+            other.connections.allowTo(this, portRange, description);
+        }
+        finally {
+            this.skip = false;
+            other.connections.remoteRule = false;
+        }
+    }
+    /**
+     * Allow hosts inside the security group to connect to each other on the given port
+     */
+    allowInternally(portRange, description) {
+        this._securityGroups.forEachAndForever((securityGroup) => {
+            this._securityGroupRules.forEachAndForever((rule) => {
+                securityGroup.addIngressRule(rule, portRange, description);
+                securityGroup.addEgressRule(rule, portRange, description);
+            });
+        });
+    }
+    /**
+     * Allow to all IPv4 ranges
+     */
+    allowToAnyIpv4(portRange, description) {
+        this.allowTo(peer_1.Peer.anyIpv4(), portRange, description);
+    }
+    /**
+     * Allow from any IPv4 ranges
+     */
+    allowFromAnyIpv4(portRange, description) {
+        this.allowFrom(peer_1.Peer.anyIpv4(), portRange, description);
+    }
+    /**
+     * Allow connections from the peer on our default port
+     *
+     * Even if the peer has a default port, we will always use our default port.
+     */
+    allowDefaultPortFrom(other, description) {
+        if (!this.defaultPort) {
+            throw new Error("Cannot call allowDefaultPortFrom(): this resource has no default port");
+        }
+        this.allowFrom(other, this.defaultPort, description);
+    }
+    /**
+     * Allow hosts inside the security group to connect to each other
+     */
+    allowDefaultPortInternally(description) {
+        if (!this.defaultPort) {
+            throw new Error("Cannot call allowDefaultPortInternally(): this resource has no default port");
+        }
+        this.allowInternally(this.defaultPort, description);
+    }
+    /**
+     * Allow default connections from all IPv4 ranges
+     */
+    allowDefaultPortFromAnyIpv4(description) {
+        if (!this.defaultPort) {
+            throw new Error("Cannot call allowDefaultPortFromAnyIpv4(): this resource has no default port");
+        }
+        this.allowFromAnyIpv4(this.defaultPort, description);
+    }
+    /**
+     * Allow connections to the security group on their default port
+     */
+    allowToDefaultPort(other, description) {
+        if (other.connections.defaultPort === undefined) {
+            throw new Error("Cannot call allowToDefaultPort(): other resource has no default port");
+        }
+        this.allowTo(other, other.connections.defaultPort, description);
+    }
+    /**
+     * Allow connections from the peer on our default port
+     *
+     * Even if the peer has a default port, we will always use our default port.
+     */
+    allowDefaultPortTo(other, description) {
+        if (!this.defaultPort) {
+            throw new Error("Cannot call allowDefaultPortTo(): this resource has no default port");
+        }
+        this.allowTo(other, this.defaultPort, description);
+    }
+}
+exports.Connections = Connections;
+_a = JSII_RTTI_SYMBOL_1;
+Connections[_a] = { fqn: "terraconstructs.aws.compute.Connections", version: "0.0.12" };
+class ReactiveList {
+    constructor() {
+        this.elements = new Array();
+        this.listeners = new Array();
+    }
+    push(...xs) {
+        this.elements.push(...xs);
+        for (const listener of this.listeners) {
+            for (const x of xs) {
+                listener(x);
+            }
+        }
+    }
+    forEachAndForever(listener) {
+        for (const element of this.elements) {
+            listener(element);
+        }
+        this.listeners.push(listener);
+    }
+    asArray() {
+        return this.elements.slice();
+    }
+    get length() {
+        return this.elements.length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connections.js","sourceRoot":"","sources":["../../../src/aws/compute/connections.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/connections.ts\n\nimport { IPeer, Peer } from \"./peer\";\nimport { Port } from \"./port\";\nimport { ISecurityGroup } from \"./security-group\";\n\n/**\n * The goal of this module is to make possible to write statements like this:\n *\n *  ```ts\n *  database.connections.allowFrom(fleet);\n *  fleet.connections.allowTo(database);\n *  rdgw.connections.allowFromCidrIp('0.3.1.5/86');\n *  rgdw.connections.allowTrafficTo(fleet, new AllPorts());\n *  ```\n *\n * The insight here is that some connecting peers have information on what ports should\n * be involved in the connection, and some don't.\n */\n\n/**\n * An object that has a Connections object\n */\nexport interface IConnectable {\n  /**\n   * The network connections associated with this resource.\n   */\n  readonly connections: Connections;\n}\n\n/**\n * Properties to intialize a new Connections object\n */\nexport interface ConnectionsProps {\n  /**\n   * Class that represents the rule by which others can connect to this connectable\n   *\n   * This object is required, but will be derived from securityGroup if that is passed.\n   *\n   * @default Derived from securityGroup if set.\n   */\n  readonly peer?: IPeer;\n\n  /**\n   * What securityGroup(s) this object is managing connections for\n   *\n   * @default No security groups\n   */\n  readonly securityGroups?: ISecurityGroup[];\n\n  /**\n   * Default port range for initiating connections to and from this object\n   *\n   * @default - No default port\n   */\n  readonly defaultPort?: Port;\n}\n\n/**\n * Manage the allowed network connections for constructs with Security Groups.\n *\n * Security Groups can be thought of as a firewall for network-connected\n * devices. This class makes it easy to allow network connections to and\n * from security groups, and between security groups individually. When\n * establishing connectivity between security groups, it will automatically\n * add rules in both security groups\n *\n * This object can manage one or more security groups.\n */\nexport class Connections implements IConnectable {\n  public readonly connections: Connections;\n\n  /**\n   * The default port configured for this connection peer, if available\n   */\n  public readonly defaultPort?: Port;\n\n  /**\n   * Underlying securityGroup for this Connections object, if present\n   *\n   * May be empty if this Connections object is not managing a SecurityGroup,\n   * but simply representing a Connectable peer.\n   */\n  private readonly _securityGroups = new ReactiveList<ISecurityGroup>();\n\n  /**\n   * The rule that defines how to represent this peer in a security group\n   */\n  private readonly _securityGroupRules = new ReactiveList<IPeer>();\n\n  /**\n   * When doing bidirectional grants between Connections, make sure we don't recursive infinitely\n   */\n  private skip: boolean = false;\n\n  /**\n   * When doing bidirectional grants between Security Groups in different stacks, put the rule on the other SG\n   */\n  private remoteRule: boolean = false;\n\n  constructor(props: ConnectionsProps = {}) {\n    this.connections = this;\n    this._securityGroups.push(...(props.securityGroups || []));\n\n    this._securityGroupRules.push(...this._securityGroups.asArray());\n    if (props.peer) {\n      this._securityGroupRules.push(props.peer);\n    }\n\n    this.defaultPort = props.defaultPort;\n  }\n\n  public get securityGroups(): ISecurityGroup[] {\n    return this._securityGroups.asArray();\n  }\n\n  /**\n   * Add a security group to the list of security groups managed by this object\n   */\n  public addSecurityGroup(...securityGroups: ISecurityGroup[]) {\n    for (const securityGroup of securityGroups) {\n      this._securityGroups.push(securityGroup);\n      this._securityGroupRules.push(securityGroup);\n    }\n  }\n\n  /**\n   * Allow connections to the peer on the given port\n   */\n  public allowTo(other: IConnectable, portRange: Port, description?: string) {\n    if (this.skip) {\n      return;\n    }\n\n    const remoteRule = this.remoteRule; // Capture current value into local for callback to close over\n    this._securityGroups.forEachAndForever((securityGroup) => {\n      other.connections._securityGroupRules.forEachAndForever((rule) => {\n        securityGroup.addEgressRule(rule, portRange, description, remoteRule);\n      });\n    });\n\n    this.skip = true;\n    other.connections.remoteRule = true;\n    try {\n      other.connections.allowFrom(this, portRange, description);\n    } finally {\n      this.skip = false;\n      other.connections.remoteRule = false;\n    }\n  }\n\n  /**\n   * Allow connections from the peer on the given port\n   */\n  public allowFrom(other: IConnectable, portRange: Port, description?: string) {\n    if (this.skip) {\n      return;\n    }\n\n    const remoteRule = this.remoteRule; // Capture current value into local for callback to close over\n    this._securityGroups.forEachAndForever((securityGroup) => {\n      other.connections._securityGroupRules.forEachAndForever((rule) => {\n        securityGroup.addIngressRule(rule, portRange, description, remoteRule);\n      });\n    });\n\n    this.skip = true;\n    other.connections.remoteRule = true;\n    try {\n      other.connections.allowTo(this, portRange, description);\n    } finally {\n      this.skip = false;\n      other.connections.remoteRule = false;\n    }\n  }\n\n  /**\n   * Allow hosts inside the security group to connect to each other on the given port\n   */\n  public allowInternally(portRange: Port, description?: string) {\n    this._securityGroups.forEachAndForever((securityGroup) => {\n      this._securityGroupRules.forEachAndForever((rule) => {\n        securityGroup.addIngressRule(rule, portRange, description);\n        securityGroup.addEgressRule(rule, portRange, description);\n      });\n    });\n  }\n\n  /**\n   * Allow to all IPv4 ranges\n   */\n  public allowToAnyIpv4(portRange: Port, description?: string) {\n    this.allowTo(Peer.anyIpv4(), portRange, description);\n  }\n\n  /**\n   * Allow from any IPv4 ranges\n   */\n  public allowFromAnyIpv4(portRange: Port, description?: string) {\n    this.allowFrom(Peer.anyIpv4(), portRange, description);\n  }\n\n  /**\n   * Allow connections from the peer on our default port\n   *\n   * Even if the peer has a default port, we will always use our default port.\n   */\n  public allowDefaultPortFrom(other: IConnectable, description?: string) {\n    if (!this.defaultPort) {\n      throw new Error(\n        \"Cannot call allowDefaultPortFrom(): this resource has no default port\",\n      );\n    }\n    this.allowFrom(other, this.defaultPort, description);\n  }\n\n  /**\n   * Allow hosts inside the security group to connect to each other\n   */\n  public allowDefaultPortInternally(description?: string) {\n    if (!this.defaultPort) {\n      throw new Error(\n        \"Cannot call allowDefaultPortInternally(): this resource has no default port\",\n      );\n    }\n    this.allowInternally(this.defaultPort, description);\n  }\n\n  /**\n   * Allow default connections from all IPv4 ranges\n   */\n  public allowDefaultPortFromAnyIpv4(description?: string) {\n    if (!this.defaultPort) {\n      throw new Error(\n        \"Cannot call allowDefaultPortFromAnyIpv4(): this resource has no default port\",\n      );\n    }\n    this.allowFromAnyIpv4(this.defaultPort, description);\n  }\n\n  /**\n   * Allow connections to the security group on their default port\n   */\n  public allowToDefaultPort(other: IConnectable, description?: string) {\n    if (other.connections.defaultPort === undefined) {\n      throw new Error(\n        \"Cannot call allowToDefaultPort(): other resource has no default port\",\n      );\n    }\n\n    this.allowTo(other, other.connections.defaultPort, description);\n  }\n\n  /**\n   * Allow connections from the peer on our default port\n   *\n   * Even if the peer has a default port, we will always use our default port.\n   */\n  public allowDefaultPortTo(other: IConnectable, description?: string) {\n    if (!this.defaultPort) {\n      throw new Error(\n        \"Cannot call allowDefaultPortTo(): this resource has no default port\",\n      );\n    }\n    this.allowTo(other, this.defaultPort, description);\n  }\n}\n\ntype Action<T> = (x: T) => void;\n\nclass ReactiveList<T> {\n  private readonly elements = new Array<T>();\n  private readonly listeners = new Array<Action<T>>();\n\n  public push(...xs: T[]) {\n    this.elements.push(...xs);\n    for (const listener of this.listeners) {\n      for (const x of xs) {\n        listener(x);\n      }\n    }\n  }\n\n  public forEachAndForever(listener: Action<T>) {\n    for (const element of this.elements) {\n      listener(element);\n    }\n    this.listeners.push(listener);\n  }\n\n  public asArray(): T[] {\n    return this.elements.slice();\n  }\n\n  public get length(): number {\n    return this.elements.length;\n  }\n}\n"]}

package/lib/aws/compute/ec2-augmentations.generated.d.ts

@@ -0,0 +1,53 @@
+import * as cw from "../cloudwatch";
+declare module "./vpn" {
+    interface IVpnConnection {
+        /**
+         * Return the given named metric for this VPNConnection
+         */
+        metric(metricName: string, props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The state of the tunnel. 0 indicates DOWN and 1 indicates UP.
+         *
+         * Average over 5 minutes
+         */
+        metricTunnelState(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The bytes received through the VPN tunnel.
+         *
+         * Sum over 5 minutes
+         */
+        metricTunnelDataIn(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The bytes sent through the VPN tunnel.
+         *
+         * Sum over 5 minutes
+         */
+        metricTunnelDataOut(props?: cw.MetricOptions): cw.Metric;
+    }
+}
+declare module "./vpn" {
+    interface VpnConnectionBase {
+        /**
+         * Return the given named metric for this VPNConnection
+         */
+        metric(metricName: string, props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The state of the tunnel. 0 indicates DOWN and 1 indicates UP.
+         *
+         * Average over 5 minutes
+         */
+        metricTunnelState(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The bytes received through the VPN tunnel.
+         *
+         * Sum over 5 minutes
+         */
+        metricTunnelDataIn(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The bytes sent through the VPN tunnel.
+         *
+         * Sum over 5 minutes
+         */
+        metricTunnelDataOut(props?: cw.MetricOptions): cw.Metric;
+    }
+}

package/lib/aws/compute/ec2-augmentations.generated.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright 2012-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+/* eslint-disable prettier/prettier,max-len */
+const cw = require("../cloudwatch");
+const vpn_1 = require("./vpn");
+vpn_1.VpnConnectionBase.prototype.metric = function (metricName, props) {
+    return new cw.Metric({
+        "namespace": "AWS/VPN",
+        "metricName": metricName,
+        "dimensionsMap": {
+            "VpnId": this.vpnId
+        },
+        ...props
+    }).attachTo(this);
+};
+vpn_1.VpnConnectionBase.prototype.metricTunnelState = function (props) {
+    return this.metric("TunnelState", {
+        "statistic": "Average",
+        ...props
+    });
+};
+vpn_1.VpnConnectionBase.prototype.metricTunnelDataIn = function (props) {
+    return this.metric("TunnelDataIn", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+vpn_1.VpnConnectionBase.prototype.metricTunnelDataOut = function (props) {
+    return this.metric("TunnelDataOut", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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