terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/nlb/network-target-group.js

@@ -0,0 +1,223 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkTargetGroup = 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-elasticloadbalancingv2/lib/nlb/network-target-group.ts
+const cdktf_1 = require("cdktf");
+const cloudwatch = require("../../cloudwatch");
+const base_target_group_1 = require("../lb-shared/base-target-group");
+const enums_1 = require("../lb-shared/enums");
+const imported_1 = require("../lb-shared/imported");
+const util_1 = require("../lb-shared/util");
+/**
+ * The metrics for a network load balancer.
+ */
+class NetworkTargetGroupMetrics {
+    constructor(scope, targetGroupFullName, loadBalancerFullName) {
+        this.scope = scope;
+        this.targetGroupFullName = targetGroupFullName;
+        this.loadBalancerFullName = loadBalancerFullName;
+    }
+    custom(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/NetworkELB",
+            metricName,
+            dimensionsMap: {
+                LoadBalancer: this.loadBalancerFullName,
+                TargetGroup: this.targetGroupFullName,
+            },
+            ...props,
+        }).attachTo(this.scope);
+    }
+    healthyHostCount(props) {
+        return this.custom("HealthyHostCount", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    unHealthyHostCount(props) {
+        return this.custom("UnHealthyHostCount", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+}
+/**
+ * Define a Network Target Group
+ */
+class NetworkTargetGroup extends base_target_group_1.TargetGroupBase {
+    /**
+     * Import an existing target group
+     */
+    static fromTargetGroupAttributes(scope, id, attrs) {
+        return new ImportedNetworkTargetGroup(scope, id, attrs);
+    }
+    /**
+     * Import an existing listener
+     *
+     * @deprecated Use `fromTargetGroupAttributes` instead
+     */
+    static import(scope, id, props) {
+        return NetworkTargetGroup.fromTargetGroupAttributes(scope, id, props);
+    }
+    constructor(scope, id, props) {
+        const proto = props.protocol || enums_1.LbProtocol.TCP;
+        (0, util_1.validateNetworkProtocol)(proto);
+        super(scope, id, props, {
+            protocol: proto,
+            port: props.port,
+        });
+        this.listeners = [];
+        if (props.proxyProtocolV2 != null) {
+            this.setAttribute("proxy_protocol_v2.enabled", props.proxyProtocolV2 ? "true" : "false");
+        }
+        if (props.preserveClientIp !== undefined) {
+            this.setAttribute("preserve_client_ip.enabled", props.preserveClientIp ? "true" : "false");
+        }
+        if (props.connectionTermination !== undefined) {
+            this.setAttribute("deregistration_delay.connection_termination.enabled", props.connectionTermination ? "true" : "false");
+        }
+        this.addTarget(...(props.targets || []));
+    }
+    get metrics() {
+        if (!this._metrics) {
+            this._metrics = new NetworkTargetGroupMetrics(this, this.targetGroupFullName, this.firstLoadBalancerFullName);
+        }
+        return this._metrics;
+    }
+    /**
+     * Add a load balancing target to this target group
+     */
+    addTarget(...targets) {
+        for (const target of targets) {
+            const result = target.attachToNetworkTargetGroup(this);
+            this.addLoadBalancerTarget(result);
+        }
+    }
+    /**
+     * Register a listener that is load balancing to this target group.
+     *
+     * Don't call this directly. It will be called by listeners.
+     */
+    registerListener(listener) {
+        this.loadBalancerAttachedDependencies.add(listener);
+        this.listeners.push(listener);
+    }
+    /**
+     * The number of targets that are considered healthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``NetworkTargetGroup.metrics.healthyHostCount`` instead
+     */
+    metricHealthyHostCount(props) {
+        return this.metrics.healthyHostCount(props);
+    }
+    /**
+     * The number of targets that are considered unhealthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``NetworkTargetGroup.metrics.healthyHostCount`` instead
+     */
+    metricUnHealthyHostCount(props) {
+        return this.metrics.unHealthyHostCount(props);
+    }
+    /**
+     * Full name of first load balancer
+     */
+    get firstLoadBalancerFullName() {
+        if (this.listeners.length === 0) {
+            throw new Error("The TargetGroup needs to be attached to a LoadBalancer before you can call this method");
+        }
+        return (0, base_target_group_1.loadBalancerNameFromListenerArn)(this.listeners[0].listenerArn);
+    }
+    validateTargetGroup() {
+        const ret = super.validateTargetGroup();
+        const healthCheck = this.healthCheck || {};
+        const lowHealthCheckInterval = 5;
+        const highHealthCheckInterval = 300;
+        if (healthCheck.interval) {
+            const seconds = healthCheck.interval.toSeconds();
+            if (!cdktf_1.Token.isUnresolved(seconds) &&
+                (seconds < lowHealthCheckInterval || seconds > highHealthCheckInterval)) {
+                ret.push(`Health check interval '${seconds}' not supported. Must be between ${lowHealthCheckInterval} and ${highHealthCheckInterval}.`);
+            }
+        }
+        if (healthCheck.healthyThresholdCount) {
+            const thresholdCount = healthCheck.healthyThresholdCount;
+            if (thresholdCount < 2 || thresholdCount > 10) {
+                ret.push(`Healthy Threshold Count '${thresholdCount}' not supported. Must be a number between 2 and 10.`);
+            }
+        }
+        if (healthCheck.unhealthyThresholdCount) {
+            const thresholdCount = healthCheck.unhealthyThresholdCount;
+            if (thresholdCount < 2 || thresholdCount > 10) {
+                ret.push(`Unhealthy Threshold Count '${thresholdCount}' not supported. Must be a number between 2 and 10.`);
+            }
+        }
+        if (!healthCheck.protocol) {
+            return ret;
+        }
+        if (!NLB_HEALTH_CHECK_PROTOCOLS.includes(healthCheck.protocol)) {
+            ret.push(`Health check protocol '${healthCheck.protocol}' is not supported. Must be one of [${NLB_HEALTH_CHECK_PROTOCOLS.join(", ")}]`);
+        }
+        if (healthCheck.path &&
+            !NLB_PATH_HEALTH_CHECK_PROTOCOLS.includes(healthCheck.protocol)) {
+            ret.push([
+                `'${healthCheck.protocol}' health checks do not support the path property.`,
+                `Must be one of [${NLB_PATH_HEALTH_CHECK_PROTOCOLS.join(", ")}]`,
+            ].join(" "));
+        }
+        const lowHealthCheckTimeout = 2;
+        const highHealthCheckTimeout = 120;
+        if (healthCheck.timeout) {
+            const timeoutSeconds = healthCheck.timeout.toSeconds();
+            if (timeoutSeconds < lowHealthCheckTimeout ||
+                timeoutSeconds > highHealthCheckTimeout) {
+                ret.push(`Health check timeout '${timeoutSeconds}' not supported. Must be a number between ${lowHealthCheckTimeout} and ${highHealthCheckTimeout}.`);
+            }
+        }
+        return ret;
+    }
+}
+exports.NetworkTargetGroup = NetworkTargetGroup;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkTargetGroup[_a] = { fqn: "terraconstructs.aws.compute.NetworkTargetGroup", version: "0.0.12" };
+/**
+ * An imported network target group
+ */
+class ImportedNetworkTargetGroup extends imported_1.ImportedTargetGroupBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (this.loadBalancerArns != util_1.NO_LOADBALANCER_ARNS) {
+            const targetGroupFullName = (0, util_1.parseTargetGroupFullName)(this.targetGroupArn);
+            const firstLoadBalancerFullName = (0, util_1.parseLoadBalancerFullName)(this.loadBalancerArns);
+            this._metrics = new NetworkTargetGroupMetrics(this, targetGroupFullName, firstLoadBalancerFullName);
+        }
+    }
+    get metrics() {
+        if (!this._metrics) {
+            throw new Error("The imported NetworkTargetGroup needs the associated NetworkLoadBalancer to be able to provide metrics. " +
+                "Please specify the ARN value when importing it.");
+        }
+        return this._metrics;
+    }
+    registerListener(_listener) {
+        // Nothing to do, we know nothing of our members
+    }
+    addTarget(...targets) {
+        for (const target of targets) {
+            const result = target.attachToNetworkTargetGroup(this);
+            if (result.targetJson !== undefined) {
+                throw new Error("Cannot add a non-self registering target to an imported TargetGroup. Create a new TargetGroup instead.");
+            }
+        }
+    }
+}
+const NLB_HEALTH_CHECK_PROTOCOLS = [
+    enums_1.LbProtocol.HTTP,
+    enums_1.LbProtocol.HTTPS,
+    enums_1.LbProtocol.TCP,
+];
+const NLB_PATH_HEALTH_CHECK_PROTOCOLS = [enums_1.LbProtocol.HTTP, enums_1.LbProtocol.HTTPS];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-target-group.js","sourceRoot":"","sources":["../../../../src/aws/compute/nlb/network-target-group.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/nlb/network-target-group.ts\n\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { INetworkListener } from \"./network-listener\";\nimport * as cloudwatch from \"../../cloudwatch\";\nimport {\n  BaseTargetGroupProps,\n  HealthCheck,\n  ITargetGroup,\n  loadBalancerNameFromListenerArn,\n  LoadBalancerTargetProps,\n  TargetGroupAttributes,\n  TargetGroupBase,\n  TargetGroupImportProps,\n} from \"../lb-shared/base-target-group\";\nimport { LbProtocol } from \"../lb-shared/enums\";\nimport { ImportedTargetGroupBase } from \"../lb-shared/imported\";\nimport {\n  parseLoadBalancerFullName,\n  parseTargetGroupFullName,\n  validateNetworkProtocol,\n  NO_LOADBALANCER_ARNS,\n} from \"../lb-shared/util\";\n\n/**\n * Properties for a new Network Target Group\n */\nexport interface NetworkTargetGroupProps extends BaseTargetGroupProps {\n  /**\n   * The port on which the target receives traffic.\n   */\n  readonly port: number;\n\n  /**\n   * Protocol for target group, expects TCP, TLS, UDP, or TCP_UDP.\n   *\n   * @default - TCP\n   */\n  readonly protocol?: LbProtocol;\n\n  /**\n   * Indicates whether Proxy Protocol version 2 is enabled.\n   *\n   * @default false\n   */\n  readonly proxyProtocolV2?: boolean;\n\n  /**\n   * Indicates whether client IP preservation is enabled.\n   *\n   * @default false if the target group type is IP address and the\n   * target group protocol is TCP or TLS. Otherwise, true.\n   */\n  readonly preserveClientIp?: boolean;\n\n  /**\n   * The targets to add to this target group.\n   *\n   * Can be `Instance`, `IPAddress`, or any self-registering load balancing\n   * target. If you use either `Instance` or `IPAddress` as targets, all\n   * target must be of the same type.\n   *\n   * @default - No targets.\n   */\n  readonly targets?: INetworkLoadBalancerTarget[];\n\n  /**\n   *\n   * Indicates whether the load balancer terminates connections at\n   * the end of the deregistration timeout.\n   *\n   * @default false\n   */\n  readonly connectionTermination?: boolean;\n}\n\n/**\n * Contains all metrics for a Target Group of a Network Load Balancer.\n */\nexport interface INetworkTargetGroupMetrics {\n  /**\n   * Return the given named metric for this Network Target Group\n   *\n   * @default Average over 5 minutes\n   */\n  custom(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of targets that are considered healthy.\n   *\n   * @default Average over 5 minutes\n   */\n  healthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of targets that are considered unhealthy.\n   *\n   * @default Average over 5 minutes\n   */\n  unHealthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\n/**\n * The metrics for a network load balancer.\n */\nclass NetworkTargetGroupMetrics implements INetworkTargetGroupMetrics {\n  private readonly scope: Construct;\n  private readonly loadBalancerFullName: string;\n  private readonly targetGroupFullName: string;\n\n  public constructor(\n    scope: Construct,\n    targetGroupFullName: string,\n    loadBalancerFullName: string,\n  ) {\n    this.scope = scope;\n    this.targetGroupFullName = targetGroupFullName;\n    this.loadBalancerFullName = loadBalancerFullName;\n  }\n\n  public custom(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/NetworkELB\",\n      metricName,\n      dimensionsMap: {\n        LoadBalancer: this.loadBalancerFullName,\n        TargetGroup: this.targetGroupFullName,\n      },\n      ...props,\n    }).attachTo(this.scope);\n  }\n\n  public healthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.custom(\"HealthyHostCount\", {\n      statistic: \"Average\",\n      ...props,\n    });\n  }\n\n  public unHealthyHostCount(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"UnHealthyHostCount\", {\n      statistic: \"Average\",\n      ...props,\n    });\n  }\n}\n\n/**\n * Define a Network Target Group\n */\nexport class NetworkTargetGroup\n  extends TargetGroupBase\n  implements INetworkTargetGroup\n{\n  /**\n   * Import an existing target group\n   */\n  public static fromTargetGroupAttributes(\n    scope: Construct,\n    id: string,\n    attrs: TargetGroupAttributes,\n  ): INetworkTargetGroup {\n    return new ImportedNetworkTargetGroup(scope, id, attrs);\n  }\n\n  /**\n   * Import an existing listener\n   *\n   * @deprecated Use `fromTargetGroupAttributes` instead\n   */\n  public static import(\n    scope: Construct,\n    id: string,\n    props: TargetGroupImportProps,\n  ): INetworkTargetGroup {\n    return NetworkTargetGroup.fromTargetGroupAttributes(scope, id, props);\n  }\n\n  private readonly listeners: INetworkListener[];\n  private _metrics?: INetworkTargetGroupMetrics;\n\n  constructor(scope: Construct, id: string, props: NetworkTargetGroupProps) {\n    const proto = props.protocol || LbProtocol.TCP;\n    validateNetworkProtocol(proto);\n\n    super(scope, id, props, {\n      protocol: proto,\n      port: props.port,\n    });\n\n    this.listeners = [];\n\n    if (props.proxyProtocolV2 != null) {\n      this.setAttribute(\n        \"proxy_protocol_v2.enabled\",\n        props.proxyProtocolV2 ? \"true\" : \"false\",\n      );\n    }\n\n    if (props.preserveClientIp !== undefined) {\n      this.setAttribute(\n        \"preserve_client_ip.enabled\",\n        props.preserveClientIp ? \"true\" : \"false\",\n      );\n    }\n    if (props.connectionTermination !== undefined) {\n      this.setAttribute(\n        \"deregistration_delay.connection_termination.enabled\",\n        props.connectionTermination ? \"true\" : \"false\",\n      );\n    }\n    this.addTarget(...(props.targets || []));\n  }\n\n  public get metrics(): INetworkTargetGroupMetrics {\n    if (!this._metrics) {\n      this._metrics = new NetworkTargetGroupMetrics(\n        this,\n        this.targetGroupFullName,\n        this.firstLoadBalancerFullName,\n      );\n    }\n    return this._metrics;\n  }\n\n  /**\n   * Add a load balancing target to this target group\n   */\n  public addTarget(...targets: INetworkLoadBalancerTarget[]) {\n    for (const target of targets) {\n      const result = target.attachToNetworkTargetGroup(this);\n      this.addLoadBalancerTarget(result);\n    }\n  }\n\n  /**\n   * Register a listener that is load balancing to this target group.\n   *\n   * Don't call this directly. It will be called by listeners.\n   */\n  public registerListener(listener: INetworkListener) {\n    this.loadBalancerAttachedDependencies.add(listener);\n    this.listeners.push(listener);\n  }\n\n  /**\n   * The number of targets that are considered healthy.\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``NetworkTargetGroup.metrics.healthyHostCount`` instead\n   */\n  public metricHealthyHostCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.healthyHostCount(props);\n  }\n\n  /**\n   * The number of targets that are considered unhealthy.\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``NetworkTargetGroup.metrics.healthyHostCount`` instead\n   */\n  public metricUnHealthyHostCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.unHealthyHostCount(props);\n  }\n\n  /**\n   * Full name of first load balancer\n   */\n  public get firstLoadBalancerFullName(): string {\n    if (this.listeners.length === 0) {\n      throw new Error(\n        \"The TargetGroup needs to be attached to a LoadBalancer before you can call this method\",\n      );\n    }\n    return loadBalancerNameFromListenerArn(this.listeners[0].listenerArn);\n  }\n\n  protected validateTargetGroup(): string[] {\n    const ret = super.validateTargetGroup();\n\n    const healthCheck: HealthCheck = this.healthCheck || {};\n\n    const lowHealthCheckInterval = 5;\n    const highHealthCheckInterval = 300;\n    if (healthCheck.interval) {\n      const seconds = healthCheck.interval.toSeconds();\n      if (\n        !Token.isUnresolved(seconds) &&\n        (seconds < lowHealthCheckInterval || seconds > highHealthCheckInterval)\n      ) {\n        ret.push(\n          `Health check interval '${seconds}' not supported. Must be between ${lowHealthCheckInterval} and ${highHealthCheckInterval}.`,\n        );\n      }\n    }\n\n    if (healthCheck.healthyThresholdCount) {\n      const thresholdCount = healthCheck.healthyThresholdCount;\n      if (thresholdCount < 2 || thresholdCount > 10) {\n        ret.push(\n          `Healthy Threshold Count '${thresholdCount}' not supported. Must be a number between 2 and 10.`,\n        );\n      }\n    }\n\n    if (healthCheck.unhealthyThresholdCount) {\n      const thresholdCount = healthCheck.unhealthyThresholdCount;\n      if (thresholdCount < 2 || thresholdCount > 10) {\n        ret.push(\n          `Unhealthy Threshold Count '${thresholdCount}' not supported. Must be a number between 2 and 10.`,\n        );\n      }\n    }\n\n    if (!healthCheck.protocol) {\n      return ret;\n    }\n\n    if (!NLB_HEALTH_CHECK_PROTOCOLS.includes(healthCheck.protocol)) {\n      ret.push(\n        `Health check protocol '${healthCheck.protocol}' is not supported. Must be one of [${NLB_HEALTH_CHECK_PROTOCOLS.join(\", \")}]`,\n      );\n    }\n    if (\n      healthCheck.path &&\n      !NLB_PATH_HEALTH_CHECK_PROTOCOLS.includes(healthCheck.protocol)\n    ) {\n      ret.push(\n        [\n          `'${healthCheck.protocol}' health checks do not support the path property.`,\n          `Must be one of [${NLB_PATH_HEALTH_CHECK_PROTOCOLS.join(\", \")}]`,\n        ].join(\" \"),\n      );\n    }\n\n    const lowHealthCheckTimeout = 2;\n    const highHealthCheckTimeout = 120;\n    if (healthCheck.timeout) {\n      const timeoutSeconds = healthCheck.timeout.toSeconds();\n      if (\n        timeoutSeconds < lowHealthCheckTimeout ||\n        timeoutSeconds > highHealthCheckTimeout\n      ) {\n        ret.push(\n          `Health check timeout '${timeoutSeconds}' not supported. Must be a number between ${lowHealthCheckTimeout} and ${highHealthCheckTimeout}.`,\n        );\n      }\n    }\n\n    return ret;\n  }\n}\n\n/**\n * A network target group\n */\nexport interface INetworkTargetGroup extends ITargetGroup {\n  /**\n   * All metrics available for this target group.\n   */\n  readonly metrics: INetworkTargetGroupMetrics;\n\n  /**\n   * Register a listener that is load balancing to this target group.\n   *\n   * Don't call this directly. It will be called by listeners.\n   */\n  registerListener(listener: INetworkListener): void;\n\n  /**\n   * Add a load balancing target to this target group\n   */\n  addTarget(...targets: INetworkLoadBalancerTarget[]): void;\n}\n\n/**\n * An imported network target group\n */\nclass ImportedNetworkTargetGroup\n  extends ImportedTargetGroupBase\n  implements INetworkTargetGroup\n{\n  private readonly _metrics?: INetworkTargetGroupMetrics;\n\n  public constructor(\n    scope: Construct,\n    id: string,\n    props: TargetGroupImportProps,\n  ) {\n    super(scope, id, props);\n    if (this.loadBalancerArns != NO_LOADBALANCER_ARNS) {\n      const targetGroupFullName = parseTargetGroupFullName(this.targetGroupArn);\n      const firstLoadBalancerFullName = parseLoadBalancerFullName(\n        this.loadBalancerArns,\n      );\n      this._metrics = new NetworkTargetGroupMetrics(\n        this,\n        targetGroupFullName,\n        firstLoadBalancerFullName,\n      );\n    }\n  }\n\n  public get metrics(): INetworkTargetGroupMetrics {\n    if (!this._metrics) {\n      throw new Error(\n        \"The imported NetworkTargetGroup needs the associated NetworkLoadBalancer to be able to provide metrics. \" +\n          \"Please specify the ARN value when importing it.\",\n      );\n    }\n    return this._metrics;\n  }\n\n  public registerListener(_listener: INetworkListener) {\n    // Nothing to do, we know nothing of our members\n  }\n\n  public addTarget(...targets: INetworkLoadBalancerTarget[]) {\n    for (const target of targets) {\n      const result = target.attachToNetworkTargetGroup(this);\n      if (result.targetJson !== undefined) {\n        throw new Error(\n          \"Cannot add a non-self registering target to an imported TargetGroup. Create a new TargetGroup instead.\",\n        );\n      }\n    }\n  }\n}\n\n/**\n * Interface for constructs that can be targets of an network load balancer\n */\nexport interface INetworkLoadBalancerTarget {\n  /**\n   * Attach load-balanced target to a TargetGroup\n   *\n   * May return JSON to directly add to the [Targets] list, or return undefined\n   * if the target will register itself with the load balancer.\n   */\n  attachToNetworkTargetGroup(\n    targetGroup: INetworkTargetGroup,\n  ): LoadBalancerTargetProps;\n}\n\nconst NLB_HEALTH_CHECK_PROTOCOLS = [\n  LbProtocol.HTTP,\n  LbProtocol.HTTPS,\n  LbProtocol.TCP,\n];\nconst NLB_PATH_HEALTH_CHECK_PROTOCOLS = [LbProtocol.HTTP, LbProtocol.HTTPS];\n"]}

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

@@ -0,0 +1,64 @@
+import { IConnectable } from "./connections";
+/**
+ * Interface for classes that provide the peer-specification parts of a security group rule
+ */
+export interface IPeer extends IConnectable {
+    /**
+     * Whether the rule can be inlined into a SecurityGroup or not
+     */
+    readonly canInlineRule: boolean;
+    /**
+     * A unique identifier for this connection peer
+     */
+    readonly uniqueId: string;
+    /**
+     * Produce the ingress rule JSON for the given connection
+     */
+    toIngressRuleConfig(): any;
+    /**
+     * Produce the egress rule JSON for the given connection
+     */
+    toEgressRuleConfig(): any;
+}
+/**
+ * Peer object factories (to be used in Security Group management)
+ *
+ * The static methods on this object can be used to create peer objects
+ * which represent a connection partner in Security Group rules.
+ *
+ * Use this object if you need to represent connection partners using plain IP
+ * addresses, or a prefix list ID.
+ *
+ * If you want to address a connection partner by Security Group, you can just
+ * use the Security Group (or the construct that contains a Security Group)
+ * directly, as it already implements `IPeer`.
+ */
+export declare class Peer {
+    /**
+     * Create an IPv4 peer from a CIDR
+     */
+    static ipv4(cidrIp: string): IPeer;
+    /**
+     * Any IPv4 address
+     */
+    static anyIpv4(): IPeer;
+    /**
+     * Create an IPv6 peer from a CIDR
+     */
+    static ipv6(cidrIp: string): IPeer;
+    /**
+     * Any IPv6 address
+     */
+    static anyIpv6(): IPeer;
+    /**
+     * A prefix list
+     */
+    static prefixList(prefixListId: string): IPeer;
+    /**
+     * A security group ID
+     *
+     * NOTE: Terraform provider AWS does not support sourceSecurityGroupOwnerId
+     */
+    static securityGroupId(securityGroupId: string, sourceSecurityGroupOwnerId?: string): IPeer;
+    protected constructor();
+}

package/lib/aws/compute/peer.js

@@ -0,0 +1,235 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Peer = 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/peer.ts
+const cdktf_1 = require("cdktf");
+const connections_1 = require("./connections");
+/**
+ * Peer object factories (to be used in Security Group management)
+ *
+ * The static methods on this object can be used to create peer objects
+ * which represent a connection partner in Security Group rules.
+ *
+ * Use this object if you need to represent connection partners using plain IP
+ * addresses, or a prefix list ID.
+ *
+ * If you want to address a connection partner by Security Group, you can just
+ * use the Security Group (or the construct that contains a Security Group)
+ * directly, as it already implements `IPeer`.
+ */
+class Peer {
+    /**
+     * Create an IPv4 peer from a CIDR
+     */
+    static ipv4(cidrIp) {
+        return new CidrIPv4(cidrIp);
+    }
+    /**
+     * Any IPv4 address
+     */
+    static anyIpv4() {
+        return new AnyIPv4();
+    }
+    /**
+     * Create an IPv6 peer from a CIDR
+     */
+    static ipv6(cidrIp) {
+        return new CidrIPv6(cidrIp);
+    }
+    /**
+     * Any IPv6 address
+     */
+    static anyIpv6() {
+        return new AnyIPv6();
+    }
+    /**
+     * A prefix list
+     */
+    static prefixList(prefixListId) {
+        return new PrefixList(prefixListId);
+    }
+    /**
+     * A security group ID
+     *
+     * NOTE: Terraform provider AWS does not support sourceSecurityGroupOwnerId
+     */
+    static securityGroupId(securityGroupId, sourceSecurityGroupOwnerId) {
+        return new SecurityGroupId(securityGroupId, sourceSecurityGroupOwnerId);
+    }
+    constructor() { }
+}
+exports.Peer = Peer;
+_a = JSII_RTTI_SYMBOL_1;
+Peer[_a] = { fqn: "terraconstructs.aws.compute.Peer", version: "0.0.12" };
+/**
+ * A connection to and from a given IP range
+ */
+class CidrIPv4 {
+    constructor(cidrIp) {
+        this.cidrIp = cidrIp;
+        this.canInlineRule = true;
+        this.connections = new connections_1.Connections({ peer: this });
+        if (!cdktf_1.Token.isUnresolved(cidrIp)) {
+            const cidrMatch = cidrIp.match(/^(\d{1,3}\.){3}\d{1,3}(\/\d+)?$/);
+            if (!cidrMatch) {
+                throw new Error(`Invalid IPv4 CIDR: "${cidrIp}"`);
+            }
+            if (!cidrMatch[2]) {
+                throw new Error(`CIDR mask is missing in IPv4: "${cidrIp}". Did you mean "${cidrIp}/32"?`);
+            }
+        }
+        this.uniqueId = cidrIp;
+    }
+    /**
+     * Produce the ingress rule JSON for the given connection
+     */
+    toIngressRuleConfig() {
+        return {
+            cidrIpv4: this.cidrIp,
+            cidrBlocks: [this.cidrIp],
+        };
+    }
+    /**
+     * Produce the egress rule JSON for the given connection
+     */
+    toEgressRuleConfig() {
+        return {
+            cidrIpv4: this.cidrIp,
+            cidrBlocks: [this.cidrIp],
+        };
+    }
+}
+/**
+ * Any IPv4 address
+ */
+class AnyIPv4 extends CidrIPv4 {
+    constructor() {
+        super("0.0.0.0/0");
+    }
+}
+/**
+ * A connection to a from a given IPv6 range
+ */
+class CidrIPv6 {
+    constructor(cidrIpv6) {
+        this.cidrIpv6 = cidrIpv6;
+        this.canInlineRule = true;
+        this.connections = new connections_1.Connections({ peer: this });
+        if (!cdktf_1.Token.isUnresolved(cidrIpv6)) {
+            const cidrMatch = cidrIpv6.match(/^([\da-f]{0,4}:){2,7}([\da-f]{0,4})?(\/\d+)?$/);
+            if (!cidrMatch) {
+                throw new Error(`Invalid IPv6 CIDR: "${cidrIpv6}"`);
+            }
+            if (!cidrMatch[3]) {
+                throw new Error(`CIDR mask is missing in IPv6: "${cidrIpv6}". Did you mean "${cidrIpv6}/128"?`);
+            }
+        }
+        this.uniqueId = cidrIpv6;
+    }
+    /**
+     * Produce the ingress rule JSON for the given connection
+     */
+    toIngressRuleConfig() {
+        return {
+            cidrIpv6: this.cidrIpv6,
+            ipv6CidrBlocks: [this.cidrIpv6],
+        };
+    }
+    /**
+     * Produce the egress rule JSON for the given connection
+     */
+    toEgressRuleConfig() {
+        return {
+            cidrIpv6: this.cidrIpv6,
+            ipv6CidrBlocks: [this.cidrIpv6],
+        };
+    }
+}
+/**
+ * Any IPv6 address
+ */
+class AnyIPv6 extends CidrIPv6 {
+    constructor() {
+        super("::/0");
+    }
+}
+/**
+ * A prefix list
+ *
+ * Prefix lists are used to allow traffic to VPC-local service endpoints.
+ *
+ * For more information, see this page:
+ *
+ * https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/vpc-endpoints.html
+ */
+class PrefixList {
+    constructor(prefixListId) {
+        this.prefixListId = prefixListId;
+        this.canInlineRule = false;
+        this.connections = new connections_1.Connections({ peer: this });
+        this.uniqueId = prefixListId;
+    }
+    toIngressRuleConfig() {
+        return {
+            prefixListId: this.prefixListId,
+            prefixListIds: [this.prefixListId],
+        };
+    }
+    toEgressRuleConfig() {
+        return {
+            prefixListId: this.prefixListId,
+            prefixListIds: [this.prefixListId],
+        };
+    }
+}
+/**
+ * A connection to or from a given security group ID
+ *
+ * For ingress rules, a sourceSecurityGroupOwnerId parameter can be specified if
+ * the security group exists in another account.
+ * This parameter will be ignored for egress rules.
+ */
+class SecurityGroupId {
+    // private readonly sourceSecurityGroupOwnerId?: string;
+    constructor(securityGroupId, sourceSecurityGroupOwnerId) {
+        this.securityGroupId = securityGroupId;
+        this.canInlineRule = true;
+        this.connections = new connections_1.Connections({ peer: this });
+        // this.sourceSecurityGroupOwnerId = _sourceSecurityGroupOwnerId;
+        if (!cdktf_1.Token.isUnresolved(securityGroupId)) {
+            const securityGroupMatch = securityGroupId.match(/^sg-[a-z0-9]{8,17}$/);
+            if (!securityGroupMatch) {
+                throw new Error(`Invalid security group ID: "${securityGroupId}"`);
+            }
+        }
+        if (sourceSecurityGroupOwnerId &&
+            !cdktf_1.Token.isUnresolved(sourceSecurityGroupOwnerId)) {
+            const accountNumberMatch = sourceSecurityGroupOwnerId.match(/^[0-9]{12}$/);
+            if (!accountNumberMatch) {
+                throw new Error(`Invalid security group owner ID: "${sourceSecurityGroupOwnerId}"`);
+            }
+        }
+        this.uniqueId = securityGroupId;
+    }
+    /**
+     * Produce the ingress rule JSON for the given connection
+     */
+    toIngressRuleConfig() {
+        return {
+            securityGroups: [this.securityGroupId],
+            // TODO: Terraform provider aws does not support sourceSecurityGroupOwnerId
+            // ...(this.sourceSecurityGroupOwnerId && {
+            //   sourceSecurityGroupOwnerId: this.sourceSecurityGroupOwnerId,
+            // }),
+        };
+    }
+    /**
+     * Produce the egress rule JSON for the given connection
+     */
+    toEgressRuleConfig() {
+        return { securityGroups: [this.securityGroupId] };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"peer.js","sourceRoot":"","sources":["../../../src/aws/compute/peer.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/peer.ts\n\nimport { Token } from \"cdktf\";\nimport { Connections, IConnectable } from \"./connections\";\n\n/**\n * Interface for classes that provide the peer-specification parts of a security group rule\n */\nexport interface IPeer extends IConnectable {\n  /**\n   * Whether the rule can be inlined into a SecurityGroup or not\n   */\n  readonly canInlineRule: boolean;\n\n  /**\n   * A unique identifier for this connection peer\n   */\n  readonly uniqueId: string;\n\n  /**\n   * Produce the ingress rule JSON for the given connection\n   */\n  toIngressRuleConfig(): any;\n\n  /**\n   * Produce the egress rule JSON for the given connection\n   */\n  toEgressRuleConfig(): any;\n}\n\n/**\n * Peer object factories (to be used in Security Group management)\n *\n * The static methods on this object can be used to create peer objects\n * which represent a connection partner in Security Group rules.\n *\n * Use this object if you need to represent connection partners using plain IP\n * addresses, or a prefix list ID.\n *\n * If you want to address a connection partner by Security Group, you can just\n * use the Security Group (or the construct that contains a Security Group)\n * directly, as it already implements `IPeer`.\n */\nexport class Peer {\n  /**\n   * Create an IPv4 peer from a CIDR\n   */\n  public static ipv4(cidrIp: string): IPeer {\n    return new CidrIPv4(cidrIp);\n  }\n\n  /**\n   * Any IPv4 address\n   */\n  public static anyIpv4(): IPeer {\n    return new AnyIPv4();\n  }\n\n  /**\n   * Create an IPv6 peer from a CIDR\n   */\n  public static ipv6(cidrIp: string): IPeer {\n    return new CidrIPv6(cidrIp);\n  }\n\n  /**\n   * Any IPv6 address\n   */\n  public static anyIpv6(): IPeer {\n    return new AnyIPv6();\n  }\n\n  /**\n   * A prefix list\n   */\n  public static prefixList(prefixListId: string): IPeer {\n    return new PrefixList(prefixListId);\n  }\n\n  /**\n   * A security group ID\n   *\n   * NOTE: Terraform provider AWS does not support sourceSecurityGroupOwnerId\n   */\n  public static securityGroupId(\n    securityGroupId: string,\n    sourceSecurityGroupOwnerId?: string,\n  ): IPeer {\n    return new SecurityGroupId(securityGroupId, sourceSecurityGroupOwnerId);\n  }\n\n  protected constructor() {}\n}\n\n/**\n * A connection to and from a given IP range\n */\nclass CidrIPv4 implements IPeer {\n  public readonly canInlineRule = true;\n  public readonly connections: Connections = new Connections({ peer: this });\n  public readonly uniqueId: string;\n\n  constructor(private readonly cidrIp: string) {\n    if (!Token.isUnresolved(cidrIp)) {\n      const cidrMatch = cidrIp.match(/^(\\d{1,3}\\.){3}\\d{1,3}(\\/\\d+)?$/);\n\n      if (!cidrMatch) {\n        throw new Error(`Invalid IPv4 CIDR: \"${cidrIp}\"`);\n      }\n\n      if (!cidrMatch[2]) {\n        throw new Error(\n          `CIDR mask is missing in IPv4: \"${cidrIp}\". Did you mean \"${cidrIp}/32\"?`,\n        );\n      }\n    }\n\n    this.uniqueId = cidrIp;\n  }\n\n  /**\n   * Produce the ingress rule JSON for the given connection\n   */\n  public toIngressRuleConfig(): any {\n    return {\n      cidrIpv4: this.cidrIp,\n      cidrBlocks: [this.cidrIp],\n    };\n  }\n  /**\n   * Produce the egress rule JSON for the given connection\n   */\n  public toEgressRuleConfig(): any {\n    return {\n      cidrIpv4: this.cidrIp,\n      cidrBlocks: [this.cidrIp],\n    };\n  }\n}\n\n/**\n * Any IPv4 address\n */\nclass AnyIPv4 extends CidrIPv4 {\n  constructor() {\n    super(\"0.0.0.0/0\");\n  }\n}\n\n/**\n * A connection to a from a given IPv6 range\n */\nclass CidrIPv6 implements IPeer {\n  public readonly canInlineRule = true;\n  public readonly connections: Connections = new Connections({ peer: this });\n  public readonly uniqueId: string;\n\n  constructor(private readonly cidrIpv6: string) {\n    if (!Token.isUnresolved(cidrIpv6)) {\n      const cidrMatch = cidrIpv6.match(\n        /^([\\da-f]{0,4}:){2,7}([\\da-f]{0,4})?(\\/\\d+)?$/,\n      );\n\n      if (!cidrMatch) {\n        throw new Error(`Invalid IPv6 CIDR: \"${cidrIpv6}\"`);\n      }\n\n      if (!cidrMatch[3]) {\n        throw new Error(\n          `CIDR mask is missing in IPv6: \"${cidrIpv6}\". Did you mean \"${cidrIpv6}/128\"?`,\n        );\n      }\n    }\n\n    this.uniqueId = cidrIpv6;\n  }\n\n  /**\n   * Produce the ingress rule JSON for the given connection\n   */\n  public toIngressRuleConfig(): any {\n    return {\n      cidrIpv6: this.cidrIpv6,\n      ipv6CidrBlocks: [this.cidrIpv6],\n    };\n  }\n  /**\n   * Produce the egress rule JSON for the given connection\n   */\n  public toEgressRuleConfig(): any {\n    return {\n      cidrIpv6: this.cidrIpv6,\n      ipv6CidrBlocks: [this.cidrIpv6],\n    };\n  }\n}\n\n/**\n * Any IPv6 address\n */\nclass AnyIPv6 extends CidrIPv6 {\n  constructor() {\n    super(\"::/0\");\n  }\n}\n\n/**\n * A prefix list\n *\n * Prefix lists are used to allow traffic to VPC-local service endpoints.\n *\n * For more information, see this page:\n *\n * https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/vpc-endpoints.html\n */\nclass PrefixList implements IPeer {\n  public readonly canInlineRule = false;\n  public readonly connections: Connections = new Connections({ peer: this });\n  public readonly uniqueId: string;\n\n  constructor(private readonly prefixListId: string) {\n    this.uniqueId = prefixListId;\n  }\n\n  public toIngressRuleConfig(): any {\n    return {\n      prefixListId: this.prefixListId,\n      prefixListIds: [this.prefixListId],\n    };\n  }\n\n  public toEgressRuleConfig(): any {\n    return {\n      prefixListId: this.prefixListId,\n      prefixListIds: [this.prefixListId],\n    };\n  }\n}\n\n/**\n * A connection to or from a given security group ID\n *\n * For ingress rules, a sourceSecurityGroupOwnerId parameter can be specified if\n * the security group exists in another account.\n * This parameter will be ignored for egress rules.\n */\nclass SecurityGroupId implements IPeer {\n  public readonly canInlineRule = true;\n  public readonly connections: Connections = new Connections({ peer: this });\n  public readonly uniqueId: string;\n\n  // private readonly sourceSecurityGroupOwnerId?: string;\n\n  constructor(\n    private readonly securityGroupId: string,\n    sourceSecurityGroupOwnerId?: string,\n  ) {\n    // this.sourceSecurityGroupOwnerId = _sourceSecurityGroupOwnerId;\n    if (!Token.isUnresolved(securityGroupId)) {\n      const securityGroupMatch = securityGroupId.match(/^sg-[a-z0-9]{8,17}$/);\n\n      if (!securityGroupMatch) {\n        throw new Error(`Invalid security group ID: \"${securityGroupId}\"`);\n      }\n    }\n\n    if (\n      sourceSecurityGroupOwnerId &&\n      !Token.isUnresolved(sourceSecurityGroupOwnerId)\n    ) {\n      const accountNumberMatch =\n        sourceSecurityGroupOwnerId.match(/^[0-9]{12}$/);\n\n      if (!accountNumberMatch) {\n        throw new Error(\n          `Invalid security group owner ID: \"${sourceSecurityGroupOwnerId}\"`,\n        );\n      }\n    }\n    this.uniqueId = securityGroupId;\n  }\n\n  /**\n   * Produce the ingress rule JSON for the given connection\n   */\n  public toIngressRuleConfig(): any {\n    return {\n      securityGroups: [this.securityGroupId],\n      // TODO: Terraform provider aws does not support sourceSecurityGroupOwnerId\n      // ...(this.sourceSecurityGroupOwnerId && {\n      //   sourceSecurityGroupOwnerId: this.sourceSecurityGroupOwnerId,\n      // }),\n    };\n  }\n\n  /**\n   * Produce the egress rule JSON for the given connection\n   */\n  public toEgressRuleConfig(): any {\n    return { securityGroups: [this.securityGroupId] };\n  }\n}\n"]}