verteilen-core 1.2.4 → 1.2.7

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

@@ -4,6 +4,10 @@ exports.Region_Project = void 0;
 const interface_1 = require("../../interface");
 const region_task_1 = require("./region_task");
 class Region_Project {
+    target;
+    state;
+    project;
+    task;
     constructor(_target, _project) {
         this.project = _project;
         this.target = _target;

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { ExecuteState, Task } from "../../interface";
+import { ExecuteManager } from "../execute_manager";
+import { Region_Subtask } from "./region_subtask";
+export declare class Region_Task {
+    target: ExecuteManager;
+    state: ExecuteState;
+    task: Task;
+    subtask: Region_Subtask | undefined;
+    constructor(_target: ExecuteManager, _task: Task);
+}

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

@@ -4,6 +4,10 @@ exports.Region_Task = void 0;
 const interface_1 = require("../../interface");
 const region_subtask_1 = require("./region_subtask");
 class Region_Task {
+    target;
+    state;
+    task;
+    subtask;
     constructor(_target, _task) {
         this.task = _task;
         this.target = _target;

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

@@ -0,0 +1,14 @@
+import { Project, Task } from "../../interface";
+import { ExecuteManager_Feedback } from "./feedback";
+export declare class ExecuteManager_Runner extends ExecuteManager_Feedback {
+    protected ExecuteProject: (project: Project) => void;
+    private ExecuteTask;
+    private ExecuteTask_Cronjob;
+    private ExecuteTask_Single;
+    private ExecuteTask_Setup;
+    private ExecuteTask_AllFinish;
+    private ExecuteCronTask;
+    private ExecuteJob;
+    SyncDatabase: (p: Project) => void;
+    protected Init_CronContainer: (task: Task, taskCount: number) => void;
+}

package/dist/script/execute/runner.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteManager_Runner = void 0;
+const uuid_1 = require("uuid");
+const interface_1 = require("../../interface");
+const feedback_1 = require("./feedback");
+const util_parser_1 = require("./util_parser");
+class ExecuteManager_Runner extends feedback_1.ExecuteManager_Feedback {
+    ExecuteProject = (project) => {
+        if (this.current_t == undefined && project.task.length > 0 && this.t_state != interface_1.ExecuteState.FINISH) {
+            this.current_t = project.task[0];
+            this.messager_log(`[Execute] Task Start ${this.current_t.uuid}`);
+            this.messager_log(`[Execute] Task cron state: ${this.current_t.cronjob}`);
+            this.current_job = [];
+            this.current_cron = [];
+        }
+        else if (project.task.length == 0) {
+            this.current_t = undefined;
+        }
+        if (this.current_t != undefined) {
+            this.ExecuteTask(project, this.current_t);
+        }
+        else {
+            const index = this.current_projects.findIndex(x => x.uuid == project.uuid);
+            if (index < this.current_projects.length - 1) {
+                this.messager_log(`[Execute] Project Finish ${this.current_p.uuid}`);
+                this.proxy?.executeProjectFinish([this.current_p, index]);
+                this.current_p = this.current_projects[index + 1];
+                this.proxy?.executeProjectStart([this.current_p, index + 1]);
+                this.t_state = interface_1.ExecuteState.NONE;
+            }
+            else {
+                this.messager_log(`[Execute] Project Finish ${this.current_p.uuid}`);
+                this.proxy?.executeProjectFinish([this.current_p, index]);
+                this.current_p = undefined;
+                this.state = interface_1.ExecuteState.FINISH;
+                this.t_state = interface_1.ExecuteState.NONE;
+            }
+        }
+    };
+    ExecuteTask = (project, task) => {
+        if (this.t_state == interface_1.ExecuteState.NONE) {
+            this.t_state = interface_1.ExecuteState.RUNNING;
+            this.current_multithread = task.multi ? this.get_task_multi_count(task) : 1;
+            this.current_task_count = this.get_task_state_count(task);
+        }
+        let allJobFinish = false;
+        const hasJob = task.jobs.length > 0;
+        if (!hasJob) {
+            this.proxy?.executeTaskStart([task, this.current_task_count]);
+            this.proxy?.executeTaskFinish(task);
+            this.messager_log(`[Execute] Skip ! No job exists ${task.uuid}`);
+            this.ExecuteTask_AllFinish(project, task);
+            return;
+        }
+        if (task.setupjob) {
+            allJobFinish = this.ExecuteTask_Setup(project, task, this.current_task_count);
+        }
+        else if (task.cronjob) {
+            allJobFinish = this.ExecuteTask_Cronjob(project, task, this.current_task_count);
+        }
+        else {
+            allJobFinish = this.ExecuteTask_Single(project, task, this.current_task_count);
+        }
+        if (allJobFinish) {
+            this.ExecuteTask_AllFinish(project, task);
+        }
+    };
+    ExecuteTask_Cronjob(project, task, taskCount) {
+        let ns = this.get_idle_open();
+        let allJobFinish = false;
+        if (this.current_cron.length == 0) {
+            this.Init_CronContainer(task, taskCount);
+            this.messager_log(`[Execute] TaskCount: ${taskCount}`);
+        }
+        else {
+            const worker = this.current_cron.filter(x => x.uuid != '').map(x => x.uuid);
+            const counter = [];
+            worker.forEach(uuid => {
+                const index = counter.findIndex(x => x[0] == uuid);
+                if (index == -1)
+                    counter.push([uuid, 1]);
+                else
+                    counter[index][1] += 1;
+            });
+            const fullLoadUUID = counter.filter(x => x[1] >= this.current_multithread).map(x => x[0]);
+            ns = ns.filter(x => !fullLoadUUID.includes(x.uuid));
+        }
+        if (this.check_all_cron_end()) {
+            allJobFinish = true;
+        }
+        else {
+            const needs = this.current_cron.filter(x => x.uuid == '' && x.work.filter(y => y.state != interface_1.ExecuteState.FINISH && y.state != interface_1.ExecuteState.ERROR).length > 0);
+            const min = Math.min(needs.length, ns.length);
+            for (let i = 0; i < min; i++) {
+                needs[i].uuid = ns[i].uuid;
+            }
+            const single = this.current_cron.filter(x => x.uuid != '');
+            for (var cronwork of single) {
+                const index = this.current_nodes.findIndex(x => x.uuid == cronwork.uuid);
+                if (index != -1) {
+                    this.ExecuteCronTask(project, task, cronwork, this.current_nodes[index]);
+                }
+            }
+        }
+        return allJobFinish;
+    }
+    ExecuteTask_Single(project, task, taskCount) {
+        let allJobFinish = false;
+        let ns = [];
+        if (this.current_job.length > 0) {
+            const last = this.current_nodes.find(x => x.uuid == this.current_job[0].uuid);
+            if (last == undefined) {
+                ns = this.get_idle();
+                this.current_job = [];
+            }
+            else {
+                ns = [last];
+                if (ns[0].websocket.readyState != 1) {
+                    ns = this.get_idle();
+                    this.current_job = [];
+                }
+            }
+        }
+        else {
+            this.sync_local_para(this.localPara);
+            ns = this.get_idle();
+            if (ns.length > 0) {
+                this.proxy?.executeTaskStart([task, taskCount]);
+                this.proxy?.executeSubtaskStart([task, 0, ns[0].uuid]);
+            }
+        }
+        if (ns.length > 0 && ns[0].websocket.readyState == 1 && this.check_socket_state(ns[0]) != interface_1.ExecuteState.RUNNING) {
+            if (this.check_single_end()) {
+                allJobFinish = true;
+            }
+            else {
+                if (this.current_job.length != task.jobs.length) {
+                    const job = JSON.parse(JSON.stringify(task.jobs[this.current_job.length]));
+                    const runtime = (0, uuid_1.v6)();
+                    this.current_job.push({
+                        uuid: ns[0].uuid,
+                        runtime: runtime,
+                        state: interface_1.ExecuteState.RUNNING,
+                        job: job
+                    });
+                    job.index = 0;
+                    job.runtime_uuid = runtime;
+                    this.ExecuteJob(project, task, job, ns[0], false);
+                }
+            }
+        }
+        return allJobFinish;
+    }
+    ExecuteTask_Setup(project, task, taskCount) {
+        let ns = this.get_idle_open();
+        let allJobFinish = false;
+        if (this.current_cron.length == 0) {
+            this.Init_CronContainer(task, taskCount);
+            this.messager_log(`[Execute] TaskCount: ${taskCount}`);
+            for (let i = 0; i < this.current_cron.length; i++) {
+                this.current_cron[i].uuid = this.current_nodes[i].uuid;
+            }
+        }
+        if (this.check_all_cron_end()) {
+            allJobFinish = true;
+        }
+        else {
+            const single = this.current_cron.filter(x => x.uuid != '');
+            for (var cronwork of single) {
+                const index = this.current_nodes.findIndex(x => x.uuid == cronwork.uuid);
+                if (index != -1) {
+                    this.ExecuteCronTask(project, task, cronwork, this.current_nodes[index]);
+                }
+            }
+        }
+        return allJobFinish;
+    }
+    ExecuteTask_AllFinish(project, task) {
+        this.proxy?.executeTaskFinish(task);
+        this.messager_log(`[Execute] Task Finish ${task.uuid}`);
+        const index = project.task.findIndex(x => x.uuid == task.uuid);
+        if (index == project.task.length - 1) {
+            this.current_t = undefined;
+            this.t_state = interface_1.ExecuteState.FINISH;
+        }
+        else {
+            this.current_t = project.task[index + 1];
+            this.t_state = interface_1.ExecuteState.NONE;
+        }
+        this.current_job = [];
+        this.current_cron = [];
+    }
+    ExecuteCronTask = (project, task, work, ns) => {
+        if (ns.current_job.length < this.current_multithread) {
+            const rindex = work.work.findIndex(x => x.state == interface_1.ExecuteState.RUNNING);
+            if (rindex != -1)
+                return;
+            const index = work.work.findIndex(x => x.state == interface_1.ExecuteState.NONE);
+            if (index == 0)
+                this.proxy?.executeSubtaskStart([task, work.id, ns.uuid]);
+            if (index == -1)
+                return;
+            work.work[index].state = interface_1.ExecuteState.RUNNING;
+            try {
+                const job = JSON.parse(JSON.stringify(task.jobs[index]));
+                job.index = work.id;
+                job.runtime_uuid = work.work[index].runtime;
+                this.ExecuteJob(project, task, job, ns, true);
+            }
+            catch (err) {
+                this.messager_log(`[ExecuteCronTask Error] UUID: ${task.uuid}, Job count: ${task.jobs.length}, index: ${index}`);
+            }
+        }
+    };
+    ExecuteJob = (project, task, job, wss, iscron) => {
+        const n = job.index;
+        this.messager_log(`[Execute] Job Start ${n}  ${job.uuid}  ${wss.uuid}`);
+        this.proxy?.executeJobStart([job, n, wss.uuid]);
+        ExecuteManager_Runner.string_args_transform(task, job, this.messager_log, this.localPara, n);
+        const h = {
+            name: 'execute_job',
+            channel: this.uuid,
+            data: job
+        };
+        wss.current_job.push(job.runtime_uuid);
+        const stringdata = JSON.stringify(h);
+        wss.websocket.send(stringdata);
+        this.jobstack = this.jobstack + 1;
+    };
+    SyncDatabase = (p) => {
+        this.localPara = JSON.parse(JSON.stringify(p.database));
+        this.messager_log("[Execute] Sync Database !");
+        this.messager_log("[Execute] Generate local database object");
+        for (let i = 0; i < this.localPara.containers.length; i++) {
+            if (this.localPara.containers[i].type == interface_1.DataType.Expression && this.localPara.containers[i].meta != undefined) {
+                const text = `%{${this.localPara.containers[i].meta}}%`;
+                const e = new util_parser_1.Util_Parser([...util_parser_1.Util_Parser.to_keyvalue(this.localPara)]);
+                this.localPara.containers[i].value = e.replacePara(text);
+            }
+        }
+        this.sync_local_para(this.localPara);
+    };
+    Init_CronContainer = (task, taskCount) => {
+        this.sync_local_para(this.localPara);
+        this.current_cron = [];
+        for (let i = 0; i < taskCount; i++) {
+            const d = {
+                id: i,
+                uuid: "",
+                work: task.jobs.map(x => ({
+                    uuid: x.uuid,
+                    runtime: '',
+                    state: interface_1.ExecuteState.NONE,
+                    job: x
+                }))
+            };
+            d.work.forEach((x, j) => x.runtime = (0, uuid_1.v6)({}, undefined, i * taskCount + j));
+            this.current_cron.push(d);
+        }
+        this.proxy?.executeTaskStart([task, taskCount]);
+    };
+}
+exports.ExecuteManager_Runner = ExecuteManager_Runner;

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

@@ -0,0 +1,14 @@
+import { KeyValue, Database, DatabaseContainer } from "../../interface";
+export declare class Util_Parser {
+    paras: Array<KeyValue>;
+    get count(): number;
+    constructor(_paras: Array<KeyValue>);
+    clone: () => Util_Parser;
+    static to_keyvalue: (p: Database) => Array<KeyValue>;
+    private static getDeepKeys;
+    static _to_keyvalue: (p: Array<DatabaseContainer>) => Array<KeyValue>;
+    static replaceAll: (str: string, fi: string, tar: string) => string;
+    replacePara: (text: string) => string;
+    parse: (str: string) => string;
+    private _replacePara;
+}

package/dist/script/execute/util_parser.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Util_Parser = void 0;
+const expressionparser_1 = require("expressionparser");
+const interface_1 = require("../../interface");
+class Util_Parser {
+    paras = [];
+    get count() {
+        return this.paras.length;
+    }
+    constructor(_paras) {
+        this.paras = _paras;
+    }
+    clone = () => {
+        const b = JSON.parse(JSON.stringify(this.paras));
+        return new Util_Parser(b);
+    };
+    static to_keyvalue = (p) => {
+        return [
+            ...this._to_keyvalue(p.containers)
+        ];
+    };
+    static getDeepKeys = (obj, name) => {
+        let keys = [];
+        for (var key in obj) {
+            keys.push([name ? name + "." + key : key, obj[key]]);
+            if (typeof obj[key] === "object") {
+                if (Array.isArray(obj[key])) {
+                    if (typeof obj[key]['length'] === 'number') {
+                        keys.push([name ? name + "." + key + ".length" : key + ".length", obj[key]['length']]);
+                    }
+                }
+                var subkeys = this.getDeepKeys(obj[key]);
+                keys = keys.concat(subkeys.map(function (subkey) {
+                    return [name ? name + "." + key + "." + subkey[0] : key + "." + subkey[0], subkey[1]];
+                }));
+            }
+        }
+        return keys;
+    };
+    static _to_keyvalue = (p) => {
+        const r = [];
+        r.push(...p.filter(x => x.type == interface_1.DataType.Boolean || x.type == interface_1.DataType.String || x.type == interface_1.DataType.Textarea || x.type == interface_1.DataType.Number || x.type == interface_1.DataType.Expression).map(x => { return { key: x.name, value: x.value.toString() }; }));
+        const objs = p.filter(x => x.type == interface_1.DataType.Object);
+        const lists = p.filter(x => x.type == interface_1.DataType.List);
+        const selects = p.filter(x => x.type == interface_1.DataType.Select);
+        for (const obj of objs) {
+            const v = obj.value;
+            const keys = this.getDeepKeys(v, obj.name);
+            r.push(...keys.map(x => { return { key: x[0], value: x[1].toString() }; }));
+        }
+        for (const list of lists) {
+            const a = list.value;
+            r.push(...a.map((x, index) => { return { key: list.name + "." + String(index), value: x }; }));
+            r.push({ key: list.name + ".length", value: a.length });
+        }
+        for (const select of selects) {
+            const a = select.meta;
+            const target = a[select.value];
+            r.push({ key: select.name, value: target });
+        }
+        return r;
+    };
+    static replaceAll = (str, fi, tar) => {
+        let p = str;
+        while (p.includes(fi))
+            p = p.replace(fi, tar);
+        return p;
+    };
+    replacePara = (text) => {
+        let buffer = '';
+        let store = '';
+        let state = false;
+        let ignore = -1;
+        let useExp = false;
+        for (const v of text) {
+            if (v == interface_1.IGNORE_CHARACTER && ignore == -1)
+                ignore = 0;
+            else if (ignore == 0)
+                ignore = 1;
+            else if (ignore == 1)
+                ignore = 2;
+            else if (ignore == 2)
+                ignore = -1;
+            if (v == interface_1.ENV_CHARACTER && ignore == -1) {
+                state = !state;
+                if (!state) {
+                    if (useExp) {
+                        buffer += this.parse(store);
+                    }
+                    else {
+                        buffer += this._replacePara(store);
+                    }
+                    store = "";
+                    useExp = false;
+                }
+            }
+            if (v == '{' && state && store.length == 0)
+                useExp = true;
+            if (state && v != interface_1.ENV_CHARACTER && (ignore != 0))
+                store += v;
+            if (!state && v != interface_1.ENV_CHARACTER && (ignore != 0))
+                buffer += (ignore > 0 ? (interface_1.ENV_CHARACTER + v) : v);
+        }
+        return buffer;
+    };
+    parse = (str) => {
+        str = str.substring(1, str.length - 1);
+        const parser = (0, expressionparser_1.init)(expressionparser_1.formula, (term) => {
+            if (term.includes("_ck_")) {
+                const index = this.paras.findIndex(x => x.key == "ck");
+                if (index != -1)
+                    term = Util_Parser.replaceAll(term, "_ck_", this.paras[index].value);
+            }
+            const index = this.paras.findIndex(x => x.key == term);
+            if (index != -1) {
+                const n = Number(this.paras[index].value);
+                if (Number.isNaN(n))
+                    return this.paras[index].value;
+                return n;
+            }
+            else
+                return 0;
+        });
+        const r = parser.expressionToValue(str).toString();
+        return r;
+    };
+    _replacePara = (store) => {
+        const index = this.paras.findIndex(x => x.key == store);
+        if (index == -1)
+            return `%${store}%`;
+        return this.paras[index].value;
+    };
+}
+exports.Util_Parser = Util_Parser;

package/dist/script/execute_manager.d.ts

@@ -0,0 +1,25 @@
+import { Libraries, WebsocketPack } from "../interface";
+import { ExecuteManager_Runner } from "./execute/runner";
+export declare class ExecuteManager extends ExecuteManager_Runner {
+    Update: () => void;
+    Stop: () => void;
+    Register: (lib?: Libraries) => number;
+    Clean: () => void;
+    Release: () => void;
+    NewConnection: (source: WebsocketPack) => void;
+    Disconnect: (source: WebsocketPack) => void;
+    ClearState: (task_index: number) => void;
+    SkipProject: () => number;
+    PreviousProject: () => number;
+    SkipTask: () => number;
+    PreviousTask: () => number;
+    SkipSubTask: (v: number) => number;
+    private jumpProject;
+    private jumpTask;
+    private skipProjectFirst;
+    private _jumpProject;
+    private skipTaskFirst;
+    private previousTaskFirst;
+    private skipTask;
+    private previousTask;
+}