anbaric-cloud-hosting 1.5.0 → 1.7.0

package/src/hosting/Router.ts

@@ -1,423 +1,38 @@
-import {readFile} from "node:fs/promises";
-import {IncomingMessage, ServerResponse} from "node:http";
-import {AuditChange, JobPersistence, JsonStore, SecretStore, deserializeJob, serializeJob} from "anbaric-tsapi";
-import {BuildLayer} from "../app-management/BuildLayer";
-import {AuditRecordStore} from "../auditing/AuditRecordStore";
-import {CliAuthorizer} from "../auth/CliAuthorizer";
-import {Tenant} from "../auth/Tenant";
-import {User} from "../auth/User";
-import {ConfirmableQueue} from "../queuing/ConfirmableQueue";
-import {ConsumerRegistry} from "../queuing/ConsumerRegistry";
+import {Request} from "./Request";
+import {RequestHandler} from "./RequestHandler";
 
-const AUDIT_CHANGES = new Set(["CREATE", "UPDATE_PROPERTIES", "CHANGE_STATE", "DELETE"]);
-
-const readRawBody = (request : IncomingMessage) : Promise<Buffer> =>
-    new Promise((resolve, reject) => {
-        const chunks : Array<Buffer> = [];
-        request.on("data", chunk => chunks.push(chunk));
-        request.on("error", reject);
-        request.on("end", () => resolve(Buffer.concat(chunks)));
-    });
-
-const readBody = async (request : IncomingMessage) : Promise<any> => {
-    const raw = (await readRawBody(request)).toString();
-    return raw.length === 0 ? undefined : JSON.parse(raw);
-};
-
-/* Routing is a tree: route() dispatches on the resource family (or the few
-   specific resources that fit no family), each family handler switches on
-   the specific resource shape, and the method switch sits underneath.
-   Unmatched requests fall through to the app proxy, then 404. */
+/* Deliberately hollow: other systems register a handler per top-level
+   resource, one for the root, and one fallback for anything unregistered
+   (the app proxy). All business logic lives in the handlers. */
 class Router {
 
-    constructor(private persistence : JobPersistence, private queue : ConfirmableQueue,
-                private registry : ConsumerRegistry,
-                private buildLayer? : BuildLayer,
-                private documentStoreFor? : (collection : string) => JsonStore,
-                private secretStore? : SecretStore,
-                private cliAuthorizer? : CliAuthorizer,
-                private tenant? : string,
-                private auditRecords? : AuditRecordStore) {}
-
-    async route(request : IncomingMessage, response : ServerResponse, user? : User, sessionTenant? : Tenant) : Promise<void> {
-        const url = new URL(request.url ?? "/", "http://localhost");
-        const [resource, id, subresource] = url.pathname.split("/").filter(Boolean);
-        const method = request.method ?? "GET";
-
-        switch (resource) {
-            case undefined:
-                if (method === "GET") return this.servePage(response);
-                break;
-            case "audit":
-                if (method === "GET" && !id) return this.servePage(response);
-                break;
-            case "manage-keys":
-                if (method === "GET" && !id && this.cliAuthorizer) return this.servePage(response);
-                break;
-            case "whoami":
-                if (method === "GET" && !id && user) {
-                    return this.reply(response, 200, { id: user.id, roles: user.roles.map(role => role.id) });
-                }
-                break;
-            case "state-machines":
-                if (method === "GET" && !id) return this.reply(response, 200, this.registry.list());
-                break;
-            case "authorize-cli":
-                if (this.cliAuthorizer && id) {
-                    return this.handleAuthorizeCli(method, id, subresource, request, response, user, sessionTenant);
-                }
-                break;
-            case "keys":
-                if (this.cliAuthorizer) return this.handleKeys(method, id, response, user);
-                break;
-            case "audits":
-                if (this.auditRecords && !id) return this.handleAudits(method, url, request, response);
-                break;
-            case "jobs":
-                return this.handleJobs(method, id, subresource, url, request, response);
-            case "queue":
-                if (id && !subresource) return this.handleQueue(method, id, request, response);
-                break;
-            case "consumers":
-                if (!id) return this.handleConsumers(method, request, response);
-                break;
-            case "apps":
-                if (this.buildLayer) return this.handleApps(method, id, subresource, url, request, response);
-                break;
-            case "documents":
-                if (id && this.documentStoreFor) {
-                    return this.handleDocuments(method, this.documentStoreFor(id), subresource, url, request, response);
-                }
-                break;
-            case "secrets":
-                if (!subresource && this.secretStore) return this.handleSecrets(method, id, request, response);
-                break;
-        }
-
-        if (resource && this.buildLayer) {
-            const app = this.buildLayer.status(resource);
-            if (app && app.status === "running") {
-                return this.forwardToApp(app.appHost, app.appPort, resource, method, url, request, response);
-            }
-        }
-
-        this.notFound(response);
-    }
-
-    private async handleAuthorizeCli(method : string, requestId : string, subresource : string | undefined,
-                                     request : IncomingMessage, response : ServerResponse, user? : User,
-                                     sessionTenant? : Tenant) : Promise<void> {
-        switch (subresource) {
-            case "poll":
-                switch (method) {
-                    case "GET": {
-                        const keyPair = this.cliAuthorizer!.collect(requestId);
-                        if (!keyPair) return this.reply(response, 202, { status: "pending" });
-                        return this.reply(response, 200, keyPair);
-                    }
-                }
-                break;
-            case undefined:
-                switch (method) {
-                    case "GET":
-                        return this.servePage(response);
-                    case "POST": {
-                        const { clientName } = await readBody(request);
-                        if (typeof clientName !== "string" || clientName.trim().length === 0) {
-                            return this.reply(response, 400, { error: "Expected a body of { clientName : string }" });
-                        }
-                        await this.cliAuthorizer!.approve(requestId, clientName.trim(), user ?? new User("local"),
-                            sessionTenant?.id ?? this.tenant);
-                        return this.reply(response, 204);
-                    }
-                }
-                break;
-        }
-
-        this.notFound(response);
-    }
-
-    private async handleKeys(method : string, id : string | undefined,
-                             response : ServerResponse, user? : User) : Promise<void> {
-        const owner = user ?? new User("local");
-
-        if (id) {
-            switch (method) {
-                case "DELETE":
-                    await this.cliAuthorizer!.revoke(id, owner.id);
-                    return this.reply(response, 204);
-            }
-        } else {
-            switch (method) {
-                case "GET": {
-                    const keys = await this.cliAuthorizer!.keysFor(owner.id);
-                    return this.reply(response, 200, keys.map(key => ({
-                        id: key.id,
-                        clientName: key.clientName,
-                        createdAt: key.createdAt.toISOString(),
-                    })));
-                }
-            }
-        }
-
-        this.notFound(response);
-    }
-
-    private async handleAudits(method : string, url : URL,
-                               request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        switch (method) {
-            case "POST": {
-                const record = await readBody(request);
-                if (typeof record?.jobId !== "string" || typeof record?.description !== "string"
-                    || typeof record?.actorId !== "string" || typeof record?.actorType !== "string"
-                    || !AUDIT_CHANGES.has(record?.change)) {
-                    return this.reply(response, 400, { error: "Expected a body of { jobId, actorId, actorType, change, description, ... }" });
-                }
-                await this.auditRecords!.save(record);
-                return this.reply(response, 204);
-            }
-            case "GET": {
-                const change = url.searchParams.get("change");
-                const records = await this.auditRecords!.list({
-                    jobId: url.searchParams.get("jobId") ?? undefined,
-                    actorId: url.searchParams.get("actorId") ?? undefined,
-                    change: change && AUDIT_CHANGES.has(change) ? change as AuditChange : undefined,
-                    search: url.searchParams.get("search") ?? undefined,
-                    pageSize: url.searchParams.has("pageSize") ? Number(url.searchParams.get("pageSize")) : undefined,
-                    page: url.searchParams.has("page") ? Number(url.searchParams.get("page")) : undefined,
-                });
-                return this.reply(response, 200, records);
-            }
-        }
-
-        this.notFound(response);
-    }
-
-    private async handleJobs(method : string, id : string | undefined, subresource : string | undefined,
-                             url : URL, request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        switch (subresource) {
-            case "properties":
-                if (id) {
-                    switch (method) {
-                        case "PATCH": {
-                            const properties = new Map<string, any>(Object.entries(await readBody(request)));
-                            await this.persistence.updateProperties(id, properties);
-                            return this.reply(response, 204);
-                        }
-                    }
-                }
-                break;
-            case undefined:
-                if (id) {
-                    switch (method) {
-                        case "PUT":
-                            await this.persistence.save(deserializeJob(await readBody(request)));
-                            return this.reply(response, 204);
-                        case "GET":
-                            return this.reply(response, 200, serializeJob(await this.persistence.retrieve(id)));
-                        case "DELETE":
-                            await this.persistence.delete(id);
-                            return this.reply(response, 204);
-                    }
-                } else {
-                    switch (method) {
-                        case "GET": {
-                            const pageSize = Number(url.searchParams.get("pageSize") ?? 100);
-                            const page = Number(url.searchParams.get("page") ?? 0);
-                            const jobs = await this.persistence.list(pageSize, page);
-                            return this.reply(response, 200, jobs.map(serializeJob));
-                        }
-                    }
-                }
-                break;
-        }
-
-        this.notFound(response);
-    }
-
-    private async handleQueue(method : string, operation : string,
-                              request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        switch (operation) {
-            case "enqueue":
-                switch (method) {
-                    case "POST": {
-                        const { jobId, workflowId } = await readBody(request);
-                        await this.queue.enqueue(jobId, workflowId);
-                        return this.reply(response, 204);
-                    }
-                }
-                break;
-            case "schedule":
-                switch (method) {
-                    case "POST": {
-                        const { jobId, workflowId, due } = await readBody(request);
-                        await this.queue.schedule(jobId, workflowId, new Date(due));
-                        return this.reply(response, 204);
-                    }
-                }
-                break;
-            case "dequeue":
-                switch (method) {
-                    case "POST":
-                        return this.reply(response, 200, { messages: await this.queue.dequeueSome() });
-                }
-                break;
-            case "confirm":
-                switch (method) {
-                    case "POST": {
-                        const { jobId, workflowId } = await readBody(request);
-                        await this.queue.confirm({ jobId, workflowId });
-                        return this.reply(response, 204);
-                    }
-                }
-                break;
-        }
-
-        this.notFound(response);
-    }
-
-    private async handleConsumers(method : string, request : IncomingMessage,
-                                  response : ServerResponse) : Promise<void> {
-        switch (method) {
-            case "POST": {
-                const { workflowId, url: consumerUrl } = await readBody(request);
-                this.registry.register(workflowId, consumerUrl);
-                return this.reply(response, 204);
-            }
-        }
-
-        this.notFound(response);
-    }
-
-    private async handleApps(method : string, appName : string | undefined, subresource : string | undefined,
-                             url : URL, request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        switch (subresource) {
-            case "deploy":
-                if (appName) {
-                    switch (method) {
-                        case "POST": {
-                            const appPort = Number(url.searchParams.get("port"));
-                            if (!Number.isInteger(appPort) || appPort <= 0) {
-                                return this.reply(response, 400, { error: "Expected a numeric port query parameter" });
-                            }
-                            const tarball = await readRawBody(request);
-                            if (tarball.length === 0) return this.reply(response, 400, { error: "Expected a gzipped tarball body" });
-                            return this.reply(response, 202, this.buildLayer!.deploy(appName, appPort, tarball));
-                        }
-                    }
-                }
-                break;
-            case undefined:
-                if (appName) {
-                    switch (method) {
-                        case "GET": {
-                            const status = this.buildLayer!.status(appName);
-                            if (!status) return this.reply(response, 404, { error: `No app named "${appName}"` });
-                            return this.reply(response, 200, status);
-                        }
-                    }
-                } else {
-                    switch (method) {
-                        case "GET":
-                            return this.reply(response, 200, this.buildLayer!.list());
-                    }
-                }
-                break;
-        }
+    private handlers = new Map<string, RequestHandler>();
+    private rootHandler? : RequestHandler;
+    private fallbackHandler? : RequestHandler;
 
-        this.notFound(response);
+    register(resource : string, handler : RequestHandler) : void {
+        this.handlers.set(resource, handler);
     }
 
-    private async handleDocuments(method : string, store : JsonStore, documentId : string | undefined,
-                                  url : URL, request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        if (documentId) {
-            switch (method) {
-                case "PUT":
-                    await store.save(documentId, await readBody(request));
-                    return this.reply(response, 204);
-                case "GET":
-                    return this.reply(response, 200, await store.retrieve(documentId));
-                case "DELETE":
-                    await store.delete(documentId);
-                    return this.reply(response, 204);
-            }
-        } else {
-            switch (method) {
-                case "GET": {
-                    const pageSize = Number(url.searchParams.get("pageSize") ?? 100);
-                    const page = Number(url.searchParams.get("page") ?? 0);
-                    return this.reply(response, 200, await store.list(pageSize, page));
-                }
-            }
-        }
-
-        this.notFound(response);
+    registerRoot(handler : RequestHandler) : void {
+        this.rootHandler = handler;
     }
 
-    private async handleSecrets(method : string, name : string | undefined,
-                                request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        if (name) {
-            switch (method) {
-                case "PUT": {
-                    const { value } = await readBody(request);
-                    if (typeof value !== "string") return this.reply(response, 400, { error: "Expected a body of { value : string }" });
-                    await this.secretStore!.save(name, value);
-                    return this.reply(response, 204);
-                }
-                case "GET":
-                    return this.reply(response, 200, { value: await this.secretStore!.retrieve(name) });
-                case "DELETE":
-                    await this.secretStore!.delete(name);
-                    return this.reply(response, 204);
-            }
-        } else {
-            switch (method) {
-                case "GET":
-                    return this.reply(response, 200, await this.secretStore!.list());
-            }
-        }
-
-        this.notFound(response);
+    registerFallback(handler : RequestHandler) : void {
+        this.fallbackHandler = handler;
     }
 
-    private async servePage(response : ServerResponse) : Promise<void> {
-        try {
-            const page = await readFile(new URL("./pages/platform-ui.html", import.meta.url));
-            response.writeHead(200, { "content-type": "text/html" });
-            response.end(page);
-        } catch {
-            this.reply(response, 501, { error: "The platform UI has not been built - run npm run build in anbaric-cloud-hosting/ui" });
+    async route(request : Request) : Promise<void> {
+        if (request.resource === undefined) {
+            if (this.rootHandler) return this.rootHandler.handle(request);
+            return request.notFound();
         }
-    }
 
-    private async forwardToApp(appHost : string, appPort : number, appName : string, method : string, url : URL,
-                               request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        const appPath = url.pathname.slice(`/${appName}`.length) || "/";
-        const body = method === "GET" || method === "HEAD" ? undefined : await readRawBody(request);
+        const handler = this.handlers.get(request.resource);
+        if (handler) return handler.handle(request);
+        if (this.fallbackHandler) return this.fallbackHandler.handle(request);
 
-        const upstream = await fetch(`http://${appHost}:${appPort}${appPath}${url.search}`, {
-            method,
-            headers: { "content-type": String(request.headers["content-type"] ?? "application/json") },
-            body: body && body.length > 0 ? new Uint8Array(body) : undefined,
-        });
-
-        const payload = Buffer.from(await upstream.arrayBuffer());
-        response.writeHead(upstream.status, { "content-type": upstream.headers.get("content-type") ?? "application/octet-stream" });
-        response.end(payload);
-    }
-
-    private notFound(response : ServerResponse) : void {
-        this.reply(response, 404, { error: "Not found" });
-    }
-
-    private reply(response : ServerResponse, status : number, body? : unknown) : void {
-        if (body === undefined) {
-            response.statusCode = status;
-            response.end();
-            return;
-        }
-        response.writeHead(status, { "content-type": "application/json" });
-        response.end(JSON.stringify(body));
+        request.notFound();
     }
 
 }

package/src/hosting/Server.ts

@@ -0,0 +1,54 @@
+import {createServer, IncomingMessage, Server as HttpServer, ServerResponse} from "node:http";
+import {AddressInfo} from "node:net";
+import {Middleware} from "./Middleware";
+import {Request} from "./Request";
+import {Router} from "./Router";
+
+/* One listener: builds the Request, stamps the ray trace id, runs the
+   middleware chain to decorate (or answer) it, then hands it to the
+   router. */
+class Server {
+
+    private server : HttpServer;
+
+    constructor(private router : Router, private middlewares : Array<Middleware> = []) {
+        this.server = createServer((incoming, response) => {
+            this.handle(incoming, response).catch(error => {
+                const message = error instanceof Error ? error.message : "Internal error";
+                const status = /^No .+ found/.test(message) ? 404 : 500;
+                if (!response.writableEnded) {
+                    response.writeHead(status, { "content-type": "application/json" });
+                    response.end(JSON.stringify({ error: message }));
+                }
+            });
+        });
+    }
+
+    get listening() : boolean {
+        return this.server.listening;
+    }
+
+    listen(port : number) : Promise<number> {
+        return new Promise(resolve =>
+            this.server.listen(port, () => resolve((this.server.address() as AddressInfo).port)));
+    }
+
+    close() : Promise<void> {
+        return new Promise((resolve, reject) =>
+            this.server.close(error => error ? reject(error) : resolve()));
+    }
+
+    private async handle(incoming : IncomingMessage, response : ServerResponse) : Promise<void> {
+        const request = new Request(incoming, response);
+        response.setHeader("x-anbaric-ray", request.rayId);
+
+        for (const middleware of this.middlewares) {
+            if (!await middleware.apply(request)) return;
+        }
+
+        await this.router.route(request);
+    }
+
+}
+
+export { Server }

package/src/hosting/handlers/AppProxyHandler.ts

@@ -0,0 +1,34 @@
+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. */
+class AppProxyHandler implements RequestHandler {
+
+    constructor(private buildLayer : BuildLayer) {}
+
+    async handle(request : Request) : Promise<void> {
+        const appName = request.resource!;
+        const app = this.buildLayer.status(appName);
+        if (!app || app.status !== "running") return request.notFound();
+
+        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,
+        });
+
+        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);
+    }
+
+}
+
+export { AppProxyHandler }

package/src/hosting/handlers/AppsHandler.ts

@@ -0,0 +1,57 @@
+import {BuildLayer} from "../../app-management/BuildLayer";
+import {Request} from "../Request";
+import {RequestHandler} from "../RequestHandler";
+
+class AppsHandler implements RequestHandler {
+
+    constructor(private buildLayer : BuildLayer) {}
+
+    async handle(request : Request) : Promise<void> {
+        switch (request.subresource) {
+            case "deploy":
+                if (request.id) return this.handleDeploy(request, request.id);
+                break;
+            case undefined:
+                if (request.id) return this.handleApp(request, request.id);
+                return this.handleCollection(request);
+        }
+        request.notFound();
+    }
+
+    private async handleDeploy(request : Request, appName : string) : Promise<void> {
+        switch (request.method) {
+            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" });
+                }
+                const tarball = await request.rawBody();
+                if (tarball.length === 0) return request.reply(400, { error: "Expected a gzipped tarball body" });
+                return request.reply(202, this.buildLayer.deploy(appName, appPort, tarball));
+            }
+        }
+        request.notFound();
+    }
+
+    private async handleApp(request : Request, appName : string) : Promise<void> {
+        switch (request.method) {
+            case "GET": {
+                const status = this.buildLayer.status(appName);
+                if (!status) return request.reply(404, { error: `No app named "${appName}"` });
+                return request.reply(200, status);
+            }
+        }
+        request.notFound();
+    }
+
+    private async handleCollection(request : Request) : Promise<void> {
+        switch (request.method) {
+            case "GET":
+                return request.reply(200, this.buildLayer.list());
+        }
+        request.notFound();
+    }
+
+}
+
+export { AppsHandler }

package/src/hosting/handlers/AuditsHandler.ts

@@ -0,0 +1,50 @@
+import {AuditChange} from "anbaric-tsapi";
+import {AuditRecordStore} from "../../auditing/AuditRecordStore";
+import {Request} from "../Request";
+import {RequestHandler} from "../RequestHandler";
+
+const AUDIT_CHANGES = new Set(["CREATE", "UPDATE_PROPERTIES", "CHANGE_STATE", "DELETE"]);
+
+class AuditsHandler implements RequestHandler {
+
+    constructor(private auditRecords : AuditRecordStore) {}
+
+    async handle(request : Request) : Promise<void> {
+        if (request.id) return request.notFound();
+
+        switch (request.method) {
+            case "POST":
+                return this.handleRecord(request);
+            case "GET":
+                return this.handleQuery(request);
+        }
+        request.notFound();
+    }
+
+    private async handleRecord(request : Request) : Promise<void> {
+        const record = await request.body();
+        if (typeof record?.jobId !== "string" || typeof record?.description !== "string"
+            || typeof record?.actorId !== "string" || typeof record?.actorType !== "string"
+            || !AUDIT_CHANGES.has(record?.change)) {
+            return request.reply(400, { error: "Expected a body of { jobId, actorId, actorType, change, description, ... }" });
+        }
+        await this.auditRecords.save(record);
+        request.reply(204);
+    }
+
+    private async handleQuery(request : Request) : Promise<void> {
+        const change = request.query("change");
+        const records = await this.auditRecords.list({
+            jobId: request.query("jobId"),
+            actorId: request.query("actorId"),
+            change: change && AUDIT_CHANGES.has(change) ? change as AuditChange : undefined,
+            search: request.query("search"),
+            pageSize: request.query("pageSize") === undefined ? undefined : Number(request.query("pageSize")),
+            page: request.query("page") === undefined ? undefined : Number(request.query("page")),
+        });
+        request.reply(200, records);
+    }
+
+}
+
+export { AuditsHandler }

package/src/hosting/handlers/ConsumersHandler.ts

@@ -0,0 +1,24 @@
+import {ConsumerRegistry} from "../../queuing/ConsumerRegistry";
+import {Request} from "../Request";
+import {RequestHandler} from "../RequestHandler";
+
+class ConsumersHandler implements RequestHandler {
+
+    constructor(private registry : ConsumerRegistry) {}
+
+    async handle(request : Request) : Promise<void> {
+        if (request.id) return request.notFound();
+
+        switch (request.method) {
+            case "POST": {
+                const { workflowId, url } = await request.body();
+                this.registry.register(workflowId, url);
+                return request.reply(204);
+            }
+        }
+        request.notFound();
+    }
+
+}
+
+export { ConsumersHandler }