node-opcua-client 2.166.0 → 2.168.0

package/source/private/reconnection/client_publish_engine_reconnection.ts

@@ -1,31 +1,23 @@
-import { types } from "util";
-import async from "async";
 import chalk from "chalk";
 import assert from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 import { StatusCodes } from "node-opcua-status-code";
-import { RepublishRequest, RepublishResponse } from "node-opcua-types";
-import { SubscriptionId } from "../../client_session";
-import { ClientSessionImpl } from "../client_session_impl";
-import { ClientSubscriptionImpl } from "../client_subscription_impl";
-import { ClientSidePublishEngine } from "../client_publish_engine";
+import { RepublishRequest, type RepublishResponse } from "node-opcua-types";
+import type { ClientSidePublishEngine } from "../client_publish_engine";
+import type { ClientSessionImpl } from "../client_session_impl";
+import type { ClientSubscriptionImpl } from "../client_subscription_impl";
 import { recreateSubscriptionAndMonitoredItem } from "./client_subscription_reconnection";
 import { _shouldNotContinue2 } from "./reconnection";
 
 const debugLog = make_debugLog("RECONNECTION");
 const doDebug = checkDebugFlag("RECONNECTION");
 
-function _republish(
-    engine: ClientSidePublishEngine,
-    subscription: ClientSubscriptionImpl,
-    callback: (err?: Error) => void
-) {
-
-    let isDone = false;
-    const session = engine.session as ClientSessionImpl;
-
-    const sendRepublishFunc = (callback2: (err?: Error) => void) => {
-        assert(isFinite(subscription.lastSequenceNumber) && subscription.lastSequenceNumber + 1 >= 0);
+function _sendRepublish(
+    session: ClientSessionImpl,
+    subscription: ClientSubscriptionImpl
+): Promise<{ isDone: boolean }> {
+    return new Promise<{ isDone: boolean }>((resolve, reject) => {
+        assert(Number.isFinite(subscription.lastSequenceNumber) && subscription.lastSequenceNumber + 1 >= 0);
 
         const request = new RepublishRequest({
             retransmitSequenceNumber: subscription.lastSequenceNumber + 1,
@@ -43,64 +35,76 @@ function _republish(
             );
         }
 
-        if (!session || session!._closeEventHasBeenEmitted) {
+        if (!session || session._closeEventHasBeenEmitted) {
             debugLog("ClientPublishEngine#_republish aborted ");
-            // has  client been disconnected in the mean time ?
-            isDone = true;
-            return callback2();
+            return resolve({ isDone: true });
         }
+
         session.republish(request, (err: Error | null, response?: RepublishResponse) => {
-            const statusCode = err ? StatusCodes.Bad : response!.responseHeader.serviceResult;
+            if (!response) {
+                reject(err);
+                return;
+            }
+            const statusCode = err ? StatusCodes.Bad : response.responseHeader.serviceResult;
             if (!err && (statusCode.equals(StatusCodes.Good) || statusCode.equals(StatusCodes.BadMessageNotAvailable))) {
-                // reprocess notification message  and keep going
+                // reprocess notification message and keep going
                 if (statusCode.equals(StatusCodes.Good)) {
-                    subscription.onNotificationMessage(response!.notificationMessage);
-                }
-            } else {
-                if (!err) {
-                    err = new Error(response!.responseHeader.serviceResult.toString());
+                    subscription.onNotificationMessage(response.notificationMessage);
                 }
-                debugLog(" _send_republish ends with ", err.message);
-                isDone = true;
+                return resolve({ isDone: false });
+            }
+            if (!err) {
+                err = new Error(response.responseHeader.serviceResult.toString());
             }
-            callback2(err ? err : undefined);
+            debugLog(" _send_republish ends with ", err.message);
+            reject(err);
         });
-    };
+    });
+}
 
-    const sendRepublishUntilDone = () => {
-        async.whilst(
-            (cb: (err: null, truth: boolean) => void) => cb(null, !isDone),
-            sendRepublishFunc,
-            ((err?: Error | null): void => {
-                debugLog("nbPendingPublishRequest = ", engine.nbPendingPublishRequests);
-                debugLog(" _republish ends with ", err ? err.message : "null");
-                callback(err!);
-            }) as any // Wait for @type/async bug to be fixed !
-        );
-    };
+async function _republish(
+    engine: ClientSidePublishEngine,
+    subscription: ClientSubscriptionImpl
+): Promise<void> {
+    const session = engine.session as ClientSessionImpl;
 
-    setImmediate(sendRepublishUntilDone);
+    // loop until done (all messages re-published or error)
+    let isDone = false;
+    while (!isDone) {
+        // yield to event loop before each iteration
+        await new Promise<void>((resolve) => setImmediate(resolve));
+        const result = await _sendRepublish(session, subscription);
+        isDone = result.isDone;
+    }
+
+    debugLog("nbPendingPublishRequest = ", engine.nbPendingPublishRequests);
+    debugLog(" _republish ends with ", "null");
 }
 
-function __askSubscriptionRepublish(
+async function __askSubscriptionRepublish(
     engine: ClientSidePublishEngine,
-    subscription: ClientSubscriptionImpl,
-    callback: (err?: Error) => void
-) {
-
-    _republish(engine, subscription, (err?: Error) => {
+    subscription: ClientSubscriptionImpl
+): Promise<void> {
+    try {
+        await _republish(engine, subscription);
+    } catch (err) {
         // prettier-ignore
-        { const _err = _shouldNotContinue2(subscription); if (_err) { return callback(_err); } }
+        {
+            const _err = _shouldNotContinue2(subscription);
+            if (_err) {
+                throw _err;
+            }
+        }
 
-        assert(!err || types.isNativeError(err));
+        const error = err as Error;
 
-        debugLog("__askSubscriptionRepublish--------------------- err =", err ? err.message : null);
+        debugLog("__askSubscriptionRepublish--------------------- err =", error.message);
 
-        if (err && err.message.match(/BadSessionInvalid/)) {
+        if (error.message.match(/BadSessionInvalid/)) {
             // _republish failed because session is not valid anymore on server side.
-            return callback(err);
+            throw error;
         }
-        if (err && err.message.match(/SubscriptionIdInvalid/)) {
+        if (error.message.match(/SubscriptionIdInvalid/)) {
             // _republish failed because subscriptionId is not valid anymore on server side.
             //
             // This could happen when the subscription has timed out and has been deleted by server
@@ -113,13 +117,18 @@ function __askSubscriptionRepublish(
             debugLog(
                 chalk.bgWhite.red("__askSubscriptionRepublish failed " + " subscriptionId is not valid anymore on server side.")
             );
-            return recreateSubscriptionAndMonitoredItem(subscription).then(() => callback()).catch(err => callback(err));
+            await recreateSubscriptionAndMonitoredItem(subscription);
+            return;
         }
-        if (err && err.message.match(/|MessageNotAvailable/)) {
+        if (error.message.match(/|MessageNotAvailable/)) {
             // start engine and start monitoring
         }
-        callback();
-    });
+    }
+    // check after successful republish too
+    const _err = _shouldNotContinue2(subscription);
+    if (_err) {
+        throw _err;
+    }
 }
 
 export function republish(engine: ClientSidePublishEngine, callback: () => void): void {
@@ -134,13 +143,12 @@ export function republish(engine: ClientSidePublishEngine, callback: () => void)
      * call Republish continuously until all Notification messages of
      * un-acknowledged notifications are reprocessed.
      */
-    const askSubscriptionRepublish = (
-        subscription: ClientSubscriptionImpl,
-        subscriptionId: SubscriptionId | string,
-        innerCallback: () => void
-    ) => {
-        __askSubscriptionRepublish(engine, subscription, innerCallback);
+    const processAll = async () => {
+        const entries = Object.entries(engine.subscriptionMap);
+        for (const [_subscriptionId, subscription] of entries) {
+            await __askSubscriptionRepublish(engine, subscription as ClientSubscriptionImpl);
+        }
     };
 
-    async.forEachOf(engine.subscriptionMap, askSubscriptionRepublish, callback);
+    processAll().then(() => callback()).catch(() => callback());
 }

package/source/private/reconnection/client_reconnection.ts

@@ -1,4 +1,4 @@
-import { ClientBaseImpl } from "../client_base_impl";
+import type { ClientBaseImpl } from "../client_base_impl";
 
 export function waitUntilReconnectionIsCanceled(client: ClientBaseImpl, callback: () => void) {
     const interval = 100;

package/source/private/reconnection/client_subscription_reconnection.ts

@@ -1,18 +1,21 @@
 import { promisify } from "node:util";
 import assert from "node-opcua-assert";
 import { TimestampsToReturn } from "node-opcua-data-value";
-import { make_debugLog, checkDebugFlag, make_warningLog } from "node-opcua-debug";
-import { MonitoredItemCreateRequestOptions, CreateMonitoredItemsRequest, CreateMonitoredItemsResponse } from "node-opcua-types";
-
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 import {
-    IBasicSessionReadAsync,
-    IBasicSessionWithSubscription,
     createMonitoredItemsLimit,
+    type IBasicSessionReadAsync,
+    type IBasicSessionWithSubscription,
     readOperationLimits
 } from "node-opcua-pseudo-session";
-import { ClientSubscription } from "../../client_subscription";
-import { ClientMonitoredItemImpl } from "../client_monitored_item_impl";
-import { ClientSubscriptionImpl, TERMINATED_SUBSCRIPTION_ID, __create_subscription } from "../client_subscription_impl";
+import {
+    CreateMonitoredItemsRequest,
+    type CreateMonitoredItemsResponse,
+    type MonitoredItemCreateRequestOptions
+} from "node-opcua-types";
+import type { ClientSubscription } from "../../client_subscription";
+import type { ClientMonitoredItemImpl } from "../client_monitored_item_impl";
+import { __create_subscription, type ClientSubscriptionImpl, TERMINATED_SUBSCRIPTION_ID } from "../client_subscription_impl";
 import { _shouldNotContinue } from "./reconnection";
 
 const debugLog = make_debugLog("RECONNECTION");
@@ -33,7 +36,7 @@ async function createMonitoredItemsAndRespectOperationalLimits(
 }
 
 async function adjustMonitoredItemNodeIds(subscription: ClientSubscription, oldMonitoredItems: any) {
-    // to Do 
+    // to Do
 }
 /**
  *  utility function to recreate new subscription
@@ -56,7 +59,9 @@ export async function recreateSubscriptionAndMonitoredItem(_subscription: Client
     await promisify(__create_subscription)(subscription);
 
     const _err = _shouldNotContinue(subscription.session);
-    if (_err) { throw _err; }
+    if (_err) {
+        throw _err;
+    }
 
     const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
 
@@ -89,9 +94,7 @@ export async function recreateSubscriptionAndMonitoredItem(_subscription: Client
 
     debugLog("Recreating ", itemsToCreate.length, " monitored items");
 
-    const response = await createMonitoredItemsAndRespectOperationalLimits(
-        session,
-        createMonitorItemsRequest);
+    const response = await createMonitoredItemsAndRespectOperationalLimits(session, createMonitorItemsRequest);
     const monitoredItemResults = response.results || [];
 
     let _errCount = 0;