@ejfdelgado/ejflab-common 1.0.0

package/src/flowchart/steps/CommandBasic.js

@@ -0,0 +1,32 @@
+const { StepBasic } = require("./StepBasic");
+
+class CommandBasic extends StepBasic {
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.alwaysEvaluateCanContinue = false;
+        super.autoDelete = true;
+    }
+    async canContinue() {
+        return true;
+    }
+    async execLast(options = {}) {
+        const lastArg = this.args[this.args.length - 1];
+        if (options.isCommand || ["always", "start"].indexOf(lastArg) >= 0) {
+            if (lastArg == "always") {
+                super.alwaysEvaluateCanContinue = true;
+            }
+            return await this.computation();
+        }
+    }
+    async arrowAccepted() {
+        const lastArg = this.args[this.args.length - 1];
+        if (lastArg == "end") {
+            return await this.computation();
+        }
+    }
+    async computation() { }
+}
+
+module.exports = {
+    CommandBasic
+};

package/src/flowchart/steps/CommandInc.js

@@ -0,0 +1,19 @@
+const { SimpleObj } = require("../../SimpleObj");
+const { CommandBasic } = require("./CommandBasic");
+
+class CommandInc extends CommandBasic {
+    async computation() {
+        const path = this.args[0];
+        let ammount = 1;
+        if (typeof this.args[1] == "number") {
+            ammount = this.args[1];
+        }
+        let old = SimpleObj.getValue(this.context.data, path, 0);
+        old += ammount;
+        SimpleObj.recreate(this.context.data, path, old);
+    }
+}
+
+module.exports = {
+    CommandInc
+};

package/src/flowchart/steps/CommandMilvus.js

@@ -0,0 +1,47 @@
+const { SimpleObj } = require("../../SimpleObj");
+const { CommandBasic } = require("./CommandBasic");
+
+class CommandMilvus extends CommandBasic {
+    async dataBaseRecreate(milvusSrv, client, dataBaseName) {
+        //await milvusSrv.introspect(client);
+        await milvusSrv.useDatabase(client, dataBaseName, true);
+    }
+    async dataBaseCreate(milvusSrv, client, dataBaseName) {
+        //await milvusSrv.introspect(client);
+        await milvusSrv.useDatabase(client, dataBaseName, false);
+    }
+    async collectionCreate(milvusSrv, client, dataBaseName, configuration) {
+        await milvusSrv.useDatabase(client, dataBaseName, false);
+        await milvusSrv.createCollectionWithSchema(client, configuration);
+    }
+    async computation() {
+        const action = this.args[0];
+        const dataBaseName = this.args[1];
+
+        const milvusSrv = this.context.getSuperContext().getMilvusClient();
+        const { client } = milvusSrv.connect();
+        if (action == "database.create") {
+            await this.dataBaseCreate(milvusSrv, client, dataBaseName);
+        } else if (action == "database.recreate") {
+            await this.dataBaseRecreate(milvusSrv, client, dataBaseName);
+        } else if (action == "collection.create") {
+            const collectionConfig = this.args[2];
+            const configuration = SimpleObj.getValue(this.context.data, collectionConfig, null);
+            if (configuration) {
+                await this.collectionCreate(milvusSrv, client, dataBaseName, configuration);
+            } else {
+                throw new Error(`No MILVUS configuration in ${collectionConfig}`);
+            }
+        } else if (action == "introspect") {
+            await milvusSrv.introspect(client);
+        } else if (action == "database.destroy") {
+            await milvusSrv.dropDatabase(client, dataBaseName);
+        } else if (action == "database.destroy_temp") {
+            await milvusSrv.dropDatabaseTemp(client);
+        }
+    }
+}
+
+module.exports = {
+    CommandMilvus
+};

package/src/flowchart/steps/CommandMinio.js

@@ -0,0 +1,28 @@
+const { SimpleObj } = require("../../SimpleObj");
+const { CommandBasic } = require("./CommandBasic");
+
+class CommandMinio extends CommandBasic {
+    async computation() {
+        const action = this.args[0];
+        const bucketName = this.args[1];
+        const minioSrv = this.context.getSuperContext().getMinioClient();
+
+        if (action == "write") {
+            const objectPath = this.args[2];
+            const sourcePath = this.args[3];
+            const metadata = this.args[4];
+            //console.log(`CommandMinio.write bucket ${bucketName} objectPath ${objectPath} from ${sourcePath}`);
+            //console.log(metadata);
+            const bytes = this.resolveArgument(sourcePath);
+            // Armar el payload para minio
+            const payload = {
+                objectPath, bytes, metadata
+            }
+            await minioSrv.writeFileLocal(bucketName, [payload]);
+        }
+    }
+}
+
+module.exports = {
+    CommandMinio
+};

package/src/flowchart/steps/CommandMongo.js

@@ -0,0 +1,59 @@
+const { SimpleObj } = require("../../SimpleObj");
+const { CommandBasic } = require("./CommandBasic");
+
+class CommandMongo extends CommandBasic {
+    async computation() {
+        const action = this.args[0];
+        const dataBaseName = this.args[1];
+
+        const mongoSrv = this.context.getSuperContext().getMongoClient();
+        if (action == "write") {
+            const collectionName = this.args[2];
+            const path = this.args[3];
+            let payload = SimpleObj.getValue(this.context.data, path, null);
+            payload = JSON.parse(JSON.stringify(payload));
+            await mongoSrv.writeLocal(dataBaseName, collectionName, payload);
+        } else if (action == "read") {
+            const path = this.args[2];
+            const payload = {
+                where: this.args[3],
+            };
+            const response = await mongoSrv.readLocal(dataBaseName, payload);
+            if (response.list) {
+                SimpleObj.recreate(this.context.data, path, response.list);
+            } else {
+                console.log(`No list found ${JSON.stringify(response)}`);
+            }
+        } else if (action == "delete") {
+            const payload = {
+                where: this.args[2],
+            };
+            const response = await mongoSrv.deleteLocal(dataBaseName, payload);
+            console.log(response);
+        } else if (action == "update") {
+            const path = this.args[2];
+            const payload = {
+                where: this.args[3],
+                update: SimpleObj.getValue(this.context.data, path, null),
+            };
+            const response = await mongoSrv.updateLocal(dataBaseName, payload);
+            console.log(response);
+        } else if (action == "index") {
+            const collectionName = this.args[2];
+            const path = this.args[3];
+            const payload = SimpleObj.getValue(this.context.data, path, null);
+            const response = await mongoSrv.indexLocal(dataBaseName, collectionName, payload);
+            console.log(response);
+        } else if (action == "create") {
+            const collectionName = this.args[2];
+            const path = this.args[3];
+            const payload = SimpleObj.getValue(this.context.data, path, null);
+            const response = await mongoSrv.createLocal(dataBaseName, collectionName, payload);
+            console.log(response);
+        }
+    }
+}
+
+module.exports = {
+    CommandMongo
+};

package/src/flowchart/steps/CommandPrint.js

@@ -0,0 +1,12 @@
+
+const { CommandBasic } = require("./CommandBasic");
+
+class CommandPrint extends CommandBasic {
+    async computation() {
+        console.log(this.args.join(" "));
+    }
+}
+
+module.exports = {
+    CommandPrint
+};

package/src/flowchart/steps/CommandSet.js

@@ -0,0 +1,14 @@
+const { SimpleObj } = require("../../SimpleObj");
+const { CommandBasic } = require("./CommandBasic");
+
+class CommandSet extends CommandBasic {
+    async computation() {
+        const path = this.args[0];
+        const val = this.args[1];
+        SimpleObj.recreate(this.context.data, path, val);
+    }
+}
+
+module.exports = {
+    CommandSet
+};

package/src/flowchart/steps/CommandTimeline.js

@@ -0,0 +1,21 @@
+const { SimpleObj } = require("../../SimpleObj");
+const { CommandBasic } = require("./CommandBasic");
+
+class CommandTimeline extends CommandBasic {
+    async computation() {
+        const timeLineId = this.args[0];
+        const start = parseFloat(this.args[1]);
+        const end = parseFloat(this.args[2]);
+        const period = parseFloat(this.args[3]);
+        const timeline = {
+            start,
+            end,
+            period,
+        };
+        this.context.registerTimeline(timeLineId, timeline);
+    }
+}
+
+module.exports = {
+    CommandTimeline
+};

package/src/flowchart/steps/CommandTimelineNext.js

@@ -0,0 +1,28 @@
+const { CommandBasic } = require("./CommandBasic");
+const { SimpleObj } = require("../../SimpleObj");
+
+class CommandTimelineNext extends CommandBasic {
+    async computation() {
+        const timeLineId = this.args[0];
+        const timeline = this.context.getTimeLine(timeLineId);
+        if (!timeline) {
+            return;
+        }
+        if ([null, undefined].indexOf(timeline.t) >= 0) {
+            timeline.t = timeline.start;
+        } else {
+            timeline.t = timeline.t + timeline.period;
+            if (timeline.t > timeline.end) {
+                timeline.t = timeline.end;
+            }
+        }
+        // Compute advance percentage
+        const percentage = (timeline.t - timeline.start) / (timeline.end - timeline.start);
+        SimpleObj.recreate(this.context.data, "scope.progress", Math.ceil(percentage * 100));
+
+    }
+}
+
+module.exports = {
+    CommandTimelineNext
+};

package/src/flowchart/steps/StepBasic.js

@@ -0,0 +1,184 @@
+const { SimpleObj } = require("../../SimpleObj");
+
+class StepBasic {
+    maxErrorCount = 3;
+    timeOutMillis = 60000;
+    //
+    firstTime = true;
+    fired = false;
+    // Si ya evaluó a true no debe volver a invocar canContinue
+    alwaysEvaluateCanContinue = true;
+    autoDelete = true;
+    args = [];
+    lastErrorTime = null;
+    errorCount = 0;
+    nextTry = null;
+    commandName;
+    argsTxt;
+    fireTime;
+    constructor(context, id, commandName, argsTxt) {
+        this.context = context;
+        this.id = id;
+        this.commandName = commandName;
+        this.argsTxt = argsTxt;
+    }
+    setTimeout(value) {
+        this.timeOutMillis = value * 1000;
+    }
+    setMaxTries(value) {
+        this.maxErrorCount = value;
+    }
+    async executeAsNode(args) {
+        const answer = {
+            canContinue: false,
+            abort: false,
+        };
+        if (this.reachMaxErrors()) {
+            answer.abort = true;
+            const message = `Abort at ${this.argsTxt} after ${this.errorCount} retries.`;
+            const room = this.context.getRoom();
+            this.context.io.to(room).emit("myerror", { origin: "StepBasic.executeAsNode", message: message });
+            return answer;
+        }
+        if (typeof this.nextTry == "number") {
+            const ahora = new Date().getTime();
+            if (ahora <= this.nextTry) {
+                return answer;
+            }
+        }
+        try {
+            this.args = args;
+            await this.execFirst();
+            await this.execLast({ isCommand: true });
+            answer.canContinue = true;
+            this.resetErrorState();
+            return answer;
+        } catch (err) {
+            this.handleError(err);
+            answer.canContinue = false;
+            return answer;
+        }
+    }
+    async executeAsArrow(args) {
+        const answer = {
+            canContinue: false,
+            abort: false,
+        };
+        if (this.reachMaxErrors()) {
+            answer.abort = true;
+            const message = `Abort at ${this.argsTxt} after ${this.errorCount} retries.`;
+            const room = this.context.getRoom();
+            this.context.io.to(room).emit("myerror", { origin: "StepBasic.executeAsArrow", message: message });
+            return answer;
+        }
+        if (typeof this.nextTry == "number") {
+            const ahora = new Date().getTime();
+            if (ahora <= this.nextTry) {
+                return answer;
+            }
+        }
+        try {
+            this.args = args;
+            if (this.alwaysEvaluateCanContinue == false) {
+                if (this.fired) {
+                    answer.canContinue = true;
+                    return answer;
+                }
+            }
+            if (this.firstTime) {
+                const done = await this.execFirst();
+                if (done === false) {
+                    return answer;
+                }
+                this.firstTime = false;
+                this.fireTime = new Date().getTime();
+            }
+            answer.canContinue = await this.canContinue();
+            if (answer.canContinue) {
+                await this.execLast();
+                this.fired = true;
+                this.resetErrorState();
+            } else {
+                //Check ellapsed time
+                const now = new Date().getTime();
+                const duration = now - this.fireTime;
+                if (duration > this.timeOutMillis) {
+                    const message = `Timeout for ${this.argsTxt} after ${duration} milliseconds`;
+                    // It breaks the timeout threshold
+                    // Erase the pendig call to ignore eventual arrive of response...
+                    if (!this.context.canRetry(this.pendingCall, new Error(message))) {
+                        this.context.stop();
+                        return;
+                    } else {
+                        this.context.clearPendingCall(this.pendingCall);
+                    }
+                }
+            }
+
+            return answer;
+        } catch (err) {
+            this.handleError(err);
+            answer.canContinue = false;
+            return answer;
+        }
+    }
+    reachMaxErrors() {
+        const reached = this.errorCount >= this.maxErrorCount;
+        return reached;
+    }
+    resetErrorState() {
+        this.errorCount = 0;
+        this.lastErrorTime = null;
+        this.nextTry = null;
+    }
+    async handleError(error) {
+        const { stack } = error;
+        this.errorCount++;
+        this.lastErrorTime = new Date().getTime();
+        const room = this.context.getRoom();
+        if (!this.reachMaxErrors()) {
+            const delay = 1000 * Math.exp(this.errorCount) / Math.exp(1);
+            this.nextTry = delay + this.lastErrorTime;
+            const message = `Error at ${this.argsTxt} #${this.errorCount}. Retrying in ${delay.toFixed(0)} ms.  ${stack}`;
+            this.context.io.to(room).emit("myerror", { origin: "StepBasic", message: message });
+        } else {
+            const message = `Error at ${this.argsTxt} #${this.errorCount}. ${stack}`;
+            this.context.io.to(room).emit("myerror", { origin: "StepBasic", message: message });
+        }
+    }
+    async execFirst() { }
+    async canContinue() { return true; }
+    async execLast() { }
+    async arrowAccepted() { }
+    async destroy() { }
+
+    readInputFrom(isBuffer, sourceId, pathId, completePath) {
+        let buffer = null;
+        if (isBuffer) {
+            // It reads from buffer
+            buffer = this.context.readBufferData(sourceId, pathId);
+            if (!buffer) {
+                console.log(`No buffer in ${sourceId} ${pathId}`);
+                return undefined;
+            }
+        } else {
+            // It reads from data model
+            buffer = SimpleObj.getValue(this.context.data, completePath, null);
+        }
+        return buffer;
+    }
+
+    resolveArgument(val) {
+        const partsSource = /^(b\.([^.]+)\.([^.]+)|d\.(.+))$/i.exec(val);
+        if (partsSource == null) {
+            console.log(`${val} doesn't match ^(b\.([^.]+)\.([^.]+)|d\.(.+))$`);
+            return undefined;
+        }
+        const buffer = this.readInputFrom(!partsSource[4], partsSource[2], partsSource[3], partsSource[4]);
+        return buffer;
+    }
+}
+
+module.exports = {
+    StepBasic
+}

package/src/flowchart/steps/StepCheckProcessor.js

@@ -0,0 +1,26 @@
+const { StepBasic } = require("./StepBasic");
+const { SimpleObj } = require("../../SimpleObj");
+
+class StepCheckProcessor extends StepBasic {
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.alwaysEvaluateCanContinue = true;
+    }
+    async execFirst() {
+    }
+
+    async canContinue() {
+        for (let i = 0; i < this.args.length; i++) {
+            const processorUID = this.args[i];
+            const socket = SimpleObj.getValue(this.context.data, `state.processors.${processorUID}.socket`, null);
+            if (!socket) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+module.exports = {
+    StepCheckProcessor
+};

package/src/flowchart/steps/StepCheckSrc.js

@@ -0,0 +1,42 @@
+const { StepBasic } = require("./StepBasic");
+const { SimpleObj } = require("../../SimpleObj");
+
+class StepCheckSrc extends StepBasic {
+    socketId = null;
+    configuration = null;
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.alwaysEvaluateCanContinue = false;
+    }
+    async execFirst() {
+        const sourceUID = this.args[0];
+        if (this.context.io) {
+            // Leo la ruta del sourceUID
+            const configuration = SimpleObj.getValue(this.context.data, `state.sources.${sourceUID}`, null);
+            this.socketId = configuration.socket;
+            if (this.socketId) {
+                this.context.io.to(this.socketId).emit("checkSrc", configuration);
+            }
+        }
+    }
+
+    async canContinue() {
+        const sourceUID = this.args[0];
+        if (!this.socketId) {
+            return false;
+        }
+        // Debe validar que todos las configuraciones hayan sido respondidas sin error
+        const configuration = SimpleObj.getValue(this.context.data, `state.sources.${sourceUID}`, null);
+        for (let key in configuration.data) {
+            const oneConf = configuration.data[key];
+            if (!oneConf.metadata) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+module.exports = {
+    StepCheckSrc
+};

package/src/flowchart/steps/StepIsTrue.js

@@ -0,0 +1,12 @@
+const { StepBasic } = require("./StepBasic");
+
+class StepIsTrue extends StepBasic {
+    async canContinue() {
+        const result = this.args[0];
+        return result;
+    }
+}
+
+module.exports = {
+    StepIsTrue
+};

package/src/flowchart/steps/StepOneTime.js

@@ -0,0 +1,21 @@
+const { StepBasic } = require("./StepBasic");
+
+class StepOneTime extends StepBasic {
+    executed = false;
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.autoDelete = false;
+    }
+
+    async canContinue() {
+        return !this.executed;
+    }
+
+    async arrowAccepted() {
+        this.executed = true;
+    }
+}
+
+module.exports = {
+    StepOneTime
+};