verteilen-core 1.2.4 → 1.2.7

package/dist/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/script/console_manager.js

@@ -0,0 +1,131 @@
+"use strict";
+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.messager_log = _messager_log;
+        this.url = _url;
+        this.emitter = _emitter;
+        this.events = [];
+        this.events_once = [];
+        this.ws = new WebSocket(this.url);
+        this.ws.onerror = (err) => {
+            this.messager_log(`[Error] Express Connection failed ${this.url}`);
+        };
+        this.ws.onclose = (ev) => {
+            this.messager_log(`[Close] Express Client close, ${ev.code}, ${ev.reason}`);
+            this.buffer = [];
+        };
+        this.ws.onopen = () => {
+            this.messager_log('[Connection] Express New Connection !');
+            for (let i = 0; i < this.buffer.length; i++) {
+                this.ws.send(JSON.stringify(this.buffer[i]));
+            }
+            this.buffer = [];
+        };
+        this.ws.onmessage = (ev) => {
+            this.received(JSON.parse(ev.data.toString()));
+        };
+    }
+    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/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/script/console_server_manager.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleServerManager = void 0;
+class ConsoleServerManager {
+    ws;
+    typeMap;
+    messager_log;
+    constructor(_ws, _messager_log, _typeMap) {
+        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/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;
+}

package/dist/script/execute/base.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteManager_Base = void 0;
+const uuid_1 = require("uuid");
+const interface_1 = require("../../interface");
+const util_parser_1 = require("./util_parser");
+class ExecuteManager_Base {
+    uuid;
+    name;
+    record;
+    current_t = undefined;
+    current_p = undefined;
+    current_projects = [];
+    current_nodes = [];
+    current_cron = [];
+    current_job = [];
+    current_multithread = 1;
+    current_task_count = -1;
+    state = interface_1.ExecuteState.NONE;
+    t_state = interface_1.ExecuteState.NONE;
+    jobstack = 0;
+    first = false;
+    libs = undefined;
+    proxy = undefined;
+    localPara = undefined;
+    websocket_manager;
+    messager_log;
+    constructor(_name, _websocket_manager, _messager_log, _record) {
+        this.name = _name;
+        this.uuid = (0, uuid_1.v6)();
+        this.record = _record;
+        this.websocket_manager = _websocket_manager;
+        this.messager_log = _messager_log;
+    }
+    sync_local_para = (target) => {
+        this.current_nodes.forEach(x => this.sync_para(target, x));
+        this.proxy?.updateDatabase(target);
+    };
+    sync_para = (target, source) => {
+        const h = {
+            name: 'set_database',
+            channel: this.uuid,
+            data: target
+        };
+        const h2 = {
+            name: 'set_libs',
+            channel: this.uuid,
+            data: this.libs
+        };
+        source.websocket.send(JSON.stringify(h));
+        source.websocket.send(JSON.stringify(h2));
+    };
+    release = (source) => {
+        const h = {
+            name: 'release',
+            channel: this.uuid,
+            data: 0
+        };
+        source.websocket.send(JSON.stringify(h));
+    };
+    check_all_cron_end = () => {
+        return this.current_cron.filter(x => !this.check_cron_end(x)).length == 0;
+    };
+    check_cron_end = (cron) => {
+        return cron.work.filter(x => x.state == interface_1.ExecuteState.RUNNING || x.state == interface_1.ExecuteState.NONE).length == 0;
+    };
+    check_single_end = () => {
+        if (this.current_t == undefined)
+            return false;
+        return this.current_job.length == this.current_t.jobs.length &&
+            this.current_job.filter(y => y.state == interface_1.ExecuteState.RUNNING || y.state == interface_1.ExecuteState.NONE).length == 0;
+    };
+    validation = (projects) => {
+        if (this.websocket_manager.targets.length == 0) {
+            this.messager_log(`[Execute State] The execute node does not exists`);
+            return false;
+        }
+        projects.forEach(x => {
+            x.task.forEach(t => {
+                if (t.cronjob) {
+                    const index = x.database?.containers.findIndex(x => x.name == t.cronjobKey && x.type == interface_1.DataType.Number) ?? -1;
+                    if (index == -1) {
+                        this.messager_log(`[Execute:CronJob] Project ${x.title} (${x.uuid}), Task ${t.title} (${t.uuid}), Has unknoed database: \"${t.cronjobKey}\"`);
+                        this.messager_log(`[Execute:CronJob] Cron task registerd key not found`);
+                        return false;
+                    }
+                    else if (x.database?.containers[index].value == 0) {
+                        this.messager_log(`[Execute:CronJob] Project ${x.title} (${x.uuid}), Task ${t.title} (${t.uuid}), Has unknoed database: \"${t.cronjobKey}\"`);
+                        this.messager_log(`[Execute:CronJob] Cron task value must bigger than 0`);
+                        return false;
+                    }
+                }
+                if (t.cronjob && t.multi) {
+                    const index = x.database?.containers.findIndex(x => x.name == t.multiKey && x.type == interface_1.DataType.Number) ?? -1;
+                    if (index == -1) {
+                        this.messager_log(`[Execute:Multi] Project ${x.title} (${x.uuid}), Task ${t.title} (${t.uuid}), Has unknoed database: \"${t.multiKey}\"`);
+                        this.messager_log(`[Execute:Multi] Cron task registerd key not found`);
+                        return false;
+                    }
+                    else if (x.database?.containers[index].value == 0) {
+                        this.messager_log(`[Execute:Multi] Project ${x.title} (${x.uuid}), Task ${t.title} (${t.uuid}), Has unknoed database: \"${t.multiKey}\"`);
+                        this.messager_log(`[Execute:Multi] Cron task value must bigger than 0`);
+                        return false;
+                    }
+                }
+            });
+        });
+        return true;
+    };
+    filter_lib = (projects, lib) => {
+        const r = { libs: [] };
+        projects.forEach(x => {
+            x.task.forEach(y => {
+                y.jobs.forEach(z => {
+                    let code = -1;
+                    if ((z.category == interface_1.JobCategory.Execution && z.type == interface_1.JobType.JAVASCRIPT) || (z.category == interface_1.JobCategory.Condition && z.type == interface_1.JobType2.JAVASCRIPT))
+                        code = 0;
+                    if (code == -1)
+                        return;
+                    z.string_args.forEach(s1 => {
+                        const target = lib.libs.find(l => l.name == s1);
+                        if (target != undefined)
+                            r.libs.push(target);
+                    });
+                });
+            });
+        });
+        return JSON.parse(JSON.stringify(r));
+    };
+    get_task_multi_count = (t) => {
+        const r = this.get_number(t.multiKey);
+        return r == -1 ? 1 : r;
+    };
+    get_task_state_count(t) {
+        if (t.setupjob)
+            return this.current_nodes.length;
+        if (t.cronjob)
+            return this.get_number(t.cronjobKey);
+        else
+            return 1;
+    }
+    get_number(key) {
+        return ExecuteManager_Base.get_number_global(key, this.localPara);
+    }
+    static get_number_global(key, localPara) {
+        const e = ExecuteManager_Base.database_update(localPara);
+        const a = e.replacePara(`%{${key}}%`);
+        return Number(a);
+    }
+    removeDups = (arr) => {
+        return [...new Set(arr)];
+    };
+    get_idle = () => {
+        return this.current_nodes.filter(x => this.check_socket_state(x) != interface_1.ExecuteState.RUNNING && x.websocket.readyState == 1);
+    };
+    get_idle_open = () => {
+        return this.current_nodes.filter(x => x.websocket.readyState == 1);
+    };
+    check_socket_state = (target) => {
+        return target.current_job.length == 0 ? interface_1.ExecuteState.NONE : interface_1.ExecuteState.RUNNING;
+    };
+    static string_args_transform = (task, job, messager_log, localPara, n) => {
+        let e = ExecuteManager_Base.database_update(localPara, n);
+        e = ExecuteManager_Base.property_update(task, e);
+        for (let i = 0; i < job.string_args.length; i++) {
+            const b = job.string_args[i];
+            if (b == null || b == undefined || b.length == 0)
+                continue;
+            if (job.category == interface_1.JobCategory.Execution && job.type == interface_1.JobType.CREATE_FILE && i == 1)
+                continue;
+            job.string_args[i] = e.replacePara(job.string_args[i]);
+        }
+    };
+    static property_update = (task, e) => {
+        for (let j = 0; j < task.properties.length; j++) {
+            const target = task.properties[j];
+            const times = target.deep ? target.deep : 1;
+            let act = target.expression;
+            for (let k = 0; k < times; k++) {
+                act = e.replacePara(`%{${act}}%`);
+            }
+            e.paras.push({ key: task.properties[j].name, value: act });
+        }
+        return e;
+    };
+    static database_update = (localPara, n) => {
+        const e = new util_parser_1.Util_Parser([...util_parser_1.Util_Parser.to_keyvalue(localPara)]);
+        if (n != undefined) {
+            e.paras.push({ key: 'ck', value: n.toString() });
+        }
+        localPara.containers.forEach((c, index) => {
+            if (c.type != interface_1.DataType.Expression)
+                return;
+            c.value = e.replacePara(`%{${c.meta}}%`);
+            e.paras.find(p => p.key == c.name).value = c.value;
+        });
+        return e;
+    };
+}
+exports.ExecuteManager_Base = ExecuteManager_Base;

package/dist/script/execute/feedback.d.ts

@@ -0,0 +1,12 @@
+import { BusAnalysis } from "../../interface";
+import { ExecuteManager_Base } from "./base";
+export declare class ExecuteManager_Feedback extends ExecuteManager_Base {
+    Analysis: (d: BusAnalysis) => void;
+    private feedback_message;
+    private feedback_job;
+    private feedback_string;
+    private feedback_number;
+    private feedback_object;
+    private feedback_boolean;
+    private GetCronAndWork;
+}

package/dist/script/execute/feedback.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteManager_Feedback = void 0;
+const interface_1 = require("../../interface");
+const base_1 = require("./base");
+class ExecuteManager_Feedback extends base_1.ExecuteManager_Base {
+    Analysis = (d) => {
+        const targetn = this.current_nodes.find(x => x.uuid == d.c?.uuid);
+        if (targetn == undefined) {
+            this.messager_log("Not inside");
+            return;
+        }
+        const typeMap = {
+            'feedback_message': this.feedback_message,
+            'feedback_job': this.feedback_job,
+            'feedback_string': this.feedback_string,
+            'feedback_boolean': this.feedback_boolean,
+            'feedback_number': this.feedback_number,
+            'feedback_object': this.feedback_object,
+        };
+        if (typeMap.hasOwnProperty(d.name)) {
+            const castingFunc = typeMap[d.h.name];
+            castingFunc(d.h.data, targetn, d.h.meta);
+        }
+        else {
+            this.messager_log(`[Source Data Analysis] Decode failed, Unknowed header, name: ${d.name}, meta: ${d.h.meta}`);
+        }
+    };
+    feedback_message = (data, source, meta) => {
+        if (source == undefined) {
+            this.messager_log("[Server Feedback Warn] source is none");
+            return;
+        }
+        if (this.state == interface_1.ExecuteState.NONE) {
+            this.messager_log("[Server Feedback Warn] state is none, should not received feedback");
+            return;
+        }
+        this.messager_log(`[Execute] Single Received data: ${data.data}, cron length: ${this.current_cron.length}`);
+        let index = 0;
+        if (this.current_cron.length > 0 && meta != undefined) {
+            const r = this.GetCronAndWork(meta, source);
+            const cron = r[0];
+            const work = r[1];
+            if (cron != undefined && work != undefined) {
+                index = cron.id;
+            }
+        }
+        const d = {
+            node_uuid: source.uuid,
+            index: index,
+            job_uuid: '',
+            runtime_uuid: '',
+            meta: 0,
+            message: data.data
+        };
+        this.proxy?.feedbackMessage(d);
+    };
+    feedback_job = (data, source) => {
+        if (source == undefined)
+            return;
+        if (this.state == interface_1.ExecuteState.NONE)
+            return;
+        this.jobstack = Math.max(this.jobstack - 1, 0);
+        if (this.current_t == undefined) {
+            console.error("Cannot feedback when task is null");
+            return;
+        }
+        this.messager_log(`[Execute] Job Feedback: ${data.job_uuid} ${data.runtime_uuid} ${data.message} ${data.meta}`);
+        if (this.current_job.length > 0) {
+            const work = this.current_job.find(x => x.uuid == source.uuid && x.state == interface_1.ExecuteState.RUNNING);
+            if (work == undefined) {
+                console.error("Cannot find the feedback container, work", work);
+                return;
+            }
+            data.index = 0;
+            this.proxy?.executeJobFinish([work.job, 0, source.uuid, data.meta]);
+            work.state = data.meta == 0 ? interface_1.ExecuteState.FINISH : interface_1.ExecuteState.ERROR;
+            if (this.check_single_end()) {
+                this.proxy?.executeSubtaskFinish([this.current_t, 0, source.uuid]);
+                this.messager_log(`[Execute] Subtask finish: ${this.current_t.uuid}`);
+            }
+        }
+        else if (this.current_cron.length > 0) {
+            const r = this.GetCronAndWork(data.runtime_uuid, source);
+            const cron = r[0];
+            const work = r[1];
+            if (cron == undefined || work == undefined) {
+                console.error("Cannot find the feedback container, cron or work", data.runtime_uuid, cron, work);
+                console.error("Full current cron instance", this.current_cron);
+                return;
+            }
+            this.proxy?.executeJobFinish([work.job, cron.id, source.uuid, data.meta]);
+            data.index = cron.id;
+            work.state = data.meta == 0 ? interface_1.ExecuteState.FINISH : interface_1.ExecuteState.ERROR;
+            if (this.check_cron_end(cron)) {
+                this.proxy?.executeSubtaskFinish([this.current_t, cron.id, cron.uuid]);
+                this.messager_log(`[Execute] Subtask finish: ${this.current_t.uuid}`);
+                cron.uuid = '';
+            }
+        }
+        const index = source.current_job.findIndex(x => x == data.runtime_uuid);
+        if (index == -1) {
+            this.messager_log(`[Execute] Cannot find runtime uuid: ${data.runtime_uuid} in websocket pack source: ${source.uuid}`);
+        }
+        else {
+            source.current_job.splice(index, 1);
+        }
+        data.node_uuid = source.uuid;
+        this.proxy?.feedbackMessage(data);
+    };
+    feedback_string = (data) => {
+        if (this.current_p == undefined)
+            return;
+        const index = this.localPara.containers.findIndex(x => x.name == data.key && x.type == interface_1.DataType.String);
+        if (index != -1)
+            this.localPara.containers[index].value = data.value;
+        else
+            this.localPara.containers.push({ name: data.key, value: data.value, type: interface_1.DataType.String, hidden: true, runtimeOnly: true });
+        this.messager_log(`[String Feedback] ${data.key} = ${data.value}`);
+        const d = { name: 'set_database', data: this.localPara };
+        this.current_nodes.forEach(x => x.websocket.send(JSON.stringify(d)));
+        this.proxy?.updateDatabase(this.localPara);
+    };
+    feedback_number = (data) => {
+        if (this.current_p == undefined)
+            return;
+        const index = this.localPara.containers.findIndex(x => x.name == data.key && x.type == interface_1.DataType.Number);
+        if (index != -1)
+            this.localPara.containers[index].value = data.value;
+        else
+            this.localPara.containers.push({ name: data.key, value: data.value, type: interface_1.DataType.Number, hidden: true, runtimeOnly: true });
+        this.messager_log(`[Number Feedback] ${data.key} = ${data.value}`);
+        const d = { name: 'set_database', data: this.localPara };
+        this.current_nodes.forEach(x => x.websocket.send(JSON.stringify(d)));
+        this.proxy?.updateDatabase(this.localPara);
+    };
+    feedback_object = (data) => {
+        if (this.current_p == undefined)
+            return;
+        const index = this.localPara.containers.findIndex(x => x.name == data.key && x.type == interface_1.DataType.Object);
+        if (index != -1)
+            this.localPara.containers[index].value = data.value;
+        else
+            this.localPara.containers.push({ name: data.key, value: data.value, type: interface_1.DataType.Object, hidden: true, runtimeOnly: true });
+        this.messager_log(`[Object Feedback] ${data.key}`);
+        const d = { name: 'set_database', data: this.localPara };
+        this.current_nodes.forEach(x => x.websocket.send(JSON.stringify(d)));
+        this.proxy?.updateDatabase(this.localPara);
+    };
+    feedback_boolean = (data) => {
+        if (this.current_p == undefined)
+            return;
+        const index = this.localPara.containers.findIndex(x => x.name == data.key && x.type == interface_1.DataType.Boolean);
+        if (index != -1)
+            this.localPara.containers[index].value = data.value;
+        else
+            this.localPara.containers.push({ name: data.key, value: data.value, type: interface_1.DataType.Boolean, hidden: true, runtimeOnly: true });
+        this.messager_log(`[Boolean Feedback] ${data.key} = ${data.value}`);
+        const d = { name: 'set_database', data: this.localPara };
+        this.current_nodes.forEach(x => x.websocket.send(JSON.stringify(d)));
+        this.proxy?.updateDatabase(this.localPara);
+    };
+    GetCronAndWork = (runtime, source) => {
+        let cron = undefined;
+        let work = undefined;
+        const crons = this.current_cron.filter(x => x.uuid == source.uuid);
+        for (let i = 0; i < crons.length; i++) {
+            const c = crons[i];
+            const a = c.work.find(x => x.runtime == runtime);
+            if (a != undefined) {
+                cron = c;
+                work = a;
+                break;
+            }
+        }
+        return [cron, work];
+    };
+}
+exports.ExecuteManager_Feedback = ExecuteManager_Feedback;

package/dist/script/execute/interface.d.ts

@@ -0,0 +1,8 @@
+export * from './base';
+export * from './feedback';
+export * from './region_job';
+export * from './region_project';
+export * from './region_subtask';
+export * from './region_task';
+export * from './runner';
+export * from './util_parser';

package/dist/script/execute/region_job.d.ts

@@ -0,0 +1,5 @@
+import { ExecuteManager } from "../execute_manager";
+export declare class Region_Job {
+    target: ExecuteManager;
+    constructor(_target: ExecuteManager);
+}

package/dist/{src/script → script}/execute/region_job.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Region_Job = void 0;
 class Region_Job {
+    target;
     constructor(_target) {
         this.target = _target;
     }

package/dist/script/execute/region_project.d.ts

@@ -0,0 +1,10 @@
+import { ExecuteState, Project } from "../../interface";
+import { ExecuteManager } from "../execute_manager";
+import { Region_Task } from "./region_task";
+export declare class Region_Project {
+    target: ExecuteManager;
+    state: ExecuteState;
+    project: Project;
+    task: Region_Task | undefined;
+    constructor(_target: ExecuteManager, _project: Project);
+}