@kensio/yulin 1.12.1 → 1.14.0

package/dist/service/elbv2/serve/sim-elbv2-response-builder.js

@@ -0,0 +1,117 @@
+import { SimElbV2BodyEncoding } from "./sim-elbv2-body-encoding.js";
+import { SimElbV2ErrorResponse } from "./sim-elbv2-error-response.js";
+import { simElbV2NullBodyStatuses } from "./sim-elbv2-null-body-statuses.js";
+/**
+ * The largest response real ELB takes from a Lambda target.
+ *
+ * The limit is on the whole response document rather than on the body alone,
+ * so a base64 body counts at its encoded size and the headers count too.
+ */
+const maximumResponseBytes = 1024 * 1024;
+/**
+ * The response headers a load balancer writes itself rather than passing on.
+ *
+ * ELB does not honour hop-by-hop headers, and it computes the content length
+ * from the body it is about to send, so a handler naming any of these is
+ * naming something the load balancer decides.
+ */
+const loadBalancerOwnedHeaders = new Set([
+    "connection",
+    "content-length",
+    "keep-alive",
+    "transfer-encoding",
+]);
+/**
+ * Turns what a Lambda target returned into the HTTP response the client sees.
+ *
+ * A load balancer takes one shape here, unlike API Gateway, which wraps
+ * anything unrecognised in a 200. A result with no usable status code is not a
+ * response ELB can send, so the client gets the load balancer's own 502 and
+ * never sees the handler's shape.
+ */
+export class SimElbV2ResponseBuilder {
+    bodyEncoding = new SimElbV2BodyEncoding();
+    errorResponse = new SimElbV2ErrorResponse();
+    /**
+     * Build the HTTP response for one handler result.
+     */
+    build(result) {
+        if (!this.isResult(result)) {
+            return this.errorResponse.badGateway();
+        }
+        if (this.isTooLarge(result)) {
+            return this.errorResponse.badGateway();
+        }
+        const statusCode = result.statusCode;
+        const body = this.bodyEncoding.decode(result.body ?? "", result.isBase64Encoded ?? false);
+        return new Response(this.sendableBody(statusCode, body), {
+            status: statusCode,
+            statusText: this.statusText(result, statusCode),
+            headers: this.headers(result),
+        });
+    }
+    /**
+     * Whether the handler returned something a load balancer can send.
+     *
+     * The status code is the whole of the test, as it is on real ELB: anything
+     * else the result carries is optional, and a result without a status code in
+     * the range a response can hold is malformed.
+     */
+    isResult(result) {
+        if (typeof result !== "object" || result === null) {
+            return false;
+        }
+        const statusCode = result.statusCode;
+        return (Number.isSafeInteger(statusCode) &&
+            typeof statusCode === "number" &&
+            statusCode >= 200 &&
+            statusCode <= 599);
+    }
+    /**
+     * Whether the response document is larger than a load balancer takes back.
+     *
+     * The whole document is measured, as real ELB measures it, so a body that is
+     * under the limit once decoded is still refused when its base64 and its
+     * headers put the response over.
+     */
+    isTooLarge(result) {
+        return Buffer.byteLength(JSON.stringify(result)) > maximumResponseBytes;
+    }
+    /**
+     * The body actually sent, which is nothing for a status that cannot hold
+     * one, and for an empty one.
+     */
+    sendableBody(statusCode, body) {
+        if (simElbV2NullBodyStatuses.has(statusCode) || body.length === 0) {
+            return null;
+        }
+        return body;
+    }
+    /**
+     * The reason phrase the response carries.
+     *
+     * Real ELB takes a `statusDescription` such as `200 OK` and puts it in the
+     * status line, where the code is already. The code is therefore taken off
+     * again here, so a client reading the reason phrase finds `OK`, which is what
+     * it would read from a real load balancer.
+     */
+    statusText(result, statusCode) {
+        const description = result.statusDescription ?? "";
+        const prefix = `${String(statusCode)} `;
+        if (description.startsWith(prefix)) {
+            return description.slice(prefix.length);
+        }
+        return description;
+    }
+    headers(result) {
+        const headers = new Headers();
+        const named = Object.entries(result.headers ?? {});
+        for (const [name, value] of named) {
+            if (!loadBalancerOwnedHeaders.has(name.toLowerCase())) {
+                headers.set(name, value);
+            }
+        }
+        return headers;
+    }
+}
+//# sourceMappingURL=sim-elbv2-response-builder.js.map

package/dist/service/elbv2/serve/sim-elbv2-response-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-response-builder.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-response-builder.ts"],"names":[],"mappings":"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"}

package/dist/service/elbv2/serve/sim-elbv2-router.d.ts

@@ -0,0 +1,81 @@
+import type { SimAwsServiceTarget } from "../../../serve/controller/sim-service-controller.js";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimEcsContainerServer } from "../../ecs/service/serve/sim-ecs-container-server.js";
+import type { SimIamInterServiceAuthZ } from "../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimLambdaFunction } from "../../lambda/function/sim-lambda-function.js";
+import type { SimElbV2LoadBalancer } from "../load-balancer/sim-elbv2-load-balancer.js";
+import type { SimElbV2 } from "../sim-elbv2.js";
+import type { SimElbV2TargetGroup } from "../target-group/sim-elbv2-target-group.js";
+interface SimElbV2RouterProperties {
+    /**
+     * The simulation to route within. Required, because a router with a
+     * simulation of its own would find no load balancer anything created.
+     */
+    readonly simAws: SimAws;
+}
+/**
+ * A load balancer a request reached, and the scope it lives in.
+ */
+export interface SimElbV2LoadBalancerRoute {
+    readonly loadBalancer: SimElbV2LoadBalancer;
+    readonly elbV2: SimElbV2;
+}
+/**
+ * A function a target group invokes, and what decides whether it may.
+ */
+export interface SimElbV2FunctionTarget {
+    readonly simFunction: SimLambdaFunction;
+    /**
+     * IAM of the Account owning the function, which is what the load balancer's
+     * invoke permission is evaluated against.
+     */
+    readonly iam: SimIamInterServiceAuthZ;
+}
+/**
+ * Routes a request to the load balancer behind its host name, and a target
+ * group to the function or container behind that.
+ *
+ * A host name names nothing but itself, while simulated ELBv2 state is per
+ * Account and Region, and the registry is the hop between the two. What a
+ * target group holds is not a second hop: real ELB requires a Lambda target to
+ * be in the same Account and Region as its target group, and simulated ECS
+ * refuses a service a target group outside its own, so the target group's own
+ * scope is the only one either is looked for in.
+ */
+export declare class SimElbV2Router {
+    /**
+     * The simulation this router routes within.
+     *
+     * Exposed so collaborators needing the same simulation, such as the clock
+     * stamping invocation events, take it from here rather than being given a
+     * second SimAws that could be a different one.
+     */
+    readonly simAws: SimAws;
+    private readonly registry;
+    constructor(properties: SimElbV2RouterProperties);
+    /**
+     * Find the load balancer a request target addresses.
+     */
+    route(target: SimAwsServiceTarget): SimElbV2LoadBalancerRoute | undefined;
+    /**
+     * Find the function registered in a target group, and the IAM deciding
+     * whether the load balancer may invoke it.
+     *
+     * A target naming another Account or Region finds nothing. Real ELB refuses
+     * to register one at all, so answering as though it were there would be the
+     * looser of the two behaviours.
+     */
+    functionFor(targetGroup: SimElbV2TargetGroup): SimElbV2FunctionTarget | undefined;
+    /**
+     * Find the container of a simulated ECS service that answers for a target
+     * group.
+     *
+     * Which service that is, and which of its containers, is simulated ECS's
+     * question rather than this one's: a service is what registered into the
+     * group, and what is bound to its containers is what decides whether any of
+     * them can answer.
+     */
+    containerFor(targetGroup: SimElbV2TargetGroup): SimEcsContainerServer | undefined;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-router.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-router.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAE/F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AACjG,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qDAAqD,CAAC;AAEnG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAExF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAErF,UAAU,wBAAwB;IAChC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,uBAAuB,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,cAAc;IACzB;;;;;;OAMG;IACH,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAE5C,YAAY,UAAU,EAAE,wBAAwB,EAG/C;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,mBAAmB,GAAG,yBAAyB,GAAG,SAAS,CAqBxE;IAED;;;;;;;OAOG;IACH,WAAW,CACT,WAAW,EAAE,mBAAmB,GAC/B,sBAAsB,GAAG,SAAS,CAiCpC;IAED;;;;;;;;OAQG;IACH,YAAY,CACV,WAAW,EAAE,mBAAmB,GAC/B,qBAAqB,GAAG,SAAS,CAOnC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-router.js

@@ -0,0 +1,92 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { parseSimLambdaFunctionArn } from "../../lambda/function/sim-lambda-function-arn-parts.js";
+/**
+ * Routes a request to the load balancer behind its host name, and a target
+ * group to the function or container behind that.
+ *
+ * A host name names nothing but itself, while simulated ELBv2 state is per
+ * Account and Region, and the registry is the hop between the two. What a
+ * target group holds is not a second hop: real ELB requires a Lambda target to
+ * be in the same Account and Region as its target group, and simulated ECS
+ * refuses a service a target group outside its own, so the target group's own
+ * scope is the only one either is looked for in.
+ */
+export class SimElbV2Router {
+    /**
+     * The simulation this router routes within.
+     *
+     * Exposed so collaborators needing the same simulation, such as the clock
+     * stamping invocation events, take it from here rather than being given a
+     * second SimAws that could be a different one.
+     */
+    simAws;
+    registry;
+    constructor(properties) {
+        this.simAws = properties.simAws;
+        this.registry = this.simAws.serviceFactory.elbV2Registry;
+    }
+    /**
+     * Find the load balancer a request target addresses.
+     */
+    route(target) {
+        const scope = this.registry.scopeForDnsName(target.resourceName);
+        if (scope === undefined) {
+            return undefined;
+        }
+        const elbV2 = this.simAws
+            .accountRegionScope(scope.accountId, scope.regionName)
+            .elbV2();
+        const loadBalancer = elbV2.findLoadBalancerByDnsName(target.resourceName);
+        // A registered DNS name is one that scope's own store holds, because the
+        // store is what registers and deregisters it.
+        assertDefined(loadBalancer, `${scope.accountId} in ${scope.regionName} is registered for the load ` +
+            `balancer DNS name ${target.resourceName} and does not hold it`);
+        return { loadBalancer, elbV2 };
+    }
+    /**
+     * Find the function registered in a target group, and the IAM deciding
+     * whether the load balancer may invoke it.
+     *
+     * A target naming another Account or Region finds nothing. Real ELB refuses
+     * to register one at all, so answering as though it were there would be the
+     * looser of the two behaviours.
+     */
+    functionFor(targetGroup) {
+        const target = targetGroup.registeredTargets[0];
+        // A group with nothing in it never gets here: that is the 503 the load
+        // balancer answers before it looks for a function.
+        assertDefined(target, `Target group ${targetGroup.name} has no registered target`);
+        const parts = parseSimLambdaFunctionArn(target.id);
+        const { accountId, regionName } = targetGroup.accountRegionScope;
+        // A lambda target group refuses anything but a function ARN when the
+        // target is registered, so a registered one is always readable.
+        assertDefined(parts, `Target '${target.id}' in target group ${targetGroup.name} is not a ` +
+            `Lambda function ARN`);
+        if (parts.accountId !== accountId || parts.regionName !== regionName) {
+            return undefined;
+        }
+        const scope = this.simAws.accountRegionScope(accountId, regionName);
+        const simFunction = scope.lambda().getSimFunctionByName(parts.functionName);
+        if (simFunction === undefined) {
+            return undefined;
+        }
+        return { simFunction, iam: scope.iam() };
+    }
+    /**
+     * Find the container of a simulated ECS service that answers for a target
+     * group.
+     *
+     * Which service that is, and which of its containers, is simulated ECS's
+     * question rather than this one's: a service is what registered into the
+     * group, and what is bound to its containers is what decides whether any of
+     * them can answer.
+     */
+    containerFor(targetGroup) {
+        const { accountId, regionName } = targetGroup.accountRegionScope;
+        return this.simAws
+            .accountRegionScope(accountId, regionName)
+            .ecs()
+            .servingContainer(targetGroup.arn);
+    }
+}
+//# sourceMappingURL=sim-elbv2-router.js.map

package/dist/service/elbv2/serve/sim-elbv2-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-router.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-router.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAIpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wDAAwD,CAAC;AAmCnG;;;;;;;;;;GAUG;AACH,MAAM,OAAO,cAAc;IACzB;;;;;;OAMG;IACa,MAAM,CAAS;IAEd,QAAQ,CAAmB;IAE5C,YAAY,UAAoC;QAC9C,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,aAAa,CAAC;IAC3D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAA2B;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAEjE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM;aACtB,kBAAkB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,UAAU,CAAC;aACrD,KAAK,EAAE,CAAC;QACX,MAAM,YAAY,GAAG,KAAK,CAAC,yBAAyB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAE1E,yEAAyE;QACzE,8CAA8C;QAC9C,aAAa,CACX,YAAY,EACZ,GAAG,KAAK,CAAC,SAAS,OAAO,KAAK,CAAC,UAAU,8BAA8B;YACrE,qBAAqB,MAAM,CAAC,YAAY,uBAAuB,CAClE,CAAC;QAEF,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;IACjC,CAAC;IAED;;;;;;;OAOG;IACH,WAAW,CACT,WAAgC;QAEhC,MAAM,MAAM,GAAG,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;QAEhD,uEAAuE;QACvE,mDAAmD;QACnD,aAAa,CACX,MAAM,EACN,gBAAgB,WAAW,CAAC,IAAI,2BAA2B,CAC5D,CAAC;QAEF,MAAM,KAAK,GAAG,yBAAyB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACnD,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,kBAAkB,CAAC;QAEjE,qEAAqE;QACrE,gEAAgE;QAChE,aAAa,CACX,KAAK,EACL,WAAW,MAAM,CAAC,EAAE,qBAAqB,WAAW,CAAC,IAAI,YAAY;YACnE,qBAAqB,CACxB,CAAC;QAEF,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;YACrE,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QACpE,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,oBAAoB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAE5E,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,EAAE,CAAC;IAC3C,CAAC;IAED;;;;;;;;OAQG;IACH,YAAY,CACV,WAAgC;QAEhC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,kBAAkB,CAAC;QAEjE,OAAO,IAAI,CAAC,MAAM;aACf,kBAAkB,CAAC,SAAS,EAAE,UAAU,CAAC;aACzC,GAAG,EAAE;aACL,gBAAgB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACvC,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-rule-evaluation.d.ts

@@ -0,0 +1,37 @@
+import type { SimElbV2Action } from "../action/sim-elbv2-action.js";
+import type { SimElbV2Listener } from "../listener/sim-elbv2-listener.js";
+import type { SimElbV2 } from "../sim-elbv2.js";
+/**
+ * The action answering one request, and what it came from.
+ *
+ * The source is carried so a refusal can name the rule or listener holding the
+ * action rather than only the action itself, which is the part a reader has to
+ * go and change.
+ */
+export declare class SimElbV2MatchedAction {
+    readonly action: SimElbV2Action;
+    readonly source: string;
+    constructor(action: SimElbV2Action, source: string);
+}
+/**
+ * Chooses the action a listener answers a request with.
+ *
+ * Rules are evaluated in priority order, lowest number first, and the first one
+ * whose conditions all hold claims the request. A later rule that would also
+ * have matched never sees it, which is what makes priority the thing worth
+ * getting right. A request no rule claims falls through to the listener's
+ * default action, which is the rule real ELB reports as `default`.
+ */
+export declare class SimElbV2RuleEvaluation {
+    private readonly elbV2;
+    constructor(elbV2: SimElbV2);
+    /**
+     * The action answering one request on one listener.
+     */
+    actionFor(listener: SimElbV2Listener, request: Request): SimElbV2MatchedAction;
+    /**
+     * The one action a listener or rule holds.
+     */
+    private only;
+}
+//# sourceMappingURL=sim-elbv2-rule-evaluation.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-rule-evaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-rule-evaluation.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-rule-evaluation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;GAMG;AACH,qBAAa,qBAAqB;aAEd,MAAM,EAAE,cAAc;aACtB,MAAM,EAAE,MAAM;IAFhC,YACkB,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EAC5B;CACL;AAED;;;;;;;;GAQG;AACH,qBAAa,sBAAsB;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAAlC,YAA6B,KAAK,EAAE,QAAQ,EAAI;IAEhD;;OAEG;IACH,SAAS,CACP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,OAAO,GACf,qBAAqB,CAWvB;IAED;;OAEG;IACH,OAAO,CAAC,IAAI;CAYb"}

package/dist/service/elbv2/serve/sim-elbv2-rule-evaluation.js

@@ -0,0 +1,56 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simElbV2MatchableRequest } from "../listener/rule/match/sim-elbv2-matchable-request.js";
+/**
+ * The action answering one request, and what it came from.
+ *
+ * The source is carried so a refusal can name the rule or listener holding the
+ * action rather than only the action itself, which is the part a reader has to
+ * go and change.
+ */
+export class SimElbV2MatchedAction {
+    action;
+    source;
+    constructor(action, source) {
+        this.action = action;
+        this.source = source;
+    }
+}
+/**
+ * Chooses the action a listener answers a request with.
+ *
+ * Rules are evaluated in priority order, lowest number first, and the first one
+ * whose conditions all hold claims the request. A later rule that would also
+ * have matched never sees it, which is what makes priority the thing worth
+ * getting right. A request no rule claims falls through to the listener's
+ * default action, which is the rule real ELB reports as `default`.
+ */
+export class SimElbV2RuleEvaluation {
+    elbV2;
+    constructor(elbV2) {
+        this.elbV2 = elbV2;
+    }
+    /**
+     * The action answering one request on one listener.
+     */
+    actionFor(listener, request) {
+        const matchable = simElbV2MatchableRequest(request);
+        const rule = this.elbV2
+            .findRulesForListener(listener.arn)
+            .find((candidate) => candidate.matches(matchable));
+        if (rule === undefined) {
+            return this.only(listener.defaultActions, `Listener ${listener.arn}`);
+        }
+        return this.only(rule.actions, `Rule ${rule.arn}`);
+    }
+    /**
+     * The one action a listener or rule holds.
+     */
+    only(actions, source) {
+        const [action] = actions;
+        // A listener and a rule are each created with exactly one action, and
+        // modifying either replaces the list with another one action long.
+        assertDefined(action, `${source} holds no action`);
+        return new SimElbV2MatchedAction(action, source);
+    }
+}
+//# sourceMappingURL=sim-elbv2-rule-evaluation.js.map

package/dist/service/elbv2/serve/sim-elbv2-rule-evaluation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-rule-evaluation.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-rule-evaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AAIjG;;;;;;GAMG;AACH,MAAM,OAAO,qBAAqB;IAEd,MAAM;IACN,MAAM;IAFxB,YACkB,MAAsB,EACtB,MAAc;sBADd,MAAM;sBACN,MAAM;IACrB,CAAC;CACL;AAED;;;;;;;;GAQG;AACH,MAAM,OAAO,sBAAsB;IACJ,KAAK;IAAlC,YAA6B,KAAe;qBAAf,KAAK;IAAa,CAAC;IAEhD;;OAEG;IACH,SAAS,CACP,QAA0B,EAC1B,OAAgB;QAEhB,MAAM,SAAS,GAAG,wBAAwB,CAAC,OAAO,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK;aACpB,oBAAoB,CAAC,QAAQ,CAAC,GAAG,CAAC;aAClC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;QAErD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,YAAY,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;QACxE,CAAC;QAED,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACK,IAAI,CACV,OAAkC,EAClC,MAAc;QAEd,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;QAEzB,sEAAsE;QACtE,mEAAmE;QACnE,aAAa,CAAC,MAAM,EAAE,GAAG,MAAM,kBAAkB,CAAC,CAAC;QAEnD,OAAO,IAAI,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-serving-target-group.factory.d.ts

@@ -0,0 +1,40 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimElbV2TargetGroup } from "../target-group/sim-elbv2-target-group.js";
+import type { SimElbV2Event, SimElbV2Result } from "./sim-elbv2-event.type.js";
+/**
+ * The statement id the invoke permission is granted under.
+ */
+export declare const simElbV2InvokeStatementId = "elb-invoke";
+/**
+ * The function code a target group holds when a test does not care what it
+ * answers, only that something did.
+ */
+export declare function simElbV2CheckoutHandler(): SimElbV2Result;
+/**
+ * What a test asks for when it wants a target group that answers.
+ */
+export interface SimElbV2ServingTargetGroupInput {
+    /**
+     * The name the function takes, and which the target group takes with `-tg`
+     * on the end.
+     */
+    readonly name: string;
+    /** The function code the target group hands its requests to. */
+    readonly handler: (event: SimElbV2Event) => unknown;
+}
+/**
+ * Creates a `lambda` target group holding a function that answers, through the
+ * ordinary commands.
+ *
+ * A target group that serves is four commands rather than one: the function,
+ * the group, the invoke permission and the registration. A test about routing a
+ * request to one of several groups is about none of them, and it needs more
+ * than one group, so building one is done here.
+ *
+ * Everything is created in the default Account and Region of the simulated AWS
+ * it is given, because real ELB requires a Lambda target to be in the same
+ * Account and Region as its target group.
+ */
+export declare const simElbV2ServingTargetGroupFactory: AsyncMappedFactory<SimElbV2ServingTargetGroupInput, SimElbV2TargetGroup, SimAws>;
+//# sourceMappingURL=sim-elbv2-serving-target-group.factory.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-serving-target-group.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-serving-target-group.factory.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-serving-target-group.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG/E;;GAEG;AACH,eAAO,MAAM,yBAAyB,eAAe,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,cAAc,CAExD;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC;CACrD;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iCAAiC,kFA+C7C,CAAC"}

package/dist/service/elbv2/serve/sim-elbv2-serving-target-group.factory.js

@@ -0,0 +1,60 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { makeLambdaZipFileInput } from "../../lambda/function/code/lambda-zip-file-input.js";
+import { createFixtureLambdaTargetGroup } from "../sim-elbv2.fixture.js";
+import { simElbV2ServicePrincipal } from "./sim-elbv2-invoke-authorizer.js";
+/**
+ * The statement id the invoke permission is granted under.
+ */
+export const simElbV2InvokeStatementId = "elb-invoke";
+/**
+ * The function code a target group holds when a test does not care what it
+ * answers, only that something did.
+ */
+export function simElbV2CheckoutHandler() {
+    return { statusCode: 200, body: "checkout" };
+}
+/**
+ * Creates a `lambda` target group holding a function that answers, through the
+ * ordinary commands.
+ *
+ * A target group that serves is four commands rather than one: the function,
+ * the group, the invoke permission and the registration. A test about routing a
+ * request to one of several groups is about none of them, and it needs more
+ * than one group, so building one is done here.
+ *
+ * Everything is created in the default Account and Region of the simulated AWS
+ * it is given, because real ELB requires a Lambda target to be in the same
+ * Account and Region as its target group.
+ */
+export const simElbV2ServingTargetGroupFactory = new AsyncMappedFactory(() => ({ name: "checkout", handler: simElbV2CheckoutHandler }), async (input, simAws) => {
+    const simLambda = simAws.lambda();
+    const { FunctionArn } = await simLambda.createFunction({
+        input: {
+            FunctionName: input.name,
+            Role: `arn:aws:iam::888888888888:role/${input.name}-role`,
+            Code: { ZipFile: makeLambdaZipFileInput(input.handler) },
+        },
+    });
+    const elbV2 = simAws.elbV2();
+    const groupArn = await createFixtureLambdaTargetGroup(elbV2, `${input.name}-tg`);
+    await simLambda.addPermission({
+        input: {
+            FunctionName: input.name,
+            StatementId: simElbV2InvokeStatementId,
+            Action: "lambda:InvokeFunction",
+            Principal: simElbV2ServicePrincipal,
+            SourceArn: groupArn,
+        },
+    });
+    await elbV2.registerTargets({
+        input: { TargetGroupArn: groupArn, Targets: [{ Id: FunctionArn }] },
+    });
+    // A target group CreateTargetGroup reported is one the store holds, so
+    // this is only missing if something is wrong with the simulator itself.
+    const targetGroup = elbV2.findTargetGroupByArn(groupArn);
+    assertDefined(targetGroup, `Simulated ELBv2 created the target group ${groupArn} and then did ` +
+        `not hold it`);
+    return targetGroup;
+});
+//# sourceMappingURL=sim-elbv2-serving-target-group.factory.js.map

package/dist/service/elbv2/serve/sim-elbv2-serving-target-group.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-serving-target-group.factory.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-serving-target-group.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qDAAqD,CAAC;AAC7F,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AAGzE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAE5E;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,YAAY,CAAC;AAEtD;;;GAGG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC/C,CAAC;AAeD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,IAAI,kBAAkB,CAKrE,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC,EAC9D,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;IACtB,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;IAClC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,SAAS,CAAC,cAAc,CAAC;QACrD,KAAK,EAAE;YACL,YAAY,EAAE,KAAK,CAAC,IAAI;YACxB,IAAI,EAAE,kCAAkC,KAAK,CAAC,IAAI,OAAO;YACzD,IAAI,EAAE,EAAE,OAAO,EAAE,sBAAsB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;SACzD;KACF,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;IAC7B,MAAM,QAAQ,GAAG,MAAM,8BAA8B,CACnD,KAAK,EACL,GAAG,KAAK,CAAC,IAAI,KAAK,CACnB,CAAC;IAEF,MAAM,SAAS,CAAC,aAAa,CAAC;QAC5B,KAAK,EAAE;YACL,YAAY,EAAE,KAAK,CAAC,IAAI;YACxB,WAAW,EAAE,yBAAyB;YACtC,MAAM,EAAE,uBAAuB;YAC/B,SAAS,EAAE,wBAAwB;YACnC,SAAS,EAAE,QAAQ;SACpB;KACF,CAAC,CAAC;IAEH,MAAM,KAAK,CAAC,eAAe,CAAC;QAC1B,KAAK,EAAE,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE;KACpE,CAAC,CAAC;IAEH,uEAAuE;IACvE,wEAAwE;IACxE,MAAM,WAAW,GAAG,KAAK,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IACzD,aAAa,CACX,WAAW,EACX,4CAA4C,QAAQ,gBAAgB;QAClE,aAAa,CAChB,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC,CACF,CAAC"}

package/dist/service/elbv2/serve/sim-elbv2-target-invocation.d.ts

@@ -0,0 +1,23 @@
+import type { SimElbV2Listener } from "../listener/sim-elbv2-listener.js";
+import type { SimElbV2TargetGroup } from "../target-group/sim-elbv2-target-group.js";
+/**
+ * One request, and the configuration that sent it to a target group.
+ */
+export interface SimElbV2TargetInvocationInput {
+    readonly listener: SimElbV2Listener;
+    readonly targetGroup: SimElbV2TargetGroup;
+    readonly request: Request;
+}
+/**
+ * What carries a request from a target group to whatever is registered in it.
+ *
+ * There is one of these per kind of target, because the two kinds have nothing
+ * in common past this point: a function is invoked with an event and answers
+ * with a result, and a container is handed the request and answers with the
+ * response. What they do share is which failures the load balancer answers for
+ * itself, and both of them answer those the same way.
+ */
+export interface SimElbV2TargetInvocation {
+    invoke(input: SimElbV2TargetInvocationInput): Promise<Response>;
+}
+//# sourceMappingURL=sim-elbv2-target-invocation.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-target-invocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-target-invocation.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-target-invocation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,KAAK,EAAE,6BAA6B,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACjE"}

package/dist/service/elbv2/serve/sim-elbv2-target-invocation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-elbv2-target-invocation.js.map

package/dist/service/elbv2/serve/sim-elbv2-target-invocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-target-invocation.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-target-invocation.ts"],"names":[],"mappings":""}

package/dist/service/elbv2/serve/sim-elbv2-target-invocations.d.ts

@@ -0,0 +1,27 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimElbV2Router } from "./sim-elbv2-router.js";
+import type { SimElbV2TargetInvocationInput } from "./sim-elbv2-target-invocation.js";
+interface SimElbV2TargetInvocationsProperties {
+    readonly router: SimElbV2Router;
+    readonly clock: SimClock;
+}
+/**
+ * Sends a request to a target group by what the group holds.
+ *
+ * The two simulated target types are reached in entirely different ways, and
+ * the target type is the only thing that decides which: a `lambda` group holds
+ * a function to invoke, and an `ip` group holds the addresses of an ECS
+ * service's tasks, whose bound container answers the request itself. Nothing
+ * else in the serving path branches on it.
+ */
+export declare class SimElbV2TargetInvocations {
+    private readonly lambda;
+    private readonly container;
+    constructor(properties: SimElbV2TargetInvocationsProperties);
+    /**
+     * Send one request to whatever the target group holds.
+     */
+    invoke(input: SimElbV2TargetInvocationInput): Promise<Response>;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-target-invocations.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-target-invocations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-target-invocations.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-target-invocations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAGjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,kCAAkC,CAAC;AAEtF,UAAU,mCAAmC;IAC3C,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAOD;;;;;;;;GAQG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoC;IAE9D,YAAY,UAAU,EAAE,mCAAmC,EAG1D;IAED;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,6BAA6B,GAAG,OAAO,CAAC,QAAQ,CAAC,CAMpE;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-target-invocations.js

@@ -0,0 +1,33 @@
+import { SimElbV2ContainerTargetInvocation } from "./sim-elbv2-container-target-invocation.js";
+import { SimElbV2LambdaTargetInvocation } from "./sim-elbv2-lambda-target-invocation.js";
+/**
+ * The target type whose targets are invoked as functions.
+ */
+const lambdaTargetType = "lambda";
+/**
+ * Sends a request to a target group by what the group holds.
+ *
+ * The two simulated target types are reached in entirely different ways, and
+ * the target type is the only thing that decides which: a `lambda` group holds
+ * a function to invoke, and an `ip` group holds the addresses of an ECS
+ * service's tasks, whose bound container answers the request itself. Nothing
+ * else in the serving path branches on it.
+ */
+export class SimElbV2TargetInvocations {
+    lambda;
+    container;
+    constructor(properties) {
+        this.lambda = new SimElbV2LambdaTargetInvocation(properties);
+        this.container = new SimElbV2ContainerTargetInvocation(properties);
+    }
+    /**
+     * Send one request to whatever the target group holds.
+     */
+    async invoke(input) {
+        if (input.targetGroup.targetType.value === lambdaTargetType) {
+            return await this.lambda.invoke(input);
+        }
+        return await this.container.invoke(input);
+    }
+}
+//# sourceMappingURL=sim-elbv2-target-invocations.js.map

package/dist/service/elbv2/serve/sim-elbv2-target-invocations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-target-invocations.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-target-invocations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AAC/F,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AASzF;;GAEG;AACH,MAAM,gBAAgB,GAAG,QAAQ,CAAC;AAElC;;;;;;;;GAQG;AACH,MAAM,OAAO,yBAAyB;IACnB,MAAM,CAAiC;IACvC,SAAS,CAAoC;IAE9D,YAAY,UAA+C;QACzD,IAAI,CAAC,MAAM,GAAG,IAAI,8BAA8B,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,GAAG,IAAI,iCAAiC,CAAC,UAAU,CAAC,CAAC;IACrE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,KAAoC;QAC/C,IAAI,KAAK,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,KAAK,gBAAgB,EAAE,CAAC;YAC5D,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACzC,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;CACF"}

package/dist/service/elbv2/sim-elbv2-protocol.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read a protocol a request names, refusing one an ALB does not speak.
+ */
+export declare function simElbV2Protocol(field: string, value: string): string;
+/**
+ * Read a port a request names, refusing one outside the range ELB takes.
+ */
+export declare function simElbV2Port(field: string, value: number): number;
+//# sourceMappingURL=sim-elbv2-protocol.d.ts.map

package/dist/service/elbv2/sim-elbv2-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-protocol.d.ts","sourceRoot":"","sources":["../../../src/service/elbv2/sim-elbv2-protocol.ts"],"names":[],"mappings":"AA0BA;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAgBrE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAQjE"}