@vitormnm/node-red-simple-opcua 1.6.2 → 1.7.0

package/server/opcua-server.js

@@ -8,12 +8,29 @@ module.exports = function (RED) {
     const { fork } = require("child_process");
     const path = require("path");
 
+    const getCertificatesFolder = (serverName) => {
+        const safeServerName = (serverName || "default")
+            .replace(/[\\/:\*\?"<>|]/g, "_")
+            .replace(/^\.+$/, "");
+        try {
+            const userDir = (RED.settings && RED.settings.userDir) || path.join(require('os').homedir(), ".node-red");
+            let flowFile = (RED.settings && RED.settings.flowFile) || "flows.json";
+            if (typeof flowFile !== "string") {
+                flowFile = "flows.json";
+            }
+            const flowFileFolder = path.isAbsolute(flowFile) ? path.dirname(flowFile) : path.join(userDir, path.dirname(flowFile));
+            return path.join(flowFileFolder, "simple_opcua", "server", safeServerName);
+        } catch (err) {
+            return path.join(require('os').homedir(), ".node-red", "simple_opcua", "server", safeServerName);
+        }
+    };
+
     function OpcUaServerNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
         const parser = new OpcUaServerConfigParser(node);
-
         const settings = parser.parseNodeConfig(config, this.credentials || {});
+        settings.certificatesFolder = getCertificatesFolder(settings.serverName);
 
 
 
@@ -21,6 +38,7 @@ module.exports = function (RED) {
         node.serverName = settings.serverName;
         node.server = null;
         node.namespace = null;
+        node.isClosing = false;
 
         node.status({ fill: "yellow", shape: "ring", text: "initializing OPC UA server" });
 
@@ -44,12 +62,35 @@ module.exports = function (RED) {
 
         registry.registerServerNames(node.serverName, node.serverName);
 
-        child.on("exit", () => {
+        let crashHandled = false;
+        function handleUnexpectedExit(code, signal) {
+            if (node.isClosing || crashHandled) {
+                return;
+            }
+            crashHandled = true;
+
+            const errorDetails = `OPC UA server child process exited unexpectedly with code ${code} and signal ${signal}`;
+            node.status({ fill: "red", shape: "dot", text: "Child process crashed" });
+
+            const catchMsg = {
+                topic: node.serverName,
+                payload: {
+                    status: "error",
+                    error: errorDetails
+                }
+            };
+            node.send(catchMsg);
+            node.error(errorDetails, catchMsg);
+        }
+
+        child.on("exit", (code, signal) => {
             registry.unregisterChild(node.serverName, child);
+            handleUnexpectedExit(code, signal);
         });
 
-        child.on("close", () => {
+        child.on("close", (code, signal) => {
             registry.unregisterChild(node.serverName, child);
+            handleUnexpectedExit(code, signal);
         });
 
 
@@ -105,13 +146,16 @@ module.exports = function (RED) {
 
                 done();
             } catch (error) {
-                reportError(node, "Input processing failed", error);
-                done(error);
+                reportError(node, "Input processing failed", error, msg);
+                if (done) {
+                    done();
+                }
             }
         });
 
         node.on("close", async function (removed, done) {
             try {
+                node.isClosing = true;
                 registry.unregisterChild(node.serverName, child);
                 registry.unregisterServerNames(node.serverName);
                 child.kill();
@@ -127,9 +171,13 @@ module.exports = function (RED) {
 
 
 
-    function reportError(node, message, error) {
+    function reportError(node, message, error, msg) {
         const details = error && error.message ? error.message : String(error);
-        node.error(message + ": " + details);
+        if (msg) {
+            node.error(message + ": " + details, msg);
+        } else {
+            node.error(message + ": " + details);
+        }
         node.status({ fill: "red", shape: "ring", text: message });
     }
 
@@ -145,6 +193,93 @@ module.exports = function (RED) {
         res.sendFile(jsPath);
     });
 
+    RED.httpAdmin.get("/opc-ua-server/certificates", function (req, res) {
+        const serverName = req.query.serverName || "default";
+        const certificatesFolder = getCertificatesFolder(serverName);
+
+        const fs = require("fs");
+        const trustedDir = path.join(certificatesFolder, "trusted", "certs");
+        const rejectedDir = path.join(certificatesFolder, "rejected");
+
+        // Ensure directories exist
+        try {
+            if (!fs.existsSync(trustedDir)) {
+                fs.mkdirSync(trustedDir, { recursive: true });
+            }
+            if (!fs.existsSync(rejectedDir)) {
+                fs.mkdirSync(rejectedDir, { recursive: true });
+            }
+        } catch (e) {
+            // Ignore directory creation errors (fallback to empty)
+        }
+
+        const listFiles = (dir) => {
+            try {
+                if (!fs.existsSync(dir)) {
+                    return [];
+                }
+                return fs.readdirSync(dir).filter(file => {
+                    const stats = fs.statSync(path.join(dir, file));
+                    return stats.isFile() && (file.endsWith(".der") || file.endsWith(".pem") || file.endsWith(".crt"));
+                });
+            } catch (err) {
+                return [];
+            }
+        };
+
+        res.json({
+            trusted: listFiles(trustedDir),
+            rejected: listFiles(rejectedDir)
+        });
+    });
+
+    RED.httpAdmin.post("/opc-ua-server/certificates/move", function (req, res) {
+        const { serverName, filename, fromFolder, toFolder } = req.body;
+        const certificatesFolder = getCertificatesFolder(serverName);
+
+        const fs = require("fs");
+
+        if (!filename || !fromFolder || !toFolder) {
+            return res.status(400).json({ error: "Missing required fields" });
+        }
+
+        const getFolderDir = (folderName) => {
+            if (folderName === "trusted") {
+                return path.join(certificatesFolder, "trusted", "certs");
+            }
+            if (folderName === "rejected") {
+                return path.join(certificatesFolder, "rejected");
+            }
+            return null;
+        };
+
+        const srcDir = getFolderDir(fromFolder);
+        const destDir = getFolderDir(toFolder);
+
+        if (!srcDir || !destDir) {
+            return res.status(400).json({ error: "Invalid folders specified" });
+        }
+
+        const srcPath = path.join(srcDir, filename);
+        const destPath = path.join(destDir, filename);
+
+        try {
+            if (!fs.existsSync(srcPath)) {
+                return res.status(404).json({ error: "Source certificate not found" });
+            }
+
+            // Ensure destination directory exists
+            if (!fs.existsSync(destDir)) {
+                fs.mkdirSync(destDir, { recursive: true });
+            }
+
+            fs.renameSync(srcPath, destPath);
+            res.json({ success: true });
+        } catch (err) {
+            res.status(500).json({ error: "Failed to move certificate: " + err.message });
+        }
+    });
+
 
 
     RED.nodes.registerType("opc-ua-server", OpcUaServerNode, {

package/server/view/opcua-server.css

@@ -442,6 +442,9 @@ body.opcua-tree-modal-open {
 
 .opcua-auth-card .form-row {
     margin-bottom: 8px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
 }
 
 .opcua-auth-card .form-row:last-child {
@@ -450,15 +453,18 @@ body.opcua-tree-modal-open {
 
 .opcua-auth-card label {
     width: 90px;
+    margin: 0;
+    flex-shrink: 0;
 }
 
-.opcua-auth-card input,
-.opcua-auth-card select {
-    width: calc(100% - 100px);
-}
-
+.opcua-auth-card input[type="text"],
+.opcua-auth-card input[type="password"],
+.opcua-auth-card input[type="number"],
+.opcua-auth-card select,
 .opcua-auth-card .red-ui-typedInput-container {
-    width: calc(100% - 100px) !important;
+    flex: 1 1 auto;
+    margin: 0;
+    width: auto !important;
 }
 
 @media (max-width: 900px) {
@@ -493,4 +499,81 @@ body.opcua-tree-modal-open {
     .opcua-tree-actions {
         margin-left: 0;
     }
+}
+
+.opcua-cert-item {
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--red-ui-form-input-border-color, #e0e0e0);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    user-select: none;
+    transition: background-color 0.2s;
+}
+.opcua-cert-item:last-child {
+    border-bottom: none;
+}
+.opcua-cert-item:hover {
+    background: var(--red-ui-list-item-background-hover, #f0f0f0);
+}
+.opcua-cert-item.is-selected {
+    background: var(--red-ui-list-item-background-selected, #d9ecff);
+    color: var(--red-ui-list-item-color-selected, inherit);
+    font-weight: 500;
+}
+.opcua-cert-item i {
+    font-size: 14px;
+}
+
+/* Standardized configuration card styling */
+.opcua-config-card {
+    padding: 14px;
+    background: var(--red-ui-form-input-background, #fcfcfc);
+    border: 1px solid var(--red-ui-form-input-border-color, #d9d9d9);
+    border-radius: 6px;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+}
+
+.opcua-config-card .opcua-card-title {
+    margin-top: 0;
+    margin-bottom: 12px;
+    font-weight: bold;
+    border-bottom: 1px solid var(--red-ui-form-input-border-color, #eee);
+    padding-bottom: 6px;
+}
+
+.opcua-config-form {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.opcua-config-row {
+    margin: 0 !important;
+    display: flex;
+    align-items: center;
+}
+
+.opcua-config-row--checkbox {
+    height: 34px;
+}
+
+.opcua-config-label {
+    width: 240px;
+    margin: 0 !important;
+    font-weight: 500;
+    flex-shrink: 0;
+    display: inline-block;
+    vertical-align: middle;
+}
+
+.opcua-config-input {
+    width: 300px !important;
+    margin: 0 !important;
+}
+
+.opcua-config-input[type="checkbox"] {
+    width: auto !important;
+    display: inline-block;
 }