terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/alb/application-target-group.js

@@ -0,0 +1,427 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationTargetGroup = 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/alb/application-target-group.ts
+const cdktf_1 = require("cdktf");
+const cloudwatch = require("../../cloudwatch");
+const elasticloadbalancingv2_canned_metrics_generated_1 = require("../elasticloadbalancingv2-canned-metrics.generated");
+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");
+const port_1 = require("../port");
+/**
+ * The metrics for a Application Load Balancer.
+ */
+class ApplicationTargetGroupMetrics {
+    constructor(scope, targetGroupFullName, loadBalancerFullName) {
+        this.scope = scope;
+        this.targetGroupFullName = targetGroupFullName;
+        this.loadBalancerFullName = loadBalancerFullName;
+    }
+    custom(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/ApplicationELB",
+            metricName,
+            dimensionsMap: {
+                TargetGroup: this.targetGroupFullName,
+                LoadBalancer: this.loadBalancerFullName,
+            },
+            ...props,
+        }).attachTo(this.scope);
+    }
+    ipv6RequestCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.iPv6RequestCountSum, props);
+    }
+    requestCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.requestCountSum, props);
+    }
+    healthyHostCount(props) {
+        return this.custom("HealthyHostCount", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    unhealthyHostCount(props) {
+        return this.custom("UnHealthyHostCount", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    httpCodeTarget(code, props) {
+        return this.custom(code, {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    requestCountPerTarget(props) {
+        return this.custom("RequestCountPerTarget", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    targetConnectionErrorCount(props) {
+        return this.custom("TargetConnectionErrorCount", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    targetResponseTime(props) {
+        return this.custom("TargetResponseTime", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    targetTLSNegotiationErrorCount(props) {
+        return this.custom("TargetTLSNegotiationErrorCount", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    cannedMetric(fn, props) {
+        return new cloudwatch.Metric({
+            ...fn({
+                LoadBalancer: this.loadBalancerFullName,
+                TargetGroup: this.targetGroupFullName,
+            }),
+            ...props,
+        }).attachTo(this.scope);
+    }
+}
+/**
+ * Define an Application Target Group
+ */
+class ApplicationTargetGroup extends base_target_group_1.TargetGroupBase {
+    /**
+     * Import an existing target group
+     */
+    static fromTargetGroupAttributes(scope, id, attrs) {
+        return new ImportedApplicationTargetGroup(scope, id, attrs);
+    }
+    /**
+     * Import an existing target group
+     *
+     * @deprecated Use `fromTargetGroupAttributes` instead
+     */
+    static import(scope, id, props) {
+        return ApplicationTargetGroup.fromTargetGroupAttributes(scope, id, props);
+    }
+    constructor(scope, id, props = {}) {
+        const [protocol, port] = (0, util_1.determineProtocolAndPort)(props.protocol, props.port);
+        const { protocolVersion } = props;
+        super(scope, id, { ...props }, {
+            protocol,
+            protocolVersion,
+            port,
+        });
+        this.protocol = protocol;
+        this.port = port;
+        // this.targetType is lazy
+        this.node.addValidation({
+            validate: () => {
+                if (this.targetType === enums_1.TargetType.LAMBDA &&
+                    (this.port || this.protocol)) {
+                    return ["port/protocol should not be specified for Lambda targets"];
+                }
+                else {
+                    return [];
+                }
+            },
+        });
+        this.connectableMembers = [];
+        this.listeners = [];
+        if (props) {
+            const isWeightedRandomAlgorithm = !cdktf_1.Token.isUnresolved(props.loadBalancingAlgorithmType) &&
+                props.loadBalancingAlgorithmType ===
+                    enums_1.TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM;
+            if (props.slowStart !== undefined) {
+                // 0 is allowed and disables slow start
+                if ((props.slowStart.toSeconds() < 30 &&
+                    props.slowStart.toSeconds() !== 0) ||
+                    props.slowStart.toSeconds() > 900) {
+                    throw new Error("Slow start duration value must be between 30 and 900 seconds, or 0 to disable slow start.");
+                }
+                this.setAttribute("slow_start.duration_seconds", props.slowStart.toSeconds().toString());
+                if (isWeightedRandomAlgorithm) {
+                    throw new Error("The weighted random routing algorithm can not be used with slow start mode.");
+                }
+            }
+            if (props.stickinessCookieDuration) {
+                this.enableCookieStickiness(props.stickinessCookieDuration, props.stickinessCookieName);
+            }
+            else {
+                this.setAttribute("stickiness.enabled", "false");
+            }
+            if (props.loadBalancingAlgorithmType) {
+                this.setAttribute("load_balancing.algorithm.type", props.loadBalancingAlgorithmType);
+            }
+            this.addTarget(...(props.targets || []));
+            if (props.enableAnomalyMitigation !== undefined) {
+                if (props.enableAnomalyMitigation && !isWeightedRandomAlgorithm) {
+                    throw new Error("Anomaly mitigation is only available when `loadBalancingAlgorithmType` is `TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`.");
+                }
+                this.setAttribute("load_balancing.algorithm.anomaly_mitigation", props.enableAnomalyMitigation ? "on" : "off");
+            }
+        }
+    }
+    get metrics() {
+        if (!this._metrics) {
+            this._metrics = new ApplicationTargetGroupMetrics(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.attachToApplicationTargetGroup(this);
+            this.addLoadBalancerTarget(result);
+        }
+        if (this.targetType === enums_1.TargetType.LAMBDA) {
+            this.setAttribute("stickiness.enabled", undefined);
+        }
+    }
+    /**
+     * Enable sticky routing via a cookie to members of this target group.
+     *
+     * Note: If the `cookieName` parameter is set, application-based stickiness will be applied,
+     * otherwise it defaults to duration-based stickiness attributes (`lb_cookie`).
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/sticky-sessions.html
+     */
+    enableCookieStickiness(duration, cookieName) {
+        if (duration.toSeconds() < 1 || duration.toSeconds() > 604800) {
+            throw new Error("Stickiness cookie duration value must be between 1 second and 7 days (604800 seconds).");
+        }
+        if (cookieName !== undefined) {
+            if (!cdktf_1.Token.isUnresolved(cookieName) &&
+                (cookieName.startsWith("AWSALB") ||
+                    cookieName.startsWith("AWSALBAPP") ||
+                    cookieName.startsWith("AWSALBTG"))) {
+                throw new Error("App cookie names that start with the following prefixes are not allowed: AWSALB, AWSALBAPP, and AWSALBTG; they're reserved for use by the load balancer.");
+            }
+            if (cookieName === "") {
+                throw new Error("App cookie name cannot be an empty string.");
+            }
+        }
+        this.setAttribute("stickiness.enabled", "true");
+        if (cookieName) {
+            this.setAttribute("stickiness.type", "app_cookie");
+            this.setAttribute("stickiness.app_cookie.cookie_name", cookieName);
+            this.setAttribute("stickiness.app_cookie.duration_seconds", duration.toSeconds().toString());
+        }
+        else {
+            this.setAttribute("stickiness.type", "lb_cookie");
+            this.setAttribute("stickiness.lb_cookie.duration_seconds", duration.toSeconds().toString());
+        }
+    }
+    /**
+     * Register a connectable as a member of this target group.
+     *
+     * Don't call this directly. It will be called by load balancing targets.
+     */
+    registerConnectable(connectable, portRange) {
+        portRange = portRange || port_1.Port.tcp(this.defaultPort);
+        // Notify all listeners that we already know about of this new connectable.
+        // Then remember for new listeners that might get added later.
+        this.connectableMembers.push({ connectable, portRange });
+        for (const listener of this.listeners) {
+            listener.registerConnectable(connectable, portRange);
+        }
+    }
+    /**
+     * Register a listener that is load balancing to this target group.
+     *
+     * Don't call this directly. It will be called by listeners.
+     */
+    registerListener(listener, associatingConstruct) {
+        // Notify this listener of all connectables that we know about.
+        // Then remember for new connectables that might get added later.
+        for (const member of this.connectableMembers) {
+            listener.registerConnectable(member.connectable, member.portRange);
+        }
+        this.listeners.push(listener);
+        this.loadBalancerAttachedDependencies.add(associatingConstruct ?? listener);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Return the given named metric for this Application Load Balancer Target Group
+     *
+     * Returns the metric for this target group from the point of view of the first
+     * load balancer load balancing to it. If you have multiple load balancers load
+     * sending traffic to the same target group, you will have to override the dimensions
+     * on this metric.
+     *
+     * @default Average over 5 minutes
+     */
+    metric(metricName, props) {
+        return this.metrics.custom(metricName, props);
+    }
+    /**
+     * The number of IPv6 requests received by the target group
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.ipv6RequestCount`` instead
+     */
+    metricIpv6RequestCount(props) {
+        return this.metrics.ipv6RequestCount(props);
+    }
+    /**
+     * The number of requests processed over IPv4 and IPv6.
+     *
+     * This count includes only the requests with a response generated by a target of the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.requestCount`` instead
+     */
+    metricRequestCount(props) {
+        return this.metrics.requestCount(props);
+    }
+    /**
+     * The number of healthy hosts in the target group
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.healthyHostCount`` instead
+     */
+    metricHealthyHostCount(props) {
+        return this.metrics.healthyHostCount(props);
+    }
+    /**
+     * The number of unhealthy hosts in the target group
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.unhealthyHostCount`` instead
+     */
+    metricUnhealthyHostCount(props) {
+        return this.metrics.unhealthyHostCount(props);
+    }
+    /**
+     * The number of HTTP 2xx/3xx/4xx/5xx response codes generated by all targets in this target group.
+     *
+     * This does not include any response codes generated by the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.httpCodeTarget`` instead
+     */
+    metricHttpCodeTarget(code, props) {
+        return this.metrics.httpCodeTarget(code, props);
+    }
+    /**
+     * The average number of requests received by each target in a target group.
+     *
+     * The only valid statistic is Sum. Note that this represents the average not the sum.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use `ApplicationTargetGroup.metrics.requestCountPerTarget` instead
+     */
+    metricRequestCountPerTarget(props) {
+        return this.metrics.requestCountPerTarget(props);
+    }
+    /**
+     * The number of connections that were not successfully established between the load balancer and target.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.targetConnectionErrorCount`` instead
+     */
+    metricTargetConnectionErrorCount(props) {
+        return this.metrics.targetConnectionErrorCount(props);
+    }
+    /**
+     * The time elapsed, in seconds, after the request leaves the load balancer until a response from the target is received.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.targetResponseTime`` instead
+     */
+    metricTargetResponseTime(props) {
+        return this.metrics.targetResponseTime(props);
+    }
+    /**
+     * The number of TLS connections initiated by the load balancer that did not establish a session with the target.
+     *
+     * Possible causes include a mismatch of ciphers or protocols.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationTargetGroup.metrics.tlsNegotiationErrorCount`` instead
+     */
+    metricTargetTLSNegotiationErrorCount(props) {
+        return this.metrics.targetTLSNegotiationErrorCount(props);
+    }
+    validateTargetGroup() {
+        const ret = super.validateTargetGroup();
+        if (this.targetType !== undefined &&
+            this.targetType !== enums_1.TargetType.LAMBDA &&
+            (this.protocol === undefined || this.port === undefined)) {
+            ret.push("At least one of 'port' or 'protocol' is required for a non-Lambda TargetGroup");
+        }
+        if (this.healthCheck) {
+            if (this.healthCheck.interval &&
+                this.healthCheck.timeout &&
+                this.healthCheck.interval.toMilliseconds() <=
+                    this.healthCheck.timeout.toMilliseconds()) {
+                ret.push(`Healthcheck interval ${this.healthCheck.interval.toHumanString()} must be greater than the timeout ${this.healthCheck.timeout.toHumanString()}`);
+            }
+            if (this.healthCheck.protocol) {
+                if (!ALB_HEALTH_CHECK_PROTOCOLS.includes(this.healthCheck.protocol)) {
+                    ret.push([
+                        `Health check protocol '${this.healthCheck.protocol}' is not supported. `,
+                        `Must be one of [${ALB_HEALTH_CHECK_PROTOCOLS.join(", ")}]`,
+                    ].join(""));
+                }
+            }
+        }
+        return ret;
+    }
+}
+exports.ApplicationTargetGroup = ApplicationTargetGroup;
+_a = JSII_RTTI_SYMBOL_1;
+ApplicationTargetGroup[_a] = { fqn: "terraconstructs.aws.compute.ApplicationTargetGroup", version: "0.0.12" };
+/**
+ * An imported application target group
+ */
+class ImportedApplicationTargetGroup 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 ApplicationTargetGroupMetrics(this, targetGroupFullName, firstLoadBalancerFullName);
+        }
+    }
+    registerListener(_listener, _associatingConstruct) {
+        // Nothing to do, we know nothing of our members
+        // "@aws-cdk/aws-elbv2:albTargetGroupCannotRegisterListener",
+        cdktf_1.Annotations.of(this).addWarning("Cannot register listener on imported target group -- security groups might need to be updated manually");
+    }
+    registerConnectable(_connectable, _portRange) {
+        // "@aws-cdk/aws-elbv2:albTargetGroupCannotRegisterConnectable",
+        cdktf_1.Annotations.of(this).addWarning("Cannot register connectable on imported target group -- security groups might need to be updated manually");
+    }
+    addTarget(...targets) {
+        for (const target of targets) {
+            const result = target.attachToApplicationTargetGroup(this);
+            if (result.targetJson !== undefined) {
+                throw new Error("Cannot add a non-self registering target to an imported TargetGroup. Create a new TargetGroup instead.");
+            }
+        }
+    }
+    get metrics() {
+        if (!this._metrics) {
+            throw new Error("The imported ApplicationTargetGroup needs the associated ApplicationBalancer to be able to provide metrics. " +
+                "Please specify the ARN value when importing it.");
+        }
+        return this._metrics;
+    }
+}
+const ALB_HEALTH_CHECK_PROTOCOLS = [enums_1.LbProtocol.HTTP, enums_1.LbProtocol.HTTPS];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application-target-group.js","sourceRoot":"","sources":["../../../../src/aws/compute/alb/application-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/alb/application-target-group.ts\n\nimport { Annotations, Token } from \"cdktf\";\nimport { IConstruct, Construct } from \"constructs\";\nimport { IApplicationListener } from \"./application-listener\";\nimport { HttpCodeTarget } from \"./application-load-balancer\";\nimport { Duration } from \"../../../duration\";\nimport * as cloudwatch from \"../../cloudwatch\";\nimport { IConnectable } from \"../connections\";\nimport { ApplicationELBMetrics } from \"../elasticloadbalancingv2-canned-metrics.generated\";\nimport {\n  BaseTargetGroupProps,\n  ITargetGroup,\n  loadBalancerNameFromListenerArn,\n  LoadBalancerTargetProps,\n  TargetGroupAttributes,\n  TargetGroupBase,\n  TargetGroupImportProps,\n} from \"../lb-shared/base-target-group\";\nimport {\n  ApplicationProtocol,\n  ApplicationProtocolVersion,\n  LbProtocol,\n  TargetType,\n  TargetGroupLoadBalancingAlgorithmType,\n} from \"../lb-shared/enums\";\nimport { ImportedTargetGroupBase } from \"../lb-shared/imported\";\nimport {\n  determineProtocolAndPort,\n  parseLoadBalancerFullName,\n  parseTargetGroupFullName,\n  NO_LOADBALANCER_ARNS,\n} from \"../lb-shared/util\";\nimport { Port } from \"../port\";\n\n/**\n * Properties for defining an Application Target Group\n */\nexport interface ApplicationTargetGroupProps extends BaseTargetGroupProps {\n  /**\n   * The protocol used for communication with the target.\n   *\n   * This is not applicable for Lambda targets.\n   *\n   * @default - Determined from port if known\n   */\n  readonly protocol?: ApplicationProtocol;\n\n  /**\n   * The protocol version to use\n   *\n   * @default ApplicationProtocolVersion.HTTP1\n   */\n  readonly protocolVersion?: ApplicationProtocolVersion;\n\n  /**\n   * The port on which the target receives traffic.\n   *\n   * This is not applicable for Lambda targets.\n   *\n   * @default - Determined from protocol if known\n   */\n  readonly port?: number;\n\n  /**\n   * The time period during which the load balancer sends a newly registered\n   * target a linearly increasing share of the traffic to the target group.\n   *\n   * The range is 30-900 seconds (15 minutes).\n   *\n   * @default 0\n   */\n  readonly slowStart?: Duration;\n\n  /**\n   * The stickiness cookie expiration period.\n   *\n   * Setting this value enables load balancer stickiness.\n   *\n   * After this period, the cookie is considered stale. The minimum value is\n   * 1 second and the maximum value is 7 days (604800 seconds).\n   *\n   * @default - Stickiness is disabled\n   */\n  readonly stickinessCookieDuration?: Duration;\n\n  /**\n   * The name of an application-based stickiness cookie.\n   *\n   * Names that start with the following prefixes are not allowed: AWSALB, AWSALBAPP,\n   * and AWSALBTG; they're reserved for use by the load balancer.\n   *\n   * Note: `stickinessCookieName` parameter depends on the presence of `stickinessCookieDuration` parameter.\n   * If `stickinessCookieDuration` is not set, `stickinessCookieName` will be omitted.\n   *\n   * @default - If `stickinessCookieDuration` is set, a load-balancer generated cookie is used. Otherwise, no stickiness is defined.\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/sticky-sessions.html\n   */\n  readonly stickinessCookieName?: string;\n\n  /**\n   * The load balancing algorithm to select targets for routing requests.\n   *\n   * @default TargetGroupLoadBalancingAlgorithmType.ROUND_ROBIN\n   */\n  readonly loadBalancingAlgorithmType?: TargetGroupLoadBalancingAlgorithmType;\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?: IApplicationLoadBalancerTarget[];\n\n  /**\n   * Indicates whether anomaly mitigation is enabled.\n   *\n   * Only available when `loadBalancingAlgorithmType` is `TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`\n   *\n   * @default false\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#automatic-target-weights\n   */\n  readonly enableAnomalyMitigation?: boolean;\n}\n\n/**\n * Contains all metrics for a Target Group of a Application Load Balancer.\n */\nexport interface IApplicationTargetGroupMetrics {\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 IPv6 requests received by the target group\n   *\n   * @default Sum over 5 minutes\n   */\n  ipv6RequestCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of requests processed over IPv4 and IPv6.\n   *\n   * This count includes only the requests with a response generated by a target of the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  requestCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of healthy hosts in the target group\n   *\n   * @default Average over 5 minutes\n   */\n  healthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of unhealthy hosts in the target group\n   *\n   * @default Average over 5 minutes\n   */\n  unhealthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of HTTP 2xx/3xx/4xx/5xx response codes generated by all targets in this target group.\n   *\n   * This does not include any response codes generated by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  httpCodeTarget(\n    code: HttpCodeTarget,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The average number of requests received by each target in a target group.\n   *\n   * The only valid statistic is Sum. Note that this represents the average not the sum.\n   *\n   * @default Sum over 5 minutes\n   */\n  requestCountPerTarget(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of connections that were not successfully established between the load balancer and target.\n   *\n   * @default Sum over 5 minutes\n   */\n  targetConnectionErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The time elapsed, in seconds, after the request leaves the load balancer until a response from the target is received.\n   *\n   * @default Average over 5 minutes\n   */\n  targetResponseTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of TLS connections initiated by the load balancer that did not establish a session with the target.\n   *\n   * Possible causes include a mismatch of ciphers or protocols.\n   *\n   * @default Sum over 5 minutes\n   */\n  targetTLSNegotiationErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n}\n\n/**\n * The metrics for a Application Load Balancer.\n */\nclass ApplicationTargetGroupMetrics implements IApplicationTargetGroupMetrics {\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/ApplicationELB\",\n      metricName,\n      dimensionsMap: {\n        TargetGroup: this.targetGroupFullName,\n        LoadBalancer: this.loadBalancerFullName,\n      },\n      ...props,\n    }).attachTo(this.scope);\n  }\n\n  public ipv6RequestCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.iPv6RequestCountSum, props);\n  }\n\n  public requestCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.requestCountSum, props);\n  }\n\n  public healthyHostCount(props?: cloudwatch.MetricOptions) {\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  public httpCodeTarget(\n    code: HttpCodeTarget,\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.custom(code, {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public requestCountPerTarget(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"RequestCountPerTarget\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public targetConnectionErrorCount(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"TargetConnectionErrorCount\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public targetResponseTime(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"TargetResponseTime\", {\n      statistic: \"Average\",\n      ...props,\n    });\n  }\n\n  public targetTLSNegotiationErrorCount(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"TargetTLSNegotiationErrorCount\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  private cannedMetric(\n    fn: (dims: {\n      LoadBalancer: string;\n      TargetGroup: string;\n    }) => cloudwatch.MetricProps,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...fn({\n        LoadBalancer: this.loadBalancerFullName,\n        TargetGroup: this.targetGroupFullName,\n      }),\n      ...props,\n    }).attachTo(this.scope);\n  }\n}\n\n/**\n * Define an Application Target Group\n */\nexport class ApplicationTargetGroup\n  extends TargetGroupBase\n  implements IApplicationTargetGroup\n{\n  /**\n   * Import an existing target group\n   */\n  public static fromTargetGroupAttributes(\n    scope: Construct,\n    id: string,\n    attrs: TargetGroupAttributes,\n  ): IApplicationTargetGroup {\n    return new ImportedApplicationTargetGroup(scope, id, attrs);\n  }\n\n  /**\n   * Import an existing target group\n   *\n   * @deprecated Use `fromTargetGroupAttributes` instead\n   */\n  public static import(\n    scope: Construct,\n    id: string,\n    props: TargetGroupImportProps,\n  ): IApplicationTargetGroup {\n    return ApplicationTargetGroup.fromTargetGroupAttributes(scope, id, props);\n  }\n\n  private readonly connectableMembers: ConnectableMember[];\n  private readonly listeners: IApplicationListener[];\n  private readonly protocol?: ApplicationProtocol;\n  private readonly port?: number;\n  private _metrics?: IApplicationTargetGroupMetrics;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: ApplicationTargetGroupProps = {},\n  ) {\n    const [protocol, port] = determineProtocolAndPort(\n      props.protocol,\n      props.port,\n    );\n    const { protocolVersion } = props;\n    super(\n      scope,\n      id,\n      { ...props },\n      {\n        protocol,\n        protocolVersion,\n        port,\n      },\n    );\n\n    this.protocol = protocol;\n    this.port = port;\n\n    // this.targetType is lazy\n    this.node.addValidation({\n      validate: () => {\n        if (\n          this.targetType === TargetType.LAMBDA &&\n          (this.port || this.protocol)\n        ) {\n          return [\"port/protocol should not be specified for Lambda targets\"];\n        } else {\n          return [];\n        }\n      },\n    });\n\n    this.connectableMembers = [];\n    this.listeners = [];\n\n    if (props) {\n      const isWeightedRandomAlgorithm =\n        !Token.isUnresolved(props.loadBalancingAlgorithmType) &&\n        props.loadBalancingAlgorithmType ===\n          TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM;\n\n      if (props.slowStart !== undefined) {\n        // 0 is allowed and disables slow start\n        if (\n          (props.slowStart.toSeconds() < 30 &&\n            props.slowStart.toSeconds() !== 0) ||\n          props.slowStart.toSeconds() > 900\n        ) {\n          throw new Error(\n            \"Slow start duration value must be between 30 and 900 seconds, or 0 to disable slow start.\",\n          );\n        }\n        this.setAttribute(\n          \"slow_start.duration_seconds\",\n          props.slowStart.toSeconds().toString(),\n        );\n\n        if (isWeightedRandomAlgorithm) {\n          throw new Error(\n            \"The weighted random routing algorithm can not be used with slow start mode.\",\n          );\n        }\n      }\n\n      if (props.stickinessCookieDuration) {\n        this.enableCookieStickiness(\n          props.stickinessCookieDuration,\n          props.stickinessCookieName,\n        );\n      } else {\n        this.setAttribute(\"stickiness.enabled\", \"false\");\n      }\n\n      if (props.loadBalancingAlgorithmType) {\n        this.setAttribute(\n          \"load_balancing.algorithm.type\",\n          props.loadBalancingAlgorithmType,\n        );\n      }\n      this.addTarget(...(props.targets || []));\n\n      if (props.enableAnomalyMitigation !== undefined) {\n        if (props.enableAnomalyMitigation && !isWeightedRandomAlgorithm) {\n          throw new Error(\n            \"Anomaly mitigation is only available when `loadBalancingAlgorithmType` is `TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`.\",\n          );\n        }\n        this.setAttribute(\n          \"load_balancing.algorithm.anomaly_mitigation\",\n          props.enableAnomalyMitigation ? \"on\" : \"off\",\n        );\n      }\n    }\n  }\n\n  public get metrics(): IApplicationTargetGroupMetrics {\n    if (!this._metrics) {\n      this._metrics = new ApplicationTargetGroupMetrics(\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: IApplicationLoadBalancerTarget[]) {\n    for (const target of targets) {\n      const result = target.attachToApplicationTargetGroup(this);\n      this.addLoadBalancerTarget(result);\n    }\n\n    if (this.targetType === TargetType.LAMBDA) {\n      this.setAttribute(\"stickiness.enabled\", undefined);\n    }\n  }\n\n  /**\n   * Enable sticky routing via a cookie to members of this target group.\n   *\n   * Note: If the `cookieName` parameter is set, application-based stickiness will be applied,\n   * otherwise it defaults to duration-based stickiness attributes (`lb_cookie`).\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/sticky-sessions.html\n   */\n  public enableCookieStickiness(duration: Duration, cookieName?: string) {\n    if (duration.toSeconds() < 1 || duration.toSeconds() > 604800) {\n      throw new Error(\n        \"Stickiness cookie duration value must be between 1 second and 7 days (604800 seconds).\",\n      );\n    }\n    if (cookieName !== undefined) {\n      if (\n        !Token.isUnresolved(cookieName) &&\n        (cookieName.startsWith(\"AWSALB\") ||\n          cookieName.startsWith(\"AWSALBAPP\") ||\n          cookieName.startsWith(\"AWSALBTG\"))\n      ) {\n        throw new Error(\n          \"App cookie names that start with the following prefixes are not allowed: AWSALB, AWSALBAPP, and AWSALBTG; they're reserved for use by the load balancer.\",\n        );\n      }\n      if (cookieName === \"\") {\n        throw new Error(\"App cookie name cannot be an empty string.\");\n      }\n    }\n    this.setAttribute(\"stickiness.enabled\", \"true\");\n    if (cookieName) {\n      this.setAttribute(\"stickiness.type\", \"app_cookie\");\n      this.setAttribute(\"stickiness.app_cookie.cookie_name\", cookieName);\n      this.setAttribute(\n        \"stickiness.app_cookie.duration_seconds\",\n        duration.toSeconds().toString(),\n      );\n    } else {\n      this.setAttribute(\"stickiness.type\", \"lb_cookie\");\n      this.setAttribute(\n        \"stickiness.lb_cookie.duration_seconds\",\n        duration.toSeconds().toString(),\n      );\n    }\n  }\n\n  /**\n   * Register a connectable as a member of this target group.\n   *\n   * Don't call this directly. It will be called by load balancing targets.\n   */\n  public registerConnectable(connectable: IConnectable, portRange?: Port) {\n    portRange = portRange || Port.tcp(this.defaultPort);\n\n    // Notify all listeners that we already know about of this new connectable.\n    // Then remember for new listeners that might get added later.\n    this.connectableMembers.push({ connectable, portRange });\n    for (const listener of this.listeners) {\n      listener.registerConnectable(connectable, portRange);\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(\n    listener: IApplicationListener,\n    associatingConstruct?: IConstruct,\n  ) {\n    // Notify this listener of all connectables that we know about.\n    // Then remember for new connectables that might get added later.\n    for (const member of this.connectableMembers) {\n      listener.registerConnectable(member.connectable, member.portRange);\n    }\n    this.listeners.push(listener);\n    this.loadBalancerAttachedDependencies.add(associatingConstruct ?? listener);\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  /**\n   * Return the given named metric for this Application Load Balancer Target Group\n   *\n   * Returns the metric for this target group from the point of view of the first\n   * load balancer load balancing to it. If you have multiple load balancers load\n   * sending traffic to the same target group, you will have to override the dimensions\n   * on this metric.\n   *\n   * @default Average over 5 minutes\n   */\n  public metric(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.metrics.custom(metricName, props);\n  }\n\n  /**\n   * The number of IPv6 requests received by the target group\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.ipv6RequestCount`` instead\n   */\n  public metricIpv6RequestCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.ipv6RequestCount(props);\n  }\n\n  /**\n   * The number of requests processed over IPv4 and IPv6.\n   *\n   * This count includes only the requests with a response generated by a target of the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.requestCount`` instead\n   */\n  public metricRequestCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.requestCount(props);\n  }\n\n  /**\n   * The number of healthy hosts in the target group\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.healthyHostCount`` instead\n   */\n  public metricHealthyHostCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.healthyHostCount(props);\n  }\n\n  /**\n   * The number of unhealthy hosts in the target group\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.unhealthyHostCount`` instead\n   */\n  public metricUnhealthyHostCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.unhealthyHostCount(props);\n  }\n\n  /**\n   * The number of HTTP 2xx/3xx/4xx/5xx response codes generated by all targets in this target group.\n   *\n   * This does not include any response codes generated by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.httpCodeTarget`` instead\n   */\n  public metricHttpCodeTarget(\n    code: HttpCodeTarget,\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metrics.httpCodeTarget(code, props);\n  }\n\n  /**\n   * The average number of requests received by each target in a target group.\n   *\n   * The only valid statistic is Sum. Note that this represents the average not the sum.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use `ApplicationTargetGroup.metrics.requestCountPerTarget` instead\n   */\n  public metricRequestCountPerTarget(props?: cloudwatch.MetricOptions) {\n    return this.metrics.requestCountPerTarget(props);\n  }\n\n  /**\n   * The number of connections that were not successfully established between the load balancer and target.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.targetConnectionErrorCount`` instead\n   */\n  public metricTargetConnectionErrorCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.targetConnectionErrorCount(props);\n  }\n\n  /**\n   * The time elapsed, in seconds, after the request leaves the load balancer until a response from the target is received.\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.targetResponseTime`` instead\n   */\n  public metricTargetResponseTime(props?: cloudwatch.MetricOptions) {\n    return this.metrics.targetResponseTime(props);\n  }\n\n  /**\n   * The number of TLS connections initiated by the load balancer that did not establish a session with the target.\n   *\n   * Possible causes include a mismatch of ciphers or protocols.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationTargetGroup.metrics.tlsNegotiationErrorCount`` instead\n   */\n  public metricTargetTLSNegotiationErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metrics.targetTLSNegotiationErrorCount(props);\n  }\n\n  protected validateTargetGroup(): string[] {\n    const ret = super.validateTargetGroup();\n\n    if (\n      this.targetType !== undefined &&\n      this.targetType !== TargetType.LAMBDA &&\n      (this.protocol === undefined || this.port === undefined)\n    ) {\n      ret.push(\n        \"At least one of 'port' or 'protocol' is required for a non-Lambda TargetGroup\",\n      );\n    }\n\n    if (this.healthCheck) {\n      if (\n        this.healthCheck.interval &&\n        this.healthCheck.timeout &&\n        this.healthCheck.interval.toMilliseconds() <=\n          this.healthCheck.timeout.toMilliseconds()\n      ) {\n        ret.push(\n          `Healthcheck interval ${this.healthCheck.interval.toHumanString()} must be greater than the timeout ${this.healthCheck.timeout.toHumanString()}`,\n        );\n      }\n\n      if (this.healthCheck.protocol) {\n        if (!ALB_HEALTH_CHECK_PROTOCOLS.includes(this.healthCheck.protocol)) {\n          ret.push(\n            [\n              `Health check protocol '${this.healthCheck.protocol}' is not supported. `,\n              `Must be one of [${ALB_HEALTH_CHECK_PROTOCOLS.join(\", \")}]`,\n            ].join(\"\"),\n          );\n        }\n      }\n    }\n\n    return ret;\n  }\n}\n\n/**\n * A connectable member of a target group\n */\ninterface ConnectableMember {\n  /**\n   * The connectable member\n   */\n  connectable: IConnectable;\n\n  /**\n   * The port (range) the member is listening on\n   */\n  portRange: Port;\n}\n\n/**\n * A Target Group for Application Load Balancers\n */\nexport interface IApplicationTargetGroup extends ITargetGroup {\n  /**\n   * All metrics available for this target group.\n   */\n  readonly metrics: IApplicationTargetGroupMetrics;\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(\n    listener: IApplicationListener,\n    associatingConstruct?: IConstruct,\n  ): void;\n\n  /**\n   * Register a connectable as a member of this target group.\n   *\n   * Don't call this directly. It will be called by load balancing targets.\n   */\n  registerConnectable(connectable: IConnectable, portRange?: Port): void;\n\n  /**\n   * Add a load balancing target to this target group\n   */\n  addTarget(...targets: IApplicationLoadBalancerTarget[]): void;\n}\n\n/**\n * An imported application target group\n */\nclass ImportedApplicationTargetGroup\n  extends ImportedTargetGroupBase\n  implements IApplicationTargetGroup\n{\n  private readonly _metrics?: IApplicationTargetGroupMetrics;\n\n  public constructor(\n    scope: Construct,\n    id: string,\n    props: TargetGroupAttributes,\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 ApplicationTargetGroupMetrics(\n        this,\n        targetGroupFullName,\n        firstLoadBalancerFullName,\n      );\n    }\n  }\n\n  public registerListener(\n    _listener: IApplicationListener,\n    _associatingConstruct?: IConstruct,\n  ) {\n    // Nothing to do, we know nothing of our members\n    // \"@aws-cdk/aws-elbv2:albTargetGroupCannotRegisterListener\",\n    Annotations.of(this).addWarning(\n      \"Cannot register listener on imported target group -- security groups might need to be updated manually\",\n    );\n  }\n\n  public registerConnectable(\n    _connectable: IConnectable,\n    _portRange?: Port | undefined,\n  ): void {\n    // \"@aws-cdk/aws-elbv2:albTargetGroupCannotRegisterConnectable\",\n    Annotations.of(this).addWarning(\n      \"Cannot register connectable on imported target group -- security groups might need to be updated manually\",\n    );\n  }\n\n  public addTarget(...targets: IApplicationLoadBalancerTarget[]) {\n    for (const target of targets) {\n      const result = target.attachToApplicationTargetGroup(this);\n\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  public get metrics(): IApplicationTargetGroupMetrics {\n    if (!this._metrics) {\n      throw new Error(\n        \"The imported ApplicationTargetGroup needs the associated ApplicationBalancer to be able to provide metrics. \" +\n          \"Please specify the ARN value when importing it.\",\n      );\n    }\n    return this._metrics;\n  }\n}\n\n/**\n * Interface for constructs that can be targets of an application load balancer\n */\nexport interface IApplicationLoadBalancerTarget {\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  attachToApplicationTargetGroup(\n    targetGroup: IApplicationTargetGroup,\n  ): LoadBalancerTargetProps;\n}\n\nconst ALB_HEALTH_CHECK_PROTOCOLS = [LbProtocol.HTTP, LbProtocol.HTTPS];\n"]}

package/lib/aws/compute/alb/conditions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * ListenerCondition providers definition.
+ */
+export declare abstract class ListenerCondition {
+    /**
+     * Create a host-header listener rule condition
+     *
+     * @param values Hosts for host headers
+     */
+    static hostHeaders(values: string[]): ListenerCondition;
+    /**
+     * Create a http-header listener rule condition
+     *
+     * @param name HTTP header name
+     * @param values HTTP header values
+     */
+    static httpHeader(name: string, values: string[]): ListenerCondition;
+    /**
+     * Create a http-request-method listener rule condition
+     *
+     * @param values HTTP request methods
+     */
+    static httpRequestMethods(values: string[]): ListenerCondition;
+    /**
+     * Create a path-pattern listener rule condition
+     *
+     * @param values Path patterns
+     */
+    static pathPatterns(values: string[]): ListenerCondition;
+    /**
+     * Create a query-string listener rule condition
+     *
+     * @param values Query string key/value pairs
+     */
+    static queryStrings(values: QueryStringCondition[]): ListenerCondition;
+    /**
+     * Create a source-ip listener rule condition
+     *
+     * @param values Source ips
+     */
+    static sourceIps(values: string[]): ListenerCondition;
+    /**
+     * Render the raw Cfn listener rule condition object.
+     */
+    abstract renderRawCondition(): any;
+}
+/**
+ * Properties for the key/value pair of the query string
+ */
+export interface QueryStringCondition {
+    /**
+     * The query string key for the condition
+     *
+     * @default - Any key can be matched.
+     */
+    readonly key?: string;
+    /**
+     * The query string value for the condition
+     */
+    readonly value: string;
+}