@kapeta/local-cluster-service 0.12.0 → 0.13.0

package/src/taskManager.ts

@@ -0,0 +1,225 @@
+/**
+ * Class that handles processing background tasks.
+ */
+import { socketManager } from './socketManager';
+
+const EVENT_TASK_UPDATED = 'task-updated';
+const EVENT_TASK_ADDED = 'task-added';
+const EVENT_TASK_REMOVED = 'task-removed';
+
+export type TaskRunner<T> = (task: Task<T>) => Promise<T>;
+
+export enum TaskStatus {
+    PENDING = 'PENDING',
+    RUNNING = 'RUNNING',
+    COMPLETED = 'COMPLETED',
+    FAILED = 'FAILED',
+}
+
+interface Future<T = void> {
+    promise: Promise<T>;
+    resolve: (result: T) => void;
+    reject: (e: any) => void;
+}
+
+interface TaskMetadata {
+    name: string;
+    /**
+     * A unique prefix for the task. If defined only 1 task with this ID prefix will be executed at a time
+     */
+    group?: string;
+    progress?: number;
+
+    [key: string]: any;
+}
+
+interface TaskData<T = void> {
+    id: string;
+    status: TaskStatus;
+    errorMessage?: string;
+    metadata: TaskMetadata;
+    future: Future<T>;
+    run: TaskRunner<T>;
+}
+
+export class Task<T = void> implements TaskData<T> {
+    private data: TaskData<T>;
+
+    constructor(task: TaskData<T>) {
+        this.data = task;
+    }
+
+    get id() {
+        return this.data.id;
+    }
+
+    get status() {
+        return this.data.status;
+    }
+
+    get errorMessage() {
+        return this.data.errorMessage;
+    }
+
+    get metadata() {
+        return this.data.metadata;
+    }
+
+    get future() {
+        return this.data.future;
+    }
+
+    get run() {
+        return this.data.run;
+    }
+
+    set status(status: TaskStatus) {
+        this.data.status = status;
+    }
+
+    set errorMessage(errorMessage: string | undefined) {
+        this.data.errorMessage = errorMessage;
+    }
+
+    set metadata(metadata: TaskMetadata) {
+        this.data.metadata = metadata;
+    }
+
+    public emitUpdate() {
+        socketManager.emitGlobal(EVENT_TASK_UPDATED, this.toData());
+    }
+
+    async wait(): Promise<T> {
+        return this.future.promise;
+    }
+
+    toData() {
+        return { ...this.data };
+    }
+}
+
+function createFuture<T>(): Future<T> {
+    let resolve: (arg: T) => void = () => {};
+    let reject: () => void = () => {};
+    const promise = new Promise<T>((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+
+class TaskManager {
+    private _tasks: Task<any>[] = [];
+
+    public add<T>(id: string, runner: TaskRunner<T>, metadata: TaskMetadata): Task<T> {
+        const existingTask = this.get(id);
+        if (existingTask) {
+            return existingTask;
+        }
+
+        const future = createFuture<T>();
+
+        const task = new Task<T>({
+            id,
+            status: TaskStatus.PENDING,
+            metadata,
+            future,
+            run: runner,
+        });
+
+        this._tasks.push(task);
+
+        socketManager.emitGlobal(EVENT_TASK_ADDED, task.toData());
+
+        this.invokeTask(task).catch(() => {});
+
+        return task;
+    }
+
+    async waitFor(filter: (task: Task<any>) => boolean) {
+        const tasks = this._tasks.filter(filter);
+        while (tasks.length > 0) {
+            const task = tasks.shift();
+            if (!task) {
+                continue;
+            }
+            try {
+                await task.wait();
+            } catch (e) {
+                //Ignore
+            }
+        }
+    }
+
+    public get(taskId: string) {
+        return this._tasks.find((t) => t.id === taskId);
+    }
+
+    public exists(taskId: string) {
+        return !!this.get(taskId);
+    }
+
+    public remove(taskId: string) {
+        const task = this.get(taskId);
+        if (!task) {
+            return;
+        }
+
+        if (task.status === TaskStatus.RUNNING) {
+            throw new Error('Cannot remove a running task');
+        }
+
+        this._tasks = this._tasks.filter((t) => t.id !== taskId);
+        socketManager.emitGlobal(EVENT_TASK_REMOVED, task.toData());
+    }
+
+    public list(): TaskData[] {
+        return this._tasks.map((t) => t.toData());
+    }
+
+    private async invokeTask(task: Task<any>): Promise<void> {
+        if (task.metadata.group) {
+            const existingTaskInGroup = this._tasks.find(
+                (t) => t.id !== task.id && t.metadata.group === task.metadata.group && t.status === TaskStatus.RUNNING
+            );
+
+            if (existingTaskInGroup) {
+                console.log('existingTaskInGroup', existingTaskInGroup.toData());
+                return;
+            }
+        }
+
+        try {
+            task.status = TaskStatus.RUNNING;
+            task.emitUpdate();
+            const result = await task.run(task);
+            task.status = TaskStatus.COMPLETED;
+            task.future.resolve(result);
+            task.emitUpdate();
+        } catch (e: any) {
+            task.errorMessage = e.message;
+            task.status = TaskStatus.FAILED;
+            task.future.reject(e);
+            task.emitUpdate();
+        } finally {
+            this.remove(task.id);
+        }
+
+        if (task.metadata.group) {
+            const nextTaskInGroup = this._tasks.find(
+                (t) => t.id !== task.id && t.metadata.group === task.metadata.group && t.status === TaskStatus.PENDING
+            );
+            if (nextTaskInGroup) {
+                console.log('nextTaskInGroup', nextTaskInGroup.toData());
+                return this.invokeTask(nextTaskInGroup);
+            }
+        }
+    }
+}
+
+export const taskManager = new TaskManager();

package/src/tasks/routes.ts

@@ -0,0 +1,38 @@
+import Router from 'express-promise-router';
+import { Request, Response } from 'express';
+
+import { corsHandler } from '../middleware/cors';
+import { taskManager } from '../taskManager';
+
+const router = Router();
+
+router.use('/', corsHandler);
+
+/**
+ * Get all current tasks
+ */
+router.get('/', (req: Request, res: Response) => {
+    res.send(taskManager.list());
+});
+
+router.get('/:taskId', (req: Request, res: Response) => {
+    const task = taskManager.get(req.params.taskId);
+    if (!task) {
+        res.status(404).send({ error: 'Task not found' });
+        return;
+    }
+
+    res.send(task.toData());
+});
+
+router.delete('/:taskId', (req: Request, res: Response) => {
+    try {
+        taskManager.remove(req.params.taskId);
+        res.send({ ok: true });
+    } catch (e: any) {
+        res.status(400).send({ error: e.message });
+        return;
+    }
+});
+
+export default router;

package/src/utils/BlockInstanceRunner.ts

@@ -5,12 +5,10 @@ import { KapetaURI, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from '../serviceManager';
 import { containerManager, DockerMounts, toLocalBindVolume } from '../containerManager';
 import { LogData } from './LogData';
-import EventEmitter from 'events';
 import { clusterService } from '../clusterService';
 import { AnyMap, BlockProcessParams, InstanceType, ProcessInfo, StringMap } from '../types';
 import { Container } from 'node-docker-api/lib/container';
 import { definitionsManager } from '../definitionsManager';
-import md5 from 'md5';
 
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
@@ -415,8 +413,6 @@ export class BlockInstanceRunner {
     private async ensureContainer(opts: any) {
         const container = await containerManager.ensureContainer(opts);
 
-        await containerManager.waitForReady(container);
-
         return this._handleContainer(container);
     }