anbaric-cloud-hosting 1.12.0 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-cloud-hosting",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "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.12.0",
-    "anbaric-plugins": "^1.12.0",
-    "anbaric-tsapi": "^1.12.0",
+    "anbaric-data-store": "^1.14.0",
+    "anbaric-plugins": "^1.14.0",
+    "anbaric-tsapi": "^1.14.0",
     "esbuild": "^0.28.2",
     "pg": "^8.16.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@types/pg": "^8.15.0",
-    "anbaric-impl-cloud": "^1.12.0",
-    "anbaric-state-machine": "^1.12.0",
+    "anbaric-impl-cloud": "^1.14.0",
+    "anbaric-state-machine": "^1.14.0",
     "tsx": "^4.20.0",
     "typescript": "^7.0.2"
   },

package/src/data-store/PostgresAuditRecordStore.ts

@@ -4,7 +4,7 @@ import {AuditFilter, AuditRecordStore} from "../auditing/AuditRecordStore";
 
 /* The writes worth keeping in the durable trail; reads (READ, LIST, QUERY) are
    dropped by default. Interactions are plain strings chosen by each store. */
-const DEFAULT_WRITE_MASK : Array<string> = ["CREATE", "SAVE", "UPDATE_PROPERTIES", "CHANGE_STATE", "DELETE", "EXECUTE"];
+const DEFAULT_WRITE_MASK : Array<string> = ["CREATE", "SAVE", "UPDATE_PROPERTIES", "CHANGE_STATE", "DELETE", "EXECUTE", "KILL"];
 
 /* Persists audit records, subject to a write mask: only the interactions in
    the mask are stored, so high-volume reads can be audited at the call site

package/src/data-store/PostgresJobPersistence.ts

@@ -9,9 +9,10 @@ type JobRow = {
     started_at : Date,
     started_by : string,
     last_updated : Date,
+    killed : boolean,
 };
 
-const JOB_COLUMNS = "id, state, properties, workflow_id, started_at, started_by, last_updated";
+const JOB_COLUMNS = "id, state, properties, workflow_id, started_at, started_by, last_updated, killed";
 
 class PostgresJobPersistence extends JobPersistence {
 
@@ -21,12 +22,12 @@ class PostgresJobPersistence extends JobPersistence {
 
     protected async saveInternal(job : Job) : Promise<void> {
         await this.pool.query(
-            `INSERT INTO jobs (id, state, properties, workflow_id, started_at, started_by, last_updated)
-             VALUES ($1, $2, $3, $4, $5, $6, $7)
+            `INSERT INTO jobs (id, state, properties, workflow_id, started_at, started_by, last_updated, killed)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
              ON CONFLICT (id) DO UPDATE SET state = EXCLUDED.state, properties = EXCLUDED.properties,
-                 workflow_id = EXCLUDED.workflow_id, last_updated = EXCLUDED.last_updated`,
+                 workflow_id = EXCLUDED.workflow_id, last_updated = EXCLUDED.last_updated, killed = EXCLUDED.killed`,
             [job.id, job.state, Object.fromEntries(job.properties), job.workflowId,
-                job.startedAt, job.startedBy, job.lastUpdated],
+                job.startedAt, job.startedBy, job.lastUpdated, job.killed],
         );
     }
 
@@ -53,6 +54,25 @@ class PostgresJobPersistence extends JobPersistence {
         return result.rows.map(row => this.deserializeRow(row));
     }
 
+    protected async killInternal(id : string) : Promise<void> {
+        await this.pool.query("UPDATE jobs SET killed = true, last_updated = now() WHERE id = $1", [id]);
+    }
+
+    protected async killOlderThanInternal(lastUpdatedBefore : Date) : Promise<number> {
+        const result = await this.pool.query(
+            "UPDATE jobs SET killed = true, last_updated = now() WHERE last_updated < $1 AND killed = false",
+            [lastUpdatedBefore],
+        );
+        return result.rowCount ?? 0;
+    }
+
+    protected async countByStateInternal() : Promise<Array<JobPersistence.StateCount>> {
+        const result = await this.pool.query(
+            "SELECT state, killed, count(*)::int AS count FROM jobs GROUP BY state, killed",
+        );
+        return result.rows.map(row => ({ state: row.state, killed: row.killed, count: row.count }));
+    }
+
     private deserializeRow(row : JobRow) : Job {
         return deserializeJob({
             ...row,
@@ -60,6 +80,7 @@ class PostgresJobPersistence extends JobPersistence {
             startedAt: row.started_at.toISOString(),
             startedBy: row.started_by,
             lastUpdated: row.last_updated.toISOString(),
+            killed: row.killed,
         });
     }
 

package/src/data-store/Schema.ts

@@ -22,6 +22,7 @@ const ensureSchema = async (pool : Pool) : Promise<void> => {
     await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS started_by TEXT NOT NULL DEFAULT 'system'");
     await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS last_updated TIMESTAMPTZ NOT NULL DEFAULT now()");
     await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS transitions JSONB NOT NULL DEFAULT '[]'");
+    await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS killed BOOLEAN NOT NULL DEFAULT false");
     await pool.query(`
         CREATE TABLE IF NOT EXISTS documents (
             collection  TEXT NOT NULL,

package/src/hosting/handlers/JobsHandler.ts

@@ -7,6 +7,21 @@ class JobsHandler implements RequestHandler {
     constructor(private persistence : JobPersistence) {}
 
     async handle(request : Request) : Promise<void> {
+        if (request.id === "stats" && !request.subresource) {
+            if (request.method !== "GET") return request.notFound();
+            return request.reply(200, { states: await this.persistence.countByState(SystemActor.actor) });
+        }
+        if (request.id === "kill-old" && !request.subresource) {
+            if (request.method !== "POST") return request.notFound();
+            const { before } = await request.body();
+            const killed = await this.persistence.killOlderThan(new Date(before), SystemActor.actor);
+            return request.reply(200, { killed });
+        }
+        if (request.id && request.subresource === "kill") {
+            if (request.method !== "POST") return request.notFound();
+            await this.persistence.kill(request.id, SystemActor.actor);
+            return request.reply(204);
+        }
         if (request.subresource) return request.notFound();
         if (request.id) return this.handleJob(request, request.id);
         return this.handleCollection(request);

package/src/hosting/handlers/QueueHandler.ts

@@ -7,7 +7,13 @@ class QueueHandler implements RequestHandler {
     constructor(private queue : ConfirmableQueue) {}
 
     async handle(request : Request) : Promise<void> {
-        if (request.method !== "POST" || !request.id || request.subresource) return request.notFound();
+        if (request.subresource) return request.notFound();
+
+        if (request.method === "GET" && request.id === "size") {
+            return request.reply(200, { size: await this.queue.size() });
+        }
+
+        if (request.method !== "POST" || !request.id) return request.notFound();
 
         switch (request.id) {
             case "enqueue": {

package/src/queuing/ConfirmableQueue.ts

@@ -3,6 +3,7 @@ import {Dequeue, QueueMessage} from "anbaric-tsapi";
 interface ConfirmableQueue extends Dequeue {
 
     confirm(message : QueueMessage) : Promise<void>;
+    size() : Promise<number>;
 
 }
 

package/src/queuing/PostgresQueue.ts

@@ -47,6 +47,11 @@ class PostgresQueue implements ConfirmableQueue {
         await this.pool.query("DELETE FROM queue WHERE position = $1", [message.position]);
     }
 
+    async size() : Promise<number> {
+        const result = await this.pool.query("SELECT count(*)::int AS count FROM queue");
+        return result.rows[0].count;
+    }
+
 }
 
 export { PostgresQueue }