web: rename queen-bee to task-manager

less corny and less cryptic

web/src/lib/state/task-manager/current-tasks.ts

@@ -0,0 +1,38 @@
+import { readable, type Updater } from "svelte/store";
+
+import type { CobaltWorkerProgress } from "$lib/types/workers";
+import type { CobaltCurrentTasks, CobaltCurrentTaskItem } from "$lib/types/task-manager";
+
+let update: (_: Updater<CobaltCurrentTasks>) => void;
+
+export const currentTasks = readable<CobaltCurrentTasks>(
+    {},
+    (_, _update) => { update = _update }
+);
+
+export function addWorkerToQueue(workerId: string, item: CobaltCurrentTaskItem) {
+    update(tasks => {
+        tasks[workerId] = item;
+        return tasks;
+    });
+}
+
+export function removeWorkerFromQueue(id: string) {
+    update(tasks => {
+        delete tasks[id];
+        return tasks;
+    });
+}
+
+export function updateWorkerProgress(workerId: string, progress: CobaltWorkerProgress) {
+    update(allTasks => {
+        allTasks[workerId].progress = progress;
+        return allTasks;
+    });
+}
+
+export function clearCurrentTasks() {
+    update(() => {
+        return {};
+    });
+}

web/src/lib/state/task-manager/queue.ts

@@ -0,0 +1,127 @@
+import { readable, type Updater } from "svelte/store";
+
+import { schedule } from "$lib/task-manager/scheduler";
+import { clearFileStorage, removeFromFileStorage } from "$lib/storage";
+import { clearCurrentTasks, removeWorkerFromQueue } from "$lib/state/task-manager/current-tasks";
+
+import type { CobaltFileReference } from "$lib/types/storage";
+import type { CobaltQueue, CobaltQueueItem, CobaltQueueItemRunning } from "$lib/types/queue";
+
+const clearPipelineCache = (queueItem: CobaltQueueItem) => {
+    if (queueItem.state === "running") {
+        let item: CobaltFileReference | undefined;
+        while ((item = queueItem.pipelineResults.pop())) {
+            removeFromFileStorage(item.file.name);
+        }
+    } else if (queueItem.state === "done") {
+        removeFromFileStorage(queueItem.resultFile.file.name);
+    }
+
+    return queueItem;
+}
+
+let update: (_: Updater<CobaltQueue>) => void;
+
+export const queue = readable<CobaltQueue>(
+    {},
+    (_, _update) => { update = _update }
+);
+
+export function addItem(item: CobaltQueueItem) {
+    update(queueData => {
+        queueData[item.id] = item;
+        return queueData;
+    });
+
+    schedule();
+}
+
+export function itemError(id: string, workerId: string, error: string) {
+    update(queueData => {
+        if (queueData[id]) {
+            queueData[id] = clearPipelineCache(queueData[id]);
+
+            queueData[id] = {
+                ...queueData[id],
+                state: "error",
+                errorCode: error,
+            }
+        }
+        return queueData;
+    });
+
+    removeWorkerFromQueue(workerId);
+    schedule();
+}
+
+export function itemDone(id: string, file: CobaltFileReference) {
+    update(queueData => {
+        if (queueData[id]) {
+            queueData[id] = clearPipelineCache(queueData[id]);
+
+            queueData[id] = {
+                ...queueData[id],
+                state: "done",
+                resultFile: file,
+            }
+        }
+        return queueData;
+    });
+
+    schedule();
+}
+
+export function pipelineTaskDone(id: string, workerId: string, file: CobaltFileReference) {
+    update(queueData => {
+        const item = queueData[id];
+
+        if (item && item.state === 'running') {
+            item.pipelineResults.push(file);
+            item.completedWorkers.add(workerId);
+        }
+
+        return queueData;
+    });
+
+    removeWorkerFromQueue(workerId);
+    schedule();
+}
+
+export function itemRunning(id: string, workerId: string) {
+    update(queueData => {
+        const data = queueData[id] as CobaltQueueItemRunning;
+
+        if (data) {
+            data.state = 'running';
+            data.runningWorker = workerId;
+            data.completedWorkers ??= new Set();
+            data.pipelineResults ??= [];
+        }
+
+        return queueData;
+    });
+
+    schedule();
+}
+
+export function removeItem(id: string) {
+    update(queueData => {
+        const item = queueData[id];
+
+        for (const worker of item.pipeline) {
+            removeWorkerFromQueue(worker.workerId);
+        }
+        clearPipelineCache(item);
+
+        delete queueData[id];
+        return queueData;
+    });
+
+    schedule();
+}
+
+export function clearQueue() {
+    update(() => ({}));
+    clearCurrentTasks();
+    clearFileStorage();
+}