verteilen-core 1.2.22 → 1.3.1

package/dist/interface/base.d.ts

@@ -1,8 +1,12 @@
-import { DataType, DataTypeBase } from "./enum";
+import { DataType, DataTypeBase, ServiceMode } from "./enum";
 import { ACLType, LocalPermission as LocalPermission } from "./server";
+import { TaskLogic } from "./struct";
 export interface DatabaseConfigTrigger {
     types: Array<DataTypeBase>;
 }
+export interface DataHeader {
+    uuid: string;
+}
 export interface DatabaseContainer {
     name: string;
     meta?: any;
@@ -17,17 +21,25 @@ export interface Property {
     expression: string;
     deep?: number;
 }
-export interface Database {
-    uuid: string;
+export interface Service extends DataHeader {
+    title: string;
+    description: string;
+    meta: any;
+    type: ServiceMode;
+    timer: string;
+    project: string;
+    permission?: LocalPermission;
+    acl?: ACLType;
+}
+export interface Database extends DataHeader {
     title: string;
     canWrite: boolean;
     containers: Array<DatabaseContainer>;
     permission?: LocalPermission;
 }
-export interface Job {
+export interface Job extends DataHeader {
     index?: number;
     meta?: any;
-    uuid: string;
     runtime_uuid?: string;
     category: number;
     type: number;
@@ -37,9 +49,9 @@ export interface Job {
     boolean_args: Array<boolean>;
     id_args: Array<boolean>;
     permission?: LocalPermission;
+    acl?: ACLType;
 }
-export interface Task {
-    uuid: string;
+export interface Task extends DataHeader {
     title: string;
     description: string;
     setupjob: boolean;
@@ -48,23 +60,25 @@ export interface Task {
     multi: boolean;
     multiKey: string;
     properties: Array<Property>;
+    logic?: TaskLogic;
     jobs: Array<Job>;
+    jobs_uuid: Array<string>;
     permission?: LocalPermission;
+    acl?: ACLType;
 }
-export interface Project {
+export interface Project extends DataHeader {
     owner?: string;
-    uuid: string;
     title: string;
     description?: string;
     database_uuid: string;
     database?: Database;
-    task: Array<Task>;
+    tasks: Array<Task>;
+    tasks_uuid: Array<string>;
     permission?: LocalPermission;
     acl?: ACLType;
 }
-export interface Node {
+export interface Node extends DataHeader {
     cluster: boolean;
-    uuid: string;
     parent?: string;
     url: string;
     permission?: LocalPermission;

package/dist/interface/enum.d.ts

@@ -1,3 +1,8 @@
+export declare enum TaskLogicType {
+    GROUP = 0,
+    ADD = 1,
+    OR = 2
+}
 export declare enum SocketState {
     CONNECTING = 0,
     OPEN = 1,
@@ -95,11 +100,13 @@ export declare enum RenderUpdateType {
 }
 export declare enum RecordType {
     PROJECT = 0,
-    Database = 1,
-    NODE = 2,
-    LOG = 3,
-    LIB = 4,
-    USER = 5
+    TASK = 1,
+    JOB = 2,
+    DATABASE = 3,
+    NODE = 4,
+    LOG = 5,
+    LIB = 6,
+    USER = 7
 }
 export declare enum JavascriptLib {
     ALL = 127,

package/dist/interface/enum.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseTemplateText = exports.ProjectTemplateText = exports.JobType2Text = exports.JobTypeText = exports.JobResultText = exports.ConnectionText = exports.JobCategoryText = exports.ExecuteStateText = exports.DataTypeText = exports.ServiceMode = exports.JavascriptLib = exports.RecordType = exports.RenderUpdateType = exports.ExecuteState = exports.DatabaseTemplate = exports.ProjectTemplate = exports.JobType2 = exports.JobType = exports.ConditionResult = exports.JobCategory = exports.FrontendUpdate = exports.ResourceType = exports.DataTypeBase = exports.BackendType = exports.DataType = exports.SocketState = void 0;
+exports.DatabaseTemplateText = exports.ProjectTemplateText = exports.JobType2Text = exports.JobTypeText = exports.JobResultText = exports.ConnectionText = exports.JobCategoryText = exports.ExecuteStateText = exports.DataTypeText = exports.ServiceMode = exports.JavascriptLib = exports.RecordType = exports.RenderUpdateType = exports.ExecuteState = exports.DatabaseTemplate = exports.ProjectTemplate = exports.JobType2 = exports.JobType = exports.ConditionResult = exports.JobCategory = exports.FrontendUpdate = exports.ResourceType = exports.DataTypeBase = exports.BackendType = exports.DataType = exports.SocketState = exports.TaskLogicType = void 0;
+var TaskLogicType;
+(function (TaskLogicType) {
+    TaskLogicType[TaskLogicType["GROUP"] = 0] = "GROUP";
+    TaskLogicType[TaskLogicType["ADD"] = 1] = "ADD";
+    TaskLogicType[TaskLogicType["OR"] = 2] = "OR";
+})(TaskLogicType || (exports.TaskLogicType = TaskLogicType = {}));
 var SocketState;
 (function (SocketState) {
     SocketState[SocketState["CONNECTING"] = 0] = "CONNECTING";
@@ -113,11 +119,13 @@ var RenderUpdateType;
 var RecordType;
 (function (RecordType) {
     RecordType[RecordType["PROJECT"] = 0] = "PROJECT";
-    RecordType[RecordType["Database"] = 1] = "Database";
-    RecordType[RecordType["NODE"] = 2] = "NODE";
-    RecordType[RecordType["LOG"] = 3] = "LOG";
-    RecordType[RecordType["LIB"] = 4] = "LIB";
-    RecordType[RecordType["USER"] = 5] = "USER";
+    RecordType[RecordType["TASK"] = 1] = "TASK";
+    RecordType[RecordType["JOB"] = 2] = "JOB";
+    RecordType[RecordType["DATABASE"] = 3] = "DATABASE";
+    RecordType[RecordType["NODE"] = 4] = "NODE";
+    RecordType[RecordType["LOG"] = 5] = "LOG";
+    RecordType[RecordType["LIB"] = 6] = "LIB";
+    RecordType[RecordType["USER"] = 7] = "USER";
 })(RecordType || (exports.RecordType = RecordType = {}));
 var JavascriptLib;
 (function (JavascriptLib) {

package/dist/interface/struct.d.ts

@@ -1,6 +1,6 @@
 import { DatabaseContainer, Project } from "./base";
 import ws from 'ws';
-import { ServiceMode } from "./enum";
+import { ServiceMode, TaskLogicType } from "./enum";
 import { ACLType, LocalPermission } from "./server";
 type ProjectCall = (p: Project) => Project;
 type DatabaseCall = () => Array<DatabaseContainer>;
@@ -186,4 +186,12 @@ export interface BuildinAssets {
 export interface ServiceConfig {
     mode: ServiceMode;
 }
+export interface TaskLogicUnit {
+    type: TaskLogicType;
+    job: string;
+    children: Array<TaskLogicUnit>;
+}
+export interface TaskLogic {
+    group: Array<TaskLogicUnit>;
+}
 export {};

package/dist/interface.d.ts

@@ -19,7 +19,7 @@ export * from './interface/struct';
 export * from './interface/table';
 export * from './interface/ui';
 export * as I18N from './plugins/i18n';
-export * as Execute_PART from './script/execute/interface';
+export * as Execute_PART from './script/execute';
 export * as Execute_ConsoleManager from './script/console_manager';
 export * as Execute_ConsoleServerManager from './script/console_server_manager';
 export * as Execute_ExecuteManager from './script/execute_manager';

package/dist/interface.js

@@ -58,7 +58,7 @@ __exportStar(require("./interface/struct"), exports);
 __exportStar(require("./interface/table"), exports);
 __exportStar(require("./interface/ui"), exports);
 exports.I18N = __importStar(require("./plugins/i18n"));
-exports.Execute_PART = __importStar(require("./script/execute/interface"));
+exports.Execute_PART = __importStar(require("./script/execute"));
 exports.Execute_ConsoleManager = __importStar(require("./script/console_manager"));
 exports.Execute_ConsoleServerManager = __importStar(require("./script/console_server_manager"));
 exports.Execute_ExecuteManager = __importStar(require("./script/execute_manager"));

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

@@ -1,18 +1,13 @@
 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';
+import { Region_Project } from './region_project';
 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;
@@ -22,7 +17,14 @@ export declare class ExecuteManager_Base {
     localPara: Database | undefined;
     websocket_manager: WebsocketManager;
     messager_log: Messager;
+    runner: Region_Project | undefined;
     constructor(_name: string, _websocket_manager: WebsocketManager, _messager_log: Messager, _record: Record);
+    get current_p(): Project | undefined;
+    get current_t(): Task | undefined;
+    get current_multithread(): number;
+    get current_task_count(): number;
+    get current_cron(): Array<CronJobState>;
+    get current_job(): Array<WorkState>;
     protected sync_local_para: (target: Database) => void;
     protected sync_para: (target: Database, source: WebsocketPack) => void;
     protected release: (source: WebsocketPack) => void;

package/dist/script/execute/base.js

@@ -8,14 +8,8 @@ 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;
@@ -25,6 +19,7 @@ class ExecuteManager_Base {
     localPara = undefined;
     websocket_manager;
     messager_log;
+    runner;
     constructor(_name, _websocket_manager, _messager_log, _record) {
         this.name = _name;
         this.uuid = (0, uuid_1.v6)();
@@ -32,6 +27,24 @@ class ExecuteManager_Base {
         this.websocket_manager = _websocket_manager;
         this.messager_log = _messager_log;
     }
+    get current_p() {
+        return this.runner?.project;
+    }
+    get current_t() {
+        return this.runner?.runner?.task;
+    }
+    get current_multithread() {
+        return this.runner?.runner?.multithread ?? 1;
+    }
+    get current_task_count() {
+        return this.runner?.runner?.task_count ?? 0;
+    }
+    get current_cron() {
+        return this.runner?.runner?.cron ?? [];
+    }
+    get current_job() {
+        return this.runner?.runner?.job ?? [];
+    }
     sync_local_para = (target) => {
         this.current_nodes.forEach(x => this.sync_para(target, x));
         this.proxy?.updateDatabase(target);
@@ -76,7 +89,7 @@ class ExecuteManager_Base {
             return false;
         }
         projects.forEach(x => {
-            x.task.forEach(t => {
+            x.tasks.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) {
@@ -110,7 +123,7 @@ class ExecuteManager_Base {
     filter_lib = (projects, lib) => {
         const r = { libs: [] };
         projects.forEach(x => {
-            x.task.forEach(y => {
+            x.tasks.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))

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

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);
+__exportStar(require("./feedback"), exports);
+__exportStar(require("./region_job"), exports);
+__exportStar(require("./region_project"), exports);
+__exportStar(require("./region_subtask"), exports);
+__exportStar(require("./region_task"), exports);
+__exportStar(require("./runner"), exports);
+__exportStar(require("./util_parser"), exports);

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

@@ -1,5 +1,13 @@
+import { Job, Task, WebsocketPack } from "../../interface";
 import { ExecuteManager } from "../execute_manager";
 export declare class Region_Job {
     target: ExecuteManager;
-    constructor(_target: ExecuteManager);
+    task: Task;
+    job: Job;
+    wss: WebsocketPack;
+    constructor(target: ExecuteManager, task: Task, job: Job, wss: WebsocketPack);
+    RUN: () => void;
+    private string_args_transform;
+    private property_update;
+    private database_update;
 }

package/dist/script/execute/region_job.js

@@ -1,10 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Region_Job = void 0;
+const interface_1 = require("../../interface");
+const util_parser_1 = require("./util_parser");
 class Region_Job {
     target;
-    constructor(_target) {
-        this.target = _target;
+    task;
+    job;
+    wss;
+    constructor(target, task, job, wss) {
+        this.target = target;
+        this.task = task;
+        this.job = job;
+        this.wss = wss;
     }
+    RUN = () => {
+        const n = this.job.index;
+        this.target.messager_log(`[Execute] Job Start ${n}  ${this.job.uuid}  ${this.wss.uuid}`);
+        this.target.proxy?.executeJobStart([this.job, n, this.wss.uuid]);
+        this.string_args_transform(this.task, this.job, this.target.localPara, n);
+        const h = {
+            name: 'execute_job',
+            channel: this.target.uuid,
+            data: this.job
+        };
+        this.wss.current_job.push(this.job.runtime_uuid);
+        const stringdata = JSON.stringify(h);
+        this.wss.websocket.send(stringdata);
+        this.target.jobstack = this.target.jobstack + 1;
+    };
+    string_args_transform = (task, job, localPara, n) => {
+        let e = this.database_update(localPara, n);
+        e = this.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]);
+        }
+    };
+    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;
+    };
+    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.Region_Job = Region_Job;

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

@@ -1,10 +1,10 @@
-import { ExecuteState, Project } from "../../interface";
+import { 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;
+    runner: Region_Task | undefined;
     constructor(_target: ExecuteManager, _project: Project);
+    RUN: () => void;
 }

package/dist/script/execute/region_project.js

@@ -5,16 +5,41 @@ const interface_1 = require("../../interface");
 const region_task_1 = require("./region_task");
 class Region_Project {
     target;
-    state;
     project;
-    task;
+    runner;
     constructor(_target, _project) {
         this.project = _project;
         this.target = _target;
-        this.state = _project.task.length > 0 ? interface_1.ExecuteState.NONE : interface_1.ExecuteState.SKIP;
-        if (_project.task.length > 0) {
-            this.task = new region_task_1.Region_Task(_target, _project.task[0]);
-        }
     }
+    RUN = () => {
+        if (this.runner == undefined && this.project.tasks.length > 0 && this.target.t_state != interface_1.ExecuteState.FINISH) {
+            this.runner = new region_task_1.Region_Task(this.target, this.project.tasks[0]);
+            this.target.messager_log(`[Execute] Task Start ${this.runner.task.uuid}`);
+            this.target.messager_log(`[Execute] Task cron state: ${this.runner.task.cronjob}`);
+        }
+        else if (this.project.tasks.length == 0) {
+            this.runner = undefined;
+        }
+        if (this.runner != undefined) {
+            this.runner.RUN();
+        }
+        else {
+            const index = this.target.current_projects.findIndex(x => x.uuid == this.project.uuid);
+            if (index < this.target.current_projects.length - 1) {
+                this.target.messager_log(`[Execute] Project Finish ${this.project.uuid}`);
+                this.target.proxy?.executeProjectFinish([this.project, index]);
+                this.target.runner = new Region_Project(this.target, this.target.current_projects[index + 1]);
+                this.target.proxy?.executeProjectStart([this.project, index + 1]);
+                this.target.t_state = interface_1.ExecuteState.NONE;
+            }
+            else {
+                this.target.messager_log(`[Execute] Project Finish ${this.project.uuid}`);
+                this.target.proxy?.executeProjectFinish([this.project, index]);
+                this.target.runner = undefined;
+                this.target.state = interface_1.ExecuteState.FINISH;
+                this.target.t_state = interface_1.ExecuteState.NONE;
+            }
+        }
+    };
 }
 exports.Region_Project = Region_Project;

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

@@ -1,5 +1,12 @@
+import { WebsocketPack, CronJobState, Task } from "../../interface";
 import { ExecuteManager } from "../execute_manager";
+import { Region_Job } from "./region_job";
 export declare class Region_Subtask {
     target: ExecuteManager;
-    constructor(_target: ExecuteManager);
+    work: CronJobState;
+    ns: WebsocketPack;
+    runner: Region_Job | undefined;
+    constructor(target: ExecuteManager, work: CronJobState, ns: WebsocketPack);
+    get task(): Task;
+    RUN: () => void;
 }

package/dist/script/execute/region_subtask.js

@@ -1,10 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Region_Subtask = void 0;
+const interface_1 = require("../../interface");
+const region_job_1 = require("./region_job");
 class Region_Subtask {
     target;
-    constructor(_target) {
-        this.target = _target;
+    work;
+    ns;
+    runner;
+    constructor(target, work, ns) {
+        this.target = target;
+        this.work = work;
+        this.ns = ns;
     }
+    get task() {
+        return this.target.current_t;
+    }
+    RUN = () => {
+        if (this.ns.current_job.length < this.target.current_multithread) {
+            const rindex = this.work.work.findIndex(x => x.state == interface_1.ExecuteState.RUNNING);
+            if (rindex != -1)
+                return;
+            const index = this.work.work.findIndex(x => x.state == interface_1.ExecuteState.NONE);
+            if (index == 0)
+                this.target.proxy?.executeSubtaskStart([this.task, this.work.id, this.ns.uuid]);
+            if (index == -1)
+                return;
+            this.work.work[index].state = interface_1.ExecuteState.RUNNING;
+            try {
+                const job = JSON.parse(JSON.stringify(this.task.jobs[index]));
+                job.index = this.work.id;
+                job.runtime_uuid = this.work.work[index].runtime;
+                if (this.runner == undefined) {
+                    this.runner = new region_job_1.Region_Job(this.target, this.task, job, this.ns);
+                }
+                this.runner.RUN();
+            }
+            catch (err) {
+                this.target.messager_log(`[ExecuteCronTask Error] UUID: ${this.task.uuid}, Job count: ${this.task.jobs.length}, index: ${index}`);
+            }
+        }
+    };
 }
 exports.Region_Subtask = Region_Subtask;

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

@@ -1,10 +1,38 @@
-import { ExecuteState, Task } from "../../interface";
+import { CronJobState, Database, ExecuteState, Project, Task, WebsocketPack, WorkState } from "../../interface";
 import { ExecuteManager } from "../execute_manager";
+import { Region_Job } from "./region_job";
+import { Region_Project } from "./region_project";
 import { Region_Subtask } from "./region_subtask";
+import { Util_Parser } from "./util_parser";
 export declare class Region_Task {
     target: ExecuteManager;
-    state: ExecuteState;
     task: Task;
-    subtask: Region_Subtask | undefined;
-    constructor(_target: ExecuteManager, _task: Task);
+    multithread: number;
+    task_count: number;
+    cron: Array<CronJobState>;
+    job: Array<WorkState>;
+    runners: Array<Region_Subtask | undefined>;
+    jrunners: Array<Region_Job | undefined>;
+    constructor(target: ExecuteManager, task: Task);
+    get project(): Project;
+    get parent(): Region_Project;
+    RUN: () => void;
+    ExecuteTask_Cronjob(project: Project, task: Task, taskCount: number): boolean;
+    ExecuteTask_Single(project: Project, task: Task, taskCount: number): boolean;
+    ExecuteTask_Setup(project: Project, task: Task, taskCount: number): boolean;
+    ExecuteTask_AllFinish(project: Project, task: Task): void;
+    Init_CronContainer: (taskCount: number) => void;
+    get_idle: () => Array<WebsocketPack>;
+    check_socket_state: (target: WebsocketPack) => ExecuteState.NONE | ExecuteState.RUNNING;
+    sync_local_para: (target: Database) => void;
+    sync_para: (target: Database, source: WebsocketPack) => void;
+    get_idle_open: () => Array<WebsocketPack>;
+    check_all_cron_end: () => boolean;
+    check_cron_end: (cron: CronJobState) => boolean;
+    check_single_end: () => boolean;
+    get_task_multi_count: (t: Task) => number;
+    get_task_state_count(t: Task): number;
+    get_number(key: string): number;
+    get_number_global(key: string, localPara: Database | undefined): number;
+    database_update: (localPara: Database, n?: number) => Util_Parser;
 }