@vitormnm/node-red-simple-opcua 1.0.0

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

@@ -0,0 +1,311 @@
+"use strict";
+
+
+
+const {
+    OPCUAServer,
+    UserTokenType,
+    buildApplicationUri
+} = require("./opcua-constants");
+const { OpcUaAddressSpaceBuilder } = require("./opcua-address-space-builder");
+const { OpcUaServerMethods } = require("./opcua-server-methods");
+
+class OpcUaServerRuntime {
+    constructor(options) {
+        this.node = options.node;
+        this.registry = options.registry;
+        this.id = options.settings.id;
+        this.name = options.settings.name;
+        this.serverName = options.settings.serverName;
+        this.port = options.settings.port;
+        this.maxConnections = options.settings.maxConnections;
+        this.namespaceUri = options.settings.namespaceUri;
+        this.resourcePath = options.settings.resourcePath;
+        this.allowAnonymous = options.settings.allowAnonymous;
+        this.users = options.settings.users;
+        this.securityPolicy = options.settings.securityPolicy;
+        this.securityMode = options.settings.securityMode;
+        this.treeConfig = options.settings.treeConfig;
+
+        this.server = null;
+        this.namespace = null;
+        this.namespaces = new Map();
+        this.namespaceDefinitions = new Map();
+        this.addressSpaceBuilder = null;
+
+
+    }
+
+    async start() {
+        if (this.server) {
+            return;
+        }
+
+        this.server = new OPCUAServer(this.buildServerOptions());
+        await this.server.initialize();
+
+        const addressSpace = this.server.engine.addressSpace;
+   
+        this.initializeNamespaces(this.treeConfig);
+
+        this.addressSpaceBuilder = new OpcUaAddressSpaceBuilder({
+            namespace: this.namespace,
+            namespaces: this.namespaces,
+            server: this.server,
+            registry: this.registry,
+            node: this.node,
+            serverName: this.serverName,
+            addressSpace: this.addressSpace
+        });
+
+
+        this.addressSpaceBuilder.rebuild(this.treeConfig);
+        await this.server.start();
+        this.registry.registerServer(this);
+
+        //Methods
+        const ServerMethods = new OpcUaServerMethods({
+            addressSpace: addressSpace,
+            registry: this.registry,
+            node: this.node
+        })
+
+        ServerMethods.start();
+
+      
+    }
+
+    async stop() {
+        if (!this.server) {
+            this.node.status({ fill: "grey", shape: "ring", text: "stopped" });
+            return;
+        }
+
+        try {
+            if (this.addressSpaceBuilder) {
+                this.addressSpaceBuilder.clearDynamicNodes();
+                this.addressSpaceBuilder.variableStore.clear();
+            }
+
+            await this.server.shutdown(1000);
+        } finally {
+            this.registry.unregisterServer(this.id);
+            this.addressSpaceBuilder = null;
+            this.namespace = null;
+            this.namespaces = new Map();
+            this.namespaceDefinitions = new Map();
+            this.server = null;
+            this.node.status({ fill: "grey", shape: "ring", text: "stopped" });
+        }
+    }
+
+    ensureReady() {
+        if (!this.server || !this.namespace || !this.addressSpaceBuilder) {
+            throw new Error("OPC UA server is not available");
+        }
+    }
+
+
+
+    async updateTree(treeConfig) {
+        this.ensureReady();
+        this.syncNamespaces(treeConfig);
+        this.treeConfig = treeConfig;
+        this.addressSpaceBuilder.sync(treeConfig);
+    }
+
+    readValueByPath(path) {
+        this.ensureReady();
+        return this.addressSpaceBuilder.readValueByPath(path);
+    }
+
+    readValueByNodeId(nodeId) {
+        this.ensureReady();
+        return this.addressSpaceBuilder.readValueByNodeId(nodeId);
+    }
+
+    readValue(identifierType, identifier) {
+        this.ensureReady();
+        return this.addressSpaceBuilder.readValue(identifierType, identifier);
+    }
+
+    writeEventByPath(valuesPayload) {
+        this.ensureReady();
+        return this.addressSpaceBuilder.eventValueByPath(valuesPayload);
+    }
+
+    writeValueByPath(path, value) {
+        this.ensureReady();
+        return this.addressSpaceBuilder.writeValueByPath(path, value);
+    }
+
+    writeValueByNodeId(nodeId, value) {
+        this.ensureReady();
+        return this.addressSpaceBuilder.writeValueByNodeId(nodeId, value);
+    }
+
+    writeValue(identifierType, identifier, value) {
+        this.ensureReady();
+        return this.addressSpaceBuilder.writeValue(identifierType, identifier, value);
+    }
+
+    getEndpointUrl() {
+        if (!this.server || !Array.isArray(this.server.endpoints)) {
+            return "";
+        }
+
+        for (let index = 0; index < this.server.endpoints.length; index += 1) {
+            const endpoint = this.server.endpoints[index];
+            if (!endpoint || typeof endpoint.endpointDescriptions !== "function") {
+                continue;
+            }
+
+            const descriptions = endpoint.endpointDescriptions();
+            if (Array.isArray(descriptions) && descriptions.length && descriptions[0].endpointUrl) {
+                return descriptions[0].endpointUrl;
+            }
+        }
+
+        return "opc.tcp://localhost:" + this.port + this.resourcePath;
+    }
+
+    buildServerOptions() {
+        const activeUsers = Array.isArray(this.users) ? this.users : [];
+        const userTokenPolicies = [];
+
+        if (this.allowAnonymous) {
+            userTokenPolicies.push({
+                policyId: "anonymous",
+                tokenType: UserTokenType.Anonymous
+            });
+        }
+
+        if (activeUsers.length) {
+            userTokenPolicies.push({
+                policyId: "username",
+                tokenType: UserTokenType.UserName
+            });
+        }
+
+        return {
+            port: this.port,
+            resourcePath: this.resourcePath,
+            buildInfo: {
+                productName: "opc-ua-server",
+                buildNumber: "1",
+                buildDate: new Date()
+            },
+            // serverCertificateManager: {
+            //     automaticallyAcceptUnknownCertificate: true
+            // },
+            serverCapabilities: {
+                maxSessions: this.maxConnections
+            },
+            serverInfo: {
+                applicationName: { text: this.serverName },
+                applicationUri: buildApplicationUri(this.serverName),
+                productUri: "urn:node-red:opc-ua-server"
+            },
+            securityPolicies: [this.securityPolicy],
+            securityModes: [this.securityMode],
+            allowAnonymous: this.allowAnonymous,
+            userManager: {
+                isValidUser: (username, password) => this.isValidUser(username, password)
+            },
+            userTokenPolicies
+        };
+    }
+
+    isValidUser(username, password) {
+        return this.users.some((user) => {
+            if (user.username !== username) {
+                return false;
+            }
+
+            if (user.password && user.password === password) {
+                return true;
+            }
+
+            if (user.passwordHash) {
+                try {
+                    return bcrypt.compareSync(password, user.passwordHash);
+                } catch (error) {
+                    this.node.warn("Failed to validate password hash for user " + username + ": " + error.message);
+                    return false;
+                }
+            }
+
+            return false;
+        });
+    }
+
+    initializeNamespaces(treeConfig) {
+        const addressSpace = this.server.engine.addressSpace;
+        const configuredNamespaces = this.buildNamespaceDefinitions(treeConfig);
+
+        this.namespaces = new Map();
+        this.namespaceDefinitions = configuredNamespaces;
+
+        configuredNamespaces.forEach((uri, namespaceId) => {
+            const namespace = addressSpace.getNamespace(uri) || addressSpace.registerNamespace(uri);
+            this.namespaces.set(namespaceId, namespace);
+        });
+
+        this.namespace = this.namespaces.get(2);
+    }
+
+    syncNamespaces(treeConfig) {
+        const addressSpace = this.server.engine.addressSpace;
+        const nextDefinitions = this.buildNamespaceDefinitions(treeConfig);
+
+        this.namespaceDefinitions.forEach((uri, namespaceId) => {
+            const nextUri = nextDefinitions.get(namespaceId);
+            if (nextUri && nextUri !== uri) {
+                throw new Error("Namespace URI changes require a redeploy: namespace " + namespaceId);
+            }
+
+            if (!nextUri) {
+                throw new Error("Removing namespaces requires a redeploy: namespace " + namespaceId);
+            }
+        });
+
+        nextDefinitions.forEach((uri, namespaceId) => {
+            if (this.namespaces.has(namespaceId)) {
+                return;
+            }
+
+            const namespace = addressSpace.getNamespace(uri) || addressSpace.registerNamespace(uri);
+            this.namespaces.set(namespaceId, namespace);
+        });
+
+        this.namespaceDefinitions = nextDefinitions;
+        this.namespace = this.namespaces.get(2);
+    }
+
+    buildNamespaceDefinitions(treeConfig) {
+        const definitions = new Map();
+        const configuredNamespaces = Array.isArray(treeConfig && treeConfig.nameSpaces) ? treeConfig.nameSpaces : [];
+        let defaultNamespaceUri = this.namespaceUri;
+
+        configuredNamespaces.forEach((namespaceConfig) => {
+            if (namespaceConfig.id === 2) {
+                defaultNamespaceUri = namespaceConfig.name;
+            }
+        });
+
+        definitions.set(2, defaultNamespaceUri);
+
+        configuredNamespaces
+            .slice()
+            .sort((left, right) => left.id - right.id)
+            .forEach((namespaceConfig) => {
+                definitions.set(namespaceConfig.id, namespaceConfig.name);
+            });
+
+        return definitions;
+    }
+}
+
+module.exports = {
+    OpcUaServerRuntime
+};

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

@@ -0,0 +1,188 @@
+"use strict";
+
+
+const registry = require("../opcua-server-registry");
+const { resolveRegisteredServer } = require("./server-node-utils");
+
+function OpcUaServerStatusNode(node, msg, nodeId) {
+
+    try {
+        const serverNode = resolveRegisteredServer(node, msg, registry);
+        const snapshot = buildServerSnapshot(serverNode);
+
+        msg.payload = snapshot;
+        msg.opcua = msg.opcua || {};
+        msg.opcua.server = snapshot.identity.serverRef;
+        msg.opcua.endpointUrl = snapshot.endpointUrl;
+
+
+
+        process.send({
+            type: "status",
+            data: {
+                fill: "green",
+                shape: "dot",
+                text: "sessions " + snapshot.counters.currentSessionCount
+            },
+            nodeId: nodeId
+        });
+
+        process.send({
+            type: "send",
+            data: msg,
+            nodeId: nodeId
+        });
+
+
+    } catch (error) {
+        //console.error("function OpcUaServerStatusNode" + error);
+        //console.error({ fill: "red", shape: "ring", text: "status failed" });
+
+         process.send({
+            type: "status",
+            data: {
+                fill: "red",
+                shape: "ring",
+                text: "Status: " + error
+            },
+            nodeId: nodeId
+        });
+        // done(error);
+    }
+
+}
+
+function buildServerSnapshot(serverNode) {
+
+    const server = serverNode.server;
+    const primaryEndpoint = Array.isArray(server.endpoints) && server.endpoints.length
+        ? server.endpoints[0]
+        : null;
+
+    return {
+        identity: {
+            id: serverNode.id || "",
+            name: serverNode.name || "",
+            serverName: serverNode.serverName || "",
+            serverRef: serverNode.name || serverNode.serverName || serverNode.id || ""
+        },
+        state: safeCall(server, "getServerState", ""),
+        endpointUrl: resolveEndpointUrl(serverNode),
+        counters: {
+            currentChannelCount: safeNumber(server.currentChannelCount, 0),
+            currentSessionCount: safeNumber(server.currentSessionCount, 0),
+            currentSubscriptionCount: safeNumber(server.currentSubscriptionCount, 0),
+            bytesRead: safeNumber(server.bytesRead, 0),
+            bytesWritten: safeNumber(server.bytesWritten, 0),
+            transactionsCount: safeNumber(server.transactionsCount, 0),
+            rejectedRequestsCount: safeNumber(server.rejectedRequestsCount, 0),
+            rejectedSessionCount: safeNumber(server.rejectedSessionCount, 0),
+            sessionAbortCount: safeNumber(server.sessionAbortCount, 0),
+            publishingIntervalCount: safeNumber(server.publishingIntervalCount, 0),
+            securityTokenCount: primaryEndpoint ? safeNumber(primaryEndpoint.securityTokenCount, 0) : 0,
+            activeChannelCount: primaryEndpoint ? safeNumber(primaryEndpoint.activeChannelCount, 0) : 0
+        },
+        capabilities: {
+            maxAllowedSessionNumber: safeNumber(server.maxAllowedSessionNumber, 0),
+            initialized: Boolean(server.initialized),
+            auditing: Boolean(server.isAuditing)
+        },
+        buildInfo: {
+            productName: extractText(server.buildInfo && server.buildInfo.productName),
+            buildNumber: extractText(server.buildInfo && server.buildInfo.buildNumber),
+            buildDate: extractDate(server.buildInfo && server.buildInfo.buildDate)
+        },
+        serverInfo: {
+            applicationUri: extractText(server.serverInfo && server.serverInfo.applicationUri),
+            productUri: extractText(server.serverInfo && server.serverInfo.productUri),
+            applicationName: extractLocalizedText(server.serverInfo && server.serverInfo.applicationName)
+        },
+        endpoints: Array.isArray(server.endpoints)
+            ? server.endpoints.map((endpoint) => buildEndpointSnapshot(endpoint))
+            : []
+    };
+}
+
+function buildEndpointSnapshot(endpoint) {
+    const descriptions = typeof endpoint.endpointDescriptions === "function"
+        ? endpoint.endpointDescriptions()
+        : [];
+
+    return {
+        port: safeNumber(endpoint.port, 0),
+        currentChannelCount: safeNumber(endpoint.currentChannelCount, 0),
+        activeChannelCount: safeNumber(endpoint.activeChannelCount, 0),
+        bytesRead: safeNumber(endpoint.bytesRead, 0),
+        bytesWritten: safeNumber(endpoint.bytesWritten, 0),
+        transactionsCount: safeNumber(endpoint.transactionsCount, 0),
+        securityTokenCount: safeNumber(endpoint.securityTokenCount, 0),
+        endpointUrls: Array.isArray(descriptions)
+            ? descriptions.map((description) => extractText(description && description.endpointUrl)).filter(Boolean)
+            : []
+    };
+}
+
+function resolveEndpointUrl(serverNode) {
+    if (serverNode.runtime && typeof serverNode.runtime.getEndpointUrl === "function") {
+        return serverNode.runtime.getEndpointUrl();
+    }
+
+    const server = serverNode.server;
+    if (!server || !Array.isArray(server.endpoints)) {
+        return "";
+    }
+
+    for (let index = 0; index < server.endpoints.length; index += 1) {
+        const endpoint = server.endpoints[index];
+        if (!endpoint || typeof endpoint.endpointDescriptions !== "function") {
+            continue;
+        }
+
+        const descriptions = endpoint.endpointDescriptions();
+        if (Array.isArray(descriptions) && descriptions.length && descriptions[0].endpointUrl) {
+            return descriptions[0].endpointUrl;
+        }
+    }
+
+    return "";
+}
+
+function safeCall(target, methodName, fallback) {
+    try {
+        if (target && typeof target[methodName] === "function") {
+            return target[methodName]();
+        }
+    } catch (error) {
+        // Ignore and use fallback.
+    }
+
+    return fallback;
+}
+
+function safeNumber(value, fallback) {
+    return Number.isFinite(Number(value)) ? Number(value) : fallback;
+}
+
+function extractText(value) {
+    return value === undefined || value === null ? "" : String(value);
+}
+
+function extractLocalizedText(value) {
+    if (value && typeof value.text === "string") {
+        return value.text;
+    }
+
+    return extractText(value);
+}
+
+function extractDate(value) {
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value.toISOString();
+    }
+
+    return "";
+}
+
+module.exports = {
+    "OpcUaServerStatusNode": OpcUaServerStatusNode
+}

package/server/lib/server-node-utils.js

@@ -0,0 +1,16 @@
+"use strict";
+
+function resolveRegisteredServer(node, msg, registry) {
+    const msgReference = msg && msg.opcua && msg.opcua.server ? msg.opcua.server : "";
+    const server = registry.resolveServer(msgReference || node.serverRef);
+
+    if (!server) {
+        throw new Error("No OPC UA server matched the configured reference");
+    }
+
+    return server;
+}
+
+module.exports = {
+    resolveRegisteredServer
+};