node-opcua-server 2.81.0 → 2.83.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-server",
-    "version": "2.81.0",
+    "version": "2.83.0",
     "description": "pure nodejs OPCUA SDK - module -server",
     "scripts": {
         "build": "tsc -b",
@@ -17,57 +17,57 @@
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space": "2.81.0",
-        "node-opcua-address-space-base": "2.81.0",
+        "node-opcua-address-space": "2.83.0",
+        "node-opcua-address-space-base": "2.83.0",
         "node-opcua-assert": "2.77.0",
-        "node-opcua-basic-types": "2.81.0",
-        "node-opcua-binary-stream": "2.77.0",
-        "node-opcua-certificate-manager": "2.77.0",
-        "node-opcua-client": "2.81.0",
-        "node-opcua-client-dynamic-extension-object": "2.81.0",
-        "node-opcua-common": "2.81.0",
+        "node-opcua-basic-types": "2.83.0",
+        "node-opcua-binary-stream": "2.83.0",
+        "node-opcua-certificate-manager": "2.83.0",
+        "node-opcua-client": "2.83.0",
+        "node-opcua-client-dynamic-extension-object": "2.83.0",
+        "node-opcua-common": "2.83.0",
         "node-opcua-constants": "2.77.0",
-        "node-opcua-crypto": "^1.11.0",
-        "node-opcua-data-model": "2.81.0",
-        "node-opcua-data-value": "2.81.0",
-        "node-opcua-date-time": "2.77.0",
-        "node-opcua-debug": "2.77.0",
-        "node-opcua-extension-object": "2.81.0",
-        "node-opcua-factory": "2.81.0",
+        "node-opcua-crypto": "^1.12.0",
+        "node-opcua-data-model": "2.83.0",
+        "node-opcua-data-value": "2.83.0",
+        "node-opcua-date-time": "2.83.0",
+        "node-opcua-debug": "2.83.0",
+        "node-opcua-extension-object": "2.83.0",
+        "node-opcua-factory": "2.83.0",
         "node-opcua-hostname": "2.77.0",
-        "node-opcua-nodeid": "2.81.0",
+        "node-opcua-nodeid": "2.83.0",
         "node-opcua-nodesets": "2.77.0",
-        "node-opcua-numeric-range": "2.81.0",
-        "node-opcua-object-registry": "2.77.0",
-        "node-opcua-secure-channel": "2.81.0",
-        "node-opcua-service-browse": "2.81.0",
-        "node-opcua-service-call": "2.81.0",
-        "node-opcua-service-discovery": "2.81.0",
-        "node-opcua-service-endpoints": "2.81.0",
-        "node-opcua-service-filter": "2.81.0",
-        "node-opcua-service-history": "2.81.0",
-        "node-opcua-service-node-management": "2.81.0",
-        "node-opcua-service-query": "2.81.0",
-        "node-opcua-service-read": "2.81.0",
-        "node-opcua-service-register-node": "2.81.0",
-        "node-opcua-service-secure-channel": "2.81.0",
-        "node-opcua-service-session": "2.81.0",
-        "node-opcua-service-subscription": "2.81.0",
-        "node-opcua-service-translate-browse-path": "2.81.0",
-        "node-opcua-service-write": "2.81.0",
-        "node-opcua-status-code": "2.77.0",
-        "node-opcua-types": "2.81.0",
-        "node-opcua-utils": "2.77.0",
-        "node-opcua-variant": "2.81.0",
+        "node-opcua-numeric-range": "2.83.0",
+        "node-opcua-object-registry": "2.83.0",
+        "node-opcua-secure-channel": "2.83.0",
+        "node-opcua-service-browse": "2.83.0",
+        "node-opcua-service-call": "2.83.0",
+        "node-opcua-service-discovery": "2.83.0",
+        "node-opcua-service-endpoints": "2.83.0",
+        "node-opcua-service-filter": "2.83.0",
+        "node-opcua-service-history": "2.83.0",
+        "node-opcua-service-node-management": "2.83.0",
+        "node-opcua-service-query": "2.83.0",
+        "node-opcua-service-read": "2.83.0",
+        "node-opcua-service-register-node": "2.83.0",
+        "node-opcua-service-secure-channel": "2.83.0",
+        "node-opcua-service-session": "2.83.0",
+        "node-opcua-service-subscription": "2.83.0",
+        "node-opcua-service-translate-browse-path": "2.83.0",
+        "node-opcua-service-write": "2.83.0",
+        "node-opcua-status-code": "2.83.0",
+        "node-opcua-types": "2.83.0",
+        "node-opcua-utils": "2.83.0",
+        "node-opcua-variant": "2.83.0",
         "thenify": "^3.3.1"
     },
     "devDependencies": {
-        "node-opcua-data-access": "2.81.0",
-        "node-opcua-leak-detector": "2.77.0",
-        "node-opcua-pki": "^2.17.0",
+        "node-opcua-data-access": "2.83.0",
+        "node-opcua-leak-detector": "2.83.0",
+        "node-opcua-pki": "^2.18.3",
         "node-opcua-test-helpers": "2.77.0",
         "should": "^13.2.3",
-        "sinon": "^14.0.0",
+        "sinon": "^14.0.2",
         "underscore": "^1.13.6"
     },
     "author": "Etienne Rossignon",
@@ -85,5 +85,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "fd89928bc4a4b9f31a6b6e5921f743e8284eba2b"
+    "gitHead": "3311f8ce9e86837fde72e923f3121072008ccdd4"
 }

package/source/base_server.ts

@@ -20,7 +20,7 @@ import { coerceLocalizedText, LocalizedText } from "node-opcua-data-model";
 import { installPeriodicClockAdjustment, uninstallPeriodicClockAdjustment } from "node-opcua-date-time";
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import { displayTraceFromThisProjectOnly } from "node-opcua-debug";
-import { extractFullyQualifiedDomainName, getHostname, resolveFullyQualifiedDomainName } from "node-opcua-hostname";
+import { extractFullyQualifiedDomainName, getFullyQualifiedDomainName, getHostname, resolveFullyQualifiedDomainName } from "node-opcua-hostname";
 import { Message, Response, ServerSecureChannelLayer, ServerSecureChannelParent } from "node-opcua-secure-channel";
 import { FindServersRequest, FindServersResponse } from "node-opcua-service-discovery";
 import { ApplicationType, GetEndpointsResponse } from "node-opcua-service-endpoints";
@@ -179,14 +179,26 @@ export class OPCUABaseServer extends OPCUASecureObject {
         if (fs.existsSync(this.certificateFile)) {
             return;
         }
+        
+        // collect all hostnames
+        const hostnames = [];
+        for (const e of this.endpoints) {
+            for( const ee of e.endpointDescriptions()) {
+                /* to do */
+            }
+        } 
+
         const lockfile = path.join(this.certificateFile + ".lock");
         await withLock({ lockfile }, async () => {
             if (!fs.existsSync(this.certificateFile)) {
                 const applicationUri = this.serverInfo.applicationUri!;
+                const fqdn = getFullyQualifiedDomainName();
                 const hostname = getHostname();
+                const dns = [... new Set([fqdn, hostname])];
+              
                 await this.serverCertificateManager.createSelfSignedCertificate({
                     applicationUri,
-                    dns: [hostname],
+                    dns,
                     // ip: await getIpAddresses(),
                     outputFile: this.certificateFile,
 
@@ -198,7 +210,7 @@ export class OPCUABaseServer extends OPCUASecureObject {
             }
         });
     }
-    
+
     public async initializeCM(): Promise<void> {
         await this.serverCertificateManager.initialize();
         await this.createDefaultCertificate();

package/source/monitored_item.ts

@@ -40,7 +40,7 @@ import {
     isOutsideDeadbandPercent,
     PseudoRange
 } from "node-opcua-service-subscription";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
 import {
     DataChangeNotification,
     EventFieldList,
@@ -56,7 +56,6 @@ import { appendToTimer, removeFromTimer } from "./node_sampler";
 import { validateFilter } from "./validate_filter";
 import { checkWhereClauseOnAdressSpace } from "./filter/check_where_clause_on_address_space";
 import { SamplingFunc } from "./sampling_func";
-import { registerNodePromoter } from "node-opcua-address-space/source/loader/register_node_promoter";
 
 export type QueueItem = MonitoredItemNotification | EventFieldList;
 
@@ -473,7 +472,7 @@ export class MonitoredItem extends EventEmitter {
             // sampling interval.
             const recordInitialValue =
                 old_monitoringMode === MonitoringMode.Invalid || old_monitoringMode === MonitoringMode.Disabled;
-
+            const installEventHandler = old_monitoringMode === MonitoringMode.Invalid;
             this._start_sampling(recordInitialValue);
         }
     }
@@ -555,11 +554,16 @@ export class MonitoredItem extends EventEmitter {
      *
      */
     public recordValue(dataValue: DataValue, skipChangeTest: boolean, indexRange?: NumericRange): void {
-        assert(dataValue instanceof DataValue);
+
+        if (!this.itemToMonitor) {
+            // we must have a valid itemToMonitor(have this monitoredItem been disposed already ?)
+            return;
+        }
+
         assert(dataValue !== this.oldDataValue, "recordValue expects different dataValue to be provided");
 
         assert(
-            !dataValue.value || dataValue.value !== this.oldDataValue!.value,
+            !dataValue.value || !this.oldDataValue || dataValue.value !== this.oldDataValue!.value,
             "recordValue expects different dataValue.value to be provided"
         );
 
@@ -581,7 +585,6 @@ export class MonitoredItem extends EventEmitter {
             }
         }
 
-        assert(this.itemToMonitor, "must have a valid itemToMonitor(have this monitoredItem been disposed already ?");
         // extract the range that we are interested with
         dataValue = extractRange(dataValue, this.itemToMonitor.indexRange);
 
@@ -760,7 +763,7 @@ export class MonitoredItem extends EventEmitter {
 
         this._adjust_queue_to_match_new_queue_size();
 
-        this._adjust_sampling(old_samplingInterval);
+        this._adjustSampling(old_samplingInterval);
 
         if (monitoringParameters.filter) {
             const statusCodeFilter = validateFilter(monitoringParameters.filter, this.itemToMonitor, this.node!);
@@ -784,12 +787,11 @@ export class MonitoredItem extends EventEmitter {
     }
 
     public async resendInitialValues(): Promise<void> {
-        // tte first Publish response(s) after the TransferSubscriptions call shall contain the current values of all
+        // the first Publish response(s) after the TransferSubscriptions call shall contain the current values of all
         // Monitored Items in the Subscription where the Monitoring Mode is set to Reporting.
         // the first Publish response after the TransferSubscriptions call shall contain only the value changes since
         // the last Publish response was sent.
         // This parameter only applies to MonitoredItems used for monitoring Attribute changes.
-        this._stop_sampling();
         return this._start_sampling(true);
     }
 
@@ -804,10 +806,13 @@ export class MonitoredItem extends EventEmitter {
     /**
      * @method _on_sampling_timer
      * @private
-     * request
-     *
      */
     private _on_sampling_timer() {
+
+        if (this.monitoringMode === MonitoringMode.Disabled) {
+            return;
+        }
+
         const sessionContext = this.getSessionContext();
         if (!sessionContext) {
             return;
@@ -971,13 +976,34 @@ export class MonitoredItem extends EventEmitter {
         return this.$subscription.$session;
     }
 
-    private _start_sampling(recordInitialValue?: boolean): void {
+    private _start_sampling(recordInitialValue: boolean): void {
         // istanbul ignore next
         if (!this.node) {
             throw new Error("Internal Error");
         }
         setImmediate(() => this.__start_sampling(recordInitialValue));
     }
+
+    private __acquireInitialValue(sessionContext: ISessionContext, callback: CallbackT<DataValue>): void {
+        // aquire initial value from the variable/object not itself or from the last known value if we have 
+        // one already
+        assert(this.itemToMonitor.attributeId === AttributeIds.Value);
+        assert(this.node);
+        if (this.node?.nodeClass !== NodeClass.Variable) {
+            return callback(new Error("Invalid "));
+        }
+        const variable = (this.node as UAVariable);
+        if (!this.oldDataValue || this.oldDataValue.statusCode == StatusCodes.BadDataUnavailable) {
+            variable.readValueAsync(sessionContext, (err: Error | null, dataValue?: DataValue) => {
+                callback(err, dataValue);
+            });
+        } else {
+            const o = this.oldDataValue;
+            this.oldDataValue = new DataValue({ statusCode: StatusCodes.BadDataUnavailable });
+            callback(null, o);
+        }
+
+    }
     private __start_sampling(recordInitialValue?: boolean): void {
         // istanbul ignore next
         if (!this.node) {
@@ -989,8 +1015,6 @@ export class MonitoredItem extends EventEmitter {
         if (!sessionContext) {
             return;
         }
-        // make sure oldDataValue is scrapped so first data recording can happen
-        this.oldDataValue = new DataValue({ statusCode: StatusCodes.BadDataUnavailable }); // unset initially
 
         this._stop_sampling();
 
@@ -999,10 +1023,11 @@ export class MonitoredItem extends EventEmitter {
             if (doDebug) {
                 debugLog("xxxxxx monitoring EventNotifier on", this.node.nodeId.toString(), this.node.browseName.toString());
             }
-            // we are monitoring OPCUA Event
-            this._on_opcua_event_received_callback = this._on_opcua_event.bind(this);
-            this.node.on("event", this._on_opcua_event_received_callback);
-
+            if (!this._on_opcua_event_received_callback) {
+                // we are monitoring OPCUA Event
+                this._on_opcua_event_received_callback = this._on_opcua_event.bind(this);
+                this.node.on("event", this._on_opcua_event_received_callback);
+            }
             return;
         }
         if (this.itemToMonitor.attributeId !== AttributeIds.Value) {
@@ -1010,10 +1035,11 @@ export class MonitoredItem extends EventEmitter {
             this.samplingInterval = 0; // turned to exception-based regardless of requested sampling interval
 
             // non value attribute only react on value change
-            this._attribute_changed_callback = this._on_value_changed.bind(this);
-            const event_name = makeAttributeEventName(this.itemToMonitor.attributeId);
-
-            this.node.on(event_name, this._attribute_changed_callback);
+            if (!this._attribute_changed_callback) {
+                this._attribute_changed_callback = this._on_value_changed.bind(this);
+                const event_name = makeAttributeEventName(this.itemToMonitor.attributeId);
+                this.node.on(event_name, this._attribute_changed_callback);
+            }
 
             if (recordInitialValue) {
                 // read initial value
@@ -1026,29 +1052,32 @@ export class MonitoredItem extends EventEmitter {
         if (this.samplingInterval === 0) {
             // we have a exception-based dataItem : event based model, so we do not need a timer
             // rather , we setup the "value_changed_event";
-            this._value_changed_callback = this._on_value_changed.bind(this);
-            this._semantic_changed_callback = this._on_semantic_changed.bind(this);
-
-            this.node.on("value_changed", this._value_changed_callback);
-            this.node.on("semantic_changed", this._semantic_changed_callback);
+            if (!this._value_changed_callback) {
+                assert(!this._semantic_changed_callback);
+                this._value_changed_callback = this._on_value_changed.bind(this);
+                this._semantic_changed_callback = this._on_semantic_changed.bind(this);
+                this.node.on("value_changed", this._value_changed_callback);
+                this.node.on("semantic_changed", this._semantic_changed_callback);
+            }
 
             // initiate first read
             if (recordInitialValue) {
-                /* await */ new Promise<void>((resolve: () => void) => {
-                    (this.node as UAVariable).readValueAsync(sessionContext, (err: Error | null, dataValue?: DataValue) => {
-                        if (!err && dataValue) {
-                            this.recordValue(dataValue, true);
-                        }
-                        resolve();
-                    });
+                this.__acquireInitialValue(sessionContext, (err: Error | null, dataValue?: DataValue) => {
+                    if (!err && dataValue) {
+                        this.recordValue(dataValue, true);
+                    }
                 });
             }
         } else {
-            this._set_timer();
             if (recordInitialValue) {
-                setImmediate(() => {
-                    this._on_sampling_timer();
+                this.__acquireInitialValue(sessionContext, (err: Error | null, dataValue?: DataValue) => {
+                    if (!err && dataValue) {
+                        this.recordValue(dataValue, true);
+                    }
+                    this._set_timer();
                 });
+            } else {
+                this._set_timer();
             }
         }
     }
@@ -1065,9 +1094,10 @@ export class MonitoredItem extends EventEmitter {
         // that the data item is exception-based rather than being sampled at some period. An exception-based
         // model means that the underlying system does not require sampling and reports data changes.
         if (this.node && this.node.nodeClass === NodeClass.Variable) {
+            const variable = (this.node as UAVariable);
             this.samplingInterval = _adjust_sampling_interval(
                 monitoredParameters.samplingInterval,
-                this.node ? (this.node as UAVariable).minimumSamplingInterval : 0
+                variable.minimumSamplingInterval || 0
             );
         } else {
             this.samplingInterval = _adjust_sampling_interval(monitoredParameters.samplingInterval, 0);
@@ -1197,11 +1227,11 @@ export class MonitoredItem extends EventEmitter {
         ) {
             throw new Error(
                 "dataValue.value.value cannot be the same object twice! " +
-                    this.node!.browseName.toString() +
-                    " " +
-                    dataValue.toString() +
-                    "  " +
-                    chalk.cyan(this.oldDataValue.toString())
+                this.node!.browseName.toString() +
+                " " +
+                dataValue.toString() +
+                "  " +
+                chalk.cyan(this.oldDataValue.toString())
             );
         }
 
@@ -1248,6 +1278,13 @@ export class MonitoredItem extends EventEmitter {
     }
 
     private _set_timer() {
+
+        if(!this.itemToMonitor) {
+            // item has already been deleted
+            // so do not create the timer !
+            return;
+        }
+        
         assert(this.samplingInterval >= MonitoredItem.minimumSamplingInterval);
         assert(!this._samplingId);
 
@@ -1289,7 +1326,7 @@ export class MonitoredItem extends EventEmitter {
         assert(this.queue.length <= this.queueSize);
     }
 
-    private _adjust_sampling(old_samplingInterval: number) {
+    private _adjustSampling(old_samplingInterval: number) {
         if (old_samplingInterval !== this.samplingInterval) {
             this._start_sampling(false);
         }

package/source/node_sampler.ts

@@ -3,6 +3,7 @@
  */
 import { assert } from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { MonitoringMode } from "node-opcua-types";
 import { hrtime } from "node-opcua-utils";
 
 const debugLog = make_debugLog(__filename);
@@ -18,6 +19,11 @@ interface MonitoredItemPriv {
 }
 function sampleMonitoredItem(monitoredItem: MonitoredItem) {
     const _monitoredItem = monitoredItem as unknown as MonitoredItemPriv;
+    
+    if (monitoredItem.monitoringMode === MonitoringMode.Disabled) {
+        return;
+    }
+
     setImmediate(() => {
         _monitoredItem._on_sampling_timer();
     });

package/source/opcua_server.ts

@@ -1141,7 +1141,7 @@ export class OPCUAServer extends OPCUABaseServer {
             });
             this.objectFactory = new Factory(this.engine);
 
-            const endpointDefinitions = options.alternateEndpoints || [];
+            const endpointDefinitions: OPCUAServerEndpointOptions[] = options.alternateEndpoints || [];
             const hostname = getFullyQualifiedDomainName();
 
             endpointDefinitions.push({
@@ -1154,7 +1154,6 @@ export class OPCUAServer extends OPCUABaseServer {
                 securityModes: options.securityModes,
                 securityPolicies: options.securityPolicies
             });
-
             // todo  should self.serverInfo.productUri  match self.engine.buildInfo.productUri ?
             for (const endpointOptions of endpointDefinitions) {
                 const endPoint = this.createEndpointDescriptions(options!, endpointOptions);
@@ -1753,7 +1752,7 @@ export class OPCUAServer extends OPCUABaseServer {
         function rejectConnection(server: OPCUAServer, statusCode: StatusCode): void {
             server.engine.incrementSecurityRejectedSessionCount();
 
-            const response1 = new CreateSessionResponse({
+            const response1 = new ServiceFault({
                 responseHeader: { serviceResult: statusCode }
             });
             channel.send_response("MSG", response1, message);
@@ -3507,7 +3506,7 @@ export class OPCUAServer extends OPCUABaseServer {
         return g_sendError(channel, message, HistoryUpdateResponse, StatusCodes.BadServiceUnsupported);
     }
 
-    private createEndpoint(port1: number, serverOptions: OPCUAServerOptions): OPCUAServerEndPoint {
+    private createEndpoint(port1: number, serverOptions: {defaultSecureTokenLifetime?: number, timeout? : number}): OPCUAServerEndPoint {
         // add the tcp/ip endpoint with no security
         const endPoint = new OPCUAServerEndPoint({
             port: port1,