verteilen-core 1.2.4 → 1.2.6

package/dist/src/server/io.d.ts

@@ -0,0 +1,46 @@
+import { Project, RecordType, Database, UserProfile, Library, ExecutionLog, Node } from "../interface";
+export interface MemoryData {
+    projects: Array<Project>;
+    database: Array<Database>;
+    nodes: Array<Node>;
+    logs: Array<ExecutionLog>;
+    libs: Array<Library>;
+    user: Array<UserProfile>;
+}
+export interface RecordIOLoader {
+    load_all: () => Promise<Array<string>>;
+    delete_all: () => Promise<void>;
+    list_all: () => Promise<Array<string>>;
+    save: (name: string, data: string) => Promise<void>;
+    load: (name: string, cache: boolean) => Promise<string>;
+    rename: (name: string, newname: string) => Promise<void>;
+    delete: (name: string) => Promise<void>;
+}
+export interface RecordLoader {
+    project: RecordIOLoader;
+    database: RecordIOLoader;
+    node: RecordIOLoader;
+    log: RecordIOLoader;
+    lib: RecordIOLoader;
+    user: RecordIOLoader;
+}
+export interface RecordIOBase {
+    root: string;
+    join: (...paths: Array<string>) => string;
+    read_dir: (path: string) => Promise<Array<string>>;
+    read_dir_dir: (path: string) => Promise<Array<string>>;
+    read_dir_file: (path: string) => Promise<Array<string>>;
+    read_string: (path: string, options?: any) => Promise<string>;
+    write_string: (path: string, content: string) => Promise<void>;
+    exists: (path: string) => boolean;
+    mkdir: (path: string) => Promise<void>;
+    rm: (path: string) => Promise<void>;
+    cp: (path: string, newpath: string) => Promise<void>;
+}
+export interface RecordMongoBase {
+}
+export declare const _CreateRecordMemoryLoader: (loader: MemoryData, type: RecordType) => RecordIOLoader;
+export declare const _CreateRecordIOLoader: (loader: RecordIOBase, memory: MemoryData, type: RecordType, folder: string, ext?: string) => RecordIOLoader;
+export declare const CreateRecordMemoryLoader: (loader: MemoryData) => RecordLoader;
+export declare const CreateRecordIOLoader: (loader: RecordIOBase, memory: MemoryData) => RecordLoader;
+export declare const CreateRecordMongoLoader: (loader: RecordMongoBase, folder: string, ext?: string) => void;

package/dist/src/server/io.js

@@ -1,13 +1,4 @@
 "use strict";
-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.CreateRecordMongoLoader = exports.CreateRecordIOLoader = exports.CreateRecordMemoryLoader = exports._CreateRecordIOLoader = exports._CreateRecordMemoryLoader = void 0;
 const interface_1 = require("../interface");
@@ -24,41 +15,41 @@ const _CreateRecordMemoryLoader = (loader, type) => {
         }
     };
     return {
-        load_all: () => __awaiter(void 0, void 0, void 0, function* () {
+        load_all: async () => {
             return get_array(type).map(x => JSON.stringify(x));
-        }),
-        delete_all: () => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        delete_all: async () => {
             const arr = get_array(type).map(x => JSON.stringify(x));
             arr.splice(0, arr.length);
-        }),
-        list_all: () => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        list_all: async () => {
             return get_array(type).map(x => x.uuid);
-        }),
-        save: (name, data) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        save: async (name, data) => {
             const arr = get_array(type);
             const b = arr.findIndex(x => name == x.uuid);
             if (b != -1)
                 arr[b] = JSON.parse(data);
             else
                 arr.push(JSON.parse(data));
-        }),
-        load: (name) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        load: async (name) => {
             const arr = get_array(type);
             const b = arr.find(x => name == x.uuid);
             return b ? JSON.stringify(b) : "";
-        }),
-        rename: (name, newname) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        rename: async (name, newname) => {
             const arr = get_array(type);
             const b = arr.findIndex(x => x.uuid == name);
             if (b != -1)
                 arr[b].uuid = newname;
-        }),
-        delete: (name) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        delete: async (name) => {
             const arr = get_array(type);
             const b = arr.findIndex(x => x.uuid == name);
             if (b != -1)
                 arr.splice(b, 1);
-        })
+        }
     };
 };
 exports._CreateRecordMemoryLoader = _CreateRecordMemoryLoader;
@@ -75,46 +66,46 @@ const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
         }
     };
     return {
-        load_all: () => __awaiter(void 0, void 0, void 0, function* () {
+        load_all: async () => {
             const root = loader.join(loader.root, folder);
             if (!loader.exists(root))
-                yield loader.mkdir(root);
-            const files = yield loader.read_dir_file(root);
+                await loader.mkdir(root);
+            const files = await loader.read_dir_file(root);
             const r = files.map(x => loader.read_string(x, { encoding: 'utf8', flag: 'r' }));
-            const p = yield Promise.all(r);
+            const p = await Promise.all(r);
             const arr = get_array(type);
             arr.splice(0, arr.length);
             arr.push(...p.map(x => JSON.parse(x)));
             return p;
-        }),
-        delete_all: () => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        delete_all: async () => {
             const root = loader.join(loader.root, folder);
             if (loader.exists(root))
-                yield loader.rm(root);
-            yield loader.mkdir(root);
+                await loader.rm(root);
+            await loader.mkdir(root);
             const arr = get_array(type);
             arr.splice(0, arr.length);
-        }),
-        list_all: () => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        list_all: async () => {
             const root = loader.join(loader.root, folder);
             if (!loader.exists(root))
-                yield loader.mkdir(root);
+                await loader.mkdir(root);
             return loader.read_dir_file(root);
-        }),
-        save: (name, data) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        save: async (name, data) => {
             const root = loader.join(loader.root, folder);
             if (!loader.exists(root))
-                yield loader.mkdir(root);
+                await loader.mkdir(root);
             const file = loader.join(root, name + ext);
-            yield loader.write_string(file, data);
+            await loader.write_string(file, data);
             const arr = get_array(type);
             const b = arr.findIndex(x => x.uuid == name);
             if (b != -1)
                 arr.push(JSON.parse(data));
             else
                 arr[b] = JSON.parse(data);
-        }),
-        load: (name, cache) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        load: async (name, cache) => {
             if (cache) {
                 const arr = get_array(type);
                 const b = arr.findIndex(x => x.uuid == name);
@@ -123,34 +114,34 @@ const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
             }
             const root = loader.join(loader.root, folder);
             if (!loader.exists(root))
-                yield loader.mkdir(root);
+                await loader.mkdir(root);
             const file = loader.join(root, name + ext);
             return loader.read_string(file);
-        }),
-        rename: (name, newname) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        rename: async (name, newname) => {
             const root = loader.join(loader.root, folder);
             if (!loader.exists(root))
-                yield loader.mkdir(root);
+                await loader.mkdir(root);
             const oldfile = loader.join(root, name + ext);
             const newfile = loader.join(root, newname + ext);
-            yield loader.cp(oldfile, newfile);
-            yield loader.rm(oldfile);
+            await loader.cp(oldfile, newfile);
+            await loader.rm(oldfile);
             const arr = get_array(type);
             const b = arr.findIndex(x => x.uuid == name);
             if (b != -1)
                 arr[b].uuid = newname;
-        }),
-        delete: (name) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        delete: async (name) => {
             const root = loader.join(loader.root, folder);
             if (!loader.exists(root))
-                yield loader.mkdir(root);
+                await loader.mkdir(root);
             const file = loader.join(root, name + ext);
-            yield loader.rm(file);
+            await loader.rm(file);
             const arr = get_array(type);
             const b = arr.findIndex(x => x.uuid == name);
             if (b != -1)
                 arr.splice(b, 1);
-        })
+        }
     };
 };
 exports._CreateRecordIOLoader = _CreateRecordIOLoader;

package/dist/src/server/plugin.d.ts

@@ -0,0 +1,18 @@
+import { RecordIOBase } from "./io";
+import { PluginList, PluginPageData, WebsocketPack } from "../interface";
+import { PluginFeedback } from "./server";
+export type SocketGetter = (uuid: string) => WebsocketPack | undefined;
+export interface PluginLoader {
+    load_all: () => Promise<PluginPageData>;
+    get_project: (group: string, filename: string) => string | undefined;
+    get_database: (group: string, filename: string) => string | undefined;
+    get_plugin: () => Promise<Array<PluginList>>;
+    import_template: (name: string, url: string, token: string) => Promise<PluginPageData>;
+    import_plugin: (name: string, url: string, token: string) => Promise<PluginPageData>;
+    delete_template: (name: string) => Promise<void>;
+    delete_plugin: (name: string) => Promise<void>;
+    plugin_download: (uuid: string, plugin: string, tokens: string) => Promise<void>;
+    plugin_remove: (uuid: string, plugin: string) => Promise<void>;
+}
+export declare const GetCurrentPlugin: (loader: RecordIOBase) => Promise<PluginPageData>;
+export declare const CreatePluginLoader: (loader: RecordIOBase, memory: PluginPageData, socket: SocketGetter, feedback: PluginFeedback) => PluginLoader;

package/dist/src/server/plugin.js

@@ -1,17 +1,8 @@
 "use strict";
-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.CreatePluginLoader = exports.GetCurrentPlugin = void 0;
-const GetCurrentPlugin = (loader) => __awaiter(void 0, void 0, void 0, function* () {
-    return new Promise((resolve) => __awaiter(void 0, void 0, void 0, function* () {
+const GetCurrentPlugin = async (loader) => {
+    return new Promise(async (resolve) => {
         const b = {
             plugins: [],
             templates: []
@@ -19,12 +10,12 @@ const GetCurrentPlugin = (loader) => __awaiter(void 0, void 0, void 0, function*
         const root = loader.join(loader.root, 'template');
         const root2 = loader.join(loader.root, 'plugin');
         if (!loader.exists(root))
-            yield loader.mkdir(root);
+            await loader.mkdir(root);
         if (!loader.exists(root2))
-            yield loader.mkdir(root2);
-        const files = (yield loader.read_dir_file(root)).filter(x => x.endsWith('.json'));
+            await loader.mkdir(root2);
+        const files = (await loader.read_dir_file(root)).filter(x => x.endsWith('.json'));
         const _configs = files.map(file => loader.read_string(loader.join(root, file), { encoding: 'utf-8' }));
-        const configs = (yield Promise.all(_configs)).map(x => JSON.parse(x));
+        const configs = (await Promise.all(_configs)).map(x => JSON.parse(x));
         for (let index = 0; index < configs.length; index++) {
             const config = configs[index];
             const ps = config.projects.map(x => ({
@@ -46,11 +37,11 @@ const GetCurrentPlugin = (loader) => __awaiter(void 0, void 0, void 0, function*
                 url: config.url
             });
         }
-        const files2 = (yield loader.read_dir_dir(root2)).filter(x => x.endsWith('.json'));
+        const files2 = (await loader.read_dir_dir(root2)).filter(x => x.endsWith('.json'));
         const p_config2 = files2.map(file => {
             return loader.read_string(loader.join(root2, file), { encoding: 'utf-8' });
         });
-        const configs2 = (yield Promise.all(p_config2)).map(x => JSON.parse(x));
+        const configs2 = (await Promise.all(p_config2)).map(x => JSON.parse(x));
         for (let index = 0; index < configs2.length; index++) {
             const config = configs2[index];
             config.title = files2[index].replace('.json', '');
@@ -58,17 +49,17 @@ const GetCurrentPlugin = (loader) => __awaiter(void 0, void 0, void 0, function*
         }
         resolve(b);
         return b;
-    }));
-});
+    });
+};
 exports.GetCurrentPlugin = GetCurrentPlugin;
 const CreatePluginLoader = (loader, memory, socket, feedback) => {
     return {
-        load_all: () => __awaiter(void 0, void 0, void 0, function* () {
-            const cp = yield (0, exports.GetCurrentPlugin)(loader);
+        load_all: async () => {
+            const cp = await (0, exports.GetCurrentPlugin)(loader);
             memory.templates = cp.templates;
             memory.plugins = cp.plugins;
             return cp;
-        }),
+        },
         get_project: (group, filename) => {
             let find = false;
             let result = undefined;
@@ -101,10 +92,10 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
             }
             return result;
         },
-        get_plugin: () => __awaiter(void 0, void 0, void 0, function* () {
+        get_plugin: async () => {
             return memory.plugins;
-        }),
-        import_template: (name, url, token) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        import_template: async (name, url, token) => {
             const root = loader.join(loader.root, 'template');
             const error_children = [];
             const tokens = [undefined, ...token.split(' ')];
@@ -112,7 +103,7 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
             const project_folder = loader.join(content_folder, 'project');
             const database_folder = loader.join(content_folder, 'database');
             if (!loader.exists(root))
-                yield loader.mkdir(root);
+                await loader.mkdir(root);
             let req = {};
             let ob = undefined;
             for (let t of tokens) {
@@ -129,8 +120,8 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
                     };
                 }
                 try {
-                    const res = yield fetch(url, req);
-                    const tex = yield res.text();
+                    const res = await fetch(url, req);
+                    const tex = await res.text();
                     ob = JSON.parse(tex);
                     break;
                 }
@@ -163,9 +154,9 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
             ob.projects.forEach((p) => {
                 project_calls.push(fetch(folder + "/" + p.filename + '.json', req));
             });
-            const pss = yield Promise.all(project_calls);
+            const pss = await Promise.all(project_calls);
             const project_calls2 = pss.map(x => x.text());
-            const pss_result = yield Promise.all(project_calls2);
+            const pss_result = await Promise.all(project_calls2);
             pss_result.forEach((text, index) => {
                 const n = ob.projects[index].filename + '.json';
                 try {
@@ -180,9 +171,9 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
             ob.databases.forEach((p) => {
                 database_calls.push(fetch(folder + "/" + p.filename + '.json', req));
             });
-            const pss2 = yield Promise.all(database_calls);
+            const pss2 = await Promise.all(database_calls);
             const database_calls2 = pss2.map(x => x.text());
-            const pss_result2 = yield Promise.all(database_calls2);
+            const pss_result2 = await Promise.all(database_calls2);
             pss_result2.forEach((text, index) => {
                 const n = ob.databases[index].filename + '.json';
                 try {
@@ -205,16 +196,16 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
                 }
                 return memory;
             }
-            const cp = yield (0, exports.GetCurrentPlugin)(loader);
+            const cp = await (0, exports.GetCurrentPlugin)(loader);
             memory.templates = cp.templates;
             memory.plugins = cp.plugins;
             return cp;
-        }),
-        import_plugin: (name, url, token) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        import_plugin: async (name, url, token) => {
             const root = loader.join(loader.root, 'plugin');
             const tokens = [undefined, ...token.split(' ')];
             if (!loader.exists(root))
-                yield loader.mkdir(root);
+                await loader.mkdir(root);
             let req = {};
             let ob = undefined;
             for (let t of tokens) {
@@ -232,8 +223,8 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
                 }
                 let tex = "";
                 try {
-                    const res = yield fetch(url, req);
-                    tex = yield res.text();
+                    const res = await fetch(url, req);
+                    tex = await res.text();
                     ob = JSON.parse(tex);
                     console.log("Fetch plugin json successfully");
                     break;
@@ -255,36 +246,36 @@ const CreatePluginLoader = (loader, memory, socket, feedback) => {
             }
             ob.url = url;
             loader.write_string(loader.join(root, name + '.json'), JSON.stringify(ob, null, 4));
-            const cp = yield (0, exports.GetCurrentPlugin)(loader);
+            const cp = await (0, exports.GetCurrentPlugin)(loader);
             memory.templates = cp.templates;
             memory.plugins = cp.plugins;
             return cp;
-        }),
-        delete_template: (name) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        delete_template: async (name) => {
             const root = loader.join(loader.root, 'template');
             if (loader.exists(loader.join(root, name + '.json')))
-                yield loader.rm(loader.join(root, name + '.json'));
+                await loader.rm(loader.join(root, name + '.json'));
             if (loader.exists(loader.join(root, name)))
-                yield loader.rm(loader.join(root, name));
-        }),
-        delete_plugin: (name) => __awaiter(void 0, void 0, void 0, function* () {
+                await loader.rm(loader.join(root, name));
+        },
+        delete_plugin: async (name) => {
             const root = loader.join(loader.root, 'plugin');
             if (loader.exists(loader.join(root, name + '.json')))
-                yield loader.rm(loader.join(root, name + '.json'));
-        }),
-        plugin_download: (uuid, plugin, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+                await loader.rm(loader.join(root, name + '.json'));
+        },
+        plugin_download: async (uuid, plugin, tokens) => {
             const p = JSON.parse(plugin);
-            const p2 = Object.assign(Object.assign({}, p), { token: tokens.split(' ') });
+            const p2 = { ...p, token: tokens.split(' ') };
             const t = socket(uuid);
             const h = { name: 'plugin_download', data: p2 };
-            t === null || t === void 0 ? void 0 : t.websocket.send(JSON.stringify(h));
-        }),
-        plugin_remove: (uuid, plugin) => __awaiter(void 0, void 0, void 0, function* () {
+            t?.websocket.send(JSON.stringify(h));
+        },
+        plugin_remove: async (uuid, plugin) => {
             const p = JSON.parse(plugin);
             const t = socket(uuid);
             const h = { name: 'plugin_remove', data: p };
-            t === null || t === void 0 ? void 0 : t.websocket.send(JSON.stringify(h));
-        }),
+            t?.websocket.send(JSON.stringify(h));
+        },
     };
 };
 exports.CreatePluginLoader = CreatePluginLoader;

package/dist/src/server/server.d.ts

@@ -0,0 +1,27 @@
+import { Execute_ConsoleServerManager, PluginPageData } from "../interface";
+import { ServerDetail } from "./detail";
+import { MemoryData, RecordIOBase, RecordLoader } from "./io";
+import { PluginLoader } from "./plugin";
+export type Caller_Electron = (channel: string, ...args: any[]) => void;
+export type Caller_Socket = (data: any) => void;
+export type TypeMap = {
+    [key: string]: Function;
+};
+export interface PluginFeedback {
+    electron: Caller_Electron | undefined;
+    socket: Caller_Socket | undefined;
+}
+export declare class Server {
+    manager: Array<Execute_ConsoleServerManager.ConsoleServerManager>;
+    memory: MemoryData;
+    plugin: PluginPageData;
+    io: RecordIOBase | undefined;
+    loader: RecordLoader | undefined;
+    plugin_loader: PluginLoader | undefined;
+    memory_loader: RecordLoader;
+    detail: ServerDetail | undefined;
+    constructor();
+    get current_loader(): RecordLoader;
+    LoadFromDisk: () => Promise<Array<Array<string>>>;
+    Boradcasting: (name: string, data: any) => void;
+}

package/dist/src/server/server.js

@@ -3,43 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Server = void 0;
 const io_1 = require("./io");
 class Server {
+    manager = [];
+    memory = {
+        projects: [],
+        database: [],
+        nodes: [],
+        logs: [],
+        libs: [],
+        user: [],
+    };
+    plugin = {
+        templates: [],
+        plugins: [],
+    };
+    io = undefined;
+    loader = undefined;
+    plugin_loader = undefined;
+    memory_loader;
+    detail;
     constructor() {
-        this.manager = [];
-        this.memory = {
-            projects: [],
-            database: [],
-            nodes: [],
-            logs: [],
-            libs: [],
-            user: [],
-        };
-        this.plugin = {
-            templates: [],
-            plugins: [],
-        };
-        this.io = undefined;
-        this.loader = undefined;
-        this.plugin_loader = undefined;
-        this.LoadFromDisk = () => {
-            const ts = [
-                this.current_loader.project.load_all(),
-                this.current_loader.database.load_all(),
-                this.current_loader.node.load_all(),
-                this.current_loader.log.load_all(),
-                this.current_loader.lib.load_all(),
-                this.current_loader.user.load_all(),
-            ];
-            return Promise.all(ts);
-        };
-        this.Boradcasting = (name, data) => {
-            const d = {
-                name: name,
-                data: data
-            };
-            this.manager.forEach(x => {
-                x.ws.send(JSON.stringify(d));
-            });
-        };
         this.memory_loader = (0, io_1.CreateRecordMemoryLoader)(this.memory);
     }
     get current_loader() {
@@ -47,5 +29,25 @@ class Server {
             return this.loader;
         return this.memory_loader;
     }
+    LoadFromDisk = () => {
+        const ts = [
+            this.current_loader.project.load_all(),
+            this.current_loader.database.load_all(),
+            this.current_loader.node.load_all(),
+            this.current_loader.log.load_all(),
+            this.current_loader.lib.load_all(),
+            this.current_loader.user.load_all(),
+        ];
+        return Promise.all(ts);
+    };
+    Boradcasting = (name, data) => {
+        const d = {
+            name: name,
+            data: data
+        };
+        this.manager.forEach(x => {
+            x.ws.send(JSON.stringify(d));
+        });
+    };
 }
 exports.Server = Server;

package/dist/src/server.d.ts

@@ -0,0 +1,4 @@
+export * from './server/detail';
+export * from './server/io';
+export * from './server/plugin';
+export * from './server/server';

package/dist/src/util/console_handle.d.ts

@@ -0,0 +1,20 @@
+import { ExecutePair, ExecuteProxy, ExecuteState, FeedBack, Job, Database, Project, Record, Task } from "../interface";
+export declare class Util_Server_Console {
+    receivedPack: (model: ExecutePair, record: Record) => boolean;
+}
+export declare class Util_Server_Console_Proxy {
+    model: ExecutePair;
+    constructor(_model: ExecutePair);
+    get execute_proxy(): ExecuteProxy;
+    execute_project_start: (d: [Project, number]) => void;
+    execute_project_finish: (d: [Project, number]) => void;
+    execute_task_start: (d: [Task, number]) => void;
+    execute_task_finish: (d: Task) => void;
+    execute_subtask_start: (d: [Task, number, string]) => void;
+    execute_subtask_update: (d: [Task, number, string, ExecuteState]) => void;
+    execute_subtask_end: (d: [Task, number, string]) => void;
+    execute_job_start: (d: [Job, number, string]) => void;
+    execute_job_finish: (d: [Job, number, string, number]) => void;
+    feedback_message: (d: FeedBack) => void;
+    update_runtime_database: (d: Database) => void;
+}