anbaric-cloud-hosting 1.16.0 → 1.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-cloud-hosting",
-  "version": "1.16.0",
+  "version": "1.16.1",
   "description": "Anbaric Cloud hosting service: Postgres-backed job persistence and queuing exposed over an HTTP API",
   "license": "MIT",
   "author": "chris@anbaric.ai",
@@ -18,17 +18,17 @@
     "@aws-sdk/client-s3": "^3.1110.0",
     "@aws-sdk/client-secrets-manager": "^3.700.0",
     "@aws-sdk/client-servicediscovery": "^3.1110.0",
-    "anbaric-data-store": "^1.16.0",
-    "anbaric-plugins": "^1.16.0",
-    "anbaric-tsapi": "^1.16.0",
+    "anbaric-data-store": "^1.16.1",
+    "anbaric-plugins": "^1.16.1",
+    "anbaric-tsapi": "^1.16.1",
     "esbuild": "^0.28.2",
     "pg": "^8.16.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@types/pg": "^8.15.0",
-    "anbaric-impl-cloud": "^1.16.0",
-    "anbaric-state-machine": "^1.16.0",
+    "anbaric-impl-cloud": "^1.16.1",
+    "anbaric-state-machine": "^1.16.1",
     "tsx": "^4.20.0",
     "typescript": "^7.0.2"
   },

package/src/app-management/BaseBuildLayer.ts

@@ -31,11 +31,24 @@ abstract class BaseBuildLayer implements BuildLayer {
 
     protected deployments = new Map<string, Deployment>();
     private nextAppIndex = 0;
+    private hydration? : Promise<void>;
 
     constructor(protected appsDir : string, private consumerPortBase : number = 8800,
                 private probe : Probe = adminProbe,
                 private livenessTimeoutMs : number = LIVENESS_TIMEOUT_MS) {}
 
+    /* The deployments map is rebuilt from the durable backend the first time the
+       app registry is read, so apps survive a platform restart. A failed
+       rehydration is not cached, so a later request retries. */
+    ensureHydrated() : Promise<void> {
+        return this.hydration ??= this.rehydrate().catch(error => {
+            this.hydration = undefined;
+            console.warn(`Could not rehydrate the app registry: ${error instanceof Error ? error.message : error}`);
+        });
+    }
+
+    protected async rehydrate() : Promise<void> {}
+
     deploy(appName : string, appPort : number, tarball : Buffer) : DeploymentSummary {
         const existing = this.deployments.get(appName);
 

package/src/app-management/BuildLayer.ts

@@ -9,6 +9,7 @@ type DeploymentSummary = {
 
 interface BuildLayer {
 
+    ensureHydrated() : Promise<void>;
     deploy(appName : string, appPort : number, tarball : Buffer) : DeploymentSummary;
     status(appName : string) : (DeploymentSummary & { log : Array<string> }) | undefined;
     list() : Array<DeploymentSummary>;

package/src/app-management/FargateBuildLayer.ts

@@ -2,6 +2,7 @@ import {readFile, writeFile} from "node:fs/promises";
 import {join} from "node:path";
 import {CodeBuildClient, BatchGetBuildsCommand, StartBuildCommand} from "@aws-sdk/client-codebuild";
 import {ECSClient, CreateServiceCommand, DeleteServiceCommand, DescribeServicesCommand,
+    DescribeTaskDefinitionCommand, ListServicesCommand as ListEcsServicesCommand,
     RegisterTaskDefinitionCommand, UpdateServiceCommand} from "@aws-sdk/client-ecs";
 import {S3Client, PutObjectCommand} from "@aws-sdk/client-s3";
 import {ServiceDiscoveryClient, CreateServiceCommand as CreateDiscoveryServiceCommand,
@@ -255,6 +256,67 @@ class FargateBuildLayer extends BaseBuildLayer {
         }));
     }
 
+    /* ECS is the durable record of what is deployed, so on the first read after
+       a restart the registry is rebuilt from the running anbaric-app-* services
+       and their task definitions (ports come from the container environment the
+       platform set at deploy time). */
+    protected async rehydrate() : Promise<void> {
+        const serviceArns = await this.appServiceArns();
+
+        for (let batch = 0; batch < serviceArns.length; batch += 10) {
+            const {services} = await this.aws.ecs.send(new DescribeServicesCommand({
+                cluster: this.options.cluster,
+                services: serviceArns.slice(batch, batch + 10),
+            }));
+            for (const service of services ?? []) {
+                if (service.status !== "ACTIVE" || !service.serviceName?.startsWith("anbaric-app-")) continue;
+                const appName = service.serviceName.slice("anbaric-app-".length);
+                if (this.deployments.has(appName)) continue;
+                const deployment = await this.deploymentFromService(appName, service);
+                if (deployment) this.deployments.set(appName, deployment);
+            }
+        }
+    }
+
+    private async appServiceArns() : Promise<Array<string>> {
+        const arns : Array<string> = [];
+        let nextToken : string | undefined;
+        do {
+            const page = await this.aws.ecs.send(new ListEcsServicesCommand({ cluster: this.options.cluster, nextToken }));
+            for (const arn of page.serviceArns ?? []) {
+                if (arn.includes("/anbaric-app-")) arns.push(arn);
+            }
+            nextToken = page.nextToken;
+        } while (nextToken);
+        return arns;
+    }
+
+    private async deploymentFromService(appName : string, service : { taskDefinition : string, runningCount? : number }) : Promise<Deployment | undefined> {
+        const {taskDefinition} = await this.aws.ecs.send(new DescribeTaskDefinitionCommand({ taskDefinition: service.taskDefinition }));
+        const container = taskDefinition?.containerDefinitions?.[0];
+        if (!container) return undefined;
+
+        const environment = new Map<string, string>(
+            (container.environment ?? []).map((entry : { name : string, value : string }) => [entry.name, entry.value]),
+        );
+        const port = (name : string, fallback : number) => {
+            const value = Number(environment.get(name));
+            return Number.isInteger(value) ? value : fallback;
+        };
+        const appPort = Number(environment.get("PORT"));
+        if (!Number.isInteger(appPort)) return undefined;
+
+        return {
+            appName,
+            status: (service.runningCount ?? 0) > 0 ? "running" : "stopped",
+            appPort,
+            appHost: this.appHostFor(appName),
+            adminPort: port("ANBARIC_ADMIN_PORT", 8791),
+            consumerPort: port("ANBARIC_CONSUMER_PORT", 0),
+            log: [],
+        };
+    }
+
     private serviceNameFor(appName : string) : string {
         return `anbaric-app-${appName}`;
     }

package/src/hosting/handlers/AppsHandler.ts

@@ -7,6 +7,7 @@ class AppsHandler implements RequestHandler {
     constructor(private buildLayer : BuildLayer) {}
 
     async handle(request : Request) : Promise<void> {
+        await this.buildLayer.ensureHydrated();
         switch (request.subresource) {
             case "deploy":
                 if (request.id) return this.handleDeploy(request, request.id);