aboutsummaryrefslogtreecommitdiff
path: root/src/NeoRuntimeManager
diff options
context:
space:
mode:
Diffstat (limited to 'src/NeoRuntimeManager')
-rw-r--r--src/NeoRuntimeManager/IPC.js178
-rw-r--r--src/NeoRuntimeManager/RuntimeProcess.js78
-rw-r--r--src/NeoRuntimeManager/index.js34
3 files changed, 211 insertions, 79 deletions
diff --git a/src/NeoRuntimeManager/IPC.js b/src/NeoRuntimeManager/IPC.js
new file mode 100644
index 0000000..817c049
--- /dev/null
+++ b/src/NeoRuntimeManager/IPC.js
@@ -0,0 +1,178 @@
+/**
+ * This module is used to communicate with a python NeoRuntime instance.
+ *
+ * @author jakobst1n.
+ * @since 3.10.2021
+ */
+
+const net = require("net");
+let logger = require(__basedir + "/src/logger");
+
+/** @type {int} How long wait between each reconnection attempt */
+const RECONNECT_INTERVAL = 1000;
+/** @type {Object} ENUM-ish for command that can be sent to neoruntime */
+const COMMAND = Object.freeze({SET_GLOB : 0,
+ SET_VAR : 1,
+ SET_SEND_STRIP_BUF: 2});
+/** @type {Object} ENUM-ish for globvars */
+const GLOBVAR = Object.freeze({POWER_ON : 0,
+ BRIGHTNESS: 1});
+/** @type {Object} ENUM-ish for what type of data neoruntime sends */
+const DATATYPE = Object.freeze({STATES : 1,
+ STRIP_BUF: 2});
+
+/**
+ * class that will keep a active connection to a socket if possible, and
+ * automatically reconnect. It will emit events when data is received,
+ * and it will send commands to the process. */
+class IPC {
+
+ constructor(_socketFile, _eventEmitter) {
+ this.socketFile = _socketFile;
+ this.eventEmitter = _eventEmitter;
+
+ this.client;
+ this.connected = false;
+ this.reconnectInterval = false;
+
+ this.globvars = {};
+ this.variables = {};
+
+ this.reconnect();
+ }
+
+ /**
+ * If we are not already attempting to reconnect, this will start a
+ * interval that tries to reconnect. */
+ reconnect() {
+ if (this.reconnectInterval === false) {
+ this.reconnectInterval = setInterval(this.tryOpenSocketConnection.bind(this), RECONNECT_INTERVAL);
+ }
+ }
+
+ /**
+ * This will attempt to connect to the socket, and then setup all listeners
+ * if it succedes. */
+ tryOpenSocketConnection() {
+ // logger.info("Attempting to start IPC");
+
+ this.client = net.createConnection(this.socketFile)
+ .on('connect', () => {
+ clearInterval(this.reconnectInterval);
+ this.reconnectInterval = false;
+ // logger.info("IPC Connected.");
+ })
+ .on("ready", () => {
+ this.connected = true;
+ })
+ .on('data', (data) => {
+ switch (data[0]) {
+ case DATATYPE.STATES:
+ let json_data;
+ try {
+ json_data = JSON.parse(data.toString("ascii", 1));
+ } catch (e) {
+ logger.warning("Could not parse json data from neoruntime");
+ return;
+ }
+
+ if (json_data.hasOwnProperty("globvars")) {
+ forEachDiff(json_data["globvars"], this.globvars, (key, newVal) => {
+ this.eventEmitter.emit("change", key, newVal);
+ });
+ this.globvars = json_data["globvars"];
+ }
+ if (json_data.hasOwnProperty("variables")) {
+ forEachDiff(json_data["variables"], this.variables, (key, newVal) => {
+ this.eventEmitter.emit("change", `variable/${key}`, newVal);
+ });
+ this.variables = json_data["variables"];
+ }
+ break;
+
+ default:
+ logger.info(data);
+ }
+
+ })
+ .on("timeout", () => {
+ logger.info("IPC Timeout");
+ })
+ .on("close", (hadError) => {
+ // logger.info("IPC Close, hadError: ", hadError);
+ this.connected = false;
+ this.reconnect();
+ })
+ .on("end", () => {
+ // logger.info("IPC End");
+ this.connected = false;
+ })
+ .on('error', (data) => {
+ // logger.info('IPC Server not active.');
+ this.connected = false;
+ this.reconnect();
+ })
+ ;
+ }
+
+ /**
+ * Will send a command to the socket if we have a active connection,
+ * if not it will just drop the command. there is no queue implemented
+ * for such events. */
+ sendCommand(commandType, name, value) {
+ if (this.connected) {
+ let buf = Buffer.allocUnsafe(128); // It's fine, we know what we are doing
+ // let buf = Buffer.alloc(128);
+
+ switch (commandType) {
+ case (COMMAND.SET_GLOB):
+ buf[1] = name;
+ buf[2] = value;
+ break;
+ case (COMMAND.SET_VAR):
+ if (name.length > 32) { return {success: false, reason: "name too long", detail: "max size of name is 32 bytes"}; }
+ if (name.length > 93) { return {success: false, reason: "value too long", detail: "max size of value is 93 bytes"}; }
+ buf[1] = name.length;
+ buf[2] = value.length;
+ buf.write(name, 3, name.length, "ascii");
+ buf.write(value, 3+name.length, value.length, "ascii");
+ break;
+ case (COMMAND.SET_SEND_STRIP_BUF):
+ buf[1] = (name) ? 1 : 0;
+ default:
+ logger.info(`IPC UNKNOWN COMMANDTYPE ${commandType}`)
+ return;
+ }
+
+ buf[0] = commandType;
+ this.client.write(buf);
+ return {success: true}
+ }
+ return {success: false, reason: "socket not connected", detail: "This usually means the python script is not running"};
+ }
+
+}
+
+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 = {IPC, COMMAND, GLOBVAR}; \ No newline at end of file
diff --git a/src/NeoRuntimeManager/RuntimeProcess.js b/src/NeoRuntimeManager/RuntimeProcess.js
index 60f6a28..60c1de9 100644
--- a/src/NeoRuntimeManager/RuntimeProcess.js
+++ b/src/NeoRuntimeManager/RuntimeProcess.js
@@ -3,10 +3,11 @@ let spawn = require("child_process");
class RuntimeProcess {
- constructor(_modePath, _onVarChange, _eventEmitter) {
+ constructor(_modePath, _eventEmitter) {
this.modePath = _modePath;
this.logfile = `${this.modePath}/mode.log`;
-
+ this.errfile = `${this.modePath}/mode.error`;
+
this.stdout = "";
this.stderr = "";
@@ -16,9 +17,6 @@ class RuntimeProcess {
this.isRunning = false;
this.exitCode = null;
- this.variables = {};
- this.globvars = {};
- this.onVarChange = _onVarChange;
this.eventEmitter = _eventEmitter;
}
@@ -29,7 +27,7 @@ class RuntimeProcess {
}
this.isRunning = true;
this.proc = spawn.spawn(
- "python3",
+ "python3",
[
"-u", // This makes us able to get real-time output
`${__basedir}/NeoRuntime/Runtime/neo_runtime.py`,
@@ -44,28 +42,13 @@ class RuntimeProcess {
});
fs.ensureFileSync(this.logfile);
+ fs.ensureFileSync(this.errfile);
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);
- }
+ fs.appendFile(this.logfile, `[${timestamp()}]: ` + stdout_str);
+ this.eventEmitter.emit("proc:stdout", stdout_str);
});
this.proc.stdout.on('end', () => {
@@ -73,9 +56,8 @@ class RuntimeProcess {
});
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);
+ let stderr_str = _stderr.toString();
+ fs.appendFile(this.errfile, `[${timestamp()}]: ` + stderr_str);
this.eventEmitter.emit("proc:stderr", stderr_str);
});
@@ -85,7 +67,7 @@ class RuntimeProcess {
this.proc.on('close', (code) => {
if (code) {
- fs.appendFile(this.logfile, "\n====close====\nScript exited with code " + code.toString());
+ fs.appendFile(this.logfile, `[${timestamp()}]: ` + "Script exited with code " + code.toString());
}
this.eventEmitter.emit("proc:exit", 0);
this.isRunning = false;
@@ -106,45 +88,15 @@ class RuntimeProcess {
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
+ * Creates and returns a timestamp that can be used in logfiles.
+ *
+ * @return {string} timestamp
*/
-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]);
- }
- }
- }
+function timestamp() {
+ return (new Date()).toISOString();
}
module.exports = RuntimeProcess;
diff --git a/src/NeoRuntimeManager/index.js b/src/NeoRuntimeManager/index.js
index 62acb8a..6238323 100644
--- a/src/NeoRuntimeManager/index.js
+++ b/src/NeoRuntimeManager/index.js
@@ -8,6 +8,7 @@
const fs = require("fs");
const fsPromises = fs.promises;
const RuntimeProcess = require("./RuntimeProcess");
+const IPC = require("./IPC");
let logger = require(__basedir + "/src/logger");
const EventEmitter = require('events');
@@ -20,6 +21,8 @@ let modeId = null;
let modeExitCode = 0;
/** @type {RuntimeProcess} This is the current RuntimeProcess instance */
let runtimeProcess = null;
+/** @type {IPC} The IPC instance, used to communicate with the script */
+let ipc = 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 */
@@ -83,13 +86,6 @@ function setMode(_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();
@@ -97,10 +93,9 @@ function setMode(_modeId) {
neoModules.userData.config.activeMode = modeId;
eventEmitter.emit("change", "mode", modeId);
- runtimeProcess = new RuntimeProcess(getModePath(_modeId), onVariableChange, eventEmitter);
- runtimeProcess.globvars = globvarsTmp;
- runtimeProcess.variables = variablesTmp;
+ runtimeProcess = new RuntimeProcess(getModePath(_modeId), eventEmitter);
startMode();
+
return {success: true}
};
@@ -194,7 +189,7 @@ function onVariableChange(location, name, newValue) {
*/
function getGlobvars() {
if (!modeRunning()) { return {}; }
- return runtimeProcess.globvars;
+ return ipc.globvars;
}
/**
@@ -207,8 +202,15 @@ function getGlobvars() {
*/
function setGlobvar(name, value) {
if (!modeRunning()) { return; }
- runtimeProcess.proc.stdin.write(`:::setglob: ${name}:${value}\n`);
- return {success: true}
+
+ switch(name) {
+ case "power_on":
+ return ipc.sendCommand(IPC.COMMAND.SET_GLOB, IPC.GLOBVAR.POWER_ON, (value) ? 1 : 0);
+ case "brightness":
+ return ipc.sendCommand(IPC.COMMAND.SET_GLOB, IPC.GLOBVAR.BRIGHTNESS, value);
+ default:
+ return {success: false, reason: "unknown globvar", detail: name};
+ }
}
/**
@@ -218,7 +220,7 @@ function setGlobvar(name, value) {
*/
function getVariables() {
if (!modeRunning()) { return {}; }
- return runtimeProcess.variables;
+ return ipc.variables;
}
/**
@@ -231,8 +233,7 @@ function getVariables() {
*/
function setVariable(name, value) {
if (!modeRunning()) { return; }
- runtimeProcess.proc.stdin.write(`:::setvar: ${name}:${value}\n`);
- return {success: true}
+ return ipc.sendCommand(IPC.COMMAND.SET_VAR, name, value);
}
/**
@@ -281,6 +282,7 @@ function stopDebugger() {
module.exports = (_neoModules) => {
neoModules = _neoModules;
+ ipc = new IPC.IPC(neoModules.userData.config.neoRuntimeIPC.socketFile, eventEmitter);
return {
event: eventEmitter,
modes: listModes,
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-27 11:19:54 +0000