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

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
                 };
 
             }
@@ -245,28 +257,73 @@ class OpcUaServerProcess {
 
 
 
-            process.send({
-                type: "send",
-                data: msg,
-                nodeId: nodeId
-            });
+            let hasFailures = false;
+            if (readArrayResults) {
+                const failed = readArrayResults.filter(item => item && item.status !== "Good");
+                if (failed.length) {
+                    hasFailures = true;
+                }
+            }
+            if (result.directError) {
+                hasFailures = true;
+            }
+
+            if (!hasFailures) {
+                process.send({
+                    type: "send",
+                    data: msg,
+                    nodeId: nodeId
+                });
+            }
 
             process.send({
                 type: "status",
                 data: {
-                    fill: "green",
+                    fill: hasFailures ? (result.directError ? "red" : "yellow") : "green",
                     shape: "dot",
-                    text: result.identifiers.length > 1 ? "read " + result.identifiers.length + " tags" : "read " + result.identifiers[0]
+                    text: hasFailures
+                        ? (result.directError ? "read failed" : "partial read failed")
+                        : (result.identifiers.length > 1 ? "read " + result.identifiers.length + " tags" : "read " + result.identifiers[0])
                 },
                 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({
                 type: "error",
                 data: { fill: "red", shape: "ring", text: "failed read" },
                 error: error.message,
+                originalMsg: msg,
                 nodeId: nodeId
             });
         }
@@ -321,6 +378,7 @@ class OpcUaServerProcess {
                 type: "error",
                 data: { fill: "red", shape: "ring", text: "failed write" },
                 error: error.message,
+                originalMsg: msg,
                 nodeId: nodeId
             });
         }
@@ -335,6 +393,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 +424,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 +447,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 +470,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 +496,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 +514,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];
             }
@@ -466,25 +541,66 @@ class OpcUaServerProcess {
                 msg.topic = writtenPaths[0];
             }
 
-            process.send({
-                type: "send",
-                data: msg,
-                nodeId
-            });
+            let hasFailures = false;
+            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");
+                if (failed.length) {
+                    hasFailures = true;
+                }
+            }
+            if (directError) {
+                hasFailures = true;
+            }
+
+            if (!hasFailures) {
+                process.send({
+                    type: "send",
+                    data: msg,
+                    nodeId
+                });
+            }
 
             process.send({
                 type: "status",
                 data: {
-                    fill: "green",
+                    fill: hasFailures ? (directError ? "red" : "yellow") : "green",
                     shape: "dot",
-                    text:
-                        writtenPaths.length > 1
-                            ? `write ${writtenPaths.length} tags`
-                            : `write ${writtenPaths[0]}`
+                    text: hasFailures
+                        ? (directError ? "write failed" : "partial write failed")
+                        : (writtenPaths.length > 1 ? `write ${writtenPaths.length} tags` : `write ${writtenPaths[0]}`)
                 },
                 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({
@@ -495,6 +611,7 @@ class OpcUaServerProcess {
                     text: "failed write"
                 },
                 error: error.message,
+                originalMsg: msg,
                 nodeId
             });
         }
@@ -541,20 +658,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
         };
     }
 
@@ -775,6 +910,222 @@ class OpcUaServerProcess {
         }
     }
 
+    async readActiveSessions(msg, nodeId) {
+        try {
+            await this.ensureReady();
+            const server = this.node && this.node.server;
+            if (!server || !server.engine) {
+                throw new Error("OPC UA server is not available");
+            }
+
+            const rawSessions = server.engine._sessions || {};
+            const sessions = Object.values(rawSessions).map((session) => buildSessionSnapshot(session));
+
+            if (msg) {
+                const outMsg = Object.assign({}, msg);
+                outMsg.payload = sessions;
+
+                process.send({
+                    type: "send",
+                    data: outMsg,
+                    nodeId: nodeId
+                });
+            }
+
+            process.send({
+                type: "status",
+                data: {
+                    fill: "green",
+                    shape: "dot",
+                    text: sessions.length === 1
+                        ? "1 session"
+                        : sessions.length + " sessions"
+                },
+                nodeId: nodeId
+            });
+        } catch (error) {
+            if (msg) {
+                process.send({
+                    type: "error",
+                    data: { fill: "red", shape: "ring", text: "failed getSessions" },
+                    error: error.message,
+                    originalMsg: msg,
+                    nodeId: nodeId
+                });
+            } else {
+                process.send({
+                    type: "status",
+                    data: { fill: "red", shape: "ring", text: "failed getSessions: " + error.message },
+                    nodeId: nodeId
+                });
+            }
+        }
+    }
+
+    async deleteActiveSessions(msg, nodeId) {
+        try {
+            await this.ensureReady();
+            const server = this.node && this.node.server;
+            if (!server || !server.engine) {
+                throw new Error("OPC UA server is not available");
+            }
+
+            const payload = msg && Array.isArray(msg.payload) ? msg.payload : [];
+            if (!payload.length) {
+                throw new Error("msg.payload must be a non-empty array of { sessionId } objects");
+            }
+
+            const engine = server.engine;
+            const rawSessions = engine._sessions || {};
+
+            const results = payload.map((item) => {
+                const requestedId = String(item && item.sessionId || "").trim();
+                if (!requestedId) {
+                    return { sessionId: requestedId, status: "error", error: "sessionId is required" };
+                }
+
+                // Sessions are keyed by authenticationToken; find by matching nodeId (the GUID sessionId)
+                const found = Object.values(rawSessions).find(
+                    (s) => safeToString(s.nodeId) === requestedId
+                );
+
+                if (!found) {
+                    return { sessionId: requestedId, status: "not_found" };
+                }
+
+                try {
+                    engine.closeSession(found.authenticationToken, true, "Forcing");
+                    return { sessionId: requestedId, status: "deleted" };
+                } catch (closeError) {
+                    return { sessionId: requestedId, status: "error", error: closeError.message };
+                }
+            });
+
+            const deletedCount = results.filter((r) => r.status === "deleted").length;
+            const notFoundCount = results.filter((r) => r.status === "not_found").length;
+            const errorCount = results.filter((r) => r.status === "error").length;
+
+            if (msg) {
+                const outMsg = Object.assign({}, msg);
+                outMsg.payload = results;
+
+                process.send({
+                    type: "send",
+                    data: outMsg,
+                    nodeId: nodeId
+                });
+            }
+
+            const statusParts = [];
+            if (deletedCount) statusParts.push("deleted " + deletedCount);
+            if (notFoundCount) statusParts.push("not found " + notFoundCount);
+            if (errorCount) statusParts.push("error " + errorCount);
+
+            process.send({
+                type: "status",
+                data: {
+                    fill: errorCount ? "red" : (notFoundCount ? "yellow" : "green"),
+                    shape: "dot",
+                    text: statusParts.join(", ") || "no sessions"
+                },
+                nodeId: nodeId
+            });
+        } catch (error) {
+            if (msg) {
+                process.send({
+                    type: "error",
+                    data: { fill: "red", shape: "ring", text: "failed deleteSessions" },
+                    error: error.message,
+                    originalMsg: msg,
+                    nodeId: nodeId
+                });
+            } else {
+                process.send({
+                    type: "status",
+                    data: { fill: "red", shape: "ring", text: "failed deleteSessions: " + error.message },
+                    nodeId: nodeId
+                });
+            }
+        }
+    }
+
+}
+
+/**
+ * Serializes a node-opcua ServerSession into a plain, IPC-safe object.
+ */
+function buildSessionSnapshot(session) {
+    return {
+        sessionId: safeToString(session.nodeId),
+        sessionName: String(session.sessionName || ""),
+        status: String(session.__status || ""),
+        creationDate: session.creationDate instanceof Date ? session.creationDate.toISOString() : null,
+        sessionTimeout: safeNumber(session.sessionTimeout),
+        clientLastContactTime: safeNumber(session.clientLastContactTime),
+        channelId: session.channelId != null ? session.channelId : null,
+        clientDescription: buildClientDescription(session.clientDescription),
+        userIdentityToken: buildUserIdentityToken(session.userIdentityToken),
+        channel: buildChannelInfo(session.channel),
+        currentSubscriptionCount: safeNumber(session.currentSubscriptionCount),
+        cumulatedSubscriptionCount: safeNumber(session.cumulatedSubscriptionCount),
+        currentMonitoredItemCount: safeNumber(session.currentMonitoredItemCount),
+        aborted: Boolean(session.aborted)
+    };
+}
+
+function safeToString(value) {
+    try {
+        return value != null ? String(value) : null;
+    } catch (_) {
+        return null;
+    }
+}
+
+function safeNumber(value) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+}
+
+function buildClientDescription(desc) {
+    if (!desc || typeof desc !== "object") {
+        return null;
+    }
+    return {
+        applicationUri: safeToString(desc.applicationUri),
+        productUri: safeToString(desc.productUri),
+        applicationName: desc.applicationName && desc.applicationName.text
+            ? String(desc.applicationName.text)
+            : safeToString(desc.applicationName),
+        applicationType: safeToString(desc.applicationType)
+    };
+}
+
+function buildUserIdentityToken(token) {
+    if (!token || typeof token !== "object") {
+        return null;
+    }
+    return {
+        policyId: safeToString(token.policyId),
+        userName: safeToString(token.userName),
+        // Never expose passwords or raw credential bytes
+        tokenType: safeToString(token.schema && token.schema.name)
+    };
+}
+
+function buildChannelInfo(channel) {
+    if (!channel || typeof channel !== "object") {
+        return null;
+    }
+    return {
+        channelId: channel.channelId != null ? channel.channelId : null,
+        remoteAddress: safeToString(channel.remoteAddress),
+        remotePort: safeNumber(channel.remotePort),
+        bytesRead: safeNumber(channel.bytesRead),
+        bytesWritten: safeNumber(channel.bytesWritten),
+        transactionsCount: safeNumber(channel.transactionsCount),
+        securityMode: safeToString(channel.securityMode),
+        securityPolicy: safeToString(channel.securityPolicy)
+    };
 }
 
 /**
@@ -827,14 +1178,33 @@ process.on("message", async (msg) => {
                 break;
 
             case "buildServerSnapshot":
-                OpcUaServerStatusNode(serverProcess.node, msg.msg, msg.nodeId)
-                break
+                try {
+                    await serverProcess.ensureReady();
+                    OpcUaServerStatusNode(serverProcess.node, msg.msg, msg.nodeId);
+                } catch (error) {
+                    process.send({
+                        type: "status",
+                        data: {
+                            fill: msg.msg ? "red" : "yellow",
+                            shape: "ring",
+                            text: msg.msg ? "Status: " + error.message : "waiting for server"
+                        },
+                        nodeId: msg.nodeId
+                    });
+                }
+                break;
             case "eventsServer":
                 eventsServer(serverProcess.node, msg.node, msg.nodeId)
                 break;
             case "readActiveAlarms":
                 serverProcess.readActiveAlarms(msg.msg, msg.nodeId)
                 break;
+            case "readActiveSessions":
+                await serverProcess.readActiveSessions(msg.msg, msg.nodeId);
+                break;
+            case "deleteActiveSessions":
+                await serverProcess.deleteActiveSessions(msg.msg, msg.nodeId);
+                break;