node-opcua-client 2.122.0 → 2.124.0

package/source/private/reconnection/client_subscription_reconnection.ts

@@ -0,0 +1,147 @@
+import async from "async";
+import assert from "node-opcua-assert";
+import { TimestampsToReturn } from "node-opcua-data-value";
+import { make_debugLog, checkDebugFlag } from "node-opcua-debug";
+import { warningLog } from "node-opcua-pki";
+import { MonitoredItemCreateRequestOptions, CreateMonitoredItemsRequest, CreateMonitoredItemsResponse } from "node-opcua-types";
+import { ErrorCallback } from "node-opcua-status-code";
+
+import {
+    IBasicSessionReadAsync,
+    IBasicSessionWithSubscription,
+    createMonitoredItemsLimit,
+    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 { _shouldNotContinue } from "./reconnection";
+
+const debugLog = make_debugLog("RECONNECTION");
+const doDebug = checkDebugFlag("RECONNECTION");
+
+function createMonitoredItemsAndRespectOperationalLimits(
+    session: IBasicSessionReadAsync & IBasicSessionWithSubscription,
+    createMonitorItemsRequest: CreateMonitoredItemsRequest,
+    callback: (err: Error | null, response?: CreateMonitoredItemsResponse) => void
+) {
+    readOperationLimits(session)
+        .then((operationalLimits) => {
+            createMonitoredItemsLimit(operationalLimits.maxMonitoredItemsPerCall || 0, session, createMonitorItemsRequest)
+                .then((createMonitoredItemResponse) => callback(null, createMonitoredItemResponse))
+                .catch(callback);
+        })
+        .catch(callback);
+}
+
+/**
+ *  utility function to recreate new subscription
+ *  @method recreateSubscriptionAndMonitoredItem
+ */
+export function recreateSubscriptionAndMonitoredItem(_subscription: ClientSubscription, callback: ErrorCallback): void {
+    debugLog("recreateSubscriptionAndMonitoredItem", _subscription.subscriptionId.toString());
+
+    const subscription = _subscription as ClientSubscriptionImpl;
+    if (subscription.subscriptionId === TERMINATED_SUBSCRIPTION_ID) {
+        debugLog("Subscription is not in a valid state");
+        return callback();
+    }
+
+    const oldMonitoredItems = subscription.monitoredItems;
+    const oldSubscriptionId = subscription.subscriptionId;
+
+
+    
+    subscription.publishEngine.unregisterSubscription(oldSubscriptionId);
+
+    async.series(
+        [
+            (innerCallback: ErrorCallback) => {
+                __create_subscription(subscription, innerCallback);
+            },
+            (innerCallback: ErrorCallback) => {
+                // prettier-ignore
+                { const _err = _shouldNotContinue(subscription.session); if (_err) { return innerCallback(_err); } }
+
+                const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
+
+                debugLog("recreating ", Object.keys(oldMonitoredItems).length, " monitored Items");
+                // re-create monitored items
+                const itemsToCreate: MonitoredItemCreateRequestOptions[] = [];
+
+                for (const monitoredItem of Object.values(oldMonitoredItems)) {
+                    assert(monitoredItem.monitoringParameters.clientHandle > 0);
+                    itemsToCreate.push({
+                        itemToMonitor: monitoredItem.itemToMonitor,
+                        monitoringMode: monitoredItem.monitoringMode,
+                        requestedParameters: monitoredItem.monitoringParameters
+                    });
+                }
+
+                const createMonitorItemsRequest = new CreateMonitoredItemsRequest({
+                    itemsToCreate,
+                    subscriptionId: subscription.subscriptionId,
+                    timestampsToReturn: TimestampsToReturn.Both // this.timestampsToReturn,
+                });
+
+                const session = subscription.session;
+                // istanbul ignore next
+                if (!session) {
+                    return innerCallback(new Error("no session"));
+                }
+
+                debugLog("Recreating ", itemsToCreate.length, " monitored items");
+
+                createMonitoredItemsAndRespectOperationalLimits(
+                    session,
+                    createMonitorItemsRequest,
+                    (err: Error | null, response?: CreateMonitoredItemsResponse) => {
+                        if (err) {
+                            debugLog("Recreating monitored item has failed with ", err.message);
+                            return innerCallback(err);
+                        }
+                        /* istanbul ignore next */
+                        if (!response) {
+                            return innerCallback(new Error("Internal Error"));
+                        }
+                        const monitoredItemResults = response.results || [];
+
+                        let _errCount = 0;
+                        monitoredItemResults.forEach((monitoredItemResult, index) => {
+                            const itemToCreate = itemsToCreate[index];
+                            /* istanbul ignore next */
+                            if (!itemToCreate || !itemToCreate.requestedParameters) {
+                                _errCount++;
+                                return;
+                            }
+                            const clientHandle = itemToCreate.requestedParameters.clientHandle;
+                            /* istanbul ignore next */
+                            if (!clientHandle) {
+                                _errCount++;
+                                return;
+                            }
+                            const monitoredItem = subscription.monitoredItems[clientHandle] as ClientMonitoredItemImpl;
+                            if (monitoredItem) {
+                                monitoredItem._applyResult(monitoredItemResult);
+                            } else {
+                                _errCount++;
+                                warningLog("cannot find monitored item for clientHandle !:", clientHandle);
+                                warningLog("itemsToCreate = ", itemsToCreate[index].toString());
+                            }
+                        });
+                        if (_errCount > 0) {
+                            warningLog("Warning: some monitored items have not been recreated properly");
+                        }
+                        innerCallback();
+                    }
+                );
+            }
+        ],
+        (err) => {
+            if (err) {
+                warningLog("!!recreateSubscriptionAndMonitoredItem has failed", err.message);
+            }
+            callback(err!);
+        }
+    );
+}

package/source/{reconnection.ts → private/reconnection/reconnection.ts}

@@ -3,7 +3,7 @@
  */
 
 // tslint:disable:only-arrow-functions
-import * as async from "async";
+import async from "async";
 import chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
@@ -13,16 +13,37 @@ import { ErrorCallback } from "node-opcua-status-code";
 import { CloseSessionRequest } from "node-opcua-types";
 import { invalidateExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
 
-import { SubscriptionId } from "./client_session";
-import { ClientSessionImpl, Reconnectable } from "./private/client_session_impl";
-import { ClientSubscriptionImpl } from "./private/client_subscription_impl";
-import { IClientBase } from "./private/i_private_client";
+import { SubscriptionId } from "../../client_session";
+import { ClientSessionImpl, Reconnectable } from "../client_session_impl";
+import { ClientSubscriptionImpl } from "../client_subscription_impl";
+import { IClientBase } from "../i_private_client";
+import { republish } from "./client_publish_engine_reconnection";
+import { recreateSubscriptionAndMonitoredItem } from "./client_subscription_reconnection";
 
 const debugLog = make_debugLog("RECONNECTION");
 const doDebug = checkDebugFlag("RECONNECTION");
 const errorLog = make_errorLog("RECONNECTION");
 const warningLog = make_warningLog("RECONNECTION");
 
+function _shouldNotContinue3(client: IClientBase) {
+    if (!client._secureChannel) {
+        return new Error("Failure during reconnection : client or session is not usable anymore");
+    }
+    return null;
+}
+
+export function _shouldNotContinue(session: ClientSessionImpl) {
+    if (!session._client || session.hasBeenClosed() || !session._client._secureChannel || session._client.isUnusable()) {
+        return new Error("Failure during reconnection : client or session is not usable anymore");
+    }
+    return null;
+}
+export function _shouldNotContinue2(subscription: ClientSubscriptionImpl) {
+    if (!subscription.hasSession) {
+        return new Error("Failure during reconnection : client or session is not usable anymore");
+    }
+    return _shouldNotContinue(subscription.session);
+}
 //
 // a new secure channel has be created, we need to reactivate the corresponding session,
 // and reestablish the subscription and restart the publish engine.
@@ -109,29 +130,26 @@ const warningLog = make_warningLog("RECONNECTION");
 //  +-------------------------------+
 
 function _ask_for_subscription_republish(session: ClientSessionImpl, callback: (err?: Error) => void) {
-    if (session.hasBeenClosed()) {
-        doDebug && debugLog("_ask_for_subscription_republish :  session is closed");
-        return callback(new Error("askForSubscriptionRepublish => canceled because session is closed"));
-    }
+    // prettier-ignore
+    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
 
     doDebug && debugLog(chalk.bgCyan.yellow.bold("_ask_for_subscription_republish "));
     // assert(session.getPublishEngine().nbPendingPublishRequests === 0,
     //   "at this time, publish request queue shall still be empty");
 
-    session.getPublishEngine().republish((err?: Error) => {
+    const engine = session.getPublishEngine();
+    republish(engine, (err?: Error) => {
         doDebug && debugLog("_ask_for_subscription_republish :  republish sent");
-        if (session.hasBeenClosed()) {
-            return callback(new Error("Cannot complete subscription republish due to session termination"));
-        }
+        // prettier-ignore
+        { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+
         doDebug && debugLog(chalk.bgCyan.green.bold("_ask_for_subscription_republish done "), err ? err.message : "OK");
         if (err) {
             warningLog("republish has failed with error :", err.message);
-
             doDebug && debugLog("_ask_for_subscription_republish has :  recreating subscription");
             return repair_client_session_by_recreating_a_new_session(session._client!, session, callback);
         }
-        // xx assert(session.getPublishEngine().nbPendingPublishRequests === 0);
-        session.resumePublishEngine();
+
         callback(err);
     });
 }
@@ -141,18 +159,16 @@ function create_session_and_repeat_if_failed(
     session: ClientSessionImpl,
     callback: CallbackT<ClientSessionImpl>
 ) {
-    if (session.hasBeenClosed()) {
-        doDebug && debugLog("Cannot complete subscription republish due to session termination");
-        return callback(new Error("Cannot complete subscription republish due to session termination"));
-    }
+    // prettier-ignore
+    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+
     doDebug && debugLog(chalk.bgWhite.red("    => creating a new session ...."));
     // create new session, based on old session,
     // so we can reuse subscriptions data
     client.__createSession_step2(session, (err: Error | null, session1?: ClientSessionImpl) => {
-        if (err && session.hasBeenClosed()) {
-            doDebug && debugLog("Cannot complete subscription republish due to session termination");
-            return callback(new Error("Cannot complete subscription republish due to session termination"));
-        }
+        // prettier-ignore
+        { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+
         if (!err && session1) {
             assert(session === session1, "session should have been recycled");
             callback(err, session);
@@ -169,9 +185,9 @@ function repair_client_session_by_recreating_a_new_session(
     session: ClientSessionImpl,
     callback: (err?: Error) => void
 ) {
-    if (session._client && session._client.isUnusable()) {
-        return callback(new Error("Client is unusable"));
-    }
+    // prettier-ignore
+    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+
     // As we don"t know if server has been rebooted or not,
     // and may be upgraded in between, we have to invalidate the extra data type manager
     invalidateExtraDataTypeManager(session);
@@ -181,13 +197,6 @@ function repair_client_session_by_recreating_a_new_session(
         debugLog(" repairing client session by_recreating a new session for old session ", session.sessionId.toString());
     }
 
-    //  TO DO : it is possible that session is already closed while we get there
-    if (session.hasBeenClosed()) {
-        // istanbul ignore next
-        doDebug && debugLog(chalk.bgWhite.red("Aborting reactivation of old session because user requested session to be closed"));
-        return callback(new Error("reconnection cancelled due to session termination"));
-    }
-
     let newSession: ClientSessionImpl;
 
     const listenerCountBefore = session.listenerCount("");
@@ -196,27 +205,40 @@ function repair_client_session_by_recreating_a_new_session(
         async.forEach(
             subscriptionsToRecreate,
             (subscriptionId: SubscriptionId, next: ErrorCallback) => {
+                // prettier-ignore
+                { const err = _shouldNotContinue(session); if (err) { return next(err); } }
+
                 if (!session.getPublishEngine().hasSubscription(subscriptionId)) {
                     doDebug && debugLog(chalk.red("          => CANNOT RECREATE SUBSCRIPTION  "), subscriptionId);
                     return next();
                 }
                 const subscription = session.getPublishEngine().getSubscription(subscriptionId);
-                assert(subscription.constructor.name === "ClientSubscriptionImpl");
                 doDebug && debugLog(chalk.red("          => RECREATING SUBSCRIPTION  "), subscriptionId);
-                assert(subscription.session === newSession, "must have the session");
+                assert(subscription.session === newSession, "must have the new session");
+
+                recreateSubscriptionAndMonitoredItem(subscription, (err1?: Error) => {
+                    // prettier-ignore
+                    { const err = _shouldNotContinue(session); if (err) { return next(err); } }
 
-                (subscription as ClientSubscriptionImpl).recreateSubscriptionAndMonitoredItem((err1?: Error) => {
                     if (err1) {
                         doDebug && debugLog("_recreateSubscription failed !" + err1.message);
                     }
 
                     doDebug &&
-                        debugLog(chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE "), subscriptionId);
+                        debugLog(
+                            chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE subscriptionId="),
+                            subscriptionId
+                        );
 
                     next();
                 });
             },
             (err1?: Error | null) => {
+                // prettier-ignore
+                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                if (!err1) {
+                    // prettier-ignore
+                }
                 innerCallback(err1!);
             }
         );
@@ -225,9 +247,9 @@ function repair_client_session_by_recreating_a_new_session(
     async.series(
         [
             function suspend_old_session_publish_engine(innerCallback: ErrorCallback) {
-                if (session.hasBeenClosed()) {
-                    return innerCallback(new Error("Cannot complete subscription republish due to session termination"));
-                }
+                // prettier-ignore
+                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+
                 // istanbul ignore next
                 doDebug && debugLog(chalk.bgWhite.red("    => suspend old session publish engine...."));
                 session.getPublishEngine().suspend(true);
@@ -236,6 +258,9 @@ function repair_client_session_by_recreating_a_new_session(
 
             function create_new_session(innerCallback: ErrorCallback) {
                 create_session_and_repeat_if_failed(client, session, (err?: Error | null, _newSession?: ClientSessionImpl) => {
+                    // prettier-ignore
+                    { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+
                     if (_newSession) {
                         newSession = _newSession;
                     }
@@ -244,9 +269,9 @@ function repair_client_session_by_recreating_a_new_session(
             },
 
             function activate_new_session(innerCallback: ErrorCallback) {
-                if (session.hasBeenClosed()) {
-                    return innerCallback(new Error("Cannot complete subscription republish due to session termination"));
-                }
+                // prettier-ignore
+                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+
                 doDebug && debugLog(chalk.bgWhite.red("    => activating a new session ...."));
 
                 client._activateSession(
@@ -285,9 +310,9 @@ function repair_client_session_by_recreating_a_new_session(
             },
 
             function attempt_subscription_transfer(innerCallback: ErrorCallback) {
-                if (session.hasBeenClosed()) {
-                    return innerCallback(new Error("Cannot complete subscription republish due to session termination"));
-                }
+                // prettier-ignore
+                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+
                 // get the old subscriptions id from the old session
                 const subscriptionsIds = session.getPublishEngine().getSubscriptionIds();
 
@@ -310,8 +335,11 @@ function repair_client_session_by_recreating_a_new_session(
                 newSession.transferSubscriptions(
                     subscriptionsToTransfer,
                     (err: Error | null, transferSubscriptionsResponse?: TransferSubscriptionsResponse) => {
+                        // may be the connection with server has been disconnected
+                        // prettier-ignore
+                        { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+
                         if (err || !transferSubscriptionsResponse) {
-                            warningLog(chalk.bgCyan("Warning TransferSubscription has failed " + err?.message));
                             warningLog(chalk.bgCyan("May be the server is not supporting this feature"));
                             // when transfer subscription has failed, we have no other choice but
                             // recreate the subscriptions on the server side
@@ -367,9 +395,9 @@ function repair_client_session_by_recreating_a_new_session(
             },
 
             function ask_for_subscription_republish(innerCallback: ErrorCallback) {
-                if (session.hasBeenClosed()) {
-                    return innerCallback(new Error("Cannot complete subscription republish due to session termination"));
-                }
+                // prettier-ignore
+                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+
                 //  assert(newSession.getPublishEngine().nbPendingPublishRequests === 0, "we should not be publishing here");
                 //      call Republish
                 return _ask_for_subscription_republish(newSession, (err) => {
@@ -381,10 +409,11 @@ function repair_client_session_by_recreating_a_new_session(
             },
 
             function start_publishing_as_normal(innerCallback: ErrorCallback) {
-                if (session.hasBeenClosed()) {
-                    return innerCallback(new Error("Cannot complete subscription republish due to session termination"));
-                }
+                // prettier-ignore
+                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+
                 newSession.getPublishEngine().suspend(false);
+
                 const listenerCountAfter = session.listenerCount("");
                 assert(newSession === session);
                 doDebug && debugLog("listenerCountBefore =", listenerCountBefore, "listenerCountAfter = ", listenerCountAfter);
@@ -404,6 +433,8 @@ function _repair_client_session(client: IClientBase, session: ClientSessionImpl,
             debugLog("Session repair completed with err: ", err2 ? err2.message : "<no error>", session.sessionId.toString());
         if (!err2) {
             session.emit("session_repaired");
+        } else {
+            session.emit("session_repaired_failed", err2);
         }
         callback(err2);
     };
@@ -412,7 +443,13 @@ function _repair_client_session(client: IClientBase, session: ClientSessionImpl,
         doDebug && debugLog(chalk.yellow("  TRYING TO REACTIVATE EXISTING SESSION"), session.sessionId.toString());
         doDebug && debugLog("   SubscriptionIds :", session.getPublishEngine().getSubscriptionIds());
     }
+
+    // prettier-ignore
+    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+
     client._activateSession(session, session.userIdentityInfo!, (err: Error | null, session2?: ClientSessionImpl) => {
+        // prettier-ignore
+        { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
         //
         // Note: current limitation :
         //  - The reconnection doesn't work yet, if connection break is caused by a server that crashes and restarts.
@@ -435,14 +472,18 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
         doDebug && debugLog("Aborting reactivation of old session because user requested session to be close");
         return callback();
     }
-
     doDebug && debugLog(chalk.yellow("Starting client session repair"));
 
     const privateSession = session as any as Reconnectable;
     privateSession._reconnecting = privateSession._reconnecting || { reconnecting: false, pendingCallbacks: [] };
 
+    if (session.hasBeenClosed()) {
+        privateSession._reconnecting.reconnecting = false;
+        doDebug && debugLog("Aborting reactivation of old session because session has been closed");
+        return callback();
+    }
     if (privateSession._reconnecting.reconnecting) {
-        doDebug && debugLog(chalk.bgCyan("Reconnecting already happening for session"), session.sessionId.toString());
+        doDebug && debugLog(chalk.bgCyan("Reconnection is already happening for session"), session.sessionId.toString());
         privateSession._reconnecting.pendingCallbacks.push(callback);
         return;
     }
@@ -453,7 +494,13 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
     const transactionQueue = privateSession.pendingTransactions ? privateSession.pendingTransactions.splice(0) : [];
 
     const repeatedAction = (callback: EmptyCallback) => {
+        // prettier-ignore
+        {   const err = _shouldNotContinue(session);   if (err) { return callback(err); }}
+
         _repair_client_session(client, session, (err) => {
+            // prettier-ignore
+            { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+
             if (err) {
                 errorLog(
                     chalk.red("session restoration has failed! err ="),
@@ -471,32 +518,30 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
                     return;
                 } else {
                     errorLog(chalk.red("session restoration should be interrupted because session has been closed forcefully"));
-                    // session does not need to be repaired anymore
-                    callback();
                 }
+                // session does not need to be repaired anymore
+                callback();
                 return;
             }
 
-            privateSession._reconnecting.reconnecting = false;
-
             // istanbul ignore next
             doDebug && debugLog(chalk.yellow("session has been restored"), session.sessionId.toString());
-
             session.emit("session_restored");
-            const otherCallbacks = privateSession._reconnecting.pendingCallbacks;
-            privateSession._reconnecting.pendingCallbacks = [];
-
-            // re-inject element in queue
-
-            // istanbul ignore next
-            doDebug && debugLog(chalk.yellow("re-injecting transaction queue"), transactionQueue.length);
-
-            transactionQueue.forEach((e: any) => privateSession.pendingTransactions.push(e));
-            otherCallbacks.forEach((c: EmptyCallback) => c(err));
             callback(err);
         });
     };
-    repeatedAction(callback);
+    repeatedAction((err) => {
+        privateSession._reconnecting.reconnecting = false;
+
+        const otherCallbacks = privateSession._reconnecting.pendingCallbacks;
+        privateSession._reconnecting.pendingCallbacks = [];
+        // re-inject element in queue
+        // istanbul ignore next
+        doDebug && debugLog(chalk.yellow("re-injecting transaction queue"), transactionQueue.length);
+        transactionQueue.forEach((e: any) => privateSession.pendingTransactions.push(e));
+        otherCallbacks.forEach((c: EmptyCallback) => c(err));
+        callback(err);
+    });
 }
 
 export function repair_client_sessions(client: IClientBase, callback: (err?: Error) => void): void {
@@ -512,6 +557,9 @@ export function repair_client_sessions(client: IClientBase, callback: (err?: Err
         },
         (err, allErrors: (undefined | Error | null)[] | undefined) => {
             err && errorLog("sessions reactivation completed with err: err ", err ? err.message : "null");
+            // prettier-ignore
+            { const err = _shouldNotContinue3(client); if (err) { return callback(err); } }
+
             return callback(err!);
         }
     );