verteilen-core 1.2.4 → 1.2.7

package/dist/script/execute_manager.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteManager = void 0;
+const interface_1 = require("../interface");
+const runner_1 = require("./execute/runner");
+class ExecuteManager extends runner_1.ExecuteManager_Runner {
+    Update = () => {
+        if (this.state != interface_1.ExecuteState.RUNNING)
+            return;
+        else if (this.current_p == undefined && this.current_projects.length > 0) {
+            this.current_p = this.current_projects[0];
+            this.messager_log(`[Execute] Project Start ${this.current_p.uuid}`);
+            this.proxy?.executeProjectStart([this.current_p, 0]);
+            this.SyncDatabase(this.current_p);
+        }
+        else if (this.current_p != undefined) {
+            if (this.first)
+                this.first = false;
+            this.ExecuteProject(this.current_p);
+        }
+    };
+    Stop = () => {
+        this.current_nodes.forEach(x => {
+            const h = {
+                name: 'stop_job',
+                message: 'Stop All Jobs',
+                data: {}
+            };
+            x.websocket.send(JSON.stringify(h));
+        });
+        this.jobstack = 0;
+        this.current_nodes.forEach(x => x.current_job = []);
+    };
+    Register = (lib) => {
+        this.current_projects = this.record.projects;
+        this.current_nodes = [];
+        this.record.nodes.forEach(x => {
+            const n = this.websocket_manager.targets.find(y => y.uuid == x.uuid);
+            if (n != undefined)
+                this.current_nodes.push(n);
+        });
+        this.messager_log(`[Execute] Start executing, Project count: ${this.current_projects.length}, Node count: ${this.current_nodes.length}`);
+        if (this.state == interface_1.ExecuteState.RUNNING) {
+            this.messager_log(`[Execute] Init error, There are projects being execute right now`);
+            return -1;
+        }
+        if (this.current_nodes.length == 0) {
+            this.messager_log(`[Execute] Node count should be bigger than one`);
+            return -1;
+        }
+        if (this.current_projects.map(x => x.task.length).reduce((acc, cur) => acc + cur, 0) == 0) {
+            this.messager_log(`[Execute] No task can be executing`);
+            return -1;
+        }
+        if (!this.validation(this.current_projects)) {
+            this.messager_log(`[Execute] Init failed, Format checking error`);
+            return -1;
+        }
+        if (lib != undefined)
+            this.libs = this.filter_lib(this.record.projects, lib);
+        else
+            this.libs = { libs: [] };
+        this.state = interface_1.ExecuteState.RUNNING;
+        this.messager_log(`[Execute] Init successfully, Enter process right now, length: ${this.current_projects.length}`);
+        let i = 0;
+        for (const x of this.current_projects) {
+            if (x.task.length > 0) {
+                break;
+            }
+            else {
+                i++;
+            }
+        }
+        return i;
+    };
+    Clean = () => {
+        this.current_projects = [];
+        this.current_p = undefined;
+        this.current_t = undefined;
+        this.current_cron = [];
+        this.current_job = [];
+        this.current_nodes = [];
+        this.current_multithread = 1;
+        this.state = interface_1.ExecuteState.NONE;
+    };
+    Release = () => {
+        this.current_nodes.forEach(x => this.release(x));
+    };
+    NewConnection = (source) => {
+        if (this.state == interface_1.ExecuteState.RUNNING && this.localPara != undefined) {
+            this.sync_para(this.localPara, source);
+        }
+    };
+    Disconnect = (source) => {
+        if (this.current_p == undefined)
+            return;
+        if (this.current_t == undefined)
+            return;
+        if (this.current_job.length > 0) {
+            const singleContainIt = this.current_job.filter(x => x.uuid == source.uuid && x.state == interface_1.ExecuteState.RUNNING);
+            singleContainIt.forEach((x, index) => {
+                x.uuid = '';
+                x.state = interface_1.ExecuteState.NONE;
+            });
+            this.proxy?.executeSubtaskUpdate([this.current_t, 0, '', interface_1.ExecuteState.NONE]);
+        }
+        else if (this.current_cron.length > 0) {
+            const cronContainIt = this.current_cron.filter(x => x.work.filter(y => y.state == interface_1.ExecuteState.RUNNING && y.uuid == source.uuid).length > 0);
+            cronContainIt.forEach(element => {
+                element.work.forEach(x => {
+                    x.uuid = '';
+                    x.state = interface_1.ExecuteState.NONE;
+                });
+                this.proxy?.executeSubtaskUpdate([this.current_t, element.id - 1, '', interface_1.ExecuteState.NONE]);
+            });
+        }
+        source.current_job = [];
+    };
+    ClearState = (task_index) => {
+        if (this.current_p == undefined)
+            return;
+        if (this.current_t == undefined)
+            return;
+        if (this.current_job.length > 0) {
+            this.current_job = [];
+            this.proxy?.executeSubtaskUpdate([this.current_t, 0, '', interface_1.ExecuteState.NONE]);
+        }
+        else if (this.current_cron.length > 0) {
+            const target = this.current_cron[task_index];
+            target.work.forEach(x => {
+                x.uuid = '';
+                x.state = interface_1.ExecuteState.NONE;
+            });
+            this.proxy?.executeSubtaskUpdate([this.current_t, target.id - 1, '', interface_1.ExecuteState.NONE]);
+        }
+    };
+    SkipProject = () => {
+        return this.jumpProject(true);
+    };
+    PreviousProject = () => {
+        return this.jumpProject(false);
+    };
+    SkipTask = () => {
+        return this.jumpTask(true);
+    };
+    PreviousTask = () => {
+        return this.jumpTask(false);
+    };
+    SkipSubTask = (v) => {
+        if (this.current_p == undefined) {
+            console.error("No project exist, Skip failed");
+            return -2;
+        }
+        if (this.current_t == undefined) {
+            console.error("Project has no task, Skip failed");
+            return -2;
+        }
+        else {
+            if (!this.current_t.cronjob) {
+                return this.SkipTask();
+            }
+            const min = Math.min(v, this.current_cron.length);
+            for (let i = 0; i < min; i++) {
+                const ps = this.current_cron[i].work.filter(y => y.state != interface_1.ExecuteState.FINISH && y.state != interface_1.ExecuteState.ERROR);
+                ps.forEach(x => x.state = interface_1.ExecuteState.FINISH);
+            }
+            return min;
+        }
+    };
+    jumpProject = (forward) => {
+        if (this.current_projects.length == 0) {
+            console.error("There is no project exists");
+            return -2;
+        }
+        if (this.current_p == undefined) {
+            return forward ? this.skipProjectFirst() : -2;
+        }
+        else {
+            return this._jumpProject(forward);
+        }
+    };
+    jumpTask = (forward) => {
+        if (this.current_p == undefined)
+            return -2;
+        if (this.current_t == undefined) {
+            return forward ? this.skipTaskFirst() : this.previousTaskFirst();
+        }
+        else {
+            return forward ? this.skipTask() : this.previousTask();
+        }
+    };
+    skipProjectFirst = () => {
+        this.current_p = this.current_projects[1];
+        this.proxy?.executeProjectStart([this.current_p, 1]);
+        this.SyncDatabase(this.current_p);
+        this.state = interface_1.ExecuteState.RUNNING;
+        return 1;
+    };
+    _jumpProject = (forward) => {
+        const index = this.current_projects.findIndex(x => x.uuid == this.current_p.uuid);
+        if (forward)
+            this.proxy?.executeProjectFinish([this.current_p, index]);
+        const atend = forward ? index == this.current_projects.length - 1 : index == 0;
+        if (atend) {
+            if (forward) {
+                this.current_p = undefined;
+                this.current_t = undefined;
+                this.state = interface_1.ExecuteState.FINISH;
+                this.messager_log(`[Execute] Skip project to Finish !`);
+            }
+            else {
+                this.current_p = this.current_projects[0];
+                this.current_t = undefined;
+                this.state = interface_1.ExecuteState.RUNNING;
+                this.messager_log(`[Execute] Previous project to Begining !`);
+            }
+            return -1;
+        }
+        else {
+            const next = forward ? this.current_projects[index + 1] : this.current_projects[index - 1];
+            this.current_p = next;
+            this.current_t = undefined;
+            this.state = interface_1.ExecuteState.RUNNING;
+            if (forward) {
+                this.messager_log(`[Execute] Skip project ${index}. ${this.current_p.uuid}`);
+            }
+            else {
+                this.messager_log(`[Execute] Previous project ${index}. ${this.current_p.uuid}`);
+            }
+            this.proxy?.executeProjectStart([this.current_p, index + (forward ? 1 : -1)]);
+            this.SyncDatabase(this.current_p);
+            return index;
+        }
+    };
+    skipTaskFirst = () => {
+        if (this.current_p.task.length > 0) {
+            this.current_t = this.current_p.task[0];
+            const taskCount = this.get_task_state_count(this.current_t);
+            if (this.current_t.cronjob) {
+                this.Init_CronContainer(this.current_t, taskCount);
+            }
+            this.t_state = interface_1.ExecuteState.NONE;
+            this.proxy?.executeTaskStart([this.current_t, taskCount]);
+            return 0;
+        }
+        else {
+            console.error("Project has no task, Skip failed");
+            return -2;
+        }
+    };
+    previousTaskFirst = () => {
+        const index = this.current_projects.findIndex(x => x.uuid == this.current_p.uuid);
+        if (index == 0) {
+            this.current_t = undefined;
+        }
+        else {
+            this.current_p = this.current_projects[index - 1];
+            this.messager_log(`[Execute] Previous task ${index}. Jump Project: ${this.current_p.uuid}`);
+        }
+        this.current_job = [];
+        this.t_state = interface_1.ExecuteState.NONE;
+        return index;
+    };
+    skipTask = () => {
+        const index = this.current_p.task.findIndex(x => x.uuid == this.current_t.uuid);
+        if (index == this.current_p.task.length - 1) {
+            this.proxy?.executeTaskFinish(this.current_t);
+            this.current_t = undefined;
+            this.messager_log(`[Execute] Skip task to Finish !`);
+        }
+        else {
+            this.proxy?.executeTaskFinish(this.current_t);
+            this.current_t = this.current_p.task[index + 1];
+            this.messager_log(`[Execute] Skip task ${index}. ${this.current_t.uuid}`);
+            const taskCount = this.get_task_state_count(this.current_t);
+            if (this.current_t.cronjob) {
+                this.Init_CronContainer(this.current_t, taskCount);
+            }
+            this.proxy?.executeTaskStart([this.current_t, taskCount]);
+        }
+        this.current_job = [];
+        this.t_state = interface_1.ExecuteState.NONE;
+        return index;
+    };
+    previousTask = () => {
+        const index = this.current_p.task.findIndex(x => x.uuid == this.current_t.uuid);
+        this.current_t = this.current_p.task[index - 1];
+        const taskCount = this.get_task_state_count(this.current_t);
+        if (this.current_t.cronjob) {
+            this.Init_CronContainer(this.current_t, taskCount);
+        }
+        this.t_state = interface_1.ExecuteState.NONE;
+        this.proxy?.executeTaskStart([this.current_t, taskCount]);
+        return 0;
+    };
+}
+exports.ExecuteManager = ExecuteManager;

package/dist/script/socket_manager.d.ts

@@ -0,0 +1,31 @@
+import { Node, NodeProxy, NodeTable, WebsocketPack } from "../interface";
+import * as ws from 'ws';
+export declare class WebsocketManager {
+    targets: Array<WebsocketPack>;
+    newConnect: Function;
+    disconnect: Function;
+    onAnalysis: Function;
+    proxy: NodeProxy;
+    private messager_log;
+    constructor(_newConnect: Function, _disconnect: Function, _onAnalysis: Function, _messager_log: Function, _proxy: NodeProxy);
+    server_start: (url: string, id: string) => WebSocket | ws.WebSocket | undefined;
+    server_stop: (uuid: string, reason?: string) => void;
+    server_update: () => Array<NodeTable>;
+    server_record: (ns: Array<Node>) => void;
+    shell_open: (uuid: string) => void;
+    shell_enter: (uuid: string, text: string) => void;
+    shell_close: (uuid: string) => void;
+    shell_folder: (uuid: string, path: string) => void;
+    private serverconnect;
+    private analysis;
+    private socket_analysis;
+    private sendUpdate;
+    private removeByUUID;
+    private update;
+    private shell_reply;
+    private shell_folder_reply;
+    private system_info;
+    private node_info;
+    private pong;
+    private plugin_info_reply;
+}

package/dist/script/socket_manager.js

@@ -0,0 +1,263 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketManager = void 0;
+const uuid_1 = require("uuid");
+const interface_1 = require("../interface");
+const jsEnv = __importStar(require("browser-or-node"));
+const ws = __importStar(require("ws"));
+const https = __importStar(require("https"));
+function isRenderer() {
+    if (typeof process === 'undefined')
+        return true;
+    if (!process)
+        return true;
+    if (!process.type)
+        return false;
+    return process.type === 'renderer';
+}
+console.log("isRenderer", isRenderer());
+class WebsocketManager {
+    targets = [];
+    newConnect;
+    disconnect;
+    onAnalysis;
+    proxy;
+    messager_log;
+    constructor(_newConnect, _disconnect, _onAnalysis, _messager_log, _proxy) {
+        this.newConnect = _newConnect;
+        this.disconnect = _disconnect;
+        this.onAnalysis = _onAnalysis;
+        this.messager_log = _messager_log;
+        this.proxy = _proxy;
+        setInterval(this.update, 1000);
+    }
+    server_start = (url, id) => this.serverconnect(url, id);
+    server_stop = (uuid, reason) => this.removeByUUID(uuid, reason);
+    server_update = () => this.sendUpdate();
+    server_record = (ns) => {
+        ns.forEach(x => {
+            this.serverconnect(x.url, x.uuid);
+        });
+    };
+    shell_open = (uuid) => {
+        const p = this.targets.find(x => x.uuid == uuid && x.websocket.readyState == interface_1.SocketState.OPEN);
+        if (p == undefined) {
+            this.messager_log(`[Shell] Error cannot find the node by ID: ${uuid}`);
+            return;
+        }
+        const d = {
+            name: "open_shell",
+            data: 0
+        };
+        p.websocket.send(JSON.stringify(d));
+    };
+    shell_enter = (uuid, text) => {
+        const p = this.targets.find(x => x.uuid == uuid && x.websocket.readyState == interface_1.SocketState.OPEN);
+        if (p == undefined) {
+            this.messager_log(`[Shell] Error cannot find the node by ID: ${uuid}`);
+            return;
+        }
+        const d = {
+            name: "enter_shell",
+            data: text
+        };
+        p.websocket.send(JSON.stringify(d));
+    };
+    shell_close = (uuid) => {
+        const p = this.targets.find(x => x.uuid == uuid && x.websocket.readyState == interface_1.SocketState.OPEN);
+        if (p == undefined) {
+            this.messager_log(`[Shell] Error cannot find the node by ID: ${uuid}`);
+            return;
+        }
+        const d = {
+            name: "close_shell",
+            data: 0
+        };
+        p.websocket.send(JSON.stringify(d));
+    };
+    shell_folder = (uuid, path) => {
+        const p = this.targets.find(x => x.uuid == uuid && x.websocket.readyState == interface_1.SocketState.OPEN);
+        if (p == undefined) {
+            this.messager_log(`[Shell] Error cannot find the node by ID: ${uuid}`);
+            return;
+        }
+        const d = {
+            name: "shell_folder",
+            data: path
+        };
+        p.websocket.send(JSON.stringify(d));
+    };
+    serverconnect = (url, uuid) => {
+        if (this.targets.findIndex(x => x.websocket.url.slice(0, -1) == url) != -1)
+            return;
+        if (this.targets.findIndex(x => x.uuid == uuid) != -1)
+            return;
+        let client = undefined;
+        if (jsEnv.isNode)
+            client = new ws.WebSocket(url, { agent: new https.Agent(), rejectUnauthorized: false });
+        else
+            client = new WebSocket(url);
+        const t = { uuid: (uuid == undefined ? (0, uuid_1.v6)() : uuid), websocket: client, current_job: [] };
+        this.targets.push(t);
+        client.onerror = (err) => {
+            this.messager_log(`[Socket] Connect failed ${url} ${err.message}`);
+        };
+        client.onclose = (ev) => {
+            if (t.s != undefined) {
+                this.messager_log(`[Socket] Client close connection, ${ev.code}, ${ev.reason}`);
+                this.disconnect(t);
+            }
+            t.s = undefined;
+            t.current_job = [];
+        };
+        client.onopen = () => {
+            this.messager_log('[Socket] New Connection !' + client.url);
+            if (t.s == undefined) {
+                t.s = true;
+            }
+            this.sendUpdate();
+            this.newConnect(t);
+        };
+        client.onmessage = (ev) => {
+            const h = JSON.parse(ev.data.toString());
+            const c = this.targets.find(x => x.uuid == uuid);
+            this.analysis(h, c);
+        };
+        return client;
+    };
+    analysis = (h, c) => {
+        if (h == undefined) {
+            this.messager_log('[Source Analysis] Decode failed, Get value undefined');
+            return;
+        }
+        if (h.message != undefined && h.message.length > 0) {
+            this.messager_log(`[Source Analysis] ${h.message}`);
+        }
+        if (h.data == undefined)
+            return;
+        const d = { name: h.name, h: h, c: c };
+        const pass = this.socket_analysis(d);
+        if (!pass)
+            this.onAnalysis(d);
+    };
+    socket_analysis = (d) => {
+        const typeMap = {
+            'system_info': this.system_info,
+            'shell_reply': this.shell_reply,
+            'shell_folder_reply': this.shell_folder_reply,
+            'node_info': this.node_info,
+            'pong': this.pong,
+            'plugin_info_reply': this.plugin_info_reply,
+        };
+        if (typeMap.hasOwnProperty(d.name)) {
+            const castingFunc = typeMap[d.h.name];
+            castingFunc(d.h.data, d.c, d.h.meta);
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    sendUpdate = () => {
+        let result = [];
+        const data = [];
+        this.targets.forEach(x => {
+            if (x.websocket.readyState == interface_1.SocketState.CLOSED) {
+                data.push({ uuid: x.uuid, url: x.websocket.url });
+            }
+        });
+        data.forEach(d => this.removeByUUID(d.uuid));
+        data.forEach(d => {
+            this.serverconnect(d.url, d.uuid);
+        });
+        result = this.targets.map(x => {
+            return {
+                s: false,
+                uuid: x.uuid,
+                state: x.websocket.readyState,
+                url: x.websocket.url,
+                connection_rate: x.ms,
+                system: x.information,
+                plugins: x.plugins
+            };
+        });
+        return result;
+    };
+    removeByUUID = (uuid, reason) => {
+        let index = this.targets.findIndex(x => x.uuid == uuid);
+        if (index != -1) {
+            if (this.targets[index].websocket.readyState == interface_1.SocketState.OPEN)
+                this.targets[index].websocket.close(1000, reason != undefined ? reason : '');
+            this.targets.splice(index, 1);
+        }
+    };
+    update = () => {
+        const h = { name: 'ping', data: 0 };
+        this.targets.forEach(x => {
+            if (x.websocket.readyState != interface_1.SocketState.OPEN)
+                return;
+            x.last = Date.now();
+            x.websocket.send(JSON.stringify(h));
+        });
+    };
+    shell_reply = (data, w) => {
+        this.proxy?.shellReply(data, w);
+    };
+    shell_folder_reply = (data, w) => {
+        this.proxy?.folderReply(data, w);
+    };
+    system_info = (info, source) => {
+        if (source == undefined)
+            return;
+        source.information = info;
+    };
+    node_info = (info, source) => {
+        if (source == undefined)
+            return;
+        source.load = info;
+    };
+    pong = (info, source) => {
+        if (source == undefined || source.last == undefined)
+            return;
+        source.ms = Date.now() - source.last;
+    };
+    plugin_info_reply = (data, source) => {
+        if (source == undefined || source.last == undefined)
+            return;
+        source.plugins = data;
+    };
+}
+exports.WebsocketManager = WebsocketManager;

package/dist/script/webhook_manager.d.ts

@@ -0,0 +1,3 @@
+export declare class WebhookManager {
+    constructor(server_url: string);
+}

package/dist/script/webhook_server_manager.d.ts

@@ -0,0 +1,13 @@
+import { Messager, Messager_log } from '../interface';
+export declare class WebhookServerManager {
+    private httpss;
+    private server;
+    private sources;
+    private messager;
+    private messager_log;
+    constructor(_messager: Messager, _messager_log: Messager_log);
+    Init: () => Promise<void>;
+    Destroy: () => void;
+    Release: () => void;
+    private get_pem;
+}