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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitormnm/node-red-simple-opcua",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "publishConfig": {
     "access": "public"
   },

package/server/lib/opcua-server-runtime-child.js

@@ -193,15 +193,18 @@ class OpcUaServerProcess {
             const target = msg && msg.opcuaServerIo ? msg.opcuaServerIo : {};
             const identifierType = this.resolveIdentifierType(target);
 
-            let result = {}
+            let result = {};
+            let readArrayResults = null;
 
             if (Array.isArray(payload)) {
                 if (!payload.length) {
                     throw new Error("msg.payload array does not contain any items");
                 }
 
+                readArrayResults = payload.map((item) => this.readPayloadItem(identifierType, item));
+
                 result = {
-                    payload: payload.map((item) => this.readPayloadItem(identifierType, item)),
+                    payload: readArrayResults,
                     identifiers: payload.map((item) => this.resolvePayloadItemIdentifier(item))
                 };
             } else if (payload && typeof payload === "object" && !Array.isArray(payload)) {
@@ -225,9 +228,18 @@ class OpcUaServerProcess {
                 };
             } else {
                 const identifier = this.resolveIdentifier(target);
+                let directValue = null;
+                let directError = null;
+                try {
+                    directValue = server.readValue(identifierType, identifier);
+                } catch (e) {
+                    directValue = null;
+                    directError = { identifier, message: e.message || String(e) };
+                }
                 result = {
-                    payload: server.readValue(identifierType, identifier),
-                    identifiers: [identifier]
+                    payload: directValue,
+                    identifiers: [identifier],
+                    directError
                 };
 
             }
@@ -261,6 +273,35 @@ class OpcUaServerProcess {
                 nodeId: nodeId
             });
 
+            // Emit a partialError for items that could not be read (array-of-objects mode only)
+            if (readArrayResults) {
+                const failed = readArrayResults
+                    .filter(item => item && item.status !== "Good")
+                    .map(item => ({ name: item.name, path: item.path, status: item.status }));
+
+                if (failed.length) {
+                    process.send({
+                        type: "partialError",
+                        error: "Some tags could not be read: " + failed.map(f => f.path).join(", "),
+                        failed: failed,
+                        originalMsg: msg,
+                        nodeId: nodeId
+                    });
+                }
+            }
+
+            // Emit a partialError for a direct single-tag read failure
+            if (result.directError) {
+                const { identifier, message } = result.directError;
+                process.send({
+                    type: "partialError",
+                    error: "Some tags could not be read: " + identifier,
+                    failed: [{ name: "", path: identifier, status: message }],
+                    originalMsg: msg,
+                    nodeId: nodeId
+                });
+            }
+
         } catch (error) {
 
             process.send({
@@ -335,6 +376,7 @@ class OpcUaServerProcess {
         try {
             let writtenPaths = null;
             let payload = msg ? msg.payload : undefined;
+            let directError = null;
 
             const target = msg && msg.opcuaServerIo ? msg.opcuaServerIo : {};
             const identifierType = this.resolveIdentifierType(target);
@@ -365,14 +407,18 @@ class OpcUaServerProcess {
             if (Buffer.isBuffer(payload) || payload instanceof Uint8Array) {
 
                 const identifier = this.resolveIdentifier(target);
-
-                this.node.writeValue(
-                    identifierType,
-                    identifier,
-                    Buffer.isBuffer(payload)
-                        ? payload
-                        : Buffer.from(payload)
-                );
+                try {
+                    this.node.writeValue(
+                        identifierType,
+                        identifier,
+                        Buffer.isBuffer(payload)
+                            ? payload
+                            : Buffer.from(payload)
+                    );
+                } catch (e) {
+                    directError = { identifier, message: e.message || String(e) };
+                    msg.payload = null;
+                }
 
                 writtenPaths = [identifier];
             }
@@ -384,14 +430,18 @@ class OpcUaServerProcess {
             ) {
 
                 const identifier = this.resolveIdentifier(target);
-
-                this.node.writeValue(
-                    identifierType,
-                    identifier,
-                    isByteString
-                        ? Buffer.from(payload)
-                        : payload
-                );
+                try {
+                    this.node.writeValue(
+                        identifierType,
+                        identifier,
+                        isByteString
+                            ? Buffer.from(payload)
+                            : payload
+                    );
+                } catch (e) {
+                    directError = { identifier, message: e.message || String(e) };
+                    msg.payload = null;
+                }
 
                 writtenPaths = [identifier];
             }
@@ -403,13 +453,13 @@ class OpcUaServerProcess {
                     throw new Error("msg.payload array does not contain any items");
                 }
 
-                payload.forEach(item => {
-                    this.writePayloadItem(identifierType, item);
-                });
-
-                writtenPaths = payload.map(item =>
-                    this.resolvePayloadItemIdentifier(item)
+                const writeArrayResults = payload.map(item =>
+                    this.writePayloadItem(identifierType, item)
                 );
+
+                msg.payload = writeArrayResults;
+
+                writtenPaths = writeArrayResults.map(item => item.path);
             }
 
             // Objeto { path: value }
@@ -429,11 +479,15 @@ class OpcUaServerProcess {
                 }
 
                 identifiers.forEach(identifier => {
-                    this.node.writeValue(
-                        identifierType,
-                        identifier,
-                        payload[identifier]
-                    );
+                    try {
+                        this.node.writeValue(
+                            identifierType,
+                            identifier,
+                            payload[identifier]
+                        );
+                    } catch (e) {
+                        // suppress per-item errors; unknown paths become undefined
+                    }
                 });
 
                 writtenPaths = identifiers;
@@ -443,12 +497,16 @@ class OpcUaServerProcess {
             else {
 
                 const identifier = this.resolveIdentifier(target);
-
-                this.node.writeValue(
-                    identifierType,
-                    identifier,
-                    payload
-                );
+                try {
+                    this.node.writeValue(
+                        identifierType,
+                        identifier,
+                        payload
+                    );
+                } catch (e) {
+                    directError = { identifier, message: e.message || String(e) };
+                    msg.payload = null;
+                }
 
                 writtenPaths = [identifier];
             }
@@ -485,6 +543,35 @@ class OpcUaServerProcess {
                 nodeId
             });
 
+            // Emit a partialError for items that could not be written (array-of-objects mode only)
+            if (Array.isArray(msg.payload) && msg.payload.length && msg.payload[0] && typeof msg.payload[0].status === "string") {
+                const failed = msg.payload
+                    .filter(item => item.status !== "Good")
+                    .map(item => ({ name: item.name, path: item.path, status: item.status }));
+
+                if (failed.length) {
+                    process.send({
+                        type: "partialError",
+                        error: "Some tags could not be written: " + failed.map(f => f.path).join(", "),
+                        failed: failed,
+                        originalMsg: msg,
+                        nodeId
+                    });
+                }
+            }
+
+            // Emit a partialError for a direct single-tag write failure
+            if (directError) {
+                const { identifier, message } = directError;
+                process.send({
+                    type: "partialError",
+                    error: "Some tags could not be written: " + identifier,
+                    failed: [{ name: "", path: identifier, status: message }],
+                    originalMsg: msg,
+                    nodeId
+                });
+            }
+
         } catch (error) {
 
             process.send({
@@ -541,20 +628,38 @@ class OpcUaServerProcess {
 
     readPayloadItem(identifierType, item) {
         const identifier = this.resolvePayloadItemIdentifier(item);
+        let value = null;
+        let status = "Good";
+        try {
+            value = this.node.readValue(identifierType, identifier);
+        } catch (e) {
+            value = null;
+            status = e.message || String(e);
+        }
         return {
             name: item.name,
             path: identifier,
-            value: this.node.readValue(identifierType, identifier)
+            value,
+            status
         };
     }
 
     writePayloadItem(identifierType, item) {
         const identifier = this.resolvePayloadItemIdentifier(item);
-        this.node.writeValue(identifierType, identifier, item.value);
+        let writtenValue = null;
+        let status = "Good";
+        try {
+            this.node.writeValue(identifierType, identifier, item.value);
+            writtenValue = item.value;
+        } catch (e) {
+            writtenValue = null;
+            status = e.message || String(e);
+        }
         return {
             name: item.name,
             path: identifier,
-            value: item.value
+            value: writtenValue,
+            status
         };
     }
 

package/server/opcua-server-io.js

@@ -152,6 +152,15 @@ module.exports = function (RED) {
                 node.error(msg.error);
             }
 
+            if (msg.type === "partialError") {
+                // Route failed items to catch node without changing the node status
+                const catchMsg = Object.assign({}, msg.originalMsg || {}, {
+                    payload: msg.failed,
+                    error: msg.error
+                });
+                node.error(msg.error, catchMsg);
+            }
+
             if (msg.type === "sendMethod") {
 
                 node.status({

package/server/opcua-server.js

@@ -21,6 +21,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 +45,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);
         });
 
 
@@ -112,6 +136,7 @@ module.exports = function (RED) {
 
         node.on("close", async function (removed, done) {
             try {
+                node.isClosing = true;
                 registry.unregisterChild(node.serverName, child);
                 registry.unregisterServerNames(node.serverName);
                 child.kill();