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

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

@@ -257,18 +257,33 @@ 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
             });
@@ -308,6 +323,7 @@ class OpcUaServerProcess {
                 type: "error",
                 data: { fill: "red", shape: "ring", text: "failed read" },
                 error: error.message,
+                originalMsg: msg,
                 nodeId: nodeId
             });
         }
@@ -362,6 +378,7 @@ class OpcUaServerProcess {
                 type: "error",
                 data: { fill: "red", shape: "ring", text: "failed write" },
                 error: error.message,
+                originalMsg: msg,
                 nodeId: nodeId
             });
         }
@@ -381,6 +398,14 @@ class OpcUaServerProcess {
             const target = msg && msg.opcuaServerIo ? msg.opcuaServerIo : {};
             const identifierType = this.resolveIdentifierType(target);
 
+            let isSingleTag = false;
+            try {
+                this.resolveIdentifier(target);
+                isSingleTag = true;
+            } catch (e) {
+                // not a single tag
+            }
+
             // Buffer serializado pelo IPC
             if (
                 payload &&
@@ -447,7 +472,7 @@ class OpcUaServerProcess {
             }
 
             // Array de objetos
-            else if (Array.isArray(payload)) {
+            else if (Array.isArray(payload) && (!isSingleTag || this.isBatchWritePayload(payload))) {
 
                 if (!payload.length) {
                     throw new Error("msg.payload array does not contain any items");
@@ -524,21 +549,33 @@ 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
             });
@@ -582,11 +619,24 @@ class OpcUaServerProcess {
                     text: "failed write"
                 },
                 error: error.message,
+                originalMsg: msg,
                 nodeId
             });
         }
     }
 
+    isBatchWritePayload(payload) {
+        if (!Array.isArray(payload) || payload.length === 0) {
+            return false;
+        }
+        return payload.every(item => 
+            item && 
+            typeof item === "object" && 
+            !Array.isArray(item) && 
+            (item.path !== undefined || item.nodeId !== undefined || item.identifier !== undefined)
+        );
+    }
+
     resolveIdentifierType(target) {
         return target && target.identifierType === "nodeId" ? "nodeId" : "path";
     }
@@ -855,10 +905,12 @@ class OpcUaServerProcess {
 
     readActiveAlarms(msg, nodeId) {
         try {
-            var result = registry.getActiveAlarms(this.node)
-            const msg2 = {
-                payload: result
-            }
+            const result = registry.getActiveAlarms(this.node);
+            const safeResult = Array.isArray(result) ? result : [];
+
+            const msg2 = Object.assign({}, msg || {}, {
+                payload: safeResult
+            });
 
             process.send({
                 type: "send",
@@ -871,17 +923,336 @@ class OpcUaServerProcess {
                 data: {
                     fill: "green",
                     shape: "dot",
-                    text: result.paths.length > 1 ? "read " + result.paths.length + " tags" : "read " + result.paths[0]
+                    text: safeResult.length + " active alarm" + (safeResult.length !== 1 ? "s" : "")
+                },
+                nodeId: nodeId
+            });
+        } catch (error) {
+            process.send({
+                type: "error",
+                data: error.message,
+                nodeId: nodeId
+            });
+        }
+    }
+
+    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 {
+        } 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
+                });
+            }
+        }
+    }
+
+    async validateLogin(msg, nodeId) {
+        try {
+            await this.ensureReady();
+            const runtime = this.runtime;
+            if (!runtime) {
+                throw new Error("OPC UA server is not available");
+            }
+
+            const payload = msg && msg.payload ? msg.payload : {};
+            const username = typeof payload.userName === "string" ? payload.userName : (typeof payload.username === "string" ? payload.username : "");
+            const password = typeof payload.password === "string" ? payload.password : "";
+
+            const normalizedUserName = username.trim();
+            const users = Array.isArray(runtime.users) ? runtime.users : [];
+            const user = users.find((entry) => entry && entry.username === normalizedUserName);
+
+            let isValid = false;
+            if (user) {
+                if (user.password && user.password === password) {
+                    isValid = true;
+                } else if (user.passwordHash) {
+                    let bcrypt = null;
+                    try {
+                        bcrypt = require("bcryptjs");
+                    } catch (e) {
+                        bcrypt = null;
+                    }
+                    if (bcrypt) {
+                        try {
+                            isValid = bcrypt.compareSync(password, user.passwordHash);
+                        } catch (err) {
+                            // ignore comparison error
+                        }
+                    }
+                }
+            }
+
+            let result;
+            if (isValid) {
+                const groups = typeof user.group === "string"
+                    ? user.group.split(",").map(g => g.trim()).filter(Boolean)
+                    : Array.isArray(user.group)
+                        ? user.group
+                        : [];
+
+                result = {
+                    status: "Good",
+                    username: user.username,
+                    group: user.group,
+                    groups: groups
+                };
+            } else {
+                result = {
+                    status: "erro",
+                    message: "Invalid username or password"
+                };
+            }
+
+            if (msg) {
+                const outMsg = Object.assign({}, msg);
+                outMsg.payload = result;
+
+                process.send({
+                    type: "send",
+                    data: outMsg,
+                    nodeId: nodeId
+                });
+            }
 
+            process.send({
+                type: "status",
+                data: {
+                    fill: isValid ? "green" : "yellow",
+                    shape: "dot",
+                    text: isValid ? "Login: Good" : "Login: erro"
+                },
+                nodeId: nodeId
+            });
+        } catch (error) {
+            if (msg) {
+                const outMsg = Object.assign({}, msg);
+                outMsg.payload = {
+                    status: "erro",
+                    message: error.message
+                };
+                process.send({
+                    type: "send",
+                    data: outMsg,
+                    nodeId: nodeId
+                });
+            }
+            process.send({
+                type: "status",
+                data: { fill: "red", shape: "ring", text: "Login error: " + 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)
+    };
+}
+
 /**
  * Instância única do processo
  */
@@ -932,14 +1303,36 @@ 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;
+            case "validateLogin":
+                await serverProcess.validateLogin(msg.msg, msg.nodeId);
+                break;
 
 
 
@@ -977,4 +1370,8 @@ process.on("unhandledRejection", (reason) => {
         data: "Unhandled Rejection: " + (reason?.message || reason),
         nodeId: serverProcess.node.id
     });
-});
+});
+
+if (require.main !== module) {
+    module.exports = { OpcUaServerProcess };
+}

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

@@ -2,13 +2,17 @@
 
 
 
+const path = require("path");
 const {
     OPCUAServer,
     UserTokenType,
     buildApplicationUri,
     makeRoles,
     WellKnownRoles,
-    resolveNodeId
+    resolveNodeId,
+    OPCUACertificateManager,
+    SecurityPolicy,
+    MessageSecurityMode
 } = require("./opcua-constants");
 const { OpcUaAddressSpaceBuilder } = require("./opcua-address-space-builder");
 const { OpcUaServerMethods } = require("./opcua-server-methods");
@@ -29,13 +33,22 @@ class OpcUaServerRuntime {
         this.serverName = options.settings.serverName;
         this.port = options.settings.port;
         this.maxConnections = options.settings.maxConnections;
+        this.minSessionTimeout = options.settings.minSessionTimeout;
+        this.defaultSessionTimeout = options.settings.defaultSessionTimeout;
+        this.maxSessionTimeout = options.settings.maxSessionTimeout;
         this.namespaceUri = options.settings.namespaceUri;
         this.resourcePath = options.settings.resourcePath;
         this.allowAnonymous = options.settings.allowAnonymous;
+        this.automaticallyAcceptUnknownCertificate = options.settings.automaticallyAcceptUnknownCertificate;
+        this.certificatesFolder = options.settings.certificatesFolder;
         this.groups = options.settings.groups;
         this.users = options.settings.users;
-        this.securityPolicy = options.settings.securityPolicy;
-        this.securityMode = options.settings.securityMode;
+        this.securityPolicies = Array.isArray(options.settings.securityPolicies) && options.settings.securityPolicies.length > 0
+            ? options.settings.securityPolicies
+            : [SecurityPolicy.None];
+        this.securityModes = Array.isArray(options.settings.securityModes) && options.settings.securityModes.length > 0
+            ? options.settings.securityModes
+            : [MessageSecurityMode.None];
         this.treeConfig = options.settings.treeConfig;
 
         this.server = null;
@@ -52,6 +65,28 @@ class OpcUaServerRuntime {
             return;
         }
 
+        const certificateFolder = this.certificatesFolder || path.resolve(__dirname, "..", "..", "certificates");
+        this.serverCertificateManager = new OPCUACertificateManager({
+            rootFolder: certificateFolder,
+            automaticallyAcceptUnknownCertificate: this.automaticallyAcceptUnknownCertificate
+        });
+        await this.serverCertificateManager.initialize();
+
+        // Ensure directories exist immediately on startup
+        const fs = require("fs");
+        try {
+            const trustedDir = path.join(certificateFolder, "trusted", "certs");
+            const rejectedDir = path.join(certificateFolder, "rejected");
+            if (!fs.existsSync(trustedDir)) {
+                fs.mkdirSync(trustedDir, { recursive: true });
+            }
+            if (!fs.existsSync(rejectedDir)) {
+                fs.mkdirSync(rejectedDir, { recursive: true });
+            }
+        } catch (e) {
+            // Ignore directory creation errors
+        }
+
         this.server = new OPCUAServer(this.buildServerOptions());
         await this.server.initialize();
 
@@ -74,6 +109,7 @@ class OpcUaServerRuntime {
 
         this.addressSpaceBuilder.rebuild(this.treeConfig);
         await this.server.start();
+
         this.registry.registerServer(this);
 
         //Methods
@@ -124,6 +160,9 @@ class OpcUaServerRuntime {
         this.ensureReady();
         this.syncNamespaces(treeConfig);
         this.treeConfig = treeConfig;
+        // Refresh the user list in the builder so newly added/removed users are
+        // recognised in access events without requiring a full server restart.
+        this.addressSpaceBuilder.updateUsers(this.users);
         this.addressSpaceBuilder.sync(treeConfig);
     }
 
@@ -200,9 +239,17 @@ class OpcUaServerRuntime {
             });
         }
 
+        const certificatesFolder = this.certificatesFolder || path.resolve(__dirname, "..", "..", "certificates");
+
         return {
             port: this.port,
+            minSessionTimeout: this.minSessionTimeout !== undefined ? this.minSessionTimeout : 100,
+            defaultSessionTimeout: this.defaultSessionTimeout !== undefined ? this.defaultSessionTimeout : 30000,
+            maxSessionTimeout: this.maxSessionTimeout !== undefined ? this.maxSessionTimeout : 3000000,
             resourcePath: this.resourcePath,
+            serverCertificateManager: this.serverCertificateManager,
+            certificateFile: path.join(certificatesFolder, "own", "certs", "server_selfsigned_cert_2048.pem"),
+            privateKeyFile: path.join(certificatesFolder, "own", "private", "private_key.pem"),
             buildInfo: {
                 productName: "opc-ua-server",
                 buildNumber: "1",
@@ -216,8 +263,8 @@ class OpcUaServerRuntime {
                 applicationUri: buildApplicationUri(this.serverName),
                 productUri: "urn:node-red:opc-ua-server"
             },
-            securityPolicies: [this.securityPolicy],
-            securityModes: [this.securityMode],
+            securityPolicies: this.securityPolicies,
+            securityModes: this.securityModes,
             allowAnonymous: this.allowAnonymous,
             userManager: {
                 isValidUser: (username, password) => this.isValidUser(username, password),