:boom: Introduce new UI based on svelte, and rewrite a lot of the node app and the NeoRuntime

2 files changed, 459 insertions, 0 deletions

diff --git a/src/NeoRuntimeManager/RuntimeProcess.js b/src/NeoRuntimeManager/RuntimeProcess.js
new file mode 100644
index 0000000..60f6a28
--- /dev/null
+++ b/src/NeoRuntimeManager/RuntimeProcess.js
@@ -0,0 +1,150 @@
+let fs = require("fs-extra");
+let spawn = require("child_process");
+
+class RuntimeProcess {
+
+    constructor(_modePath, _onVarChange, _eventEmitter) {
+        this.modePath = _modePath;
+        this.logfile = `${this.modePath}/mode.log`;
+        
+        this.stdout = "";
+        this.stderr = "";
+
+        this.fl = false;
+        this.proc = null;
+
+        this.isRunning = false;
+        this.exitCode = null;
+
+        this.variables = {};
+        this.globvars  = {};
+        this.onVarChange = _onVarChange;
+        this.eventEmitter = _eventEmitter;
+    }
+
+    start() {
+        if (this.isRunning) {
+            console.log("PROCESS ALREADY RUNNING");
+            return;
+        }
+        this.isRunning = true;
+        this.proc = spawn.spawn(
+            "python3", 
+            [
+                "-u", // This makes us able to get real-time output
+                `${__basedir}/NeoRuntime/Runtime/neo_runtime.py`,
+                `--strip-config="${__datadir}/config/strip.ini"`,
+                `--mode-path="${this.modePath}"`,
+                `--mode-entry=script`
+            ]
+        );
+
+        this.proc.on('error', (err) => {
+            console.log(err);
+        });
+
+        fs.ensureFileSync(this.logfile);
+        this.eventEmitter.emit("proc:start");
+
+        this.proc.stdout.on('data', (_stdout) => {
+            let stdout_str = _stdout.toString();
+            
+            let regex = /{ ":::data:": { (.*) } }/gi;
+            let data = stdout_str.match(regex);
+            stdout_str = stdout_str.replace(regex, () => "");
+
+            if ((data != null) && (data.length > 0)) {
+                try {
+                    this.processVarData(data)
+                } catch {}
+            }
+
+            if (stdout_str.replace("\n", "").replace(" ", "") == "") {
+                // In this case, we want to ignore the data.
+            } else {
+                // stdout_str = stdout_str.replace(/\n$/, "")
+                fs.appendFile(this.logfile, "\n====stdout====\n" + stdout_str);
+                this.eventEmitter.emit("proc:stdout", stdout_str);
+            }
+        });
+
+        this.proc.stdout.on('end', () => {
+            fs.appendFile(this.logfile, "\n");
+        });
+
+        this.proc.stderr.on('data', (_stderr) => {
+            // let stderr_str =  _stderr.toString().replace(/\n$/, "")
+            let stderr_str =  _stderr.toString()
+            fs.appendFile(this.logfile, "\n====stderr====\n" + stderr_str);
+            this.eventEmitter.emit("proc:stderr", stderr_str);
+        });
+
+        this.proc.stderr.on('end', () => {
+            fs.appendFile(this.logfile, "\n");
+        });
+
+        this.proc.on('close', (code) => {
+            if (code) {
+                fs.appendFile(this.logfile, "\n====close====\nScript exited with code " +  code.toString());
+            }
+            this.eventEmitter.emit("proc:exit", 0);
+            this.isRunning = false;
+            this.exitCode = code;
+        });
+
+    }
+
+    stop(restart=false) {
+        try {
+            if (restart) {
+                this.proc.once("close", () => {
+                    setTimeout(() =>  this.start(), 500);
+                });
+            }
+            this.proc.kill("SIGINT");
+        } catch (err) {
+            console.log(err);
+        }
+    }
+
+    processVarData(data) {
+        data = JSON.parse(data)[":::data:"];
+        if (data.hasOwnProperty("globvars")) {
+            forEachDiff(data["globvars"], this.globvars, (key, newVal) => {
+                this.onVarChange("globvars", key, newVal);
+            });
+            this.globvars = data["globvars"];
+        }
+        if (data.hasOwnProperty("variables")) {
+            forEachDiff(data["variables"], this.variables, (key, newVal) => {
+                this.onVarChange("variables", key, newVal); 
+            });
+            this.variables = data["variables"];
+        }
+    }
+
+}
+
+const isObject = v => v && typeof v === 'object';
+
+/**
+ * Will call callback on all the differences between the dicts
+ */
+function forEachDiff(dict1, dict2, callback) {
+    for (const key of new Set([...Object.keys(dict1), ...Object.keys(dict2)])) {
+        if (isObject(dict1[key]) && isObject(dict2[key])) {
+            if (dict1[key].value !== dict2[key].value) {
+                callback(key, dict1[key]);
+            }
+        } else if (dict1[key] !== dict2[key]) {
+            if (isObject(dict2[key]) && (dict1[key] == null)) {
+                dict2[key].value = null;
+                callback(key, dict2[key])
+            } else {
+                callback(key, dict1[key]);
+            }
+        }
+    }
+}
+
+module.exports = RuntimeProcess;
diff --git a/src/NeoRuntimeManager/index.js b/src/NeoRuntimeManager/index.js
new file mode 100644
index 0000000..62acb8a
--- /dev/null
+++ b/src/NeoRuntimeManager/index.js
@@ -0,0 +1,309 @@
+/**
+ * This module is used to execute and communicate with a python NeoRuntime instance.
+ *
+ * @author jakobst1n.
+ * @since  19.12.2019
+ */
+
+const fs = require("fs");
+const fsPromises = fs.promises;
+const RuntimeProcess = require("./RuntimeProcess");
+let logger = require(__basedir + "/src/logger");
+const EventEmitter = require('events');
+
+/** @type {object} this should be a pointer to a object referencing all neoModules (see app.js) */
+let neoModules;
+
+/** @type {string} Currently active mode */
+let modeId = null;
+/** @type {int} Last exit code of a mode */
+let modeExitCode = 0;
+/** @type {RuntimeProcess} This is the current RuntimeProcess instance */
+let runtimeProcess = null;
+/** @type {EventEmitter} This is used to emit events when things change */
+const eventEmitter = new EventEmitter();
+/** @type {boolean} If this is true, we will not do things the usual way */
+let modeDebuggerActive = false;
+/** @type {string} Should be the modeId the debugger is attached to */
+let modeDebuggerId = null;
+
+eventEmitter.on("proc:exit", (code) => modeExitCode = code);
+
+/**
+ * Check if a path id actually a mode (if it is a folder with a script.py file)
+ * 
+ * @param {string} path - Path to check.
+ * 
+ * @return {boolean} wether the path points to a valid mode.
+ */
+function isMode(path) {
+    if (!fs.existsSync(path)) { return false; }
+    let folderStat = fs.statSync(path);
+    if (!folderStat.isDirectory()) { return false; }
+    if (!fs.existsSync(path + "/script.py")) { return false; }
+    return true;
+}
+
+/**
+ * Get all ids of modes that can be set.
+ * 
+ * @returns {array} All modeids
+ */
+function listModes() {
+    let modeDirs = [
+        ["builtin/", fs.readdirSync(__basedir + "/NeoRuntime/builtin")],
+        ["remote/", fs.readdirSync(__datadir + "/remoteCode")],
+        ["user/", fs.readdirSync(__datadir + "/userCode")]
+    ]
+    let validModes = [];
+    for (modeDir of modeDirs) {
+        for (modeName of modeDir[1]) {
+            let modeId = `${modeDir[0]}${modeName}`;
+            if (isMode(getModePath(modeId))) {
+                validModes.push(modeId);
+            }
+        }
+    }
+    return validModes;
+}
+
+/**
+ * Change mode, stop the old one and start the new one.
+ * 
+ * @param {string} _modeId - Id of the mode to change to.
+ * 
+ * @return {object} A standardform return object.
+ */
+function setMode(_modeId) {
+    if (modeDebuggerActive && (_modeId != modeDebuggerId)) {
+        return {success: false, reason: "debugger active", detail: "Cannot change mode when debugger is active."}
+    }
+    if (!isMode(getModePath(_modeId))) {
+        console.log(`Invalid mode "${_modeId}".`);
+        return {success: false, reason: "unknown modeId"};
+    }
+    logger.info(`Changing mode to "${_modeId}".`);
+    
+    let globvarsTmp = {};
+    let variablesTmp = {};
+    if (runtimeProcess != null) {
+        globvarsTmp = runtimeProcess.globvars;
+        variablesTmp = runtimeProcess.variables;
+    }
+
+    stopMode();
+    
+    modeId = _modeId;
+    neoModules.userData.config.activeMode = modeId;
+    eventEmitter.emit("change", "mode", modeId);
+
+    runtimeProcess = new RuntimeProcess(getModePath(_modeId), onVariableChange, eventEmitter);
+    runtimeProcess.globvars = globvarsTmp;
+    runtimeProcess.variables = variablesTmp;
+    startMode();
+    return {success: true}
+};
+
+/**
+ * Get current mode
+ * 
+ * @return {string} current modeId
+ */
+function currentMode() {
+    return modeId;
+}
+
+/**
+ * Will attempt to stop current mode
+ * 
+ * @return {object} A standardform return object.
+ */
+function stopMode(restart=false) {
+    if (modeRunning()) {
+        runtimeProcess.stop(restart);
+    }
+    return {success: true}
+};
+
+/**
+ * Will attempt to start current mode
+ * 
+ * @return {object} A standardform return object.
+ */
+function startMode() {
+    if (runtimeProcess === null) { return {success: false, reason: "no runtimeprocess", detail: "Runtimeprocess not set, did you mean to call setMode?"}; }
+    runtimeProcess.start();
+    return {success: true}
+};
+
+/**
+ * Will attempt to restart current mode
+ * 
+ * @return {object} A standardform return object.
+ */
+function restartMode() {
+    return stopMode(true);
+};
+
+/**
+ * Checks if mode is running currently
+ * 
+ * @return {boolean} if mode is running
+ */
+function modeRunning() {
+    if (runtimeProcess === null) { return false; }
+    return runtimeProcess.isRunning;
+};
+
+/**
+ * Get the full system path to a mode
+ * 
+ * @param {string} modeId
+ * 
+ * @return {string} Full path of mode
+ */
+function getModePath(modeId) {
+    let path = modeId.split("/");
+    let location = path.splice(0, 1).toString();
+    if (location === "user") { path = __datadir + "/userCode/" + path.join("/"); }
+    if (location === "remote") { path = __datadir + "/remoteCode/" + path.join("/"); }
+    if (location === "builtin") { path = __basedir + "/NeoRuntime/builtin/" + path.join("/"); }
+    return path;
+}
+
+/**
+ * This should be called by RuntimeProcess when a variable changes in the mode
+ *
+ * @param {string} location - This is globvars/variables
+ * @param {string} name - Name of the variable
+ * @param {any} newValue - The new value of the variable
+ */
+function onVariableChange(location, name, newValue) {
+    if (location == "variables") {
+        eventEmitter.emit("change", `variable/${name}`, newValue)
+    } else if (location == "globvars") {
+        eventEmitter.emit("change", `${name}`, newValue)
+    }
+}
+
+/**
+ * Function that returns all globvars (brightness, power_on) as the values they
+ * had last time we heard from the python script.
+ * 
+ * @return {object}
+ */
+function getGlobvars() {
+    if (!modeRunning()) { return {}; }
+    return runtimeProcess.globvars;
+}
+
+/**
+ * Sets value of a globvar power_on/brightness.
+ * 
+ * @param {string} name - Name of the variable power_on/brightness
+ * @param {any} value - The value the variable should be set to
+ * 
+ * @return {object} Standardform return object
+ */
+function setGlobvar(name, value) {
+    if (!modeRunning()) { return; }
+    runtimeProcess.proc.stdin.write(`:::setglob: ${name}:${value}\n`);
+    return {success: true}
+}
+
+/**
+ * Get all variables declared in mode
+ * 
+ * @return {object}
+ */
+function getVariables() {
+    if (!modeRunning()) { return {}; }
+    return runtimeProcess.variables;
+}
+
+/**
+ * Sets value of a variable
+ * 
+ * @param {string} name - Name of the variable
+ * @param {any} value - The value the variable should be set to
+ * 
+ * @return {object} Standardform return object
+ */
+function setVariable(name, value) {
+    if (!modeRunning()) { return; }
+    runtimeProcess.proc.stdin.write(`:::setvar: ${name}:${value}\n`);
+    return {success: true}
+}
+
+/**
+ * Start debugger for a mode
+ * 
+ * @param {string} modeId - The mode to debug
+ * 
+ * @return {object} Standardform return object
+ */
+function startDebugger(debuggerModeId) {
+    if (debuggerModeId.substr(0, 5) !== "user/") { return {success: false, reason: "not user mode"}; }
+    if (!isMode(getModePath(debuggerModeId))) { return {success: false, reason: "unknown modeId"}; }
+    if (modeDebuggerActive) { return {success: false, reason: "debugger already active"}; }
+    logger.info(`Starting debugger for ${debuggerModeId}`);
+    modeDebuggerActive = true;
+    modeDebuggerId = debuggerModeId;
+    if (debuggerModeId != modeId) {
+        setMode(debuggerModeId);
+    } else {
+        restartMode();
+    }
+    return {success: true, code: fs.readFileSync(getModePath(debuggerModeId) + "/script.py").toString()}
+}
+
+/**
+ * Save mode
+ */
+function saveModeCode(_modeId, code) {
+    if (!modeDebuggerActive) { return {success: false, reason: "debugger not active"}; };
+    if (_modeId != modeDebuggerId) { return {success: false, reason: "modeid not the same as debuggermodeid"}; };
+    fs.writeFileSync(getModePath(`${modeDebuggerId}/script.py`), code);
+    return {success: true};
+}
+
+/**
+ * Stop the active debugger
+ * 
+ * @return {object} Standardform return object
+ */
+function stopDebugger() {
+    if (!modeDebuggerActive) { return {success: true, detail: "No debugger active"} }
+    logger.info(`Stopping debugger`);
+    modeDebuggerActive = false;
+    return {success: true}
+}
+
+module.exports = (_neoModules) => {
+    neoModules = _neoModules;
+    return {
+        event: eventEmitter,
+        modes: listModes,
+        mode: {
+            current: currentMode,
+            set: (modeId) => setMode(modeId),
+            status: {
+                modeRunning: modeRunning(),
+                modeExitCode: modeExitCode
+            },
+            globvars: {
+                get: getGlobvars,
+                set: setGlobvar
+            },
+            variables: {
+                get: getVariables,
+                set: setVariable
+            }
+        },
+        getModePath,
+        isMode,
+        modeRunning,
+        startDebugger, stopDebugger, saveModeCode,
+        startMode, stopMode, restartMode
+    }
+};
\ No newline at end of file