@kensio/yulin 1.13.0 → 1.14.0

package/dist/service/ecs/service/load-balancer/sim-ecs-service-registration.d.ts

@@ -0,0 +1,38 @@
+import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
+import type { SimEcsServiceLoadBalancer } from "../sim-ecs-service-detail.js";
+/**
+ * One load balancer registration a service was created with, read once.
+ *
+ * A registration is three things together: the target group tasks are
+ * registered into, the container that answers for it, and the port that
+ * container was declared to listen on. Real ECS requires all three, and each
+ * is refused here when it is missing rather than leaving a service that looks
+ * registered and answers nothing.
+ *
+ * The target group has to be in the service's own Account and Region. Real ECS
+ * requires that too, and here it is what makes the registration reachable from
+ * both ends: the tasks are registered into that scope's target group, and a
+ * request routed to that target group finds this service in the same place.
+ */
+export declare class SimEcsServiceRegistration {
+    readonly targetGroupArn: string;
+    readonly containerName: string;
+    readonly containerPort: number;
+    constructor(declared: SimEcsServiceLoadBalancer, accountRegionScope: SimAwsAccountRegionScope);
+    /**
+     * Refuse a registration with a Classic Load Balancer.
+     *
+     * `loadBalancerName` is the Classic Load Balancer form, which routes below
+     * the Application Load Balancer this simulation has, so a service naming one
+     * is refused rather than registered into something else.
+     */
+    private static refuseLoadBalancerName;
+    private static requiredTargetGroupArn;
+    private static requiredContainerName;
+    private static requiredContainerPort;
+    /**
+     * This registration as a described service reports it.
+     */
+    toOutput(): SimEcsServiceLoadBalancer;
+}
+//# sourceMappingURL=sim-ecs-service-registration.d.ts.map

package/dist/service/ecs/service/load-balancer/sim-ecs-service-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-registration.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/load-balancer/sim-ecs-service-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AAE7F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAY9E;;;;;;;;;;;;;GAaG;AACH,qBAAa,yBAAyB;IACpC,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,YACE,QAAQ,EAAE,yBAAyB,EACnC,kBAAkB,EAAE,wBAAwB,EAe7C;IAED;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAYrC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAoCrC,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAgBpC,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA8BpC;;OAEG;IACH,QAAQ,IAAI,yBAAyB,CAMpC;CACF"}

package/dist/service/ecs/service/load-balancer/sim-ecs-service-registration.js

@@ -0,0 +1,104 @@
+import { parseSimArn } from "../../../aws/arn.js";
+import { SimEcsInvalidParameterException } from "../../error/sim-ecs.error.js";
+/**
+ * The service an ARN has to name for a service to register into it.
+ */
+const targetGroupResourceType = "targetgroup";
+/**
+ * The ports a target can be registered on, which are every port there is.
+ */
+const portRange = { lowest: 1, highest: 65_535 };
+/**
+ * One load balancer registration a service was created with, read once.
+ *
+ * A registration is three things together: the target group tasks are
+ * registered into, the container that answers for it, and the port that
+ * container was declared to listen on. Real ECS requires all three, and each
+ * is refused here when it is missing rather than leaving a service that looks
+ * registered and answers nothing.
+ *
+ * The target group has to be in the service's own Account and Region. Real ECS
+ * requires that too, and here it is what makes the registration reachable from
+ * both ends: the tasks are registered into that scope's target group, and a
+ * request routed to that target group finds this service in the same place.
+ */
+export class SimEcsServiceRegistration {
+    targetGroupArn;
+    containerName;
+    containerPort;
+    constructor(declared, accountRegionScope) {
+        SimEcsServiceRegistration.refuseLoadBalancerName(declared);
+        this.targetGroupArn = SimEcsServiceRegistration.requiredTargetGroupArn(declared, accountRegionScope);
+        this.containerName = SimEcsServiceRegistration.requiredContainerName(declared, this.targetGroupArn);
+        this.containerPort = SimEcsServiceRegistration.requiredContainerPort(declared, this.targetGroupArn);
+    }
+    /**
+     * Refuse a registration with a Classic Load Balancer.
+     *
+     * `loadBalancerName` is the Classic Load Balancer form, which routes below
+     * the Application Load Balancer this simulation has, so a service naming one
+     * is refused rather than registered into something else.
+     */
+    static refuseLoadBalancerName(declared) {
+        if (declared.loadBalancerName !== undefined) {
+            throw new SimEcsInvalidParameterException(`A service load balancer naming loadBalancerName ` +
+                `'${declared.loadBalancerName}' registers with a Classic Load ` +
+                `Balancer, which is not simulated. Name a targetGroupArn instead.`);
+        }
+    }
+    static requiredTargetGroupArn(declared, accountRegionScope) {
+        const { targetGroupArn } = declared;
+        if (targetGroupArn === undefined || targetGroupArn === "") {
+            throw new SimEcsInvalidParameterException("A service load balancer needs a targetGroupArn, which is the target " +
+                "group its tasks are registered into.");
+        }
+        const parts = parseSimArn(targetGroupArn);
+        if (parts?.resourceType !== targetGroupResourceType) {
+            throw new SimEcsInvalidParameterException(`'${targetGroupArn}' is not a target group ARN.`);
+        }
+        if (parts.accountId !== accountRegionScope.accountId ||
+            parts.region !== accountRegionScope.regionName) {
+            throw new SimEcsInvalidParameterException(`The target group ${targetGroupArn} is in another Account or Region ` +
+                `than the service, which is ${accountRegionScope.accountId} in ` +
+                `${accountRegionScope.regionName}. A service registers into a ` +
+                `target group of its own Account and Region.`);
+        }
+        return targetGroupArn;
+    }
+    static requiredContainerName(declared, targetGroupArn) {
+        const { containerName } = declared;
+        if (containerName === undefined || containerName === "") {
+            throw new SimEcsInvalidParameterException(`The registration into ${targetGroupArn} needs a containerName, ` +
+                `which is the container of the task that answers for it.`);
+        }
+        return containerName;
+    }
+    static requiredContainerPort(declared, targetGroupArn) {
+        const { containerPort } = declared;
+        if (containerPort === undefined) {
+            throw new SimEcsInvalidParameterException(`The registration into ${targetGroupArn} needs a containerPort, ` +
+                `which is the port its tasks are registered on.`);
+        }
+        if (!Number.isSafeInteger(containerPort) ||
+            containerPort < portRange.lowest ||
+            containerPort > portRange.highest) {
+            throw new SimEcsInvalidParameterException(`The registration into ${targetGroupArn} states a containerPort of ` +
+                `${String(containerPort)}, which is not a port between ` +
+                `${String(portRange.lowest)} and ${String(portRange.highest)}. ` +
+                `A target is registered on the port, so a port nothing could ` +
+                `listen on registers nothing.`);
+        }
+        return containerPort;
+    }
+    /**
+     * This registration as a described service reports it.
+     */
+    toOutput() {
+        return {
+            targetGroupArn: this.targetGroupArn,
+            containerName: this.containerName,
+            containerPort: this.containerPort,
+        };
+    }
+}
+//# sourceMappingURL=sim-ecs-service-registration.js.map

package/dist/service/ecs/service/load-balancer/sim-ecs-service-registration.js.map

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

package/dist/service/ecs/service/load-balancer/sim-ecs-service-targets.d.ts

@@ -0,0 +1,56 @@
+import type { SimEcsTask } from "../../task/sim-ecs-task.js";
+import type { SimEcsService } from "../sim-ecs-service.js";
+import type { SimEcsServiceRegistration } from "./sim-ecs-service-registration.js";
+import type { SimEcsTargetGroups } from "./sim-ecs-target-groups.js";
+interface SimEcsServiceTargetsProperties {
+    readonly targetGroups: SimEcsTargetGroups;
+}
+/**
+ * Registers the tasks of the services in one simulated ECS scope as load
+ * balancer targets.
+ *
+ * A task is a target from the moment the service starts it until the moment it
+ * stops, which is what makes a service scaled to nothing, or deleted, leave a
+ * target group with nothing in it to answer for. Registration is immediate at
+ * both ends: real ECS waits for a health check before a new task takes traffic
+ * and drains connections before an old one goes, and neither of those exists
+ * here.
+ *
+ * The address a task is registered under is held here rather than on the task,
+ * because it is the load balancer's way of naming a task rather than anything
+ * ECS reports about one.
+ */
+export declare class SimEcsServiceTargets {
+    private readonly targetGroups;
+    private readonly addresses;
+    private readonly registered;
+    constructor(properties: SimEcsServiceTargetsProperties);
+    /**
+     * Refuse the registrations a service could not be created with.
+     *
+     * This is what a target group that is not there, or that holds something
+     * other than addresses, is reported by. Real ECS refuses `CreateService` for
+     * both, and refusing here is what stops a service being created registered
+     * with something that could never carry it a request.
+     */
+    requireRegistrable(registrations: readonly SimEcsServiceRegistration[]): void;
+    /**
+     * Register a task the service has started into every target group it named.
+     */
+    register(service: SimEcsService, task: SimEcsTask): void;
+    /**
+     * Take the tasks a service has stopped out of every target group it named.
+     */
+    deregisterAll(service: SimEcsService, tasks: readonly SimEcsTask[]): void;
+    /**
+     * Take one stopped task out of every target group the service named.
+     *
+     * A target group something else has deleted in the meantime is left alone
+     * rather than reported, since the targets went with it and there is nothing
+     * a stopping task could do about it.
+     */
+    private deregister;
+    private requireRegistrableGroup;
+}
+export {};
+//# sourceMappingURL=sim-ecs-service-targets.d.ts.map

package/dist/service/ecs/service/load-balancer/sim-ecs-service-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-targets.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/load-balancer/sim-ecs-service-targets.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAWrE,UAAU,8BAA8B;IACtC,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;CAC3C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IAExD,YAAY,UAAU,EAAE,8BAA8B,EAErD;IAED;;;;;;;OAOG;IACH,kBAAkB,CAChB,aAAa,EAAE,SAAS,yBAAyB,EAAE,GAClD,IAAI,CAIN;IAED;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CAgBvD;IAED;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAIxE;IAED;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,uBAAuB;CAoBhC"}

package/dist/service/ecs/service/load-balancer/sim-ecs-service-targets.js

@@ -0,0 +1,102 @@
+import { SimEcsInvalidParameterException } from "../../error/sim-ecs.error.js";
+import { SimEcsTaskAddresses } from "./sim-ecs-task-addresses.js";
+/**
+ * The target type a service's tasks are registered as.
+ *
+ * Real ECS registers an `awsvpc` task by the address of its network interface,
+ * which is an `ip` target. A target group of any other type is refused when the
+ * service is created, as real ECS refuses one.
+ */
+const registeredTargetType = "ip";
+/**
+ * Registers the tasks of the services in one simulated ECS scope as load
+ * balancer targets.
+ *
+ * A task is a target from the moment the service starts it until the moment it
+ * stops, which is what makes a service scaled to nothing, or deleted, leave a
+ * target group with nothing in it to answer for. Registration is immediate at
+ * both ends: real ECS waits for a health check before a new task takes traffic
+ * and drains connections before an old one goes, and neither of those exists
+ * here.
+ *
+ * The address a task is registered under is held here rather than on the task,
+ * because it is the load balancer's way of naming a task rather than anything
+ * ECS reports about one.
+ */
+export class SimEcsServiceTargets {
+    targetGroups;
+    addresses = new SimEcsTaskAddresses();
+    registered = new Map();
+    constructor(properties) {
+        this.targetGroups = properties.targetGroups;
+    }
+    /**
+     * Refuse the registrations a service could not be created with.
+     *
+     * This is what a target group that is not there, or that holds something
+     * other than addresses, is reported by. Real ECS refuses `CreateService` for
+     * both, and refusing here is what stops a service being created registered
+     * with something that could never carry it a request.
+     */
+    requireRegistrable(registrations) {
+        for (const registration of registrations) {
+            this.requireRegistrableGroup(registration);
+        }
+    }
+    /**
+     * Register a task the service has started into every target group it named.
+     */
+    register(service, task) {
+        const { registrations } = service;
+        if (registrations.length === 0) {
+            return;
+        }
+        const address = this.addresses.take();
+        this.registered.set(task.taskArn, address);
+        for (const registration of registrations) {
+            this.targetGroups
+                .find(registration.targetGroupArn)
+                ?.register({ address, port: registration.containerPort });
+        }
+    }
+    /**
+     * Take the tasks a service has stopped out of every target group it named.
+     */
+    deregisterAll(service, tasks) {
+        for (const task of tasks) {
+            this.deregister(service, task);
+        }
+    }
+    /**
+     * Take one stopped task out of every target group the service named.
+     *
+     * A target group something else has deleted in the meantime is left alone
+     * rather than reported, since the targets went with it and there is nothing
+     * a stopping task could do about it.
+     */
+    deregister(service, task) {
+        const address = this.registered.get(task.taskArn);
+        if (address === undefined) {
+            return;
+        }
+        this.registered.delete(task.taskArn);
+        for (const registration of service.registrations) {
+            this.targetGroups
+                .find(registration.targetGroupArn)
+                ?.deregister({ address, port: registration.containerPort });
+        }
+    }
+    requireRegistrableGroup(registration) {
+        const targetGroup = this.targetGroups.find(registration.targetGroupArn);
+        if (targetGroup === undefined) {
+            throw new SimEcsInvalidParameterException(`${registration.targetGroupArn} names no simulated target group, so ` +
+                `the service has nothing to register its tasks into.`);
+        }
+        if (targetGroup.targetType !== registeredTargetType) {
+            throw new SimEcsInvalidParameterException(`${registration.targetGroupArn} holds ${targetGroup.targetType} ` +
+                `targets. A service registers its tasks by address, so it needs a ` +
+                `target group of the ${registeredTargetType} type.`);
+        }
+    }
+}
+//# sourceMappingURL=sim-ecs-service-targets.js.map

package/dist/service/ecs/service/load-balancer/sim-ecs-service-targets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-targets.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/load-balancer/sim-ecs-service-targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,8BAA8B,CAAC;AAI/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAGlE;;;;;;GAMG;AACH,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAMlC;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,oBAAoB;IACd,YAAY,CAAqB;IACjC,SAAS,GAAG,IAAI,mBAAmB,EAAE,CAAC;IACtC,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;IAExD,YAAY,UAA0C;QACpD,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;IAC9C,CAAC;IAED;;;;;;;OAOG;IACH,kBAAkB,CAChB,aAAmD;QAEnD,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;YACzC,IAAI,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,OAAsB,EAAE,IAAgB;QAC/C,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC;QAElC,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QAEtC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAE3C,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;YACzC,IAAI,CAAC,YAAY;iBACd,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC;gBAClC,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,aAAa,EAAE,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,OAAsB,EAAE,KAA4B;QAChE,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,UAAU,CAAC,OAAsB,EAAE,IAAgB;QACzD,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAElD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAErC,KAAK,MAAM,YAAY,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YACjD,IAAI,CAAC,YAAY;iBACd,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC;gBAClC,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,aAAa,EAAE,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAEO,uBAAuB,CAC7B,YAAuC;QAEvC,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QAExE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,+BAA+B,CACvC,GAAG,YAAY,CAAC,cAAc,uCAAuC;gBACnE,qDAAqD,CACxD,CAAC;QACJ,CAAC;QAED,IAAI,WAAW,CAAC,UAAU,KAAK,oBAAoB,EAAE,CAAC;YACpD,MAAM,IAAI,+BAA+B,CACvC,GAAG,YAAY,CAAC,cAAc,UAAU,WAAW,CAAC,UAAU,GAAG;gBAC/D,mEAAmE;gBACnE,uBAAuB,oBAAoB,QAAQ,CACtD,CAAC;QACJ,CAAC;IACH,CAAC;CACF"}

package/dist/service/ecs/service/load-balancer/sim-ecs-target-groups.d.ts

@@ -0,0 +1,50 @@
+/**
+ * One task of a service as a target group holds it.
+ *
+ * The address stands in for the task's own network interface address, which is
+ * what real ECS registers for an `awsvpc` task, and the port is the one the
+ * service's registration named.
+ */
+export interface SimEcsTaskTarget {
+    readonly address: string;
+    readonly port: number;
+}
+/**
+ * One target group a service registers its tasks into.
+ *
+ * Registering goes straight to the target group rather than through
+ * `RegisterTargets`, because nothing here is making the request: real ECS
+ * registers a task through its service-linked role, which is not something a
+ * test creates or could take away, so there is no caller for simulated IAM to
+ * decide about.
+ */
+export interface SimEcsRegistrableTargetGroup {
+    /** What the target group holds, which has to be addresses. */
+    readonly targetType: string;
+    register(target: SimEcsTaskTarget): void;
+    deregister(target: SimEcsTaskTarget): void;
+}
+/**
+ * Where a simulated ECS service's tasks are registered as load balancer
+ * targets.
+ *
+ * A target group is looked for when a service is created and again as each of
+ * its tasks starts and stops, rather than held from the first of those, because
+ * a target group is a resource of its own that something else may have deleted
+ * in between.
+ */
+export interface SimEcsTargetGroups {
+    find(targetGroupArn: string): SimEcsRegistrableTargetGroup | undefined;
+}
+/**
+ * The target groups a simulated ECS built on its own can reach, which is none.
+ *
+ * Simulated ECS is usually built through a SimAws instance, which hands it that
+ * simulation's ELBv2. One built by itself has none to reach, so a service
+ * declaring a load balancer says so rather than being created with a
+ * registration that could never carry a request.
+ */
+export declare class SimEcsUnreachableTargetGroups implements SimEcsTargetGroups {
+    find(targetGroupArn: string): SimEcsRegistrableTargetGroup | undefined;
+}
+//# sourceMappingURL=sim-ecs-target-groups.d.ts.map

package/dist/service/ecs/service/load-balancer/sim-ecs-target-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-target-groups.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/load-balancer/sim-ecs-target-groups.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,4BAA4B;IAC3C,8DAA8D;IAC9D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEzC,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,4BAA4B,GAAG,SAAS,CAAC;CACxE;AAED;;;;;;;GAOG;AACH,qBAAa,6BAA8B,YAAW,kBAAkB;IACtE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,4BAA4B,GAAG,SAAS,CAMrE;CACF"}

package/dist/service/ecs/service/load-balancer/sim-ecs-target-groups.js

@@ -0,0 +1,17 @@
+import { SimEcsInvalidParameterException } from "../../error/sim-ecs.error.js";
+/**
+ * The target groups a simulated ECS built on its own can reach, which is none.
+ *
+ * Simulated ECS is usually built through a SimAws instance, which hands it that
+ * simulation's ELBv2. One built by itself has none to reach, so a service
+ * declaring a load balancer says so rather than being created with a
+ * registration that could never carry a request.
+ */
+export class SimEcsUnreachableTargetGroups {
+    find(targetGroupArn) {
+        throw new SimEcsInvalidParameterException(`${targetGroupArn} cannot be registered into, because this simulated ` +
+            `ECS reaches no simulated Elastic Load Balancing. Build it through a ` +
+            `SimAws instance to register a service with a target group.`);
+    }
+}
+//# sourceMappingURL=sim-ecs-target-groups.js.map

package/dist/service/ecs/service/load-balancer/sim-ecs-target-groups.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-target-groups.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/load-balancer/sim-ecs-target-groups.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,8BAA8B,CAAC;AA6C/E;;;;;;;GAOG;AACH,MAAM,OAAO,6BAA6B;IACxC,IAAI,CAAC,cAAsB;QACzB,MAAM,IAAI,+BAA+B,CACvC,GAAG,cAAc,qDAAqD;YACpE,sEAAsE;YACtE,4DAA4D,CAC/D,CAAC;IACJ,CAAC;CACF"}

package/dist/service/ecs/service/load-balancer/sim-ecs-task-addresses.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The addresses the tasks of one simulated ECS scope are registered under.
+ *
+ * A real `awsvpc` task gets a private address on its own network interface, and
+ * that address is what its service registers into a target group. There is no
+ * network here to take one from, so they are counted out of the private range
+ * instead, which is what simulated ELBv2 does with its ARN ids and DNS name
+ * suffixes: a counted value is the real shape and a test can predict it, where
+ * a random one can only be read back.
+ *
+ * They count within one Account and Region, because a task addresses nothing
+ * outside its own scope and nothing outside it addresses a task. An address is
+ * never reused, as a real interface address is not handed back the moment a
+ * task stops, and the whole of 10.0.0.0/8 is counted through before one could
+ * be: a simulation would have to start sixteen million tasks in one scope to
+ * reach the end of it.
+ */
+export declare class SimEcsTaskAddresses {
+    #private;
+    /**
+     * The address the next task of this scope is registered under.
+     */
+    take(): string;
+}
+//# sourceMappingURL=sim-ecs-task-addresses.d.ts.map

package/dist/service/ecs/service/load-balancer/sim-ecs-task-addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-task-addresses.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/load-balancer/sim-ecs-task-addresses.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,mBAAmB;;IAG9B;;OAEG;IACH,IAAI,IAAI,MAAM,CAOb;CACF"}

package/dist/service/ecs/service/load-balancer/sim-ecs-task-addresses.js

@@ -0,0 +1,34 @@
+/**
+ * How many addresses one octet holds.
+ */
+const octet = 256;
+/**
+ * The addresses the tasks of one simulated ECS scope are registered under.
+ *
+ * A real `awsvpc` task gets a private address on its own network interface, and
+ * that address is what its service registers into a target group. There is no
+ * network here to take one from, so they are counted out of the private range
+ * instead, which is what simulated ELBv2 does with its ARN ids and DNS name
+ * suffixes: a counted value is the real shape and a test can predict it, where
+ * a random one can only be read back.
+ *
+ * They count within one Account and Region, because a task addresses nothing
+ * outside its own scope and nothing outside it addresses a task. An address is
+ * never reused, as a real interface address is not handed back the moment a
+ * task stops, and the whole of 10.0.0.0/8 is counted through before one could
+ * be: a simulation would have to start sixteen million tasks in one scope to
+ * reach the end of it.
+ */
+export class SimEcsTaskAddresses {
+    #issued = 0;
+    /**
+     * The address the next task of this scope is registered under.
+     */
+    take() {
+        this.#issued += 1;
+        const second = Math.floor(this.#issued / (octet * octet)) % octet;
+        const third = Math.floor(this.#issued / octet) % octet;
+        return `10.${String(second)}.${String(third)}.${String(this.#issued % octet)}`;
+    }
+}
+//# sourceMappingURL=sim-ecs-task-addresses.js.map

package/dist/service/ecs/service/load-balancer/sim-ecs-task-addresses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-task-addresses.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/load-balancer/sim-ecs-task-addresses.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,KAAK,GAAG,GAAG,CAAC;AAElB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,mBAAmB;IAC9B,OAAO,GAAG,CAAC,CAAC;IAEZ;;OAEG;IACH,IAAI;QACF,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;QAElB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;QAClE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC;QAEvD,OAAO,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC;IACjF,CAAC;CACF"}

package/dist/service/ecs/service/run/sim-ecs-service-consumption.d.ts

@@ -0,0 +1,47 @@
+import type { SimEcsBoundContainer } from "../../bind/sim-ecs-bound-container.js";
+import type { SimEcsContainerDefinition } from "../../task-definition/container/sim-ecs-container-definition.js";
+import type { SimEcsResolvedSecrets } from "../../task/run/secret/sim-ecs-resolved-secrets.js";
+import type { SimEcsServiceConsumers } from "../consume/sim-ecs-service-consumers.js";
+import type { SimEcsServiceDeployment } from "./sim-ecs-service-deployment.js";
+/**
+ * One container of a service's task, as it comes up.
+ */
+export interface SimEcsStartingServiceContainer {
+    readonly deployment: SimEcsServiceDeployment;
+    readonly declared: SimEcsContainerDefinition;
+    readonly bound: SimEcsBoundContainer;
+    readonly secrets: SimEcsResolvedSecrets;
+}
+interface SimEcsServiceConsumptionProperties {
+    readonly consumers: SimEcsServiceConsumers;
+    readonly regionName: string;
+}
+/**
+ * Starts the queue polling a service's containers do, as its tasks come up.
+ *
+ * A container bound to consume a queue is the one kind that does something on
+ * its own once a service is running, so it is the one kind that has anything to
+ * start here. Everything else about a service container is a record that it is
+ * up.
+ *
+ * The container's environment is built from what the task's secrets resolved to
+ * a moment ago, so a handler polling a queue reads the same variables one run
+ * by `RunTask` would. There is no override, because nothing overrode anything:
+ * a service starts its own tasks rather than being asked to start one.
+ */
+export declare class SimEcsServiceConsumption {
+    private readonly consumers;
+    private readonly environments;
+    constructor(properties: SimEcsServiceConsumptionProperties);
+    /**
+     * Have this container's queue polled for, if it consumes one.
+     *
+     * Every task of the service reaches this as it starts, and the polling is
+     * kept per service and container rather than per task, so the second task
+     * finds the first task's poller rather than adding another.
+     */
+    begin(starting: SimEcsStartingServiceContainer): void;
+    private environmentFor;
+}
+export {};
+//# sourceMappingURL=sim-ecs-service-consumption.d.ts.map

package/dist/service/ecs/service/run/sim-ecs-service-consumption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-consumption.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-consumption.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iEAAiE,CAAC;AAIjH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC/F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACtF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;CACzC;AAED,UAAU,kCAAkC;IAC1C,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAE3D,YAAY,UAAU,EAAE,kCAAkC,EAMzD;IAED;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,EAAE,8BAA8B,GAAG,IAAI,CAiBpD;IAED,OAAO,CAAC,cAAc;CAUvB"}

package/dist/service/ecs/service/run/sim-ecs-service-consumption.js

@@ -0,0 +1,53 @@
+import { SimEcsContainerEnvironments } from "../../task/run/sim-ecs-container-environments.js";
+import { SimEcsTaskOverrides } from "../../task/run/sim-ecs-task-overrides.js";
+/**
+ * Starts the queue polling a service's containers do, as its tasks come up.
+ *
+ * A container bound to consume a queue is the one kind that does something on
+ * its own once a service is running, so it is the one kind that has anything to
+ * start here. Everything else about a service container is a record that it is
+ * up.
+ *
+ * The container's environment is built from what the task's secrets resolved to
+ * a moment ago, so a handler polling a queue reads the same variables one run
+ * by `RunTask` would. There is no override, because nothing overrode anything:
+ * a service starts its own tasks rather than being asked to start one.
+ */
+export class SimEcsServiceConsumption {
+    consumers;
+    environments;
+    constructor(properties) {
+        this.consumers = properties.consumers;
+        this.environments = new SimEcsContainerEnvironments({
+            regionName: properties.regionName,
+            overrides: new SimEcsTaskOverrides(undefined),
+        });
+    }
+    /**
+     * Have this container's queue polled for, if it consumes one.
+     *
+     * Every task of the service reaches this as it starts, and the polling is
+     * kept per service and container rather than per task, so the second task
+     * finds the first task's poller rather than adding another.
+     */
+    begin(starting) {
+        const { consumes } = starting.bound;
+        if (consumes === undefined) {
+            return;
+        }
+        const { service, taskDefinition } = starting.deployment;
+        this.consumers.ensure({
+            clusterName: service.clusterName,
+            serviceName: service.serviceName,
+            containerName: starting.declared.name,
+            consumes,
+            environment: this.environmentFor(starting),
+            taskRoleArn: taskDefinition.settings.taskRoleArn,
+        });
+    }
+    environmentFor(starting) {
+        const { declared } = starting;
+        return this.environments.for(declared, starting.secrets.forContainer(declared.name));
+    }
+}
+//# sourceMappingURL=sim-ecs-service-consumption.js.map

package/dist/service/ecs/service/run/sim-ecs-service-consumption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-consumption.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-consumption.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAoB/E;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,wBAAwB;IAClB,SAAS,CAAyB;IAClC,YAAY,CAA8B;IAE3D,YAAY,UAA8C;QACxD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,YAAY,GAAG,IAAI,2BAA2B,CAAC;YAClD,UAAU,EAAE,UAAU,CAAC,UAAU;YACjC,SAAS,EAAE,IAAI,mBAAmB,CAAC,SAAS,CAAC;SAC9C,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,QAAwC;QAC5C,MAAM,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC;QAEpC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QAED,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,QAAQ,CAAC,UAAU,CAAC;QAExD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YACpB,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,aAAa,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI;YACrC,QAAQ;YACR,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC;YAC1C,WAAW,EAAE,cAAc,CAAC,QAAQ,CAAC,WAAW;SACjD,CAAC,CAAC;IACL,CAAC;IAEO,cAAc,CACpB,QAAwC;QAExC,MAAM,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;QAE9B,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAC1B,QAAQ,EACR,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,CAC7C,CAAC;IACJ,CAAC;CACF"}

package/dist/service/ecs/service/run/sim-ecs-service-containers.d.ts

@@ -0,0 +1,51 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimAwsRunAsOwner } from "../../../aws/caller/sim-aws-run-as-context.js";
+import type { SimEcsContainerBindings } from "../../bind/sim-ecs-container-bindings.js";
+import type { SimEcsServiceServers } from "../serve/sim-ecs-service-servers.js";
+import type { SimEcsSecretStores } from "../../task/run/secret/sim-ecs-secret-stores.js";
+import type { SimEcsTask } from "../../task/sim-ecs-task.js";
+import type { SimEcsServiceConsumers } from "../consume/sim-ecs-service-consumers.js";
+import type { SimEcsServiceDeployment } from "./sim-ecs-service-deployment.js";
+interface SimEcsServiceContainersProperties {
+    readonly bindings: SimEcsContainerBindings;
+    readonly secretStores: SimEcsSecretStores;
+    readonly consumers: SimEcsServiceConsumers;
+    readonly servers: SimEcsServiceServers;
+    readonly runAsOwner: SimAwsRunAsOwner;
+    readonly regionName: string;
+    readonly background: BackgroundScheduler;
+}
+/**
+ * Brings the containers of one task of a service up.
+ *
+ * No handler is run to completion here, which is the difference between a
+ * service container and one of a task started by `RunTask`. A service container
+ * is treated as running from this point, and what calls its handler is whatever
+ * reaches it: a request served to it, or a poll it makes. A container bound to
+ * consume a queue is the one kind that starts something of its own, which is
+ * the polling Yulin does on its behalf. A container with no binding is recorded
+ * as not simulated instead, exactly as one of a run task is.
+ *
+ * A task's secrets are still resolved before it starts, as a real task agent
+ * pulls them while the task is provisioning. A secret that cannot be read stops
+ * the task here as it stops a run task, so a service naming one that is not
+ * there says so rather than reporting a task running against it.
+ */
+export declare class SimEcsServiceContainers {
+    private readonly bindings;
+    private readonly background;
+    private readonly secrets;
+    private readonly consumption;
+    private readonly serving;
+    constructor(properties: SimEcsServiceContainersProperties);
+    /**
+     * Mark a task, and the containers something is bound to, as running.
+     *
+     * A task asked to stop before this reached it stays stopped, so a service
+     * deleted between the request and the background work brings nothing up.
+     */
+    start(task: SimEcsTask, deployment: SimEcsServiceDeployment): Promise<void>;
+    private markContainers;
+}
+export {};
+//# sourceMappingURL=sim-ecs-service-containers.d.ts.map

package/dist/service/ecs/service/run/sim-ecs-service-containers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-containers.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-containers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACxF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAIhF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAEzF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAEtF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,UAAU,iCAAiC;IACzC,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAC3C,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IACnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2B;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAE/C,YAAY,UAAU,EAAE,iCAAiC,EAMxD;IAED;;;;;OAKG;IACG,KAAK,CACT,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,uBAAuB,GAClC,OAAO,CAAC,IAAI,CAAC,CAcf;IAED,OAAO,CAAC,cAAc;CAmBvB"}