node-opcua-server 2.81.0 → 2.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-server",
-    "version": "2.81.0",
+    "version": "2.82.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.82.0",
+        "node-opcua-address-space-base": "2.82.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.82.0",
+        "node-opcua-binary-stream": "2.82.0",
+        "node-opcua-certificate-manager": "2.82.0",
+        "node-opcua-client": "2.82.0",
+        "node-opcua-client-dynamic-extension-object": "2.82.0",
+        "node-opcua-common": "2.82.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.82.0",
+        "node-opcua-data-value": "2.82.0",
+        "node-opcua-date-time": "2.82.0",
+        "node-opcua-debug": "2.82.0",
+        "node-opcua-extension-object": "2.82.0",
+        "node-opcua-factory": "2.82.0",
         "node-opcua-hostname": "2.77.0",
-        "node-opcua-nodeid": "2.81.0",
+        "node-opcua-nodeid": "2.82.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.82.0",
+        "node-opcua-object-registry": "2.82.0",
+        "node-opcua-secure-channel": "2.82.0",
+        "node-opcua-service-browse": "2.82.0",
+        "node-opcua-service-call": "2.82.0",
+        "node-opcua-service-discovery": "2.82.0",
+        "node-opcua-service-endpoints": "2.82.0",
+        "node-opcua-service-filter": "2.82.0",
+        "node-opcua-service-history": "2.82.0",
+        "node-opcua-service-node-management": "2.82.0",
+        "node-opcua-service-query": "2.82.0",
+        "node-opcua-service-read": "2.82.0",
+        "node-opcua-service-register-node": "2.82.0",
+        "node-opcua-service-secure-channel": "2.82.0",
+        "node-opcua-service-session": "2.82.0",
+        "node-opcua-service-subscription": "2.82.0",
+        "node-opcua-service-translate-browse-path": "2.82.0",
+        "node-opcua-service-write": "2.82.0",
+        "node-opcua-status-code": "2.82.0",
+        "node-opcua-types": "2.82.0",
+        "node-opcua-utils": "2.82.0",
+        "node-opcua-variant": "2.82.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.82.0",
+        "node-opcua-leak-detector": "2.82.0",
+        "node-opcua-pki": "^2.18.0",
         "node-opcua-test-helpers": "2.77.0",
         "should": "^13.2.3",
-        "sinon": "^14.0.0",
+        "sinon": "^14.0.1",
         "underscore": "^1.13.6"
     },
     "author": "Etienne Rossignon",
@@ -85,5 +85,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "fd89928bc4a4b9f31a6b6e5921f743e8284eba2b"
+    "gitHead": "2f66e1fe69c825305f94b15ca17cff066aa37496"
 }

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

@@ -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);

package/source/server_engine.ts

@@ -96,7 +96,6 @@ import { ServerSession } from "./server_session";
 import { Subscription } from "./server_subscription";
 import { sessionsCompatibleForTransfer } from "./sessions_compatible_for_transfer";
 import { OPCUAServerOptions } from "./opcua_server";
-import { IUserManager } from "node-opcua-address-space/source";
 
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
@@ -123,25 +122,13 @@ function setSubscriptionDurable(
 ) {
     // see https://reference.opcfoundation.org/v104/Core/docs/Part5/9.3/
     // https://reference.opcfoundation.org/v104/Core/docs/Part4/6.8/
-    assert(Array.isArray(inputArguments));
     assert(typeof callback === "function");
-    assert(Object.prototype.hasOwnProperty.call(context, "session"), " expecting a session id in the context object");
-    const session = context.session as ServerSession;
-    if (!session) {
-        return callback(null, { statusCode: StatusCodes.BadInternalError });
-    }
-    const subscriptionId = inputArguments[0].value as UInt32;
-    const lifetimeInHours = inputArguments[1].value as UInt32;
 
-    const subscription = session.getSubscription(subscriptionId);
-    if (!subscription) {
-        // subscription may belongs to a different session  that ours
-        if (this.findSubscription(subscriptionId)) {
-            // if yes, then access to  Subscription data should be denied
-            return callback(null, { statusCode: StatusCodes.BadUserAccessDenied });
-        }
-        return callback(null, { statusCode: StatusCodes.BadSubscriptionIdInvalid });
-    }
+    const data = _getSubscription.call(this, inputArguments, context);
+    if (data.statusCode) return callback(null, { statusCode: data.statusCode });
+    const { subscription } = data;
+
+    const lifetimeInHours = inputArguments[1].value as UInt32;
     if (subscription.monitoredItemCount > 0) {
         // This is returned when a Subscription already contains MonitoredItems.
         return callback(null, { statusCode: StatusCodes.BadInvalidState });
@@ -199,8 +186,7 @@ function setSubscriptionDurable(
     callback(null, callMethodResult);
 }
 
-// binding methods
-function getMonitoredItemsId(
+function requestServerStateChange(
     this: ServerEngine,
     inputArguments: Variant[],
     context: ISessionContext,
@@ -209,23 +195,70 @@ function getMonitoredItemsId(
     assert(Array.isArray(inputArguments));
     assert(typeof callback === "function");
     assert(Object.prototype.hasOwnProperty.call(context, "session"), " expecting a session id in the context object");
-
     const session = context.session as ServerSession;
     if (!session) {
         return callback(null, { statusCode: StatusCodes.BadInternalError });
     }
 
+    return callback(null, { statusCode: StatusCodes.BadNotImplemented });
+}
+
+function _getSubscription(
+    this: ServerEngine,
+    inputArguments: Variant[],
+    context: ISessionContext
+): { 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;
+    if (!session) {
+        return { statusCode: StatusCodes.BadInternalError };
+    }
     const subscriptionId = inputArguments[0].value;
     const subscription = session.getSubscription(subscriptionId);
     if (!subscription) {
         // subscription may belongs to a different session  that ours
         if (this.findSubscription(subscriptionId)) {
             // if yes, then access to  Subscription data should be denied
-            return callback(null, { statusCode: StatusCodes.BadUserAccessDenied });
+            return { statusCode: StatusCodes.BadUserAccessDenied };
         }
-
-        return callback(null, { statusCode: StatusCodes.BadSubscriptionIdInvalid });
+        return { statusCode: StatusCodes.BadSubscriptionIdInvalid };
     }
+    return { subscription };
+
+}
+function resendData(
+    this: ServerEngine,
+    inputArguments: Variant[],
+    context: ISessionContext,
+    callback: CallbackT<CallMethodResultOptions>
+): void {
+    assert(typeof callback === "function");
+
+    const data = _getSubscription.call(this, inputArguments, context);
+    if (data.statusCode) return callback(null, { statusCode: data.statusCode });
+    const { subscription } = data;
+
+    subscription.resendInitialValues().then(() => {
+        callback(null, { statusCode: StatusCodes.Good });
+    }).catch((err) => callback(err));
+
+}
+
+
+// binding methods
+function getMonitoredItemsId(
+    this: ServerEngine,
+    inputArguments: Variant[],
+    context: ISessionContext,
+    callback: CallbackT<CallMethodResultOptions>
+) {
+    assert(typeof callback === "function");
+
+    const data = _getSubscription.call(this, inputArguments, context);
+    if (data.statusCode) return callback(null, { statusCode: data.statusCode });
+    const { subscription } = data;
+
     const result = subscription.getMonitoredItems();
     assert(result.statusCode);
     assert(result.serverHandles.length === result.clientHandles.length);
@@ -1202,6 +1235,8 @@ export class ServerEngine extends EventEmitter {
 
             this.__internal_bindMethod(makeNodeId(MethodIds.Server_GetMonitoredItems), getMonitoredItemsId.bind(this));
             this.__internal_bindMethod(makeNodeId(MethodIds.Server_SetSubscriptionDurable), setSubscriptionDurable.bind(this));
+            this.__internal_bindMethod(makeNodeId(MethodIds.Server_ResendData), resendData.bind(this));
+            this.__internal_bindMethod(makeNodeId(MethodIds.Server_RequestServerStateChange), requestServerStateChange.bind(this));
 
             // fix getMonitoredItems.outputArguments arrayDimensions
             const fixGetMonitoredItemArgs = () => {
@@ -1415,7 +1450,7 @@ export class ServerEngine extends EventEmitter {
                 (!dataValue.serverTimestamp || dataValue.serverTimestamp.getTime() === minOPCUADate.getTime())
             ) {
                 dataValue.serverTimestamp = context.currentTime.timestamp;
-                dataValue.sourcePicoseconds = 0; // context.currentTime.picosecond // do we really need picosecond here ? this would inflate binary data
+                dataValue.serverPicoseconds = 0; // context.currentTime.picoseconds; 
             }
             dataValues.push(dataValue);
         }
@@ -2246,8 +2281,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());
         }

package/source/server_subscription.ts

@@ -6,7 +6,7 @@
 import { EventEmitter } from "events";
 import * as chalk from "chalk";
 
-import { SessionContext,AddressSpace, BaseNode, Duration, UAObjectType } from "node-opcua-address-space";
+import { SessionContext, AddressSpace, BaseNode, Duration, UAObjectType } from "node-opcua-address-space";
 import { assert } from "node-opcua-assert";
 import { Byte, UInt32 } from "node-opcua-basic-types";
 import { SubscriptionDiagnosticsDataType } from "node-opcua-common";
@@ -81,19 +81,22 @@ function _adjust_maxKeepAliveCount(maxKeepAliveCount?: number /*,publishingInter
     return maxKeepAliveCount;
 }
 
+const MaxUint32 = 0xFFFFFFFF;
+
 function _adjust_lifeTimeCount(lifeTimeCount: number, maxKeepAliveCount: number, publishingInterval: number): number {
     lifeTimeCount = lifeTimeCount || 1;
 
-    // let's make sure that lifeTimeCount is at least three time maxKeepAliveCount
-    // Note : the specs say ( part 3  - CreateSubscriptionParameter )
-    //        "The lifetime count shall be a minimum of three times the keep keep-alive count."
-    lifeTimeCount = Math.max(lifeTimeCount, maxKeepAliveCount * 3);
-
     const minTicks = Math.ceil(Subscription.minimumLifetimeDuration / publishingInterval);
     const maxTicks = Math.floor(Subscription.maximumLifetimeDuration / publishingInterval);
 
     lifeTimeCount = Math.max(minTicks, lifeTimeCount);
     lifeTimeCount = Math.min(maxTicks, lifeTimeCount);
+
+    // let's make sure that lifeTimeCount is at least three time maxKeepAliveCount
+    // Note : the specs say ( part 3  - CreateSubscriptionParameter )
+    //        "The lifetime count shall be a minimum of three times the keep keep-alive count."
+    lifeTimeCount = Math.max(lifeTimeCount, Math.min(maxKeepAliveCount * 3, MaxUint32));
+
     return lifeTimeCount;
 }
 
@@ -1362,7 +1365,7 @@ export class Subscription extends EventEmitter {
         const availableSequenceNumbers = this.getAvailableSequenceNumbers();
         assert(
             !response.notificationMessage ||
-                availableSequenceNumbers[availableSequenceNumbers.length - 1] === response.notificationMessage.sequenceNumber
+            availableSequenceNumbers[availableSequenceNumbers.length - 1] === response.notificationMessage.sequenceNumber
         );
         response.availableSequenceNumbers = availableSequenceNumbers;
 
@@ -1439,7 +1442,7 @@ export class Subscription extends EventEmitter {
             } else {
                 debugLog(
                     "     -> subscription.state === LATE , " +
-                        "because keepAlive Response cannot be send due to lack of PublishRequest"
+                    "because keepAlive Response cannot be send due to lack of PublishRequest"
                 );
                 if (this.messageSent || this.keepAliveCounterHasExpired) {
                     this.state = SubscriptionState.LATE;