web: rename queen-bee to task-manager

less corny and less cryptic

web/src/lib/task-manager/scheduler.ts

@@ -0,0 +1,76 @@
+import { get } from "svelte/store";
+import { startWorker } from "$lib/task-manager/run-worker";
+import { addWorkerToQueue, currentTasks } from "$lib/state/task-manager/current-tasks";
+import { itemDone, itemError, itemRunning, queue } from "$lib/state/task-manager/queue";
+
+import type { CobaltPipelineItem } from "$lib/types/workers";
+
+const startPipeline = (pipelineItem: CobaltPipelineItem) => {
+    addWorkerToQueue(pipelineItem.workerId, {
+        type: pipelineItem.worker,
+        parentId: pipelineItem.parentId,
+    });
+
+    itemRunning(
+        pipelineItem.parentId,
+        pipelineItem.workerId,
+    );
+
+    startWorker(pipelineItem);
+}
+
+export const schedule = () => {
+    const queueItems = get(queue);
+    const ongoingTasks = get(currentTasks);
+
+    // TODO (?): task concurrency
+    if (Object.keys(ongoingTasks).length > 0) {
+        return;
+    }
+
+    for (const task of Object.values(queueItems)) {
+        if (task.state === "running") {
+            // if the running worker isn't completed, wait
+            // to be called again on worker completion
+            if (!task.completedWorkers.has(task.runningWorker)) {
+                break;
+            }
+
+            // if all workers are completed, then return the
+            // the final file and go to the next task
+            if (task.completedWorkers.size === task.pipeline.length) {
+                const finalFile = task.pipelineResults.pop();
+
+                if (finalFile) {
+                    itemDone(task.id, finalFile);
+                } else {
+                    itemError(task.id, task.runningWorker, "no final file");
+                }
+
+                continue;
+            }
+
+            // if current worker is completed, but there are more workers,
+            // then start the next one and wait to be called again
+            for (const worker of task.pipeline) {
+                if (!task.completedWorkers.has(worker.workerId)) {
+                    startPipeline(worker);
+                    break;
+                }
+            }
+
+            // break because we don't want to start next tasks before this one is done
+            // it's necessary because some tasks might take some time before being marked as running
+            break;
+        }
+
+        // start the nearest waiting task and wait to be called again
+        else if (task.state === "waiting" && task.pipeline.length > 0) {
+            startPipeline(task.pipeline[0]);
+
+            // break because we don't want to start next tasks before this one is done
+            // it's necessary because some tasks might take some time before being marked as running
+            break;
+        }
+    }
+}