anbaric-cloud-hosting 1.68.3 → 1.70.0

package/src/hosting/handlers/AppsHandler.ts

@@ -6,11 +6,12 @@ import {appAddress} from "../../app-management/appAddress";
 import {redactEmails} from "../../app-management/redactEmails";
 import {RequestHandler} from "../RequestHandler";
 import {Subdomains} from "../../subdomains/Subdomains";
+import {AppSettingsStore} from "../../data-store/AppSettingsStore";
 
 class AppsHandler implements RequestHandler {
 
     constructor(private buildLayer : BuildLayer, private tenant? : string,
-                private subdomains? : Subdomains) {}
+                private subdomains? : Subdomains, private settings? : AppSettingsStore) {}
 
     async handle(request : Request) : Promise<void> {
         // Changing what is deployed is a builder's job; a USER may look.
@@ -35,6 +36,9 @@ class AppsHandler implements RequestHandler {
             case "size":
                 if (request.id) return this.handleSize(request, request.id);
                 break;
+            case "zero-downtime":
+                if (request.id) return this.handleZeroDowntime(request, request.id);
+                break;
             case undefined:
                 if (request.id) return this.handleApp(request, request.id);
                 return this.handleCollection(request);
@@ -44,10 +48,30 @@ class AppsHandler implements RequestHandler {
 
     private changesApps(request : Request) : boolean {
         if (request.subresource === "deploy" || request.subresource === "docs") return true;
-        if (request.subresource === "subdomain" || request.subresource === "size") return request.method === "PUT";
+        if (["subdomain", "size", "zero-downtime"].includes(request.subresource ?? "")) return request.method === "PUT";
         return request.subresource === undefined && request.method === "DELETE";
     }
 
+    /* Whether the app's deploys keep the old version up until the new one
+       answers. A builder's choice, priced per app per month as the console
+       says; it takes effect from the next deploy and restarts nothing now. */
+    private async handleZeroDowntime(request : Request, appName : string) : Promise<void> {
+        if (request.method !== "PUT") return request.notFound();
+        if (! this.settings) return request.reply(409, { error: "This platform does not offer zero-downtime deploys" });
+        if (! this.buildLayer.status(appName)) return request.reply(404, { error: `No app named "${appName}"` });
+
+        const body = await request.body() as { on? : unknown } | undefined;
+        if (typeof body?.on !== "boolean") return request.reply(400, { error: "Expected a body of { on : boolean }" });
+
+        const settings = await this.settings.set(appName, { zeroDowntime: body.on });
+        return request.reply(200, { appName, zeroDowntime: settings.zeroDowntime });
+    }
+
+    private async zeroDowntimeOf(appName : string) : Promise<boolean | undefined> {
+        if (! this.settings) return undefined;
+        return (await this.settings.get(appName)).zeroDowntime;
+    }
+
     /* How big the app's instance is, which is a builder's to change and costs
        what the console told them it would. The app is rolled onto the new
        size; what it is doing is drained first, as any deploy does. */
@@ -110,7 +134,7 @@ class AppsHandler implements RequestHandler {
                 const tarball = await request.rawBody();
                 if (tarball.length === 0) return request.reply(400, { error: "Expected a gzipped tarball body" });
 
-                const summary = this.buildLayer.deploy(appName, appPort, tarball);
+                const summary = this.buildLayer.deploy(appName, appPort, tarball, { zeroDowntime: await this.zeroDowntimeOf(appName) });
 
                 /* An address is asked for alongside the build rather than
                    after it: allocation is idempotent, so a redeploy costs
@@ -134,11 +158,13 @@ class AppsHandler implements RequestHandler {
                 if (!status) return request.reply(404, { error: `No app named "${appName}"` });
                 const live = await this.buildLayer.ping(appName);
                 const subdomain = await this.addressOf(appName);
-                return request.reply(200, { ...status, live, subdomain, url: appAddress(appName, subdomain) });
+                const zeroDowntime = await this.zeroDowntimeOf(appName);
+                return request.reply(200, { ...status, live, subdomain, url: appAddress(appName, subdomain), zeroDowntime });
             }
             case "DELETE": {
                 const outcome = await this.buildLayer.teardown(appName);
                 if (!outcome) return request.reply(404, { error: `No app named "${appName}"` });
+                await this.settings?.remove(appName);
 
                 // The address is let go by the build layer's appRemoved hook,
                 // which an app that drains reaches minutes after this returns.
@@ -192,9 +218,11 @@ class AppsHandler implements RequestHandler {
         switch (request.method) {
             case "GET": {
                 const addresses = new Map((await this.addresses()).map(held => [held.appName, held.subdomain]));
+                const settings = new Map((await this.settings?.list() ?? []).map(each => [each.appName, each]));
                 return request.reply(200, this.buildLayer.list().map(app => {
                     const subdomain = addresses.get(app.appName);
-                    return { ...app, subdomain, url: appAddress(app.appName, subdomain) };
+                    const zeroDowntime = this.settings ? settings.get(app.appName)?.zeroDowntime ?? false : undefined;
+                    return { ...app, subdomain, url: appAddress(app.appName, subdomain), zeroDowntime };
                 }));
             }
         }

package/src/hosting/handlers/SkillsHandler.ts

@@ -0,0 +1,81 @@
+import {deniesBuild} from "../../auth/TenantRole";
+import {isSkillId, Skill, SkillStore} from "../../data-store/SkillStore";
+import {Request} from "../Request";
+import {RequestHandler} from "../RequestHandler";
+
+/* The tenant's skills: guidance its builders write for the agents that work
+   on it. Anyone in the tenant may read them - an agent acting for a user
+   needs them as much as one acting for a builder - but writing them is a
+   builder's job. Served to people and their agents only, never to deployed
+   apps, which is why this is registered on the public entry point alone. */
+class SkillsHandler implements RequestHandler {
+
+    constructor(private skills : SkillStore) {}
+
+    async handle(request : Request) : Promise<void> {
+        if (request.subresource) return request.notFound();
+        if (request.id) return this.handleSkill(request, request.id);
+        return this.handleCollection(request);
+    }
+
+    private async handleCollection(request : Request) : Promise<void> {
+        if (request.method !== "GET") return request.notFound();
+        return request.reply(200, (await this.skills.list()).map(skill => this.publicSkill(skill)));
+    }
+
+    private async handleSkill(request : Request, id : string) : Promise<void> {
+        switch (request.method) {
+            case "GET": {
+                const skill = await this.skills.get(id);
+                if (! skill) return request.reply(404, { error: `No skill with id "${id}"` });
+                return request.reply(200, this.publicSkill(skill));
+            }
+            case "PUT": {
+                if (deniesBuild(request.user?.tenantRole)) return this.refuse(request);
+                if (! isSkillId(id)) {
+                    return request.reply(400, { error: `"${id}" is not a skill id: lower-case letters, digits and hyphens, up to 50 characters` });
+                }
+                const body = await request.body();
+                const draft = this.draftFrom(body);
+                if (! draft) return request.reply(400, { error: "Expected a body of { title : string, usageHints : string, body : string }, none empty" });
+
+                return request.reply(200, this.publicSkill(await this.skills.save({ id, ...draft })));
+            }
+            case "DELETE": {
+                if (deniesBuild(request.user?.tenantRole)) return this.refuse(request);
+                const removed = await this.skills.remove(id);
+                return removed ? request.reply(204) : request.reply(404, { error: `No skill with id "${id}"` });
+            }
+        }
+        request.notFound();
+    }
+
+    private refuse(request : Request) : void {
+        request.reply(403, { error: "Your role in this tenant cannot manage skills" });
+    }
+
+    private draftFrom(body : unknown) : { title : string, usageHints : string, body : string } | undefined {
+        const fields = body as Record<string, unknown> | undefined;
+        const text = (value : unknown) : string | undefined =>
+            typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+
+        const title = text(fields?.title);
+        const usageHints = text(fields?.usageHints);
+        const content = text(fields?.body);
+        return title && usageHints && content ? { title, usageHints, body: content } : undefined;
+    }
+
+    private publicSkill(skill : Skill) {
+        return {
+            id: skill.id,
+            title: skill.title,
+            usageHints: skill.usageHints,
+            body: skill.body,
+            createdAt: skill.createdAt.toISOString(),
+            updatedAt: skill.updatedAt.toISOString(),
+        };
+    }
+
+}
+
+export { SkillsHandler };