@kapeta/local-cluster-service 0.0.0-96f91ef

package/dist/esm/src/socketManager.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socketManager = exports.SocketManager = exports.EVENT_LOG = exports.EVENT_SYSTEM_LOG = exports.EVENT_INSTANCE_LOG = exports.EVENT_INSTANCE_EXITED = exports.EVENT_INSTANCE_CREATED = exports.EVENT_STATUS_CHANGED = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const containerManager_1 = require("./containerManager");
+exports.EVENT_STATUS_CHANGED = 'status-changed';
+exports.EVENT_INSTANCE_CREATED = 'instance-created';
+exports.EVENT_INSTANCE_EXITED = 'instance-exited';
+exports.EVENT_INSTANCE_LOG = 'instance-log';
+exports.EVENT_SYSTEM_LOG = 'system-log';
+exports.EVENT_LOG = 'log';
+class SocketManager {
+    _io;
+    _sockets;
+    constructor() {
+        this._io = null;
+        this._sockets = [];
+        return this;
+    }
+    setIo(io) {
+        this._io = io;
+        this._bindIO();
+    }
+    isAlive() {
+        return !!this._io;
+    }
+    get io() {
+        if (!this._io) {
+            throw new Error('Socket server not ready');
+        }
+        return this._io;
+    }
+    emit(context, type, payload) {
+        if (!this._io) {
+            return;
+        }
+        this.io.to(context).emit(type, { context, payload });
+    }
+    emitGlobal(type, payload) {
+        if (!this._io) {
+            return;
+        }
+        this.io.emit(type, payload);
+    }
+    emitSystemEvent(systemId, type, payload) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        try {
+            const contextId = `system-events/${encodeURIComponent(systemId)}`;
+            this.emit(contextId, type, payload);
+        }
+        catch (e) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
+    emitInstanceLog(systemId, instanceId, payload) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        try {
+            this.emit(`instance-logs/${encodeURIComponent(systemId)}/${encodeURIComponent(instanceId)}`, exports.EVENT_INSTANCE_LOG, payload);
+        }
+        catch (e) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
+    emitSystemLog(systemId, payload) {
+        this.emitSystemEvent(systemId, exports.EVENT_SYSTEM_LOG, payload);
+    }
+    emitGlobalLog(payload) {
+        this.emitGlobal(exports.EVENT_LOG, payload);
+    }
+    _bindIO() {
+        this.io.on('connection', (socket) => this._handleSocketCreated(socket));
+    }
+    _handleSocketCreated(socket) {
+        this._bindSocket(socket);
+        this._sockets.push(socket);
+    }
+    _bindSocket(socket) {
+        socket.on('disconnect', () => {
+            lodash_1.default.pull(this._sockets, socket);
+            socket.rooms.forEach((roomId) => {
+                this.handleLeaveRoom(roomId);
+            });
+        });
+        socket.on('join', (id) => {
+            socket.join(id);
+            this.handleJoinRoom(id);
+        });
+        socket.on('leave', (id) => {
+            socket.leave(id);
+            this.handleLeaveRoom(id);
+        });
+    }
+    handleJoinRoom(id) {
+        if (id.startsWith('instance-logs/')) {
+            let [, systemId, instanceId] = id.split(/\//g);
+            systemId = decodeURIComponent(systemId);
+            instanceId = decodeURIComponent(instanceId);
+            console.log('Start listening for logs', systemId, instanceId);
+            containerManager_1.containerManager
+                .ensureLogListening(systemId, instanceId, (log) => {
+                this.emitInstanceLog(systemId, instanceId, log);
+            })
+                .catch((e) => { });
+        }
+    }
+    handleLeaveRoom(id) {
+        if (id.startsWith('instance-logs/')) {
+            let [, systemId, instanceId] = id.split(/\//g);
+            systemId = decodeURIComponent(systemId);
+            instanceId = decodeURIComponent(instanceId);
+            console.log('Stop listening for logs', systemId, instanceId);
+            containerManager_1.containerManager.stopLogListening(systemId, instanceId).catch((e) => { });
+        }
+    }
+}
+exports.SocketManager = SocketManager;
+exports.socketManager = new SocketManager();

package/dist/esm/src/storageService.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/**
+ * Class that handles reading and writing from local configuration file.
+ */
+declare class StorageService {
+    private _data;
+    constructor();
+    getKapetaBasedir(): string;
+    _readConfig(): import("@kapeta/local-cluster-config").ClusterConfig;
+    _writeConfig(): void;
+    section<T = any>(section: string, defaultValue?: any): T;
+    put(section: string, property: string | any, value?: any): void;
+    get<T = any>(section: string, property?: string, defaultValue?: T): T | undefined;
+    contains(section: string, property: string): any;
+    ensure(section: string, property: string, value: any): any;
+}
+export declare const storageService: StorageService;
+export {};

package/dist/esm/src/storageService.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageService = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const yaml_1 = __importDefault(require("yaml"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+/**
+ * Class that handles reading and writing from local configuration file.
+ */
+class StorageService {
+    _data;
+    constructor() {
+        this._data = this._readConfig();
+    }
+    getKapetaBasedir() {
+        return local_cluster_config_1.default.getKapetaBasedir();
+    }
+    _readConfig() {
+        return local_cluster_config_1.default.getClusterConfig();
+    }
+    _writeConfig() {
+        const configFile = local_cluster_config_1.default.getClusterConfigFile();
+        fs_extra_1.default.mkdirsSync(this.getKapetaBasedir());
+        fs_1.default.writeFileSync(configFile, yaml_1.default.stringify(this._data));
+    }
+    section(section, defaultValue) {
+        if (!defaultValue) {
+            defaultValue = {};
+        }
+        if (!this._data[section]) {
+            this._data[section] = defaultValue;
+            this._writeConfig();
+        }
+        return this._data[section];
+    }
+    put(section, property, value) {
+        if (!lodash_1.default.isString(property)) {
+            this._data[section] = property;
+            this._writeConfig();
+            return;
+        }
+        this.section(section)[property] = value;
+        this._writeConfig();
+    }
+    get(section, property, defaultValue) {
+        if (!property) {
+            return this.section(section);
+        }
+        if (!this.contains(section, property)) {
+            return defaultValue;
+        }
+        return this.section(section)[property];
+    }
+    contains(section, property) {
+        if (!this._data[section]) {
+            return false;
+        }
+        return this._data[section].hasOwnProperty(property);
+    }
+    ensure(section, property, value) {
+        if (this.contains(section, property)) {
+            return this.get(section, property);
+        }
+        let out = value;
+        if (typeof value === 'function') {
+            out = value();
+        }
+        this.put(section, property, out);
+        return out;
+    }
+}
+exports.storageService = new StorageService();

package/dist/esm/src/taskManager.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { LogLevel } from './types';
+export type TaskRunner<T> = (task: Task<T>) => Promise<T>;
+export declare 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 declare class Task<T = void> implements TaskData<T> {
+    private data;
+    constructor(task: TaskData<T>);
+    get id(): string;
+    get status(): TaskStatus;
+    get errorMessage(): string | undefined;
+    get metadata(): TaskMetadata;
+    get future(): Future<T>;
+    get run(): TaskRunner<T>;
+    set status(status: TaskStatus);
+    set errorMessage(errorMessage: string | undefined);
+    set metadata(metadata: TaskMetadata);
+    emitUpdate(): void;
+    addLog(log: string, level?: LogLevel): void;
+    wait(): Promise<T>;
+    toData(): {
+        id: string;
+        status: TaskStatus;
+        errorMessage?: string | undefined;
+        metadata: TaskMetadata;
+        future: Future<T>;
+        run: TaskRunner<T>;
+    };
+}
+declare class TaskManager {
+    private _tasks;
+    add<T>(id: string, runner: TaskRunner<T>, metadata: TaskMetadata): Task<T>;
+    waitFor(filter: (task: Task<any>) => boolean): Promise<void>;
+    get(taskId: string): Task<any> | undefined;
+    exists(taskId: string): boolean;
+    remove(taskId: string): void;
+    list(): TaskData[];
+    private invokeTask;
+}
+export declare const taskManager: TaskManager;
+export {};

package/dist/esm/src/taskManager.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskManager = exports.Task = exports.TaskStatus = void 0;
+/**
+ * Class that handles processing background tasks.
+ */
+const socketManager_1 = require("./socketManager");
+const EVENT_TASK_UPDATED = 'task-updated';
+const EVENT_TASK_ADDED = 'task-added';
+const EVENT_TASK_REMOVED = 'task-removed';
+const EVENT_TASK_LOG = 'task-log';
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["PENDING"] = "PENDING";
+    TaskStatus["RUNNING"] = "RUNNING";
+    TaskStatus["COMPLETED"] = "COMPLETED";
+    TaskStatus["FAILED"] = "FAILED";
+})(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
+class Task {
+    data;
+    constructor(task) {
+        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) {
+        this.data.status = status;
+    }
+    set errorMessage(errorMessage) {
+        this.data.errorMessage = errorMessage;
+    }
+    set metadata(metadata) {
+        this.data.metadata = metadata;
+    }
+    emitUpdate() {
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_UPDATED, this.toData());
+    }
+    addLog(log, level = 'INFO') {
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_LOG, {
+            id: this.id,
+            message: log,
+            level,
+            time: Date.now(),
+        });
+    }
+    async wait() {
+        return this.future.promise;
+    }
+    toData() {
+        return { ...this.data };
+    }
+}
+exports.Task = Task;
+function createFuture() {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    // Ignore unhandled promise rejections
+    promise.catch(() => { });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+class TaskManager {
+    _tasks = [];
+    add(id, runner, metadata) {
+        const existingTask = this.get(id);
+        if (existingTask) {
+            return existingTask;
+        }
+        const future = createFuture();
+        const task = new Task({
+            id,
+            status: TaskStatus.PENDING,
+            metadata,
+            future,
+            run: runner,
+        });
+        this._tasks.push(task);
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_ADDED, task.toData());
+        this.invokeTask(task).catch((err) => {
+            console.warn(`Task ${task.id} failed`, err);
+        });
+        return task;
+    }
+    async waitFor(filter) {
+        const tasks = this._tasks.filter(filter);
+        while (tasks.length > 0) {
+            const task = tasks.shift();
+            if (!task) {
+                continue;
+            }
+            try {
+                await task.wait();
+            }
+            catch (e) {
+                //Ignore
+            }
+        }
+    }
+    get(taskId) {
+        return this._tasks.find((t) => t.id === taskId);
+    }
+    exists(taskId) {
+        return !!this.get(taskId);
+    }
+    remove(taskId) {
+        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_1.socketManager.emitGlobal(EVENT_TASK_REMOVED, task.toData());
+    }
+    list() {
+        return this._tasks.map((t) => t.toData());
+    }
+    async invokeTask(task) {
+        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) {
+                return;
+            }
+        }
+        const startTime = Date.now();
+        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) {
+            console.warn(`Task ${task.id} failed while waiting for it to resolve`, e);
+            task.errorMessage = e.message;
+            task.status = TaskStatus.FAILED;
+            task.future.reject(e);
+            task.emitUpdate();
+        }
+        finally {
+            this.remove(task.id);
+            console.log(`Task ${task.id} completed in ${Date.now() - startTime}ms`);
+        }
+        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) {
+                return this.invokeTask(nextTaskInGroup);
+            }
+        }
+    }
+}
+exports.taskManager = new TaskManager();

package/dist/esm/src/tasks/routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/esm/src/tasks/routes.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const cors_1 = require("../middleware/cors");
+const taskManager_1 = require("../taskManager");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+/**
+ * Get all current tasks
+ */
+router.get('/', (req, res) => {
+    res.send(taskManager_1.taskManager.list());
+});
+router.get('/:taskId', (req, res) => {
+    const task = taskManager_1.taskManager.get(req.params.taskId);
+    if (!task) {
+        res.status(404).send({ error: 'Task not found' });
+        return;
+    }
+    res.send(task.toData());
+});
+router.delete('/:taskId', (req, res) => {
+    try {
+        taskManager_1.taskManager.remove(req.params.taskId);
+        res.send({ ok: true });
+    }
+    catch (e) {
+        res.status(400).send({ error: e.message });
+        return;
+    }
+});
+exports.default = router;

package/dist/esm/src/traffic/routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/esm/src/traffic/routes.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const networkManager_1 = require("../networkManager");
+const router = (0, express_promise_router_1.default)();
+router.get('/:systemId/target/:connectionId/', (req, res) => {
+    res.send(networkManager_1.networkManager.getTrafficForConnection(req.params.systemId, req.params.connectionId));
+});
+router.get('/:systemId/source/:blockInstanceId/', (req, res) => {
+    res.send(networkManager_1.networkManager.getTrafficForSource(req.params.systemId, req.params.blockInstanceId));
+});
+router.get('/:systemId/target/:blockInstanceId/', (req, res) => {
+    res.send(networkManager_1.networkManager.getTrafficForTarget(req.params.systemId, req.params.blockInstanceId));
+});
+exports.default = router;

package/dist/esm/src/types.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import express from 'express';
+import { Connection, Resource } from '@kapeta/schemas';
+import { StringBodyRequest } from './middleware/stringBody';
+import { KapetaRequest } from './middleware/kapeta';
+export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
+export declare const KIND_BLOCK_TYPE = "core/block-type";
+export declare const KIND_BLOCK_TYPE_OPERATOR = "core/block-type-operator";
+export declare const KIND_BLOCK_TYPE_EXECUTABLE = "core/block-type-executable";
+export type StringMap = {
+    [key: string]: string;
+};
+export type AnyMap = {
+    [key: string]: any;
+};
+export type SourceOfChange = 'user' | 'filesystem';
+export type WatchEventName = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
+export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE' | 'FATAL';
+export type LogSource = 'stdout' | 'stderr';
+export type EnvironmentType = 'docker' | 'process';
+export declare const DOCKER_HOST_INTERNAL = "host.docker.internal";
+export interface LogEntry {
+    source: LogSource;
+    level: LogLevel;
+    message: string;
+    time: number;
+}
+export interface BlockProcessParams {
+    id: string;
+    ref: string;
+    configuration?: AnyMap;
+}
+export declare enum InstanceType {
+    DOCKER = "docker",
+    LOCAL = "local",
+    UNKNOWN = "unknown"
+}
+export declare enum InstanceOwner {
+    INTERNAL = "internal",
+    EXTERNAL = "external"
+}
+export declare enum InstanceStatus {
+    STOPPED = "stopped",
+    STARTING = "starting",
+    BUSY = "busy",
+    READY = "ready",
+    STOPPING = "stopping",
+    UNHEALTHY = "unhealthy",
+    FAILED = "failed"
+}
+export declare enum DesiredInstanceStatus {
+    STOP = "stop",
+    RUN = "run",
+    EXTERNAL = "external"
+}
+export type ProcessInfo = {
+    type: InstanceType;
+    pid?: number | string | null;
+    portType?: string;
+};
+export type InstanceInfo = {
+    systemId: string;
+    instanceId: string;
+    ref: string;
+    name: string;
+    type: InstanceType;
+    owner: InstanceOwner;
+    status: InstanceStatus;
+    errorMessage?: string;
+    desiredStatus: DesiredInstanceStatus;
+    address?: string;
+    startedAt?: number;
+    health?: string | null;
+    pid?: number | string | null;
+    portType?: string;
+};
+export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
+export interface ProxyRequestInfo {
+    address: string;
+    connection: Connection;
+    providerResource: Resource;
+    consumerResource: Resource;
+    consumerPath: string;
+}
+export interface SimpleResponse {
+    code: number;
+    headers: StringMap;
+    body: any;
+}
+export interface SimpleRequest {
+    method: string;
+    url: string;
+    headers: StringMap;
+    body: any;
+}
+export type KapetaBodyRequest = KapetaRequest & StringBodyRequest;