verteilen-core 1.2.4 → 1.2.6

package/dist/src/script/console_manager.d.ts

@@ -0,0 +1,18 @@
+import { BusType, EmitterProxy, Header, RawSend } from "../interface";
+export type Listener = (...args: any[]) => void;
+export declare class ConsoleManager {
+    url: string;
+    ws: WebSocket;
+    emitter: EmitterProxy<BusType>;
+    messager_log: Function;
+    events: Array<[string, Array<Listener>]>;
+    events_once: Array<[string, Array<Listener>]>;
+    buffer: Array<Header>;
+    constructor(_url: string, _messager_log: Function, _emitter: EmitterProxy<BusType>);
+    get connected(): boolean;
+    on: (channel: string, listener: Listener) => void;
+    once: (channel: string, listener: Listener) => void;
+    off: (channel: string, listener: Listener) => void;
+    send: (data: RawSend) => void;
+    received: (h: Header) => void;
+}

package/dist/src/script/console_manager.js

@@ -2,98 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleManager = void 0;
 class ConsoleManager {
+    url;
+    ws;
+    emitter;
+    messager_log;
+    events;
+    events_once;
+    buffer = [];
     constructor(_url, _messager_log, _emitter) {
-        this.buffer = [];
-        this.on = (channel, listener) => {
-            const index = this.events.findIndex(x => x[0] == channel);
-            if (index == -1) {
-                this.events.push([channel, [listener]]);
-            }
-            else {
-                this.events[index][1].push(listener);
-            }
-        };
-        this.once = (channel, listener) => {
-            const index = this.events.findIndex(x => x[0] == channel);
-            if (index == -1) {
-                this.events_once.push([channel, [listener]]);
-            }
-            else {
-                this.events_once[index][1].push(listener);
-            }
-        };
-        this.off = (channel, listener) => {
-            const index = this.events.findIndex(x => x[0] == channel);
-            if (index == -1) {
-                return;
-            }
-            else {
-                const index2 = this.events[index][1].findIndex(x => x == listener);
-                if (index2 != -1)
-                    this.events[index][1].splice(index2, 1);
-            }
-        };
-        this.send = (data) => {
-            const d = {
-                name: data.name,
-                token: data.token,
-                data: data.data
-            };
-            if (this.ws.readyState !== WebSocket.OPEN) {
-                this.buffer.push(d);
-            }
-            else {
-                this.ws.send(JSON.stringify(d));
-            }
-        };
-        this.received = (h) => {
-            if (h == undefined) {
-                this.messager_log('[Source Analysis] Analysis Failed, Value is undefined');
-                return;
-            }
-            if (h.message != undefined && h.message.length > 0) {
-                this.messager_log(`[Source Analysis] ${h.message}`);
-            }
-            if (h.data == undefined)
-                return;
-            const index = this.events.findIndex(x => x[0] == h.name);
-            const index2 = this.events_once.findIndex(x => x[0] == h.name);
-            let p = false;
-            if (index != -1) {
-                const castingFunc = this.events[index][1];
-                castingFunc.forEach(x => {
-                    if (h.data instanceof Array) {
-                        if (h.data.length == 1)
-                            x(h.data[0]);
-                        else
-                            x(...h.data);
-                    }
-                    else {
-                        x(h.data);
-                    }
-                });
-                p = true;
-            }
-            if (index2 != -1) {
-                const castingFunc = this.events_once[index2][1];
-                castingFunc.forEach(x => {
-                    if (h.data instanceof Array) {
-                        if (h.data.length == 1)
-                            x(h.data[0]);
-                        else
-                            x(...h.data);
-                    }
-                    else {
-                        x(h.data);
-                    }
-                });
-                this.events_once.splice(index2, 1);
-                p = true;
-            }
-            if (!p) {
-                this.messager_log(`[Source Analysis] Analysis Failed, Unknowed header, name: ${h.name}, meta: ${h.meta}`);
-            }
-        };
         this.messager_log = _messager_log;
         this.url = _url;
         this.emitter = _emitter;
@@ -121,5 +37,95 @@ class ConsoleManager {
     get connected() {
         return this.ws.readyState === 1;
     }
+    on = (channel, listener) => {
+        const index = this.events.findIndex(x => x[0] == channel);
+        if (index == -1) {
+            this.events.push([channel, [listener]]);
+        }
+        else {
+            this.events[index][1].push(listener);
+        }
+    };
+    once = (channel, listener) => {
+        const index = this.events.findIndex(x => x[0] == channel);
+        if (index == -1) {
+            this.events_once.push([channel, [listener]]);
+        }
+        else {
+            this.events_once[index][1].push(listener);
+        }
+    };
+    off = (channel, listener) => {
+        const index = this.events.findIndex(x => x[0] == channel);
+        if (index == -1) {
+            return;
+        }
+        else {
+            const index2 = this.events[index][1].findIndex(x => x == listener);
+            if (index2 != -1)
+                this.events[index][1].splice(index2, 1);
+        }
+    };
+    send = (data) => {
+        const d = {
+            name: data.name,
+            token: data.token,
+            data: data.data
+        };
+        if (this.ws.readyState !== WebSocket.OPEN) {
+            this.buffer.push(d);
+        }
+        else {
+            this.ws.send(JSON.stringify(d));
+        }
+    };
+    received = (h) => {
+        if (h == undefined) {
+            this.messager_log('[Source Analysis] Analysis Failed, Value is undefined');
+            return;
+        }
+        if (h.message != undefined && h.message.length > 0) {
+            this.messager_log(`[Source Analysis] ${h.message}`);
+        }
+        if (h.data == undefined)
+            return;
+        const index = this.events.findIndex(x => x[0] == h.name);
+        const index2 = this.events_once.findIndex(x => x[0] == h.name);
+        let p = false;
+        if (index != -1) {
+            const castingFunc = this.events[index][1];
+            castingFunc.forEach(x => {
+                if (h.data instanceof Array) {
+                    if (h.data.length == 1)
+                        x(h.data[0]);
+                    else
+                        x(...h.data);
+                }
+                else {
+                    x(h.data);
+                }
+            });
+            p = true;
+        }
+        if (index2 != -1) {
+            const castingFunc = this.events_once[index2][1];
+            castingFunc.forEach(x => {
+                if (h.data instanceof Array) {
+                    if (h.data.length == 1)
+                        x(h.data[0]);
+                    else
+                        x(...h.data);
+                }
+                else {
+                    x(h.data);
+                }
+            });
+            this.events_once.splice(index2, 1);
+            p = true;
+        }
+        if (!p) {
+            this.messager_log(`[Source Analysis] Analysis Failed, Unknowed header, name: ${h.name}, meta: ${h.meta}`);
+        }
+    };
 }
 exports.ConsoleManager = ConsoleManager;

package/dist/src/script/console_server_manager.d.ts

@@ -0,0 +1,13 @@
+import * as ws from 'ws';
+import { Header } from "../interface";
+type calltype = {
+    [key: string]: Function;
+};
+export declare class ConsoleServerManager {
+    ws: ws.WebSocket;
+    typeMap: calltype;
+    messager_log: Function;
+    constructor(_ws: ws.WebSocket, _messager_log: Function, _typeMap: calltype);
+    Analysis: (h: Header) => void;
+}
+export {};

package/dist/src/script/console_server_manager.js

@@ -2,36 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleServerManager = void 0;
 class ConsoleServerManager {
+    ws;
+    typeMap;
+    messager_log;
     constructor(_ws, _messager_log, _typeMap) {
-        this.Analysis = (h) => {
-            if (h == undefined) {
-                this.messager_log('[Source Analysis] Failed, Get a undefined value');
-                return;
-            }
-            if (h.message != undefined && h.message.length > 0) {
-                this.messager_log(`[Source Analysis] ${h.message}`);
-            }
-            if (h.data == undefined)
-                return;
-            if (this.typeMap.hasOwnProperty(h.name)) {
-                const castingFunc = this.typeMap[h.name];
-                if (h.data instanceof Array) {
-                    if (h.data.length == 1)
-                        castingFunc(this.ws, h.data[0]);
-                    else
-                        castingFunc(this.ws, ...h.data);
-                }
-                else {
-                    castingFunc(this.ws, h.data);
-                }
-            }
-            else {
-                this.messager_log(`[Source Analysis] Failed, Unknown, name: ${h.name}, meta: ${h.meta}`);
-            }
-        };
         this.messager_log = _messager_log;
         this.ws = _ws;
         this.typeMap = _typeMap;
     }
+    Analysis = (h) => {
+        if (h == undefined) {
+            this.messager_log('[Source Analysis] Failed, Get a undefined value');
+            return;
+        }
+        if (h.message != undefined && h.message.length > 0) {
+            this.messager_log(`[Source Analysis] ${h.message}`);
+        }
+        if (h.data == undefined)
+            return;
+        if (this.typeMap.hasOwnProperty(h.name)) {
+            const castingFunc = this.typeMap[h.name];
+            if (h.data instanceof Array) {
+                if (h.data.length == 1)
+                    castingFunc(this.ws, h.data[0]);
+                else
+                    castingFunc(this.ws, ...h.data);
+            }
+            else {
+                castingFunc(this.ws, h.data);
+            }
+        }
+        else {
+            this.messager_log(`[Source Analysis] Failed, Unknown, name: ${h.name}, meta: ${h.meta}`);
+        }
+    };
 }
 exports.ConsoleServerManager = ConsoleServerManager;

package/dist/src/script/execute/base.d.ts

@@ -0,0 +1,45 @@
+import { CronJobState, ExecuteProxy, ExecuteState, Job, Libraries, Messager, Database, Project, Record, Task, WebsocketPack, WorkState } from "../../interface";
+import { WebsocketManager } from "../socket_manager";
+import { Util_Parser } from './util_parser';
+export declare class ExecuteManager_Base {
+    uuid: string;
+    name: string;
+    record: Record;
+    current_t: Task | undefined;
+    current_p: Project | undefined;
+    current_projects: Array<Project>;
+    current_nodes: Array<WebsocketPack>;
+    current_cron: Array<CronJobState>;
+    current_job: Array<WorkState>;
+    current_multithread: number;
+    current_task_count: number;
+    state: ExecuteState;
+    t_state: ExecuteState;
+    jobstack: number;
+    first: boolean;
+    libs: Libraries | undefined;
+    proxy: ExecuteProxy | undefined;
+    localPara: Database | undefined;
+    websocket_manager: WebsocketManager;
+    messager_log: Messager;
+    constructor(_name: string, _websocket_manager: WebsocketManager, _messager_log: Messager, _record: Record);
+    protected sync_local_para: (target: Database) => void;
+    protected sync_para: (target: Database, source: WebsocketPack) => void;
+    protected release: (source: WebsocketPack) => void;
+    protected check_all_cron_end: () => boolean;
+    protected check_cron_end: (cron: CronJobState) => boolean;
+    protected check_single_end: () => boolean;
+    protected validation: (projects: Array<Project>) => boolean;
+    protected filter_lib: (projects: Array<Project>, lib: Libraries) => Libraries;
+    protected get_task_multi_count: (t: Task) => number;
+    get_task_state_count(t: Task): number;
+    protected get_number(key: string): number;
+    static get_number_global(key: string, localPara: Database | undefined): number;
+    protected removeDups: (arr: any[]) => any[];
+    protected get_idle: () => Array<WebsocketPack>;
+    protected get_idle_open: () => Array<WebsocketPack>;
+    protected check_socket_state: (target: WebsocketPack) => ExecuteState.NONE | ExecuteState.RUNNING;
+    static string_args_transform: (task: Task, job: Job, messager_log: Messager, localPara: Database, n: number) => void;
+    static property_update: (task: Task, e: Util_Parser) => Util_Parser;
+    static database_update: (localPara: Database, n?: number) => Util_Parser;
+}