node-opcua-server 2.99.0 → 2.101.0

package/source/opcua_server.ts

@@ -168,7 +168,7 @@ import { RegisterServerManager } from "./register_server_manager";
 import { RegisterServerManagerHidden } from "./register_server_manager_hidden";
 import { RegisterServerManagerMDNSONLY } from "./register_server_manager_mdns_only";
 import { ServerCapabilitiesOptions } from "./server_capabilities";
-import { OPCUAServerEndPoint } from "./server_end_point";
+import { EndpointDescriptionEx, OPCUAServerEndPoint } from "./server_end_point";
 import { ClosingReason, CreateSessionOption, ServerEngine } from "./server_engine";
 import { ServerSession } from "./server_session";
 import { CreateMonitoredItemHook, DeleteMonitoredItemHook, Subscription } from "./server_subscription";
@@ -642,10 +642,10 @@ function validate_security_endpoint(
     if (endpoints.length === 0) {
         // we have a UrlMismatch here
         const ua_server = server.engine.addressSpace!.rootFolder.objects.server;
+        errorLog("Cannot find suitable endpoints in available endpoints. endpointUri =", request.endpointUrl);
         ua_server.raiseEvent("AuditUrlMismatchEventType", {
             endpointUrl: { dataType: DataType.String, value: request.endpointUrl }
         });
-        debugLog("Cannot find endpoint  in available endpoints with endpointUri", request.endpointUrl);
         if (OPCUAServer.requestExactEndpointUrl) {
             return { errCode: StatusCodes.BadServiceUnsupported };
         } else {
@@ -653,7 +653,7 @@ function validate_security_endpoint(
         }
     }
     // ignore restricted endpoints
-    endpoints = endpoints.filter((e: EndpointDescription) => !(e as any).restricted);
+    endpoints = endpoints.filter((e: EndpointDescription) => !(e as EndpointDescriptionEx).restricted);
 
     const endpoints_matching_security_mode = endpoints.filter((e: EndpointDescription) => {
         return e.securityMode === channel.securityMode;
@@ -1148,7 +1148,7 @@ export class OPCUAServer extends OPCUABaseServer {
             const hostname = getFullyQualifiedDomainName();
 
             endpointDefinitions.push({
-                port: options.port || 26543,
+                port: options.port  === undefined ? 26543 : options.port,
 
                 allowAnonymous: options.allowAnonymous,
                 alternateHostname: options.alternateHostname,
@@ -3526,7 +3526,7 @@ export class OPCUAServer extends OPCUABaseServer {
         }
         const hostname = getFullyQualifiedDomainName();
         endpointOptions.hostname = endpointOptions.hostname || hostname;
-        endpointOptions.port = endpointOptions.port || 26543;
+        endpointOptions.port = endpointOptions.port === undefined ? 26543 : endpointOptions.port ;
 
         /* istanbul ignore next */
         if (

package/source/register_server_manager_mdns_only.ts

@@ -43,10 +43,12 @@ export class RegisterServerManagerMDNSONLY extends EventEmitter implements IRegi
         }
         assert(this.server instanceof OPCUABaseServer);
 
+        const host = "TODO-find how to extract hostname";
         this.bonjour.announcedOnMulticastSubnetWithCallback({
             capabilities: this.server.capabilitiesForMDNS,
             name: this.server.serverInfo.applicationUri!,
             path: "/", // <- to do
+            host,
             port: this.server.endpoints[0].port
         }, ()=>{
             this.emit("serverRegistered");

package/source/server_end_point.ts

@@ -9,8 +9,8 @@ import * as chalk from "chalk";
 import * as async from "async";
 
 import { assert } from "node-opcua-assert";
-import { ICertificateManager, OPCUACertificateManager } from "node-opcua-certificate-manager";
-import { Certificate, convertPEMtoDER, makeSHA1Thumbprint, PrivateKey, PrivateKeyPEM, split_der } from "node-opcua-crypto";
+import { OPCUACertificateManager } from "node-opcua-certificate-manager";
+import { Certificate, makeSHA1Thumbprint, PrivateKey, split_der } from "node-opcua-crypto";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { getFullyQualifiedDomainName, resolveFullyQualifiedDomainName } from "node-opcua-hostname";
 import {
@@ -20,7 +20,6 @@ import {
     ServerSecureChannelLayer,
     ServerSecureChannelParent,
     toURI,
-    AsymmetricAlgorithmSecurityHeader,
     IServerSessionBase,
     Message
 } from "node-opcua-secure-channel";
@@ -83,9 +82,8 @@ function extractChannelData(channel: ServerSecureChannelLayer): IChannelData {
 
 function dumpChannelInfo(channels: ServerSecureChannelLayer[]): void {
     function d(s: IServerSessionBase) {
-        return `[ status=${s.status} lastSeen=${s.clientLastContactTime.toFixed(0)}ms sessionName=${s.sessionName} timeout=${
-            s.sessionTimeout
-        } ]`;
+        return `[ status=${s.status} lastSeen=${s.clientLastContactTime.toFixed(0)}ms sessionName=${s.sessionName} timeout=${s.sessionTimeout
+            } ]`;
     }
     function dumpChannel(channel: ServerSecureChannelLayer): void {
         console.log("------------------------------------------------------");
@@ -381,7 +379,6 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         }
         //
 
-        const port = this.port;
 
         // resource Path is a string added at the end of the url such as "/UA/Server"
         const resourcePath = (options.resourcePath || "").replace(/\\/g, "/");
@@ -389,7 +386,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         assert(resourcePath.length === 0 || resourcePath.charAt(0) === "/", "resourcePath should start with /");
 
         const hostname = options.hostname || getFullyQualifiedDomainName();
-        const endpointUrl = `opc.tcp://${hostname}:${port}${resourcePath}`;
+        const endpointUrl = `opc.tcp://${hostname}:${this.port}${resourcePath}`;
 
         const endpoint_desc = this.getEndpointDescription(securityMode, securityPolicy, endpointUrl);
 
@@ -404,10 +401,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         this._endpoints.push(
             _makeEndpointDescription({
                 collection: this._policy_deduplicator,
-                endpointUrl,
                 hostname,
-                port,
-
                 server: this.serverInfo,
                 serverCertificateChain: this.getCertificateChain(),
 
@@ -421,7 +415,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                 securityPolicies: options.securityPolicies || [],
 
                 userTokenTypes
-            })
+            }, this)
         );
     }
 
@@ -511,16 +505,23 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         this._server!.on("listening", () => {
             debugLog("server is listening");
         });
+
         this._server!.listen(
             this.port,
-            /*"::",*/ (err?: Error) => {
+            /*"::",*/(err?: Error) => {
                 // 'listening' listener
                 debugLog(chalk.green.bold("LISTENING TO PORT "), this.port, "err  ", err);
                 assert(!err, " cannot listen to port ");
                 this._started = true;
+                if (!this.port) {
+                    const add = this._server!.address()!;
+                    this.port = typeof add !== "string" ? add.port : this.port;
+
+                }
                 this._end_listen();
             }
         );
+
     }
 
     public killClientSockets(callback: (err?: Error) => void): void {
@@ -691,7 +692,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
             debugLog(
                 chalk.bgWhite.cyan(
                     "OPCUAServerEndPoint#_on_client_connection " +
-                        "SERVER END POINT IS PROBABLY SHUTTING DOWN !!! - Connection is refused"
+                    "SERVER END POINT IS PROBABLY SHUTTING DOWN !!! - Connection is refused"
                 )
             );
             socket.end();
@@ -701,7 +702,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
             console.log(
                 chalk.bgWhite.cyan(
                     "OPCUAServerEndPoint#_on_client_connection " +
-                        "The maximum number of connection has been reached - Connection is refused"
+                    "The maximum number of connection has been reached - Connection is refused"
                 )
             );
             const reason = "maxConnections reached (" + this.maxConnections + ")";
@@ -937,19 +938,11 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
 }
 
 interface MakeEndpointDescriptionOptions {
-    /**
-     * port number s
-     */
-    port: number;
 
     /**
      * @default  default hostname (default value will be full qualified domain name)
      */
     hostname: string;
-    /**
-     *
-     */
-    endpointUrl: string;
 
     serverCertificateChain: Certificate;
     /**
@@ -1000,7 +993,8 @@ interface MakeEndpointDescriptionOptions {
     noUserIdentityTokens?: boolean;
 }
 
-interface EndpointDescriptionEx extends EndpointDescription {
+export interface EndpointDescriptionEx extends EndpointDescription {
+    _parent: OPCUAServerEndPoint;
     restricted: boolean;
 }
 
@@ -1038,8 +1032,7 @@ function estimateSecurityLevel(securityMode: MessageSecurityMode, securityPolicy
 /**
  * @private
  */
-function _makeEndpointDescription(options: MakeEndpointDescriptionOptions): EndpointDescriptionEx {
-    assert(isFinite(options.port), "expecting a valid port number");
+function _makeEndpointDescription(options: MakeEndpointDescriptionOptions, parent: OPCUAServerEndPoint): EndpointDescriptionEx {
     assert(Object.prototype.hasOwnProperty.call(options, "serverCertificateChain"));
     assert(!Object.prototype.hasOwnProperty.call(options, "serverCertificate"));
     assert(!!options.securityMode); // s.MessageSecurityMode
@@ -1146,7 +1139,7 @@ function _makeEndpointDescription(options: MakeEndpointDescriptionOptions): Endp
     }
     // return the endpoint object
     const endpoint = new EndpointDescription({
-        endpointUrl: options.endpointUrl,
+        endpointUrl: '<to be evaluated at run time>',// options.endpointUrl,
 
         server: undefined, // options.server,
         serverCertificate: options.serverCertificateChain,
@@ -1158,9 +1151,16 @@ function _makeEndpointDescription(options: MakeEndpointDescriptionOptions): Endp
         securityLevel: options.securityLevel,
         transportProfileUri: default_transportProfileUri
     }) as EndpointDescriptionEx;
-
+    endpoint._parent = parent;
+   
+    // endpointUrl is dynamic as port number may be adjusted
+    // when the tcp socker start listening
     (endpoint as any).__defineGetter__("endpointUrl", () => {
-        return resolveFullyQualifiedDomainName(options.endpointUrl);
+        const port = endpoint._parent.port;
+        const resourcePath = options.resourcePath || "";
+        const hostname = options.hostname;
+        const endpointUrl = `opc.tcp://${hostname}:${port}${resourcePath}`;
+        return resolveFullyQualifiedDomainName(endpointUrl);
     });
 
     endpoint.server = options.server;

package/source/server_engine.ts

@@ -207,7 +207,7 @@ function _getSubscription(
     this: ServerEngine,
     inputArguments: Variant[],
     context: ISessionContext
-): { subscription: Subscription, statusCode?: never } | { statusCode: StatusCode, subscription?: never } {
+): { subscription: Subscription; statusCode?: never } | { statusCode: StatusCode; subscription?: never } {
     assert(Array.isArray(inputArguments));
     assert(Object.prototype.hasOwnProperty.call(context, "session"), " expecting a session id in the context object");
     const session = context.session as ServerSession;
@@ -225,7 +225,6 @@ function _getSubscription(
         return { statusCode: StatusCodes.BadSubscriptionIdInvalid };
     }
     return { subscription };
-
 }
 function resendData(
     this: ServerEngine,
@@ -239,13 +238,14 @@ function resendData(
     if (data.statusCode) return callback(null, { statusCode: data.statusCode });
     const { subscription } = data;
 
-    subscription.resendInitialValues().then(() => {
-        callback(null, { statusCode: StatusCodes.Good });
-    }).catch((err) => callback(err));
-
+    subscription
+        .resendInitialValues()
+        .then(() => {
+            callback(null, { statusCode: StatusCodes.Good });
+        })
+        .catch((err) => callback(err));
 }
 
-
 // binding methods
 function getMonitoredItemsId(
     this: ServerEngine,
@@ -1450,7 +1450,7 @@ export class ServerEngine extends EventEmitter {
                 (!dataValue.serverTimestamp || dataValue.serverTimestamp.getTime() === minOPCUADate.getTime())
             ) {
                 dataValue.serverTimestamp = context.currentTime.timestamp;
-                dataValue.serverPicoseconds = 0; // context.currentTime.picoseconds; 
+                dataValue.serverPicoseconds = 0; // context.currentTime.picoseconds;
             }
             dataValues.push(dataValue);
         }
@@ -1990,11 +1990,12 @@ export class ServerEngine extends EventEmitter {
      * performs a call to ```asyncRefresh``` on all variable nodes that provide an async refresh func.
      *
      * @method refreshValues
-     * @param nodesToRefresh {Array<Object>}  an array containing the node to consider
+     * @param nodesToRefresh {Array<ReadValueId|HistoryReadValueId>}  an array containing the node to consider
      * Each element of the array shall be of the form { nodeId: <xxx>, attributeIds: <value> }.
+     * @param maxAge {number}  the maximum age of the value to be read, in milliseconds.
      * @param callback
-     * @param callback.err
-     * @param callback.data  an array containing value read
+     * @param callback.err       {Error}
+     * @param callback.dataValue {DataValue}  an array containing value read
      * The array length matches the number of  nodeIds that are candidate for an async refresh (i.e: nodes that
      * are of type Variable with asyncRefresh func }
      *
@@ -2005,10 +2006,12 @@ export class ServerEngine extends EventEmitter {
         maxAge: number,
         callback: (err: Error | null, dataValues?: DataValue[]) => void
     ): void {
-        const referenceTime = new Date(Date.now() - maxAge);
+        const referenceTime = getCurrentClock();
+        maxAge && referenceTime.timestamp.setTime(referenceTime.timestamp.getTime() - maxAge);
 
         assert(typeof callback === "function");
-        const objectMap: Record<string, BaseNode> = {};
+
+        const nodeMap: Record<string, UAVariable> = {};
         for (const nodeToRefresh of nodesToRefresh) {
             // only consider node  for which the caller wants to read the Value attribute
             // assuming that Value is requested if attributeId is missing,
@@ -2016,51 +2019,38 @@ export class ServerEngine extends EventEmitter {
                 continue;
             }
             // ... and that are valid object and instances of Variables ...
-            const obj = this.addressSpace!.findNode(nodeToRefresh.nodeId);
-            if (!obj || !(obj.nodeClass === NodeClass.Variable)) {
+            const uaNode = this.addressSpace!.findNode(nodeToRefresh.nodeId);
+            if (!uaNode || !(uaNode.nodeClass === NodeClass.Variable)) {
                 continue;
             }
             // ... and that have been declared as asynchronously updating
-            if (typeof (obj as any).refreshFunc !== "function") {
+            if (typeof (uaNode as any).refreshFunc !== "function") {
                 continue;
             }
-            const key = obj.nodeId.toString();
-            if (objectMap[key]) {
+            const key = uaNode.nodeId.toString();
+            if (nodeMap[key]) {
                 continue;
             }
-
-            objectMap[key] = obj;
+            nodeMap[key] = uaNode as UAVariable;
         }
 
-        const objectArray = Object.values(objectMap);
-        if (objectArray.length === 0) {
+        const uaVariableArray = Object.values(nodeMap);
+        if (uaVariableArray.length === 0) {
             // nothing to do
             return callback(null, []);
         }
         // perform all asyncRefresh in parallel
         async.map(
-            objectArray,
-            (obj: BaseNode, inner_callback: CallbackT<DataValue>) => {
-                if (obj.nodeClass !== NodeClass.Variable) {
-                    inner_callback(
-                        null,
-                        new DataValue({
-                            statusCode: StatusCodes.BadNodeClassInvalid
-                        })
-                    );
-                    return;
-                }
+            uaVariableArray,
+            (uaVariable: UAVariable, inner_callback: CallbackT<DataValue>) => {
                 try {
-                    (obj as UAVariable).asyncRefresh(referenceTime, (err, dataValue) => {
+                    uaVariable.asyncRefresh(referenceTime, (err, dataValue) => {
                         inner_callback(err, dataValue);
                     });
                 } catch (err) {
-                    // istanbul ignore next
-                    if (!(err instanceof Error)) {
-                        throw new Error("internal error");
-                    }
-                    errorLog("asyncRefresh internal error", err);
-                    inner_callback(err);
+                    const _err = err as Error;
+                    errorLog("asyncRefresh internal error", _err.message);
+                    inner_callback(_err);
                 }
             },
             (err?: Error | null, arrResult?: (DataValue | undefined)[]) => {
@@ -2091,7 +2081,7 @@ export class ServerEngine extends EventEmitter {
         assert(subscriptionDiagnostics instanceof SubscriptionDiagnosticsDataType);
         if (subscriptionDiagnostics && serverSubscriptionDiagnosticsArray) {
             const node = (serverSubscriptionDiagnosticsArray as any)[subscription.id];
-            removeElement(serverSubscriptionDiagnosticsArray, (a)=> a.subscriptionId === subscription.id);
+            removeElement(serverSubscriptionDiagnosticsArray, (a) => a.subscriptionId === subscription.id);
             /*assert(
                 !(subscriptionDiagnosticsArray as any)[subscription.id],
                 " subscription node must have been removed from subscriptionDiagnosticsArray"
@@ -2281,8 +2271,8 @@ export class ServerEngine extends EventEmitter {
         } else {
             warningLog(
                 chalk.yellow("WARNING:  cannot bind a method with id ") +
-                chalk.cyan(nodeId.toString()) +
-                chalk.yellow(". please check your nodeset.xml file or add this node programmatically")
+                    chalk.cyan(nodeId.toString()) +
+                    chalk.yellow(". please check your nodeset.xml file or add this node programmatically")
             );
             warningLog(traceFromThisProjectOnly());
         }