node-opcua-client 2.178.0 → 2.179.0

package/source/private/client_monitored_item_group_impl.ts

@@ -1,11 +1,10 @@
 /**
  * @module node-opcua-client-private
  */
-// tslint:disable:no-empty
 import { EventEmitter } from "node:events";
 import { assert } from "node-opcua-assert";
 import { coerceTimestampsToReturn, type DataValue, TimestampsToReturn } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
+import { make_warningLog } from "node-opcua-debug";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { MonitoringMode, type MonitoringParametersOptions } from "node-opcua-service-subscription";
 import type { Callback, ErrorCallback, StatusCode } from "node-opcua-status-code";
@@ -17,7 +16,6 @@ import type { ClientSubscription } from "../client_subscription";
 import { ClientMonitoredItemImpl } from "./client_monitored_item_impl";
 import type { ClientSubscriptionImpl } from "./client_subscription_impl";
 
-
 const warningLog = make_warningLog(__filename);
 
 /**
@@ -34,6 +32,7 @@ export class ClientMonitoredItemGroupImpl extends EventEmitter implements Client
     private readonly subscription: ClientSubscription;
     private timestampsToReturn: TimestampsToReturn;
     private readonly monitoringMode: MonitoringMode;
+    private _terminated = false;
 
     constructor(
         subscription: ClientSubscription,
@@ -91,11 +90,11 @@ export class ClientMonitoredItemGroupImpl extends EventEmitter implements Client
      */
     public async terminate(): Promise<void>;
     public terminate(done: ErrorCallback): void;
-    public terminate(...args: any[]): any {
+    public terminate(...args: unknown[]): unknown {
         const done = args[0] as ErrorCallback;
         assert(!done || typeof done === "function");
         const subscription = this.subscription as ClientSubscriptionImpl;
-        subscription._delete_monitored_items(this.monitoredItems, (err?: Error) => {
+        return subscription._delete_monitored_items(this.monitoredItems, (err?: Error) => {
             subscription._removeGroup(this);
 
             if (done) {
@@ -104,27 +103,29 @@ export class ClientMonitoredItemGroupImpl extends EventEmitter implements Client
         });
     }
 
-    // tslint:disable:unified-signatures
     /**
 
      */
     public async modify(parameters: MonitoringParametersOptions): Promise<MonitoredItemModifyResult>;
-    public async modify(parameters: MonitoringParametersOptions, timestampsToReturn: TimestampsToReturn): Promise<MonitoredItemModifyResult>;
+    public async modify(
+        parameters: MonitoringParametersOptions,
+        timestampsToReturn: TimestampsToReturn
+    ): Promise<MonitoredItemModifyResult>;
     public modify(parameters: MonitoringParametersOptions, callback: Callback<MonitoredItemModifyResult>): void;
     public modify(
         parameters: MonitoringParametersOptions,
         timestampsToReturn: TimestampsToReturn | null,
         callback: Callback<MonitoredItemModifyResult>
     ): void;
-    public modify(...args: any[]): any {
+    public modify(...args: unknown[]): unknown {
         if (args.length === 2) {
-            return this.modify(args[0], null, args[1]);
+            return this.modify(args[0] as MonitoringParametersOptions, null, args[1] as Callback<MonitoredItemModifyResult>);
         }
         const parameters = args[0] as MonitoringParametersOptions;
         const timestampsToReturn = args[1] as TimestampsToReturn;
         const callback = args[2] as ErrorCallback;
         this.timestampsToReturn = timestampsToReturn || this.timestampsToReturn;
-        ClientMonitoredItemToolbox._toolbox_modify(
+        return ClientMonitoredItemToolbox._toolbox_modify(
             this.subscription,
             this.monitoredItems,
             parameters,
@@ -137,16 +138,16 @@ export class ClientMonitoredItemGroupImpl extends EventEmitter implements Client
 
     public async setMonitoringMode(monitoringMode: MonitoringMode): Promise<StatusCode>;
     public setMonitoringMode(monitoringMode: MonitoringMode, callback: Callback<StatusCode>): void;
-    public setMonitoringMode(...args: any[]): any {
+    public setMonitoringMode(...args: unknown[]): unknown {
         const monitoringMode = args[0] as MonitoringMode;
         const callback = args[1] as Callback<StatusCode>;
-        ClientMonitoredItemToolbox._toolbox_setMonitoringMode(
+        return ClientMonitoredItemToolbox._toolbox_setMonitoringMode(
             this.subscription,
             this.monitoredItems,
             monitoringMode,
             (err: Error | null, statusCode?: StatusCode[]) => {
                 // todo fix me
-                callback(err, statusCode![0]);
+                callback(err, statusCode?.[0]);
             }
         );
     }
@@ -201,8 +202,8 @@ Please investigate the code of the event handler function to fix the error.`
         );
     }
     public _terminate_and_emit(err?: Error): void {
-        assert(!(this as any)._terminated);
-        (this as any)._terminated = true;
+        assert(!this._terminated);
+        this._terminated = true;
         if (err) {
             this.emit("err", err.message);
         }
@@ -210,11 +211,9 @@ Please investigate the code of the event handler function to fix the error.`
     }
 }
 
-// tslint:disable:no-var-requires
-// tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
 
-const opts = { multiArgs: false };
+const _opts = { multiArgs: false };
 
 ClientMonitoredItemGroupImpl.prototype.terminate = withCallback(ClientMonitoredItemGroupImpl.prototype.terminate);
 ClientMonitoredItemGroupImpl.prototype.setMonitoringMode = withCallback(ClientMonitoredItemGroupImpl.prototype.setMonitoringMode);

package/source/private/client_monitored_item_impl.ts

@@ -1,8 +1,6 @@
 /**
  * @module node-opcua-client-private
  */
-// tslint:disable:unified-signatures
-// tslint:disable:no-empty
 import { EventEmitter } from "node:events";
 import { assert } from "node-opcua-assert";
 
@@ -404,8 +402,6 @@ export class ClientMonitoredItemImpl extends EventEmitter implements ClientMonit
     }
 }
 
-// tslint:disable:no-var-requires
-// tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
 
 const _opts = { multiArgs: false };

package/source/private/client_publish_engine.ts

@@ -5,7 +5,9 @@ import chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { getMinOPCUADate } from "node-opcua-date-time";
 import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
+import type { ServiceFaultAnnotatedError } from "node-opcua-secure-channel";
 import { PublishRequest, type PublishResponse } from "node-opcua-service-subscription";
+import type { SubscriptionAcknowledgementOptions } from "node-opcua-types";
 
 import type { ClientSession, SubscriptionId } from "../client_session";
 import type { ClientSubscription } from "../client_subscription";
@@ -35,7 +37,7 @@ export class ClientSidePublishEngine {
     public nbMaxPublishRequestsAcceptedByServer: number;
     public isSuspended: boolean;
     public session: ClientSession | null;
-    private subscriptionAcknowledgements: any[];
+    private subscriptionAcknowledgements: SubscriptionAcknowledgementOptions[];
 
     /**
      * @internal
@@ -128,7 +130,8 @@ export class ClientSidePublishEngine {
      * @private
      */
     public terminate(): void {
-        debugLog("Terminated ClientPublishEngine ");
+        // c8 ignore next
+        doDebug && debugLog("Terminated ClientPublishEngine ");
         this.session = null;
     }
 
@@ -136,21 +139,22 @@ export class ClientSidePublishEngine {
      * @private
      */
     public registerSubscription(subscription: ClientSubscription): void {
-        debugLog("ClientSidePublishEngine#registerSubscription ", subscription.subscriptionId);
+        // c8 ignore next
+        doDebug && debugLog("ClientSidePublishEngine#registerSubscription ", subscription.subscriptionId);
 
         const _subscription = subscription as ClientSubscriptionImpl;
-        assert(arguments.length === 1);
-        assert(isFinite(subscription.subscriptionId));
+        assert(Number.isFinite(subscription.subscriptionId));
         assert(!Object.hasOwn(this.subscriptionMap, subscription.subscriptionId)); // already registered ?
         assert(typeof _subscription.onNotificationMessage === "function");
-        assert(isFinite(subscription.timeoutHint));
+        assert(Number.isFinite(subscription.timeoutHint));
 
         this.activeSubscriptionCount += 1;
         this.subscriptionMap[subscription.subscriptionId] = _subscription;
 
         this.timeoutHint = Math.min(Math.max(this.timeoutHint, subscription.timeoutHint), 0x7ffffff);
 
-        debugLog("                       setting timeoutHint = ", this.timeoutHint, subscription.timeoutHint);
+        // c8 ignore next
+        doDebug && debugLog("                       setting timeoutHint = ", this.timeoutHint, subscription.timeoutHint);
 
         this.replenish_publish_request_queue();
     }
@@ -179,9 +183,10 @@ export class ClientSidePublishEngine {
      * @private
      */
     public unregisterSubscription(subscriptionId: SubscriptionId): void {
-        debugLog("ClientSidePublishEngine#unregisterSubscription ", subscriptionId);
+        // c8 ignore next
+        doDebug && debugLog("ClientSidePublishEngine#unregisterSubscription ", subscriptionId);
 
-        assert(isFinite(subscriptionId) && subscriptionId > 0);
+        assert(Number.isFinite(subscriptionId) && subscriptionId > 0);
         this.activeSubscriptionCount -= 1;
         // note : it is possible that we get here while the server has already requested
         //        a session shutdown ... in this case it is possible that subscriptionId is already
@@ -189,7 +194,8 @@ export class ClientSidePublishEngine {
         if (Object.hasOwn(this.subscriptionMap, subscriptionId)) {
             delete this.subscriptionMap[subscriptionId];
         } else {
-            debugLog("ClientSidePublishEngine#unregisterSubscription cannot find subscription  ", subscriptionId);
+            // c8 ignore next
+            doDebug && debugLog("ClientSidePublishEngine#unregisterSubscription cannot find subscription  ", subscriptionId);
         }
     }
 
@@ -201,22 +207,26 @@ export class ClientSidePublishEngine {
      * get the client subscription from Id
      */
     public getSubscription(subscriptionId: SubscriptionId): ClientSubscription {
-        assert(isFinite(subscriptionId) && subscriptionId > 0);
+        assert(Number.isFinite(subscriptionId) && subscriptionId > 0);
         assert(Object.hasOwn(this.subscriptionMap, subscriptionId));
         return this.subscriptionMap[subscriptionId];
     }
 
     public hasSubscription(subscriptionId: SubscriptionId): boolean {
-        assert(isFinite(subscriptionId) && subscriptionId > 0);
+        assert(Number.isFinite(subscriptionId) && subscriptionId > 0);
         return Object.hasOwn(this.subscriptionMap, subscriptionId);
     }
 
     public internalSendPublishRequest(): void {
         assert(this.session, "ClientSidePublishEngine terminated ?");
+        if (!this.session) {
+            throw new Error("ClientSidePublishEngine terminated ?");
+        }
 
         this.nbPendingPublishRequests += 1;
 
-        debugLog(chalk.yellow("sending publish request "), this.nbPendingPublishRequests);
+        // c8 ignore next
+        doDebug && debugLog(chalk.yellow("sending publish request "), this.nbPendingPublishRequests);
 
         const subscriptionAcknowledgements = this.subscriptionAcknowledgements;
         this.subscriptionAcknowledgements = [];
@@ -260,22 +270,38 @@ export class ClientSidePublishEngine {
 
         let active = true;
 
-        const session = this.session! as ClientSessionImpl;
+        const session = this.session as ClientSessionImpl;
         session.publish(publishRequest, (err: Error | null, response?: PublishResponse) => {
             this.nbPendingPublishRequests -= 1;
 
-            this.lastRequestSentTime = new Date();
+            // despite its name, this timestamp records the *answer*, not the send: it is what
+            // ClientSubscriptionImpl.evaluateRemainingLifetime() uses to estimate when the server
+            // will drop the subscription. A publish that failed on a timeout or a broken channel
+            // says nothing about the server and must not move it, or the subscription would look
+            // healthy for the whole outage. A ServiceFault does count - the server answered.
+            // Same rule as ClientSessionImpl.lastResponseReceivedTime (see #1569).
+            if (response || (err as ServiceFaultAnnotatedError)?.response) {
+                this.lastRequestSentTime = new Date();
+            }
 
             if (err) {
-                debugLog(
-                    chalk.cyan("ClientSidePublishEngine.prototype.internalSendPublishRequest callback : "),
-                    chalk.yellow(err.message)
-                );
-                debugLog("'" + err.message + "'");
+                // c8 ignore next
+                if (doDebug) {
+                    debugLog(
+                        chalk.cyan("ClientSidePublishEngine.prototype.internalSendPublishRequest callback : "),
+                        chalk.yellow(err.message)
+                    );
+                    debugLog(`'${err.message}'`);
+                }
 
                 if (err.message.match("not connected")) {
-                    debugLog(chalk.bgWhite.red(" WARNING :  CLIENT IS NOT CONNECTED :" + " MAY BE RECONNECTION IS IN PROGRESS"));
-                    debugLog("this.activeSubscriptionCount =", this.activeSubscriptionCount);
+                    // c8 ignore next
+                    if (doDebug) {
+                        debugLog(
+                            chalk.bgWhite.red(" WARNING :  CLIENT IS NOT CONNECTED :" + " MAY BE RECONNECTION IS IN PROGRESS")
+                        );
+                        debugLog("this.activeSubscriptionCount =", this.activeSubscriptionCount);
+                    }
                     // the previous publish request has ended up with an error because
                     // the connection has failed ...
                     // There is no need to send more publish request for the time being until reconnection is completed
@@ -287,8 +313,11 @@ export class ClientSidePublishEngine {
                     // the server tells us that there is no subscription for this session
                     // but the client have some active subscription left.
                     // This could happen if the client has missed or not received the StatusChange Notification
-                    debugLog(chalk.bgWhite.red(" WARNING: server tells that there is no Subscription, but client disagree"));
-                    debugLog("this.activeSubscriptionCount =", this.activeSubscriptionCount);
+                    // c8 ignore next
+                    if (doDebug) {
+                        debugLog(chalk.bgWhite.red(" WARNING: server tells that there is no Subscription, but client disagree"));
+                        debugLog("this.activeSubscriptionCount =", this.activeSubscriptionCount);
+                    }
                     active = false;
                 }
 
@@ -298,10 +327,13 @@ export class ClientSidePublishEngine {
                     // may be the session timeout is shorted than the subscription life time
                     // and the client does not send intermediate keepAlive request to keep the connection working.
                     //
-                    debugLog(chalk.bgWhite.red(" WARNING : Server tells that the session has closed ..."));
-                    debugLog(
-                        "   the ClientSidePublishEngine shall now be disabled," + " as server will reject any further request"
-                    );
+                    // c8 ignore next
+                    if (doDebug) {
+                        debugLog(chalk.bgWhite.red(" WARNING : Server tells that the session has closed ..."));
+                        debugLog(
+                            "   the ClientSidePublishEngine shall now be disabled," + " as server will reject any further request"
+                        );
+                    }
                     // close all active subscription....
                     active = false;
                 }
@@ -332,24 +364,26 @@ export class ClientSidePublishEngine {
                     // completed the session transfer. We should pause and let the
                     // reconnection flow replenish publish requests once the session
                     // transfer completes.
-                    debugLog(
-                        chalk.bgWhite.yellow(
-                            " WARNING: BadSecureChannelIdInvalid on PublishRequest" + " - session transfer may be in progress"
-                        )
-                    );
+                    // c8 ignore next
+                    doDebug &&
+                        debugLog(
+                            chalk.bgWhite.yellow(
+                                " WARNING: BadSecureChannelIdInvalid on PublishRequest" + " - session transfer may be in progress"
+                            )
+                        );
                     active = false;
                 }
-            } else {
+            } else if (response) {
                 // c8 ignore next
                 if (doDebug) {
                     debugLog(chalk.cyan("ClientSidePublishEngine.prototype.internalSendPublishRequest callback "));
                 }
-                this._receive_publish_response(response!);
+                this._receive_publish_response(response);
             }
 
             // feed the server with a new publish Request to the server
             if (!this.isSuspended && active && this.activeSubscriptionCount > 0) {
-                if (err && err.message.match(/Connection Break/)) {
+                if (err?.message.match(/Connection Break/)) {
                     // do not renew when connection is broken
                 } else {
                     this.send_publish_request();
@@ -359,7 +393,8 @@ export class ClientSidePublishEngine {
     }
 
     private _receive_publish_response(response: PublishResponse) {
-        debugLog(chalk.yellow("receive publish response"));
+        // c8 ignore next
+        doDebug && debugLog(chalk.yellow("receive publish response"));
 
         // the id of the subscription sending the notification message
         const subscriptionId = response.subscriptionId;
@@ -401,9 +436,12 @@ export class ClientSidePublishEngine {
                 }
             }
         } else {
-            debugLog(" ignoring notificationMessage", notificationMessage, " for subscription", subscriptionId);
-            debugLog(" because there is no subscription.");
-            debugLog(" or because there is no session for the subscription (session terminated ?).");
+            // c8 ignore next
+            if (doDebug) {
+                debugLog(" ignoring notificationMessage", notificationMessage, " for subscription", subscriptionId);
+                debugLog(" because there is no subscription.");
+                debugLog(" or because there is no session for the subscription (session terminated ?).");
+            }
         }
     }
 }