verteilen-core 1.2.4 → 1.2.6

package/dist/src/script/socket_manager.js

@@ -50,211 +50,214 @@ function isRenderer() {
 }
 console.log("isRenderer", isRenderer());
 class WebsocketManager {
+    targets = [];
+    newConnect;
+    disconnect;
+    onAnalysis;
+    proxy;
+    messager_log;
     constructor(_newConnect, _disconnect, _onAnalysis, _messager_log, _proxy) {
-        this.targets = [];
-        this.server_start = (url, id) => this.serverconnect(url, id);
-        this.server_stop = (uuid, reason) => this.removeByUUID(uuid, reason);
-        this.server_update = () => this.sendUpdate();
-        this.server_record = (ns) => {
-            ns.forEach(x => {
-                this.serverconnect(x.url, x.uuid);
-            });
-        };
-        this.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));
-        };
-        this.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));
+        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
         };
-        this.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));
+        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
         };
-        this.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));
+        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
         };
-        this.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;
+        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
         };
-        this.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);
+        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}`);
         };
-        this.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;
+        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 = [];
         };
-        this.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;
-        };
-        this.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);
+        client.onopen = () => {
+            this.messager_log('[Socket] New Connection !' + client.url);
+            if (t.s == undefined) {
+                t.s = true;
             }
+            this.sendUpdate();
+            this.newConnect(t);
         };
-        this.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));
-            });
-        };
-        this.shell_reply = (data, w) => {
-            var _a;
-            (_a = this.proxy) === null || _a === void 0 ? void 0 : _a.shellReply(data, w);
+        client.onmessage = (ev) => {
+            const h = JSON.parse(ev.data.toString());
+            const c = this.targets.find(x => x.uuid == uuid);
+            this.analysis(h, c);
         };
-        this.shell_folder_reply = (data, w) => {
-            var _a;
-            (_a = this.proxy) === null || _a === void 0 ? void 0 : _a.folderReply(data, w);
-        };
-        this.system_info = (info, source) => {
-            if (source == undefined)
-                return;
-            source.information = info;
-        };
-        this.node_info = (info, source) => {
-            if (source == undefined)
-                return;
-            source.load = info;
-        };
-        this.pong = (info, source) => {
-            if (source == undefined || source.last == undefined)
-                return;
-            source.ms = Date.now() - source.last;
+        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,
         };
-        this.plugin_info_reply = (data, source) => {
-            if (source == undefined || source.last == undefined)
+        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;
-            source.plugins = data;
-        };
-        this.newConnect = _newConnect;
-        this.disconnect = _disconnect;
-        this.onAnalysis = _onAnalysis;
-        this.messager_log = _messager_log;
-        this.proxy = _proxy;
-        setInterval(this.update, 1000);
-    }
+            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/src/script/webhook_manager.d.ts

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

package/dist/src/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;
+}

package/dist/src/script/webhook_server_manager.js

@@ -32,15 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhookServerManager = void 0;
 const path = __importStar(require("path"));
@@ -52,89 +43,91 @@ const interface_1 = require("../interface");
 const tcp_port_used_1 = require("tcp-port-used");
 const fs_1 = require("fs");
 class WebhookServerManager {
+    httpss = undefined;
+    server = undefined;
+    sources = [];
+    messager;
+    messager_log;
     constructor(_messager, _messager_log) {
-        this.httpss = undefined;
-        this.server = undefined;
-        this.sources = [];
-        this.Init = () => __awaiter(this, void 0, void 0, function* () {
-            let port_result = interface_1.WebHookPORT;
-            let canbeuse = false;
-            while (!canbeuse) {
-                yield (0, tcp_port_used_1.check)(port_result).then(x => {
-                    canbeuse = !x;
-                }).catch(err => {
-                    canbeuse = true;
-                });
-                if (!canbeuse)
-                    port_result += 1;
-            }
-            const pems = yield this.get_pem();
-            this.httpss = https.createServer({ key: pems[0], cert: pems[1], minVersion: 'TLSv1.2', maxVersion: 'TLSv1.3' }, (req, res) => {
-                res.writeHead(200);
-                res.end('HTTPS server is running');
-            });
-            this.httpss.addListener('upgrade', (req, res, head) => console.log('UPGRADE:', req.url));
-            this.server = new ws.Server({ server: this.httpss });
-            this.server.on('listening', () => {
-                this.messager_log('[Server] Listen PORT: ' + port_result.toString());
+        this.messager = _messager;
+        this.messager_log = _messager_log;
+    }
+    Init = async () => {
+        let port_result = interface_1.WebHookPORT;
+        let canbeuse = false;
+        while (!canbeuse) {
+            await (0, tcp_port_used_1.check)(port_result).then(x => {
+                canbeuse = !x;
+            }).catch(err => {
+                canbeuse = true;
             });
-            this.server.on('error', (err) => {
-                this.messager_log(`[Server] Error ${err.name}\n\t${err.message}\n\t${err.stack}`);
+            if (!canbeuse)
+                port_result += 1;
+        }
+        const pems = await this.get_pem();
+        this.httpss = https.createServer({ key: pems[0], cert: pems[1], minVersion: 'TLSv1.2', maxVersion: 'TLSv1.3' }, (req, res) => {
+            res.writeHead(200);
+            res.end('HTTPS server is running');
+        });
+        this.httpss.addListener('upgrade', (req, res, head) => console.log('UPGRADE:', req.url));
+        this.server = new ws.Server({ server: this.httpss });
+        this.server.on('listening', () => {
+            this.messager_log('[Server] Listen PORT: ' + port_result.toString());
+        });
+        this.server.on('error', (err) => {
+            this.messager_log(`[Server] Error ${err.name}\n\t${err.message}\n\t${err.stack}`);
+        });
+        this.server.on('close', () => {
+            this.messager_log('[Server] Close !');
+            this.Release();
+        });
+        this.server.on('connection', (ws, request) => {
+            this.messager_log(`[Server] New Connection detected, ${ws.url}`);
+            ws.on('close', (code, reason) => {
+                this.messager_log(`[Source] Close ${code} ${reason}`);
             });
-            this.server.on('close', () => {
-                this.messager_log('[Server] Close !');
-                this.Release();
+            ws.on('error', (err) => {
+                this.messager_log(`[Source] Error ${err.name}\n\t${err.message}\n\t${err.stack}`);
             });
-            this.server.on('connection', (ws, request) => {
-                this.messager_log(`[Server] New Connection detected, ${ws.url}`);
-                ws.on('close', (code, reason) => {
-                    this.messager_log(`[Source] Close ${code} ${reason}`);
-                });
-                ws.on('error', (err) => {
-                    this.messager_log(`[Source] Error ${err.name}\n\t${err.message}\n\t${err.stack}`);
-                });
-                ws.on('open', () => {
-                    this.messager_log(`[Source] New source is connected, URL: ${ws === null || ws === void 0 ? void 0 : ws.url}`);
-                });
-                ws.on('message', (data, isBinery) => {
-                    const h = JSON.parse(data.toString());
-                });
+            ws.on('open', () => {
+                this.messager_log(`[Source] New source is connected, URL: ${ws?.url}`);
             });
-            this.httpss.listen(port_result, () => {
-                this.messager_log('[Server] Select Port: ' + port_result.toString());
+            ws.on('message', (data, isBinery) => {
+                const h = JSON.parse(data.toString());
             });
         });
-        this.Destroy = () => {
-            if (this.server == undefined)
-                return;
-            this.server.close((err) => {
-                this.messager_log(`[Client] Close error ${err}`);
-            });
-            this.Release();
-        };
-        this.Release = () => {
-        };
-        this.get_pem = () => {
-            return new Promise((resolve) => {
-                const pemFolder = path.join(os.homedir(), interface_1.DATA_FOLDER, 'pem');
-                if (!(0, fs_1.existsSync)(pemFolder))
-                    (0, fs_1.mkdirSync)(pemFolder);
-                const clientKey = path.join(pemFolder, "cluster_clientkey.pem");
-                const certificate = path.join(pemFolder, "cluster_certificate.pem");
-                if (!(0, fs_1.existsSync)(clientKey) || !(0, fs_1.existsSync)(certificate)) {
-                    pem.createCertificate({ selfSigned: true }, (err, keys) => {
-                        (0, fs_1.writeFileSync)(clientKey, keys.clientKey, { encoding: 'utf8' });
-                        (0, fs_1.writeFileSync)(certificate, keys.certificate, { encoding: 'utf8' });
-                        resolve([keys.clientKey, keys.certificate]);
-                    });
-                }
-                else {
-                    resolve([(0, fs_1.readFileSync)(clientKey, 'utf8').toString(), (0, fs_1.readFileSync)(certificate, 'utf8').toString()]);
-                }
-            });
-        };
-        this.messager = _messager;
-        this.messager_log = _messager_log;
-    }
+        this.httpss.listen(port_result, () => {
+            this.messager_log('[Server] Select Port: ' + port_result.toString());
+        });
+    };
+    Destroy = () => {
+        if (this.server == undefined)
+            return;
+        this.server.close((err) => {
+            this.messager_log(`[Client] Close error ${err}`);
+        });
+        this.Release();
+    };
+    Release = () => {
+    };
+    get_pem = () => {
+        return new Promise((resolve) => {
+            const pemFolder = path.join(os.homedir(), interface_1.DATA_FOLDER, 'pem');
+            if (!(0, fs_1.existsSync)(pemFolder))
+                (0, fs_1.mkdirSync)(pemFolder);
+            const clientKey = path.join(pemFolder, "cluster_clientkey.pem");
+            const certificate = path.join(pemFolder, "cluster_certificate.pem");
+            if (!(0, fs_1.existsSync)(clientKey) || !(0, fs_1.existsSync)(certificate)) {
+                pem.createCertificate({ selfSigned: true }, (err, keys) => {
+                    (0, fs_1.writeFileSync)(clientKey, keys.clientKey, { encoding: 'utf8' });
+                    (0, fs_1.writeFileSync)(certificate, keys.certificate, { encoding: 'utf8' });
+                    resolve([keys.clientKey, keys.certificate]);
+                });
+            }
+            else {
+                resolve([(0, fs_1.readFileSync)(clientKey, 'utf8').toString(), (0, fs_1.readFileSync)(certificate, 'utf8').toString()]);
+            }
+        });
+    };
 }
 exports.WebhookServerManager = WebhookServerManager;