@kensio/yulin 1.12.1 → 1.14.0

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

@@ -0,0 +1,66 @@
+import { SimEcsServiceServing } from "../serve/sim-ecs-service-serving.js";
+import { simEcsNotSimulatedContainerReason } from "../../task/run/sim-ecs-container-reason.js";
+import { SimEcsTaskSecrets } from "../../task/run/secret/sim-ecs-task-secrets.js";
+import { SimEcsServiceConsumption } from "./sim-ecs-service-consumption.js";
+/**
+ * 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 class SimEcsServiceContainers {
+    bindings;
+    background;
+    secrets;
+    consumption;
+    serving;
+    constructor(properties) {
+        this.bindings = properties.bindings;
+        this.background = properties.background;
+        this.secrets = new SimEcsTaskSecrets({ stores: properties.secretStores });
+        this.consumption = new SimEcsServiceConsumption(properties);
+        this.serving = new SimEcsServiceServing(properties);
+    }
+    /**
+     * 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.
+     */
+    async start(task, deployment) {
+        if (task.isStopRequested) {
+            return;
+        }
+        const secrets = await this.secrets.resolve(deployment.taskDefinition);
+        if (!secrets.isResolved) {
+            task.failToStart(this.background.now(), secrets.failureReason);
+            return;
+        }
+        task.start(this.background.now());
+        this.markContainers(task, deployment, secrets);
+    }
+    markContainers(task, deployment, secrets) {
+        for (const declared of deployment.taskDefinition.containers.all()) {
+            const container = task.container(declared.name);
+            const bound = this.bindings.find(task.family, declared);
+            if (bound === undefined) {
+                container.neverStarted(simEcsNotSimulatedContainerReason);
+                continue;
+            }
+            container.start();
+            this.consumption.begin({ deployment, declared, bound, secrets });
+            this.serving.begin({ deployment, declared, bound, secrets });
+        }
+    }
+}
+//# sourceMappingURL=sim-ecs-service-containers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-containers.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-containers.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AAG/F,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAGlF,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAa5E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,uBAAuB;IACjB,QAAQ,CAA0B;IAClC,UAAU,CAAsB;IAChC,OAAO,CAAoB;IAC3B,WAAW,CAA2B;IACtC,OAAO,CAAuB;IAE/C,YAAY,UAA6C;QACvD,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAiB,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,YAAY,EAAE,CAAC,CAAC;QAC1E,IAAI,CAAC,WAAW,GAAG,IAAI,wBAAwB,CAAC,UAAU,CAAC,CAAC;QAC5D,IAAI,CAAC,OAAO,GAAG,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CACT,IAAgB,EAChB,UAAmC;QAEnC,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QAEtE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YACxB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;YAC/D,OAAO;QACT,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;IAEO,cAAc,CACpB,IAAgB,EAChB,UAAmC,EACnC,OAA8B;QAE9B,KAAK,MAAM,QAAQ,IAAI,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC;YAClE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAChD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAExD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,SAAS,CAAC,YAAY,CAAC,iCAAiC,CAAC,CAAC;gBAC1D,SAAS;YACX,CAAC;YAED,SAAS,CAAC,KAAK,EAAE,CAAC;YAClB,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;YACjE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;CACF"}

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

@@ -0,0 +1,16 @@
+import type { SimEcsCluster } from "../../cluster/sim-ecs-cluster.js";
+import type { SimEcsTaskDefinition } from "../../task-definition/sim-ecs-task-definition.js";
+import type { SimEcsService } from "../sim-ecs-service.js";
+/**
+ * What a service is keeping running, and the revision it is running.
+ *
+ * The revision travels with the service rather than being read back from it,
+ * because an update carries the one the service is moving to while the service
+ * is still on the one it had.
+ */
+export interface SimEcsServiceDeployment {
+    readonly service: SimEcsService;
+    readonly cluster: SimEcsCluster;
+    readonly taskDefinition: SimEcsTaskDefinition;
+}
+//# sourceMappingURL=sim-ecs-service-deployment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-deployment.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-deployment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kDAAkD,CAAC;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;CAC/C"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-ecs-service-deployment.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-deployment.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-deployment.ts"],"names":[],"mappings":""}

package/dist/service/ecs/service/run/sim-ecs-service-task-starter.d.ts

@@ -0,0 +1,60 @@
+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 { SimEcsServiceTargets } from "../load-balancer/sim-ecs-service-targets.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 { SimEcsTaskArn } from "../../task/sim-ecs-task-arn.js";
+import type { SimEcsTaskStore } from "../../task/sim-ecs-task-store.js";
+import type { SimEcsServiceConsumers } from "../consume/sim-ecs-service-consumers.js";
+import type { SimEcsServiceDeployment } from "./sim-ecs-service-deployment.js";
+/**
+ * What starting and stopping a service's tasks is done with.
+ *
+ * It is exported because `SimEcsServiceTasks` is built with exactly this: it
+ * holds the starter, and everything it does itself is done with the same
+ * collaborators.
+ */
+export interface SimEcsServiceTaskStarterProperties {
+    readonly tasks: SimEcsTaskStore;
+    readonly taskArn: SimEcsTaskArn;
+    readonly bindings: SimEcsContainerBindings;
+    readonly secretStores: SimEcsSecretStores;
+    readonly consumers: SimEcsServiceConsumers;
+    readonly servers: SimEcsServiceServers;
+    readonly targets: SimEcsServiceTargets;
+    readonly runAsOwner: SimAwsRunAsOwner;
+    readonly regionName: string;
+    readonly background: BackgroundScheduler;
+}
+/**
+ * Starts the tasks a simulated ECS service keeps running.
+ *
+ * A task exists as soon as the request that asked for it is answered, so it is
+ * listed straight away, and reaches `RUNNING` on the simulator's background
+ * work. That is what real ECS does with a service that has just been created or
+ * scaled out, and it is what makes a service deleted in between bring nothing
+ * up.
+ *
+ * A service's tasks carry the group and the `startedBy` real ECS gives one, so
+ * a listing can be narrowed to the service that is keeping them.
+ *
+ * A task is registered as a load balancer target as it is started rather than
+ * once it is running, because there is no health check here for a target to
+ * pass: real ECS registers a task as soon as it has an address, and waits for
+ * the target to be healthy before sending it anything.
+ */
+export declare class SimEcsServiceTaskStarter {
+    private readonly tasks;
+    private readonly background;
+    private readonly taskFactory;
+    private readonly containers;
+    private readonly targets;
+    constructor(properties: SimEcsServiceTaskStarterProperties);
+    /**
+     * Start a number of tasks for a service, and hand them to it.
+     */
+    start(deployment: SimEcsServiceDeployment, count: number): void;
+    private startOne;
+}
+//# sourceMappingURL=sim-ecs-service-task-starter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-task-starter.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-task-starter.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,6CAA6C,CAAC;AACxF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAEtF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E;;;;;;GAMG;AACH,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,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,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;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0B;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAE/C,YAAY,UAAU,EAAE,kCAAkC,EAMzD;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,EAAE,uBAAuB,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI9D;IAED,OAAO,CAAC,QAAQ;CAmBjB"}

package/dist/service/ecs/service/run/sim-ecs-service-task-starter.js

@@ -0,0 +1,60 @@
+import { SimEcsTaskFactory } from "../../task/sim-ecs-task-factory.js";
+import { SimEcsServiceContainers } from "./sim-ecs-service-containers.js";
+/**
+ * Starts the tasks a simulated ECS service keeps running.
+ *
+ * A task exists as soon as the request that asked for it is answered, so it is
+ * listed straight away, and reaches `RUNNING` on the simulator's background
+ * work. That is what real ECS does with a service that has just been created or
+ * scaled out, and it is what makes a service deleted in between bring nothing
+ * up.
+ *
+ * A service's tasks carry the group and the `startedBy` real ECS gives one, so
+ * a listing can be narrowed to the service that is keeping them.
+ *
+ * A task is registered as a load balancer target as it is started rather than
+ * once it is running, because there is no health check here for a target to
+ * pass: real ECS registers a task as soon as it has an address, and waits for
+ * the target to be healthy before sending it anything.
+ */
+export class SimEcsServiceTaskStarter {
+    tasks;
+    background;
+    taskFactory;
+    containers;
+    targets;
+    constructor(properties) {
+        this.tasks = properties.tasks;
+        this.background = properties.background;
+        this.targets = properties.targets;
+        this.taskFactory = new SimEcsTaskFactory(properties.taskArn);
+        this.containers = new SimEcsServiceContainers(properties);
+    }
+    /**
+     * Start a number of tasks for a service, and hand them to it.
+     */
+    start(deployment, count) {
+        for (let started = 0; started < count; started += 1) {
+            this.startOne(deployment);
+        }
+    }
+    startOne(deployment) {
+        const { service, cluster, taskDefinition } = deployment;
+        const task = this.taskFactory.make({
+            cluster,
+            taskDefinition,
+            createdAt: this.background.now(),
+            group: `service:${service.serviceName}`,
+            startedBy: `ecs-svc/${service.serviceName}`,
+            serviceName: service.serviceName,
+            launchType: service.launchType,
+        });
+        this.tasks.put(task);
+        service.tasks.add(task);
+        this.targets.register(service, task);
+        this.background.schedule(async () => {
+            await this.containers.start(task, deployment);
+        });
+    }
+}
+//# sourceMappingURL=sim-ecs-service-task-starter.js.map

package/dist/service/ecs/service/run/sim-ecs-service-task-starter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-task-starter.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-task-starter.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAGvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAuB1E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,wBAAwB;IAClB,KAAK,CAAkB;IACvB,UAAU,CAAsB;IAChC,WAAW,CAAoB;IAC/B,UAAU,CAA0B;IACpC,OAAO,CAAuB;IAE/C,YAAY,UAA8C;QACxD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,WAAW,GAAG,IAAI,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC7D,IAAI,CAAC,UAAU,GAAG,IAAI,uBAAuB,CAAC,UAAU,CAAC,CAAC;IAC5D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAmC,EAAE,KAAa;QACtD,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,KAAK,EAAE,OAAO,IAAI,CAAC,EAAE,CAAC;YACpD,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAEO,QAAQ,CAAC,UAAmC;QAClD,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;QACxD,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACjC,OAAO;YACP,cAAc;YACd,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE;YAChC,KAAK,EAAE,WAAW,OAAO,CAAC,WAAW,EAAE;YACvC,SAAS,EAAE,WAAW,OAAO,CAAC,WAAW,EAAE;YAC3C,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,UAAU,EAAE,OAAO,CAAC,UAAU;SAC/B,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE;YAClC,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

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

@@ -0,0 +1,63 @@
+import type { SimEcsService } from "../sim-ecs-service.js";
+import type { SimEcsServiceDeployment } from "./sim-ecs-service-deployment.js";
+import { type SimEcsServiceTaskStarterProperties } from "./sim-ecs-service-task-starter.js";
+/**
+ * What keeping a service's tasks running takes, which is what starting one
+ * takes: everything here beyond the starter is done with the same things.
+ */
+type SimEcsServiceTasksProperties = SimEcsServiceTaskStarterProperties;
+/**
+ * Keeps a simulated ECS service's tasks at the count it wants.
+ *
+ * This is where the modelling decision that runs through simulated services
+ * lives. A desired count of three cannot mean three copies of one in-process
+ * handler, because Yulin runs in a single Node.js process and there are no
+ * containers to copy, so the count is kept as state: three tasks exist, are
+ * reported as running, and hold a record of every container their definition
+ * declares. The handler bound to a container is called once per request or per
+ * poll rather than once per task.
+ *
+ * Starting a task takes until the simulator's background work reaches it, as it
+ * does on real ECS. Stopping one is immediate, because there is nothing here to
+ * drain.
+ */
+export declare class SimEcsServiceTasks {
+    private readonly background;
+    private readonly starter;
+    private readonly consumers;
+    private readonly servers;
+    private readonly targets;
+    constructor(properties: SimEcsServiceTasksProperties);
+    /**
+     * Bring a service's tasks to the count it wants, starting or stopping them.
+     *
+     * A service scaled to nothing stops consuming and serving as well, since
+     * there is no container left to be doing either. Scaling back out starts them
+     * again, because the task that comes up brings its containers up as any first
+     * task does.
+     */
+    reconcile(deployment: SimEcsServiceDeployment): void;
+    /**
+     * Replace every task with one started from the revision the service is on.
+     *
+     * Real ECS replaces them a few at a time under a deployment configuration,
+     * bringing new ones up before old ones go down. Nothing is served here yet
+     * and nothing takes any time to start, so the replacement happens at once.
+     */
+    redeploy(deployment: SimEcsServiceDeployment): void;
+    /**
+     * Stop every task a service is running, and give up holding them.
+     *
+     * The queue polling its containers were doing stops with them, the containers
+     * that were answering requests stop answering, and the tasks leave the target
+     * groups they were registered into. A redeploy comes back through here and
+     * then starts again from the revision the service moved to, so a container
+     * that stopped consuming or serving, or started, in the new revision is
+     * treated accordingly.
+     */
+    stopAll(service: SimEcsService, reason: string): void;
+    private stopContainers;
+    private stopEach;
+}
+export {};
+//# sourceMappingURL=sim-ecs-service-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-tasks.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-tasks.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,mCAAmC,CAAC;AAE3C;;;GAGG;AACH,KAAK,4BAA4B,GAAG,kCAAkC,CAAC;AAUvE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAE/C,YAAY,UAAU,EAAE,4BAA4B,EAMnD;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,UAAU,EAAE,uBAAuB,GAAG,IAAI,CAkBnD;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,uBAAuB,GAAG,IAAI,CAGlD;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAGpD;IAED,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,QAAQ;CAcjB"}

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

@@ -0,0 +1,95 @@
+import { SimEcsServiceTaskStarter, } from "./sim-ecs-service-task-starter.js";
+/**
+ * Why a task of a service stopped, in each of the ways one does.
+ */
+const stoppedReasons = {
+    scaledIn: "Task stopped by the service scaling in.",
+    redeployed: "Task stopped by the service moving to another task definition.",
+};
+/**
+ * Keeps a simulated ECS service's tasks at the count it wants.
+ *
+ * This is where the modelling decision that runs through simulated services
+ * lives. A desired count of three cannot mean three copies of one in-process
+ * handler, because Yulin runs in a single Node.js process and there are no
+ * containers to copy, so the count is kept as state: three tasks exist, are
+ * reported as running, and hold a record of every container their definition
+ * declares. The handler bound to a container is called once per request or per
+ * poll rather than once per task.
+ *
+ * Starting a task takes until the simulator's background work reaches it, as it
+ * does on real ECS. Stopping one is immediate, because there is nothing here to
+ * drain.
+ */
+export class SimEcsServiceTasks {
+    background;
+    starter;
+    consumers;
+    servers;
+    targets;
+    constructor(properties) {
+        this.background = properties.background;
+        this.starter = new SimEcsServiceTaskStarter(properties);
+        this.consumers = properties.consumers;
+        this.servers = properties.servers;
+        this.targets = properties.targets;
+    }
+    /**
+     * Bring a service's tasks to the count it wants, starting or stopping them.
+     *
+     * A service scaled to nothing stops consuming and serving as well, since
+     * there is no container left to be doing either. Scaling back out starts them
+     * again, because the task that comes up brings its containers up as any first
+     * task does.
+     */
+    reconcile(deployment) {
+        const { service } = deployment;
+        const shortfall = service.desiredCount - service.tasks.count;
+        if (shortfall > 0) {
+            this.starter.start(deployment, shortfall);
+            return;
+        }
+        this.stopEach(service, service.tasks.takeNewest(-shortfall), stoppedReasons.scaledIn);
+        if (service.tasks.count === 0) {
+            this.stopContainers(service);
+        }
+    }
+    /**
+     * Replace every task with one started from the revision the service is on.
+     *
+     * Real ECS replaces them a few at a time under a deployment configuration,
+     * bringing new ones up before old ones go down. Nothing is served here yet
+     * and nothing takes any time to start, so the replacement happens at once.
+     */
+    redeploy(deployment) {
+        this.stopAll(deployment.service, stoppedReasons.redeployed);
+        this.reconcile(deployment);
+    }
+    /**
+     * Stop every task a service is running, and give up holding them.
+     *
+     * The queue polling its containers were doing stops with them, the containers
+     * that were answering requests stop answering, and the tasks leave the target
+     * groups they were registered into. A redeploy comes back through here and
+     * then starts again from the revision the service moved to, so a container
+     * that stopped consuming or serving, or started, in the new revision is
+     * treated accordingly.
+     */
+    stopAll(service, reason) {
+        this.stopContainers(service);
+        this.stopEach(service, service.tasks.takeAll(), reason);
+    }
+    stopContainers(service) {
+        this.consumers.stop(service);
+        this.servers.stop(service);
+    }
+    stopEach(service, tasks, reason) {
+        const at = this.background.now();
+        for (const task of tasks) {
+            task.requestStop(reason);
+            task.stop({ at, stopCode: "UserInitiated", reason });
+        }
+        this.targets.deregisterAll(service, tasks);
+    }
+}
+//# sourceMappingURL=sim-ecs-service-tasks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-tasks.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/run/sim-ecs-service-tasks.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,wBAAwB,GAEzB,MAAM,mCAAmC,CAAC;AAQ3C;;GAEG;AACH,MAAM,cAAc,GAAG;IACrB,QAAQ,EAAE,yCAAyC;IACnD,UAAU,EAAE,gEAAgE;CACpE,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,kBAAkB;IACZ,UAAU,CAAsB;IAChC,OAAO,CAA2B;IAClC,SAAS,CAAyB;IAClC,OAAO,CAAuB;IAC9B,OAAO,CAAuB;IAE/C,YAAY,UAAwC;QAClD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,OAAO,GAAG,IAAI,wBAAwB,CAAC,UAAU,CAAC,CAAC;QACxD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;IACpC,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,UAAmC;QAC3C,MAAM,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;QAC/B,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;QAE7D,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YAClB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,QAAQ,CACX,OAAO,EACP,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,EACpC,cAAc,CAAC,QAAQ,CACxB,CAAC;QAEF,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,UAAmC;QAC1C,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;QAC5D,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAsB,EAAE,MAAc;QAC5C,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC7B,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC;IAC1D,CAAC;IAEO,cAAc,CAAC,OAAsB;QAC3C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAEO,QAAQ,CACd,OAAsB,EACtB,KAA4B,EAC5B,MAAc;QAEd,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;QAEjC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;CACF"}

package/dist/service/ecs/service/serve/sim-ecs-container-server.d.ts

@@ -0,0 +1,50 @@
+import type { SimAwsRunAsOwner } from "../../../aws/caller/sim-aws-run-as-context.js";
+import type { SimEcsContainerHttpHandler } from "../../bind/sim-ecs-container-binding.type.js";
+import type { SimEcsContainerDefinition } from "../../task-definition/container/sim-ecs-container-definition.js";
+import type { SimEcsContainerEnvironment } from "../../task/run/sim-ecs-container-environment.js";
+interface SimEcsContainerServerProperties {
+    readonly declared: SimEcsContainerDefinition;
+    readonly handler: SimEcsContainerHttpHandler;
+    readonly environment: SimEcsContainerEnvironment;
+    readonly taskRoleArn: string | undefined;
+    readonly runAsOwner: SimAwsRunAsOwner;
+}
+/**
+ * One container of a running service, answering the requests routed to it.
+ *
+ * The handler is called once per request rather than once per task, which
+ * follows the decision a service's desired count already rests on: the count is
+ * state rather than concurrency, so there are no copies of the container to
+ * share requests between.
+ *
+ * A request is answered as the task Role, with the container's environment
+ * applied, exactly as a container consuming a queue handles a batch and as a
+ * container of a run task runs its handler. That is what makes a service
+ * container's AWS calls authorized the way the deployed one's would be, rather
+ * than as whoever sent the request.
+ */
+export declare class SimEcsContainerServer {
+    readonly containerName: string;
+    private readonly declared;
+    private readonly handler;
+    private readonly environment;
+    private readonly taskRoleArn;
+    private readonly runAsOwner;
+    constructor(properties: SimEcsContainerServerProperties);
+    /**
+     * Whether this container declared it listens on a port.
+     *
+     * That is what tells two bound containers of the same task apart when a load
+     * balancer registration names a port rather than one of them.
+     */
+    listensOn(port: number): boolean;
+    /**
+     * Answer one request with this container's handler.
+     *
+     * Whatever the handler throws is left to the load balancer, which is what
+     * turns it into the status a real one sends when a target fails.
+     */
+    handle(request: Request): Promise<Response>;
+}
+export {};
+//# sourceMappingURL=sim-ecs-container-server.d.ts.map

package/dist/service/ecs/service/serve/sim-ecs-container-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-container-server.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/serve/sim-ecs-container-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AAEtF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAC/F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iEAAiE,CAAC;AACjH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAC;AAGlG,UAAU,+BAA+B;IACvC,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAC;IAC7C,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAAC;IACjD,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;CACvC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;IAChC,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAE9C,YAAY,UAAU,EAAE,+BAA+B,EAOtD;IAED;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/B;IAED;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAOhD;CACF"}

package/dist/service/ecs/service/serve/sim-ecs-container-server.js

@@ -0,0 +1,51 @@
+import { simAwsRunAsContext } from "../../../aws/caller/sim-aws-run-as-context.js";
+import { simEcsTaskPrincipal } from "../../task/run/sim-ecs-task-principal.js";
+/**
+ * One container of a running service, answering the requests routed to it.
+ *
+ * The handler is called once per request rather than once per task, which
+ * follows the decision a service's desired count already rests on: the count is
+ * state rather than concurrency, so there are no copies of the container to
+ * share requests between.
+ *
+ * A request is answered as the task Role, with the container's environment
+ * applied, exactly as a container consuming a queue handles a batch and as a
+ * container of a run task runs its handler. That is what makes a service
+ * container's AWS calls authorized the way the deployed one's would be, rather
+ * than as whoever sent the request.
+ */
+export class SimEcsContainerServer {
+    containerName;
+    declared;
+    handler;
+    environment;
+    taskRoleArn;
+    runAsOwner;
+    constructor(properties) {
+        this.declared = properties.declared;
+        this.containerName = properties.declared.name;
+        this.handler = properties.handler;
+        this.environment = properties.environment;
+        this.taskRoleArn = properties.taskRoleArn;
+        this.runAsOwner = properties.runAsOwner;
+    }
+    /**
+     * Whether this container declared it listens on a port.
+     *
+     * That is what tells two bound containers of the same task apart when a load
+     * balancer registration names a port rather than one of them.
+     */
+    listensOn(port) {
+        return this.declared.containerPorts.includes(port);
+    }
+    /**
+     * Answer one request with this container's handler.
+     *
+     * Whatever the handler throws is left to the load balancer, which is what
+     * turns it into the status a real one sends when a target fails.
+     */
+    async handle(request) {
+        return await simAwsRunAsContext.run(this.runAsOwner, simEcsTaskPrincipal(this.taskRoleArn), async () => await this.environment.runWith(async () => await this.handler(request)));
+    }
+}
+//# sourceMappingURL=sim-ecs-container-server.js.map

package/dist/service/ecs/service/serve/sim-ecs-container-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-container-server.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/serve/sim-ecs-container-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,+CAA+C,CAAC;AAInF,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAU/E;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,qBAAqB;IAChB,aAAa,CAAS;IAErB,QAAQ,CAA4B;IACpC,OAAO,CAA6B;IACpC,WAAW,CAA6B;IACxC,WAAW,CAAqB;IAChC,UAAU,CAAmB;IAE9C,YAAY,UAA2C;QACrD,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;QAC9C,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;QAC1C,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,IAAY;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,OAAgB;QAC3B,OAAO,MAAM,kBAAkB,CAAC,GAAG,CACjC,IAAI,CAAC,UAAU,EACf,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,EACrC,KAAK,IAAI,EAAE,CACT,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAC1E,CAAC;IACJ,CAAC;CACF"}

package/dist/service/ecs/service/serve/sim-ecs-service-servers.d.ts

@@ -0,0 +1,50 @@
+import type { SimEcsContainerServer } from "./sim-ecs-container-server.js";
+/**
+ * What a service names the containers of it that answer requests.
+ */
+export interface SimEcsServedService {
+    readonly clusterName: string;
+    readonly serviceName: string;
+}
+/**
+ * The containers of the running services in one simulated ECS scope that
+ * answer requests.
+ *
+ * One server per service and container, rather than one per task, for the same
+ * reason a consuming container is polled for once per service: a desired count
+ * of three is three simulated tasks reported as running rather than three
+ * copies of one in-process handler. Every task of the service reaches this as
+ * it comes up, and the second one finds the first one's server.
+ *
+ * They are held here rather than on the service because a service is state a
+ * request can read and a server is the running thing behind it. That is what
+ * gives deleting a service somewhere to take its containers away, and it is
+ * what makes a target group with a service registered and nothing serving it
+ * answer for itself.
+ */
+export declare class SimEcsServiceServers {
+    private readonly servers;
+    private static keyFor;
+    /**
+     * Take on a container of a service that has come up, unless the service is
+     * already serving from a container of that name.
+     */
+    ensure(service: SimEcsServedService, server: SimEcsContainerServer): void;
+    /**
+     * The containers of a service that answer requests, in declaration order.
+     *
+     * A service with none is one nothing can be routed to, which is what a
+     * target group holding it has to be able to tell.
+     */
+    of(service: SimEcsServedService): readonly SimEcsContainerServer[];
+    /**
+     * Give up the containers a service was serving from, as deleting it does.
+     *
+     * A redeploy comes back through here and then takes on the containers of the
+     * revision the service moved to, so a container that stopped serving, or
+     * started, in the new revision is answered for accordingly.
+     */
+    stop(service: SimEcsServedService): void;
+    private containersOf;
+}
+//# sourceMappingURL=sim-ecs-service-servers.d.ts.map

package/dist/service/ecs/service/serve/sim-ecs-service-servers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-servers.d.ts","sourceRoot":"","sources":["../../../../../src/service/ecs/service/serve/sim-ecs-service-servers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAGpB;IAEJ,OAAO,CAAC,MAAM,CAAC,MAAM;IAIrB;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAQxE;IAED;;;;;OAKG;IACH,EAAE,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,qBAAqB,EAAE,CAOjE;IAED;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAEvC;IAED,OAAO,CAAC,YAAY;CAerB"}

package/dist/service/ecs/service/serve/sim-ecs-service-servers.js

@@ -0,0 +1,66 @@
+/**
+ * The containers of the running services in one simulated ECS scope that
+ * answer requests.
+ *
+ * One server per service and container, rather than one per task, for the same
+ * reason a consuming container is polled for once per service: a desired count
+ * of three is three simulated tasks reported as running rather than three
+ * copies of one in-process handler. Every task of the service reaches this as
+ * it comes up, and the second one finds the first one's server.
+ *
+ * They are held here rather than on the service because a service is state a
+ * request can read and a server is the running thing behind it. That is what
+ * gives deleting a service somewhere to take its containers away, and it is
+ * what makes a target group with a service registered and nothing serving it
+ * answer for itself.
+ */
+export class SimEcsServiceServers {
+    servers = new Map();
+    static keyFor(service) {
+        return `${service.clusterName}/${service.serviceName}`;
+    }
+    /**
+     * Take on a container of a service that has come up, unless the service is
+     * already serving from a container of that name.
+     */
+    ensure(service, server) {
+        const containers = this.containersOf(service);
+        if (containers.has(server.containerName)) {
+            return;
+        }
+        containers.set(server.containerName, server);
+    }
+    /**
+     * The containers of a service that answer requests, in declaration order.
+     *
+     * A service with none is one nothing can be routed to, which is what a
+     * target group holding it has to be able to tell.
+     */
+    of(service) {
+        return (this.servers
+            .get(SimEcsServiceServers.keyFor(service))
+            ?.values()
+            .toArray() ?? []);
+    }
+    /**
+     * Give up the containers a service was serving from, as deleting it does.
+     *
+     * A redeploy comes back through here and then takes on the containers of the
+     * revision the service moved to, so a container that stopped serving, or
+     * started, in the new revision is answered for accordingly.
+     */
+    stop(service) {
+        this.servers.delete(SimEcsServiceServers.keyFor(service));
+    }
+    containersOf(service) {
+        const key = SimEcsServiceServers.keyFor(service);
+        const held = this.servers.get(key);
+        if (held !== undefined) {
+            return held;
+        }
+        const containers = new Map();
+        this.servers.set(key, containers);
+        return containers;
+    }
+}
+//# sourceMappingURL=sim-ecs-service-servers.js.map

package/dist/service/ecs/service/serve/sim-ecs-service-servers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-service-servers.js","sourceRoot":"","sources":["../../../../../src/service/ecs/service/serve/sim-ecs-service-servers.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,oBAAoB;IACd,OAAO,GAAG,IAAI,GAAG,EAG/B,CAAC;IAEI,MAAM,CAAC,MAAM,CAAC,OAA4B;QAChD,OAAO,GAAG,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IACzD,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,OAA4B,EAAE,MAA6B;QAChE,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAE9C,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC;YACzC,OAAO;QACT,CAAC;QAED,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACH,EAAE,CAAC,OAA4B;QAC7B,OAAO,CACL,IAAI,CAAC,OAAO;aACT,GAAG,CAAC,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC1C,EAAE,MAAM,EAAE;aACT,OAAO,EAAE,IAAI,EAAE,CACnB,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,OAA4B;QAC/B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5D,CAAC;IAEO,YAAY,CAClB,OAA4B;QAE5B,MAAM,GAAG,GAAG,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACjD,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEnC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,GAAG,EAAiC,CAAC;QAC5D,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAElC,OAAO,UAAU,CAAC;IACpB,CAAC;CACF"}