node-opcua-server 2.120.0 → 2.122.0

package/source/server_subscription.ts

@@ -6,14 +6,23 @@
 import { EventEmitter } from "events";
 import chalk from "chalk";
 
-import { SessionContext, AddressSpace, BaseNode, Duration, UAObjectType } from "node-opcua-address-space";
+import {
+    SessionContext,
+    AddressSpace,
+    BaseNode,
+    Duration,
+    UAObjectType,
+    ISessionContext,
+    IAddressSpace
+} 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";
-import { NodeClass, AttributeIds, isValidDataEncoding } from "node-opcua-data-model";
-import { TimestampsToReturn } from "node-opcua-data-value";
+import { NodeClass, AttributeIds, isValidDataEncoding, QualifiedNameLike } from "node-opcua-data-model";
+import { DataValue, TimestampsToReturn } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
+import { NumericRange } from "node-opcua-numeric-range";
 import { ObjectRegistry } from "node-opcua-object-registry";
 import { SequenceNumberGenerator } from "node-opcua-secure-channel";
 import { EventFilter, checkSelectClauses } from "node-opcua-service-filter";
@@ -81,7 +90,7 @@ function _adjust_maxKeepAliveCount(maxKeepAliveCount?: number /*,publishingInter
     return maxKeepAliveCount;
 }
 
-const MaxUint32 = 0xFFFFFFFF;
+const MaxUint32 = 0xffffffff;
 
 function _adjust_lifeTimeCount(lifeTimeCount: number, maxKeepAliveCount: number, publishingInterval: number): number {
     lifeTimeCount = lifeTimeCount || 1;
@@ -137,7 +146,7 @@ function _getSequenceNumbers(arr: NotificationMessage[]): number[] {
     return arr.map((notificationMessage) => notificationMessage.sequenceNumber);
 }
 
-function analyseEventFilterResult(node: BaseNode, eventFilter: EventFilter): EventFilterResult {
+function analyzeEventFilterResult(node: BaseNode, eventFilter: EventFilter): EventFilterResult {
     /* istanbul ignore next */
     if (!(eventFilter instanceof EventFilter)) {
         throw new Error("Internal Error");
@@ -154,13 +163,13 @@ function analyseEventFilterResult(node: BaseNode, eventFilter: EventFilter): Eve
     });
 }
 
-function analyseDataChangeFilterResult(node: BaseNode, dataChangeFilter: DataChangeFilter): null {
+function analyzeDataChangeFilterResult(node: BaseNode, dataChangeFilter: DataChangeFilter): null {
     assert(dataChangeFilter instanceof DataChangeFilter);
     // the opcua specification doesn't provide dataChangeFilterResult
     return null;
 }
 
-function analyseAggregateFilterResult(node: BaseNode, aggregateFilter: AggregateFilter): AggregateFilterResult {
+function analyzeAggregateFilterResult(node: BaseNode, aggregateFilter: AggregateFilter): AggregateFilterResult {
     assert(aggregateFilter instanceof AggregateFilter);
     return new AggregateFilterResult({});
 }
@@ -171,11 +180,11 @@ function _process_filter(node: BaseNode, filter: any): EventFilterResult | Aggre
     }
 
     if (filter instanceof EventFilter) {
-        return analyseEventFilterResult(node, filter);
+        return analyzeEventFilterResult(node, filter);
     } else if (filter instanceof DataChangeFilter) {
-        return analyseDataChangeFilterResult(node, filter);
+        return analyzeDataChangeFilterResult(node, filter);
     } else if (filter instanceof AggregateFilter) {
-        return analyseAggregateFilterResult(node, filter);
+        return analyzeAggregateFilterResult(node, filter);
     }
     // istanbul ignore next
     throw new Error("invalid filter");
@@ -270,7 +279,7 @@ function createSubscriptionDiagnostics(subscription: Subscription): Subscription
             if (!this.$subscription) {
                 return 0;
             }
-            return this.$subscription._get_future_sequence_number();
+            return this.$subscription.futureSequenceNumber;
         }
     );
     subscription_subscriptionDiagnostics.__defineGetter__(
@@ -466,6 +475,15 @@ export interface ServerCapabilitiesPartial {
     maxMonitoredItemsPerSubscription: UInt32;
 }
 
+export interface IReadAttributeCapable {
+    readAttribute(
+        context: ISessionContext | null,
+        attributeId: AttributeIds,
+        indexRange?: NumericRange,
+        dataEncoding?: QualifiedNameLike | null
+    ): DataValue;
+}
+
 /**
  * The Subscription class used in the OPCUA server side.
  */
@@ -564,8 +582,8 @@ export class Subscription extends EventEmitter {
     }
 
     private _life_time_counter: number;
-    private _keep_alive_counter = 0;
-    private _pending_notifications: Queue<InternalNotification>;
+    protected _keep_alive_counter = 0;
+    public _pending_notifications: Queue<InternalNotification>;
     private _sent_notification_messages: NotificationMessage[];
     private readonly _sequence_number_generator: SequenceNumberGenerator;
     private readonly monitoredItems: { [key: number]: MonitoredItem };
@@ -649,7 +667,7 @@ export class Subscription extends EventEmitter {
     public toString(): string {
         let str = "Subscription:\n";
         str += "  subscriptionId          " + this.id + "\n";
-        str += "  sessionId          " + this.getSessionId().toString() + "\n";
+        str += "  sessionId          " + this.getSessionId()?.toString() + "\n";
 
         str += "  publishingEnabled  " + this.publishingEnabled + "\n";
         str += "  maxKeepAliveCount  " + this.maxKeepAliveCount + "\n";
@@ -687,6 +705,7 @@ export class Subscription extends EventEmitter {
             // todo
         }
         this._stop_timer();
+
         this._start_timer({ firstTime: false });
     }
 
@@ -923,8 +942,8 @@ export class Subscription extends EventEmitter {
      * number of disabled monitored items.
      */
     public get disabledMonitoredItemCount(): number {
-        return Object.values(this.monitoredItems).reduce((cumul: any, monitoredItem: MonitoredItem) => {
-            return cumul + (monitoredItem.monitoringMode === MonitoringMode.Disabled ? 1 : 0);
+        return Object.values(this.monitoredItems).reduce((sum: number, monitoredItem: MonitoredItem) => {
+            return sum + (monitoredItem.monitoringMode === MonitoringMode.Disabled ? 1 : 0);
         }, 0);
     }
 
@@ -941,13 +960,16 @@ export class Subscription extends EventEmitter {
      *  - otherwise the sampling is adjusted
      * @private
      */
-    public adjustSamplingInterval(samplingInterval: number, node: BaseNode): number {
+    public adjustSamplingInterval(samplingInterval: number, node?: IReadAttributeCapable): number {
         if (samplingInterval < 0) {
             // - The value -1 indicates that the default sampling interval defined by the publishing
             //   interval of the Subscription is requested.
             // - Any negative number is interpreted as -1.
             samplingInterval = this.publishingInterval;
         } else if (samplingInterval === 0) {
+            // istanbul ignore next
+            if (!node) throw new Error("Internal Error");
+
             // OPCUA 1.0.3 Part 4 - 5.12.1.2
             // The value 0 indicates that the Server should use the fastest practical rate.
 
@@ -993,7 +1015,7 @@ export class Subscription extends EventEmitter {
      * @param monitoredItemCreateRequest - the parameters describing the monitored Item to create
      */
     public preCreateMonitoredItem(
-        addressSpace: AddressSpace,
+        addressSpace: IAddressSpace,
         timestampsToReturn: TimestampsToReturn,
         monitoredItemCreateRequest: MonitoredItemCreateRequest
     ): InternalCreateMonitoredItemResult {
@@ -1088,7 +1110,7 @@ export class Subscription extends EventEmitter {
     }
 
     public async createMonitoredItem(
-        addressSpace: AddressSpace,
+        addressSpace: IAddressSpace,
         timestampsToReturn: TimestampsToReturn,
         monitoredItemCreateRequest: MonitoredItemCreateRequest
     ): Promise<MonitoredItemCreateResult> {
@@ -1252,12 +1274,33 @@ export class Subscription extends EventEmitter {
      * @private
      */
     public async resendInitialValues(): Promise<void> {
-        const promises: Promise<void>[] = [];
-        for (const monitoredItem of Object.values(this.monitoredItems)) {
-            assert(monitoredItem.clientHandle !== 4294967295);
-            promises.push(monitoredItem.resendInitialValues());
+        this._keep_alive_counter = 0;
+
+        try {
+            const promises: Promise<void>[] = [];
+            for (const monitoredItem of Object.values(this.monitoredItems)) {
+                promises.push(
+                    (async () => {
+                        try {
+                            monitoredItem.resendInitialValue();
+                        } catch (err) {
+                            warningLog(
+                                "resendInitialValues:",
+                                monitoredItem.node?.nodeId.toString(),
+                                "error:",
+                                (err as any).message
+                            );
+                        }
+                    })()
+                );
+            }
+            await Promise.all(promises);
+        } catch (err) {
+            warningLog("resendInitialValues: error:", (err as any).message);
         }
-        await Promise.all(promises);
+        // make sure data will be sent immediately
+        this._keep_alive_counter = this.maxKeepAliveCount - 1 ;
+        this.state = SubscriptionState.NORMAL;
         this._harvestMonitoredItems();
     }
 
@@ -1368,7 +1411,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;
 
@@ -1380,7 +1423,6 @@ export class Subscription extends EventEmitter {
 
         this.resetLifeTimeAndKeepAliveCounters();
 
-        
         // istanbul ignore next
         if (doDebug) {
             debugLog(
@@ -1419,7 +1461,10 @@ export class Subscription extends EventEmitter {
         if (this.hasPendingNotifications) {
             this._publish_pending_notifications();
 
-            if (this.state === SubscriptionState.NORMAL && this.hasPendingNotifications) {
+            if (
+                this.state === SubscriptionState.NORMAL ||
+                (this.state === SubscriptionState.LATE && this.hasPendingNotifications)
+            ) {
                 // istanbul ignore next
                 if (doDebug) {
                     debugLog("    -> pendingPublishRequestCount > 0 " + "&& normal state => re-trigger tick event immediately ");
@@ -1433,10 +1478,6 @@ export class Subscription extends EventEmitter {
         }
     }
 
-    public _get_future_sequence_number(): number {
-        return this._sequence_number_generator ? this._sequence_number_generator.future() : 0;
-    }
-
     private _process_keepAlive() {
         this.increaseKeepAliveCounter();
 
@@ -1447,7 +1488,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;
@@ -1483,7 +1524,7 @@ export class Subscription extends EventEmitter {
 
         // make sure that a keep-alive Message will be send at the end of the first publishing cycle
         // if there are no Notifications ready.
-        this._keep_alive_counter = 0; // this.maxKeepAliveCount;
+        this._keep_alive_counter = this.maxKeepAliveCount - 1;
 
         if (firstTime) {
             assert(this.messageSent === false);
@@ -1494,10 +1535,19 @@ export class Subscription extends EventEmitter {
         this.timerId = setInterval(this._tick.bind(this), this.publishingInterval);
     }
 
+    private _get_future_sequence_number(): number {
+        return this._sequence_number_generator ? this._sequence_number_generator.future() : 0;
+    }
+    public get futureSequenceNumber(): number {
+        return this._get_future_sequence_number();
+    }
     // counter
     private _get_next_sequence_number(): number {
         return this._sequence_number_generator ? this._sequence_number_generator.next() : 0;
     }
+    public get nextSequenceNumber(): number {
+        return this._get_next_sequence_number();
+    }
 
     /**
      * @private
@@ -1846,7 +1896,7 @@ export class Subscription extends EventEmitter {
         monitoredItem.setMonitoringMode(monitoringMode);
     }
 
-    private _harvestMonitoredItems() {
+    public _harvestMonitoredItems() {
         for (const monitoredItem of Object.values(this.monitoredItems)) {
             const notifications_chunks = monitoredItem.extractMonitoredItemNotifications();
             for (const chunk of notifications_chunks) {