node-red-contrib-me-vplc 1.0.0

package/me-vplc.js

@@ -0,0 +1,603 @@
+module.exports = function (RED) {
+  "use strict";
+
+  const fs = require("fs");
+  const path = require("path");
+  const http = require("http");
+  const os = require("os");
+  const { spawn } = require("child_process");
+
+  function copyRecursive(src, dst) {
+    if (!fs.existsSync(src)) return;
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      fs.mkdirSync(dst, { recursive: true });
+      for (const entry of fs.readdirSync(src)) {
+        if (entry === "__pycache__" || entry === "node_modules" || entry === "dist" || entry === ".venv") continue;
+        copyRecursive(path.join(src, entry), path.join(dst, entry));
+      }
+    } else {
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      fs.copyFileSync(src, dst);
+    }
+  }
+
+  function normalizeWindowsPathMaybe(p) {
+    if (process.platform !== "win32") return p;
+    if (!p) return p;
+
+    // Node-RED kann userDir in seltenen Fällen als \Users\name\.node-red
+    // statt C:\Users\name\.node-red liefern. child_process.spawn akzeptiert
+    // root-relative Windows-Pfade als Programm-Pfad nicht zuverlässig.
+    if (/^[\\\/][^\\\/]/.test(p) && !/^[a-zA-Z]:[\\\/]/.test(p)) {
+      const drive = process.env.HOMEDRIVE || process.env.SystemDrive || (path.parse(process.cwd()).root || "C:\\").slice(0, 2);
+      return drive + p;
+    }
+    return p;
+  }
+
+  function resolveUserDir() {
+    let userDir = RED.settings.userDir || process.env.NODE_RED_HOME || path.join(os.homedir(), ".node-red");
+    userDir = normalizeWindowsPathMaybe(userDir);
+    if (process.platform === "win32" && (!userDir || !/^[a-zA-Z]:[\\\/]/.test(userDir))) {
+      userDir = path.join(os.homedir(), ".node-red");
+    }
+    return userDir;
+  }
+
+  function isConnectionError(err) {
+    return err && ["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "EHOSTUNREACH", "ENOENT"].includes(err.code);
+  }
+
+  function tailFile(file, maxChars) {
+    try {
+      if (!fs.existsSync(file)) return "";
+      const text = fs.readFileSync(file, "utf8");
+      return text.slice(-(maxChars || 4000));
+    } catch (_) {
+      return "";
+    }
+  }
+
+  function requestJson(port, apiPath, method, body, done) {
+    const payload = body ? JSON.stringify(body) : null;
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port: Number(port || 5000),
+      path: apiPath,
+      method: method || "GET",
+      timeout: 2500,
+      headers: payload ? {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload)
+      } : {}
+    }, (res) => {
+      let data = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        try {
+          const json = data ? JSON.parse(data) : {};
+          done(null, json, res.statusCode);
+        } catch (err) {
+          err.message = `Ungültige JSON-Antwort von ME vPLC (${res.statusCode}): ${err.message}`;
+          done(err);
+        }
+      });
+    });
+    req.on("timeout", () => req.destroy(Object.assign(new Error("ME vPLC Backend Timeout"), { code: "ETIMEDOUT" })));
+    req.on("error", done);
+    if (payload) req.write(payload);
+    req.end();
+  }
+
+  function MeVplcNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.name = config.name || "ME vPLC";
+    node.backendPort = Number(config.backendPort || 5000);
+    node.pythonPathConfigured = String(config.pythonPath || "").trim();
+    // Windows kennt in der Regel kein echtes "python3".
+    // Falls im UI noch python3 steht, wird es nur als erster Kandidat getestet
+    // und danach automatisch auf python / py -3 / py zurückgefallen.
+    node.pythonPath = node.pythonPathConfigured || (process.platform === "win32" ? "python" : "python3");
+    node.basePython = null;
+    node.autoStart = config.autoStart !== false && config.autoStart !== "false";
+    node.copyOnStart = config.copyOnStart === true || config.copyOnStart === "true";
+    node.autoInstallDeps = config.autoInstallDeps !== false && config.autoInstallDeps !== "false";
+    node.child = null;
+    node.childExited = null;
+    node.pollTimer = null;
+    node.starting = false;
+    node.runtimeDir = path.join(resolveUserDir(), "me-vplc-runtime", node.id.replace(/[^a-zA-Z0-9_-]/g, ""));
+    node.embeddedProjectDir = path.join(__dirname, "project");
+    node.logDir = path.join(node.runtimeDir, "logs");
+    node.stdoutLog = path.join(node.logDir, "backend_stdout.log");
+    node.stderrLog = path.join(node.logDir, "backend_stderr.log");
+
+    function ensureRuntimeProject(forceCopy) {
+      const marker = path.join(node.runtimeDir, "backend", "app.py");
+      if (forceCopy && fs.existsSync(node.runtimeDir)) fs.rmSync(node.runtimeDir, { recursive: true, force: true });
+      if (!fs.existsSync(marker)) copyRecursive(node.embeddedProjectDir, node.runtimeDir);
+      fs.mkdirSync(node.logDir, { recursive: true });
+    }
+
+    function setStatus(fill, shape, text) {
+      node.status({ fill, shape, text });
+    }
+
+    function backendUrl(pathname) {
+      return `http://127.0.0.1:${node.backendPort}${pathname || ""}`;
+    }
+
+    function venvPythonPath() {
+      const venvDir = path.join(node.runtimeDir, ".venv");
+      if (process.platform === "win32") return path.join(venvDir, "Scripts", "python.exe");
+      return path.join(venvDir, "bin", "python");
+    }
+
+    function findExistingVenvPython() {
+      const venvDir = path.join(node.runtimeDir, ".venv");
+      const candidates = process.platform === "win32"
+        ? [
+            path.join(venvDir, "Scripts", "python.exe"),
+            path.join(venvDir, "Scripts", "python3.exe"),
+            path.join(venvDir, "python.exe")
+          ]
+        : [
+            path.join(venvDir, "bin", "python3"),
+            path.join(venvDir, "bin", "python")
+          ];
+      return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+    }
+
+    function spawnCollect(command, args, options, timeoutMs, callback) {
+      let stdout = "";
+      let stderr = "";
+      let finished = false;
+      let child;
+      try {
+        child = spawn(command, args, Object.assign({ windowsHide: true }, options || {}));
+      } catch (err) {
+        callback(err, stdout, stderr);
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (!finished) {
+          child.kill();
+          const err = new Error(`Timeout bei Kommando: ${command} ${args.join(" ")}`);
+          err.code = "ETIMEDOUT";
+          callback(err, stdout, stderr);
+        }
+      }, timeoutMs || 60000);
+      child.stdout && child.stdout.on("data", (d) => { stdout += String(d); });
+      child.stderr && child.stderr.on("data", (d) => { stderr += String(d); });
+      child.on("error", (err) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        callback(err, stdout, stderr);
+      });
+      child.on("exit", (code) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        if (code === 0) callback(null, stdout, stderr);
+        else {
+          const err = new Error(`Kommando fehlgeschlagen (${code}): ${command} ${args.join(" ")}\n${stderr || stdout}`);
+          err.code = `EXIT_${code}`;
+          callback(err, stdout, stderr);
+        }
+      });
+    }
+
+    function pythonCandidates() {
+      const list = [];
+      function add(command, args) {
+        if (!command) return;
+        const key = command + "\u0000" + (args || []).join("\u0000");
+        if (!list.some((x) => x.key === key)) list.push({ key, command, args: args || [] });
+      }
+
+      // Im UI konfigurierte Angabe zuerst testen. "py -3" ist erlaubt.
+      if (node.pythonPathConfigured) {
+        const parts = node.pythonPathConfigured.split(/\s+/).filter(Boolean);
+        add(parts[0], parts.slice(1));
+      }
+
+      if (process.platform === "win32") {
+        add("python", []);
+        add("py", ["-3"]);
+        add("py", []);
+        add("python3", []);
+      } else {
+        add("python3", []);
+        add("python", []);
+      }
+      return list;
+    }
+
+    function resolveBasePython(callback) {
+      if (node.basePython && fs.existsSync(node.basePython)) {
+        callback(null, node.basePython);
+        return;
+      }
+      const candidates = pythonCandidates();
+      let index = 0;
+      const errors = [];
+
+      function tryNext() {
+        if (index >= candidates.length) {
+          const err = new Error("Keine funktionierende Python-Installation gefunden. Getestet: " + candidates.map((c) => [c.command].concat(c.args).join(" ")).join(", ") + "\n" + errors.join("\n"));
+          err.code = "PYTHON_NOT_FOUND";
+          callback(err);
+          return;
+        }
+
+        const c = candidates[index++];
+        const label = [c.command].concat(c.args).join(" ");
+        setStatus("yellow", "ring", `Prüfe Python: ${label}`);
+        spawnCollect(c.command, c.args.concat(["-c", "import sys; print(sys.executable)"]), { cwd: node.runtimeDir }, 30000, (err, stdout, stderr) => {
+          if (err) {
+            errors.push(`${label}: ${err.message || stderr || stdout}`);
+            tryNext();
+            return;
+          }
+          const exe = String(stdout || "").trim().split(/\r?\n/).pop();
+          if (!exe) {
+            errors.push(`${label}: kein sys.executable erhalten`);
+            tryNext();
+            return;
+          }
+          node.basePython = exe;
+          node.pythonPath = exe;
+          node.log(`Python erkannt: ${exe}`);
+          callback(null, exe);
+        });
+      }
+      tryNext();
+    }
+
+    function preparePython(callback) {
+      ensureRuntimeProject(node.copyOnStart);
+      const backendDir = path.join(node.runtimeDir, "backend");
+      const requirements = path.join(backendDir, "requirements.txt");
+      const wheelhouse = path.join(__dirname, "wheelhouse");
+
+      const existingVenvPy = findExistingVenvPython();
+      const py = existingVenvPy || venvPythonPath();
+      if (existingVenvPy) {
+        node.pythonRuntime = existingVenvPy;
+        checkImports(existingVenvPy, backendDir, requirements, wheelhouse, callback);
+        return;
+      }
+
+      resolveBasePython((baseErr, basePy) => {
+        if (baseErr) {
+          callback(baseErr);
+          return;
+        }
+
+        setStatus("yellow", "ring", "Python venv wird erstellt");
+        spawnCollect(basePy, ["-m", "venv", path.join(node.runtimeDir, ".venv")], { cwd: node.runtimeDir }, 120000, (err, stdout, stderr) => {
+          if (err) {
+            node.warn(`Venv konnte nicht erstellt werden, nutze System-Python '${basePy}': ${err.message}`);
+            checkImports(basePy, backendDir, requirements, wheelhouse, callback);
+            return;
+          }
+          const createdVenvPy = findExistingVenvPython();
+          if (!createdVenvPy) {
+            const venvErr = new Error(`Virtuelle Python-Umgebung wurde erstellt, aber python.exe wurde nicht gefunden. Erwartet unter: ${path.join(node.runtimeDir, ".venv")}. stdout=${stdout || ""} stderr=${stderr || ""}`);
+            venvErr.code = "VENV_PYTHON_MISSING";
+            callback(venvErr);
+            return;
+          }
+          node.pythonRuntime = createdVenvPy;
+          node.pythonPath = createdVenvPy;
+          checkImports(createdVenvPy, backendDir, requirements, wheelhouse, callback);
+        });
+      });
+    }
+
+    function checkImports(py, backendDir, requirements, wheelhouse, callback) {
+      const checkCode = "import flask, flask_cors; import pymodbus; print('ME_VPLC_PYTHON_OK')";
+      spawnCollect(py, ["-c", checkCode], { cwd: backendDir }, 30000, (checkErr) => {
+        if (!checkErr) {
+          node.pythonRuntime = py;
+          callback(null, py);
+          return;
+        }
+        if (!node.autoInstallDeps) {
+          const err = new Error(`Python-Abhängigkeiten fehlen. Bitte installiere: ${requirements}`);
+          err.code = "PY_DEPS_MISSING";
+          callback(err);
+          return;
+        }
+        installDeps(py, backendDir, requirements, wheelhouse, callback);
+      });
+    }
+
+    function installDeps(py, backendDir, requirements, wheelhouse, callback) {
+      setStatus("yellow", "ring", "Python Pakete werden installiert");
+      const args = ["-m", "pip", "install", "-r", requirements];
+      const hasLocalWheelhouse = fs.existsSync(wheelhouse) && fs.readdirSync(wheelhouse).some((f) => f.toLowerCase().endsWith(".whl"));
+      if (hasLocalWheelhouse) {
+        // Voller Offline-Modus: keine Verbindung zu PyPI, ausschließlich lokale Wheels aus dem Node-Paket.
+        args.splice(3, 0, "--no-index", "--find-links", wheelhouse);
+        node.log(`Nutze integriertes Offline-Wheelhouse: ${wheelhouse}`);
+      } else {
+        node.warn("Kein lokales Wheelhouse im Node-Paket gefunden. Pip versucht Online-Installation.");
+      }
+      node.log(`Installiere Python-Abhängigkeiten: ${py} ${args.join(" ")}`);
+      spawnCollect(py, args, { cwd: backendDir }, 180000, (err, stdout, stderr) => {
+        if (stdout.trim()) node.log(stdout.trim());
+        if (stderr.trim()) node.warn(stderr.trim());
+        if (err) {
+          err.message = `Python-Abhängigkeiten konnten nicht installiert werden. ${err.message}`;
+          callback(err);
+          return;
+        }
+        node.pythonRuntime = py;
+        callback(null, py);
+      });
+    }
+
+    function publishStatus() {
+      requestJson(node.backendPort, "/api/status", "GET", null, (err, data) => {
+        if (err) {
+          setStatus("red", "ring", isConnectionError(err) ? "Backend nicht erreichbar" : "Backend Fehler");
+          return;
+        }
+        setStatus(data.running ? "green" : "yellow", data.running ? "dot" : "ring", data.running ? `RUN ${data.cycle_time_ms || "?"} ms` : "Backend OK / PLC STOP");
+      });
+    }
+
+    function startPolling() {
+      if (node.pollTimer) clearInterval(node.pollTimer);
+      node.pollTimer = setInterval(publishStatus, 2000);
+    }
+
+    function makeStartupError(err) {
+      const stderr = tailFile(node.stderrLog, 5000);
+      const stdout = tailFile(node.stdoutLog, 3000);
+      const detail = stderr || stdout;
+      if (detail && !String(err.message || "").includes(detail.slice(0, 80))) {
+        err.message = `${err.message}\nBackend-Log:\n${detail}`;
+      }
+      return err;
+    }
+
+    function startBackend(callback) {
+      requestJson(node.backendPort, "/api/status", "GET", null, (alreadyRunningErr) => {
+        if (!alreadyRunningErr) {
+          setStatus("yellow", "ring", "Backend bereits aktiv");
+          startPolling();
+          if (callback) callback(null, { alreadyRunning: true });
+          return;
+        }
+
+        if (node.child) {
+          if (callback) callback(null, { alreadyStarting: true });
+          return;
+        }
+        if (node.starting) {
+          waitForBackend(40, callback || function () {});
+          return;
+        }
+
+        node.starting = true;
+        node.childExited = null;
+        preparePython((prepErr, py) => {
+          if (prepErr) {
+            node.starting = false;
+            setStatus("red", "ring", "Python/Deps Fehler");
+            if (callback) callback(prepErr);
+            return;
+          }
+
+          try {
+            const backendDir = path.join(node.runtimeDir, "backend");
+            fs.writeFileSync(node.stdoutLog, "", "utf8");
+            fs.writeFileSync(node.stderrLog, "", "utf8");
+            const out = fs.createWriteStream(node.stdoutLog, { flags: "a" });
+            const errOut = fs.createWriteStream(node.stderrLog, { flags: "a" });
+
+            node.child = spawn(py, ["-u", "app.py"], {
+              cwd: backendDir,
+              env: Object.assign({}, process.env, {
+                ME_VPLC_PORT: String(node.backendPort),
+                PYTHONUNBUFFERED: "1",
+                FLASK_ENV: "production"
+              }),
+              stdio: ["ignore", "pipe", "pipe"],
+              windowsHide: true
+            });
+
+            setStatus("yellow", "ring", `Backend startet (${path.basename(py)})`);
+            node.log(`ME vPLC Runtime: ${node.runtimeDir}`);
+            node.log(`ME vPLC Backend: ${backendUrl()}`);
+            node.log(`ME vPLC Python: ${py}`);
+
+            node.child.stdout.on("data", (data) => {
+              out.write(data);
+              const text = String(data).trim();
+              if (text) node.log(text);
+            });
+            node.child.stderr.on("data", (data) => {
+              errOut.write(data);
+              const text = String(data).trim();
+              if (text) node.warn(text);
+            });
+            node.child.on("error", (err) => {
+              node.child = null;
+              node.starting = false;
+              setStatus("red", "ring", `Python Startfehler: ${err.code || err.message}`);
+              node.error(`ME vPLC Backend konnte nicht gestartet werden. Python='${py}'. ${err.message}`);
+              if (callback) callback(makeStartupError(err));
+            });
+            node.child.on("exit", (code, signal) => {
+              node.childExited = { code, signal, at: new Date().toISOString() };
+              node.child = null;
+              node.starting = false;
+              setStatus("red", "ring", `Backend beendet ${code !== null ? code : signal}`);
+            });
+
+            startPolling();
+            waitForBackend(60, (waitErr, data, statusCode) => {
+              node.starting = false;
+              if (waitErr) {
+                if (callback) callback(makeStartupError(waitErr));
+                return;
+              }
+              if (callback) callback(null, { started: true, data, statusCode });
+            });
+          } catch (err) {
+            node.starting = false;
+            node.error(err);
+            setStatus("red", "ring", "Startfehler");
+            if (callback) callback(makeStartupError(err));
+          }
+        });
+      });
+    }
+
+    function waitForBackend(maxAttempts, callback) {
+      let attempts = 0;
+      function check() {
+        attempts += 1;
+        requestJson(node.backendPort, "/api/status", "GET", null, (err, data, statusCode) => {
+          if (!err) {
+            callback(null, data, statusCode);
+            return;
+          }
+          if (node.childExited) {
+            const exit = node.childExited;
+            const exitErr = new Error(`ME vPLC Backend wurde direkt beendet (${exit.code !== null ? "Code " + exit.code : exit.signal}).`);
+            exitErr.code = "BACKEND_EXITED";
+            callback(exitErr);
+            return;
+          }
+          if (attempts >= maxAttempts) {
+            callback(err);
+            return;
+          }
+          setTimeout(check, 500);
+        });
+      }
+      check();
+    }
+
+    function ensureBackendReady(callback) {
+      requestJson(node.backendPort, "/api/status", "GET", null, (err, data, statusCode) => {
+        if (!err) {
+          callback(null, data, statusCode);
+          return;
+        }
+        startBackend((startErr) => {
+          if (startErr) {
+            callback(startErr);
+            return;
+          }
+          requestJson(node.backendPort, "/api/status", "GET", null, callback);
+        });
+      });
+    }
+
+    function stopBackend() {
+      if (node.pollTimer) {
+        clearInterval(node.pollTimer);
+        node.pollTimer = null;
+      }
+      if (node.child) {
+        node.child.kill();
+        node.child = null;
+      }
+      setStatus("grey", "ring", "gestoppt");
+    }
+
+    function finishError(msg, send, done, err) {
+      const stderr = tailFile(node.stderrLog, 5000);
+      const stdout = tailFile(node.stdoutLog, 3000);
+      const payload = {
+        ok: false,
+        error: err.message,
+        code: err.code || null,
+        hint: isConnectionError(err)
+          ? `Backend ist auf ${backendUrl()} nicht erreichbar. Der Node startet es automatisch; falls es sofort beendet wird, siehe backendLog.`
+          : "Details stehen im Node-RED-Log und in backendLog.",
+        backendUrl: backendUrl(),
+        runtimeDir: node.runtimeDir,
+        python: node.pythonRuntime || node.basePython || node.pythonPath,
+        backendLog: {
+          stderr,
+          stdout
+        }
+      };
+      setStatus("red", "ring", isConnectionError(err) ? "Backend nicht erreichbar" : "Fehler");
+      msg.payload = payload;
+      msg.error = payload;
+      send(msg);
+      if (done) done();
+    }
+
+    node.on("input", function (msg, send, done) {
+      send = send || function () { node.send.apply(node, arguments); };
+      const command = String(msg.command || msg.payload || "status").toLowerCase();
+
+      if (command === "start-backend" || command === "backend-start") {
+        startBackend((err) => {
+          if (err) { finishError(msg, send, done, err); return; }
+          requestJson(node.backendPort, "/api/status", "GET", null, (statusErr, data, statusCode) => {
+            if (statusErr) { finishError(msg, send, done, statusErr); return; }
+            msg.statusCode = statusCode;
+            msg.payload = { ok: true, backend: backendUrl(), runtimeDir: node.runtimeDir, python: node.pythonRuntime || node.basePython || node.pythonPath, status: data };
+            send(msg);
+            publishStatus();
+            if (done) done();
+          });
+        });
+        return;
+      }
+
+      if (command === "stop-backend" || command === "backend-stop") {
+        stopBackend();
+        msg.payload = { ok: true, backend: "stopped" };
+        send(msg);
+        if (done) done();
+        return;
+      }
+
+      const endpoint = (command === "start" || command === "plc-start") ? "/api/start"
+        : (command === "stop" || command === "plc-stop") ? "/api/stop"
+          : "/api/status";
+      const method = endpoint === "/api/status" ? "GET" : "POST";
+
+      ensureBackendReady((readyErr) => {
+        if (readyErr) { finishError(msg, send, done, readyErr); return; }
+        requestJson(node.backendPort, endpoint, method, null, (err, data, statusCode) => {
+          if (err) { finishError(msg, send, done, err); return; }
+          msg.statusCode = statusCode;
+          msg.payload = data;
+          msg.meVplc = { backendUrl: backendUrl(), runtimeDir: node.runtimeDir, python: node.pythonRuntime || node.basePython || node.pythonPath };
+          send(msg);
+          publishStatus();
+          if (done) done();
+        });
+      });
+    });
+
+    node.on("close", function (removed, done) {
+      stopBackend();
+      done();
+    });
+
+    if (node.autoStart) {
+      startBackend(() => setTimeout(publishStatus, 500));
+    } else {
+      setStatus("grey", "ring", "bereit");
+    }
+  }
+
+  RED.nodes.registerType("me-vplc", MeVplcNode);
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "node-red-contrib-me-vplc",
+  "version": "1.0.0",
+  "description": "Node-RED Node zur Integration der ME vPLC Flask/React Runtime mit eingebettetem Projekt, automatischem Backend-Start und voll integriertem Python-Wheelhouse fuer Offline-Installation.",
+  "keywords": [
+    "node-red",
+    "plc",
+    "structured-text",
+    "me-vplc",
+    "flask",
+    "react"
+  ],
+  "license": "UNLICENSED",
+  "node-red": {
+    "nodes": {
+      "me-vplc": "me-vplc.js"
+    }
+  },
+  "files": [
+    "me-vplc.js",
+    "me-vplc.html",
+    "project/**/*",
+    "README.md",
+    "wheelhouse/**/*"
+  ]
+}