anbaric-cloud-hosting 1.16.0 → 1.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-cloud-hosting",
-  "version": "1.16.0",
+  "version": "1.16.2",
   "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.2",
+    "anbaric-plugins": "^1.16.2",
+    "anbaric-tsapi": "^1.16.2",
     "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.2",
+    "anbaric-state-machine": "^1.16.2",
     "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/AppProxyHandler.ts

@@ -1,9 +1,21 @@
+import {IncomingHttpHeaders, OutgoingHttpHeaders, request as httpRequest} from "node:http";
 import {BuildLayer} from "../../app-management/BuildLayer";
 import {Request} from "../Request";
 import {RequestHandler} from "../RequestHandler";
 
-/* The router's fallback: any unregistered top-level path naming a running
-   app is forwarded to it. */
+/* Headers that describe a single hop and must not be forwarded across the
+   proxy in either direction. */
+const HOP_BY_HOP = new Set([
+    "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
+    "te", "trailer", "transfer-encoding", "upgrade",
+]);
+
+/* The router's fallback: any unregistered top-level path naming a running app
+   is reverse-proxied to it. The app is exposed at /<appName>; that prefix is
+   stripped before forwarding (the app sees the sub-path) and surfaced to the
+   app as X-Forwarded-Prefix so it can rebuild public URLs. Request and response
+   headers pass through both ways - notably cookies, Set-Cookie and Location - so
+   sessions and redirects work from app-served HTML. */
 class AppProxyHandler implements RequestHandler {
 
     constructor(private buildLayer : BuildLayer) {}
@@ -16,17 +28,41 @@ class AppProxyHandler implements RequestHandler {
         const appPath = request.url.pathname.slice(`/${appName}`.length) || "/";
         const body = request.method === "GET" || request.method === "HEAD" ? undefined : await request.rawBody();
 
-        const upstream = await fetch(`http://${app.appHost}:${app.appPort}${appPath}${request.url.search}`, {
-            method: request.method,
-            headers: { "content-type": request.header("content-type") ?? "application/json" },
-            body: body && body.length > 0 ? new Uint8Array(body) : undefined,
+        await new Promise<void>((resolve, reject) => {
+            const upstream = httpRequest({
+                host: app.appHost,
+                port: app.appPort,
+                method: request.method,
+                path: `${appPath}${request.url.search}`,
+                headers: this.forwardHeaders(request, appName),
+            }, response => {
+                request.rawResponse.writeHead(response.statusCode ?? 502, this.passThrough(response.headers));
+                response.pipe(request.rawResponse);
+                response.on("end", resolve);
+                response.on("error", reject);
+            });
+            upstream.on("error", reject);
+            if (body && body.length > 0) upstream.write(body);
+            upstream.end();
         });
+    }
 
-        const payload = Buffer.from(await upstream.arrayBuffer());
-        request.rawResponse.writeHead(upstream.status, {
-            "content-type": upstream.headers.get("content-type") ?? "application/octet-stream",
-        });
-        request.rawResponse.end(payload);
+    private forwardHeaders(request : Request, appName : string) : OutgoingHttpHeaders {
+        const headers = this.passThrough(request.raw.headers);
+        delete headers.host;
+        headers["x-forwarded-prefix"] = `/${appName}`;
+        headers["x-forwarded-host"] = request.raw.headers.host;
+        headers["x-forwarded-proto"] = "https";
+        return headers;
+    }
+
+    private passThrough(headers : IncomingHttpHeaders) : OutgoingHttpHeaders {
+        const kept : OutgoingHttpHeaders = {};
+        for (const [name, value] of Object.entries(headers)) {
+            if (value === undefined || HOP_BY_HOP.has(name)) continue;
+            kept[name] = value;
+        }
+        return kept;
     }
 
 }

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);
@@ -26,7 +27,7 @@ class AppsHandler implements RequestHandler {
             case "POST": {
                 const appPort = Number(request.query("port"));
                 if (!Number.isInteger(appPort) || appPort <= 0) {
-                    return request.reply(400, { error: "Expected a numeric port query parameter" });
+                    return request.reply(400, { error: "Expected a numeric ?port query parameter - the app's internal port (\"internalPort\" in .anbaric/app-config.json)" });
                 }
                 const tarball = await request.rawBody();
                 if (tarball.length === 0) return request.reply(400, { error: "Expected a gzipped tarball body" });