node-opcua-client 2.123.0 → 2.125.0

package/source/private/reconnection/client_publish_engine_reconnection.ts

@@ -0,0 +1,146 @@
+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 { 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);
+
+        const request = new RepublishRequest({
+            retransmitSequenceNumber: subscription.lastSequenceNumber + 1,
+            subscriptionId: subscription.subscriptionId
+        });
+
+        // istanbul ignore next
+        if (doDebug) {
+            // istanbul ignore next
+            debugLog(
+                chalk.bgCyan.yellow.bold(" republish Request for subscription"),
+                request.subscriptionId,
+                " retransmitSequenceNumber=",
+                request.retransmitSequenceNumber
+            );
+        }
+
+        if (!session || session!._closeEventHasBeenEmitted) {
+            debugLog("ClientPublishEngine#_republish aborted ");
+            // has  client been disconnected in the mean time ?
+            isDone = true;
+            return callback2();
+        }
+        session.republish(request, (err: Error | null, response?: RepublishResponse) => {
+            const statusCode = err ? StatusCodes.Bad : response!.responseHeader.serviceResult;
+            if (!err && (statusCode.equals(StatusCodes.Good) || statusCode.equals(StatusCodes.BadMessageNotAvailable))) {
+                // 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());
+                }
+                debugLog(" _send_republish ends with ", err.message);
+                isDone = true;
+            }
+            callback2(err ? err : undefined);
+        });
+    };
+
+    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 !
+        );
+    };
+
+    setImmediate(sendRepublishUntilDone);
+}
+
+function __askSubscriptionRepublish(
+    engine: ClientSidePublishEngine,
+    subscription: ClientSubscriptionImpl,
+    callback: (err?: Error) => void
+) {
+
+    _republish(engine, subscription, (err?: Error) => {
+        // prettier-ignore
+        { const _err = _shouldNotContinue2(subscription); if (_err) { return callback(_err); } }
+
+        assert(!err || types.isNativeError(err));
+
+        debugLog("__askSubscriptionRepublish--------------------- err =", err ? err.message : null);
+
+        if (err && err.message.match(/BadSessionInvalid/)) {
+            // _republish failed because session is not valid anymore on server side.
+            return callback(err);
+        }
+        if (err && err.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
+            // Subscription may time out if the duration of the connection break exceed the max life time
+            // of the subscription.
+            //
+            // In this case, Client must recreate a subscription and recreate monitored item without altering
+            // the event handlers
+            //
+            debugLog(
+                chalk.bgWhite.red("__askSubscriptionRepublish failed " + " subscriptionId is not valid anymore on server side.")
+            );
+            return recreateSubscriptionAndMonitoredItem(subscription).then(() => callback()).catch(err => callback(err));
+        }
+        if (err && err.message.match(/|MessageNotAvailable/)) {
+            // start engine and start monitoring
+        }
+        callback();
+    });
+}
+
+export function republish(engine: ClientSidePublishEngine, callback: () => void): void {
+    // After re-establishing the connection the Client shall call Republish in a loop, starting with
+    // the next expected sequence number and incrementing the sequence number until the Server returns
+    // the status BadMessageNotAvailable.
+    // After receiving this status, the Client shall start sending Publish requests with the normal Publish
+    // handling.
+    // This sequence ensures that the lost NotificationMessages queued in the Server are not overwritten
+    // by newPublish responses
+    /**
+     * 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);
+    };
+
+    async.forEachOf(engine.subscriptionMap, askSubscriptionRepublish, callback);
+}

package/source/private/reconnection/client_reconnection.ts

@@ -0,0 +1,17 @@
+import { warn } from "console";
+import { ClientBaseImpl } from "../client_base_impl";
+
+export function waitUntilReconnectionIsCanceled(client: ClientBaseImpl, callback: () => void) {
+    const interval = 100;
+    const maxIntervalCount = 100;
+    let intervalCount = 0;
+    const timer = setInterval(() => {
+        if (!client.isReconnecting || ++intervalCount > maxIntervalCount) {
+            clearInterval(timer);
+            if (intervalCount > maxIntervalCount) {
+                warn("waitUntilReconnectionIsCanceled: timeout");
+            }
+            callback();
+        }
+    }, interval);
+}

package/source/private/reconnection/client_subscription_reconnection.ts

@@ -0,0 +1,124 @@
+import { promisify } from "util";
+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 {
+    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");
+
+async function createMonitoredItemsAndRespectOperationalLimits(
+    session: IBasicSessionReadAsync & IBasicSessionWithSubscription,
+    createMonitorItemsRequest: CreateMonitoredItemsRequest
+): Promise<CreateMonitoredItemsResponse> {
+    const operationalLimits = await readOperationLimits(session);
+    const createMonitoredItemResponse = await createMonitoredItemsLimit(
+        operationalLimits.maxMonitoredItemsPerCall || 0,
+        session,
+        createMonitorItemsRequest
+    );
+    return createMonitoredItemResponse;
+}
+
+async function adjustMonitoredItemNodeIds(subscription: ClientSubscription, oldMonitoredItems: any) {
+// to Do 
+}
+/**
+ *  utility function to recreate new subscription
+ *  @method recreateSubscriptionAndMonitoredItem
+ */
+export async function recreateSubscriptionAndMonitoredItem(_subscription: ClientSubscription): Promise<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;
+    }
+
+    const oldMonitoredItems = subscription.monitoredItems;
+    const oldSubscriptionId = subscription.subscriptionId;
+
+    subscription.publishEngine.unregisterSubscription(oldSubscriptionId);
+
+    await promisify(__create_subscription)(subscription);
+    
+    const _err = _shouldNotContinue(subscription.session); 
+    if (_err) { throw _err;  }
+
+    const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
+
+    debugLog("recreating ", Object.keys(oldMonitoredItems).length, " monitored Items");
+                // re-create monitored items
+    const itemsToCreate: MonitoredItemCreateRequestOptions[] = [];
+
+    await adjustMonitoredItemNodeIds(subscription, oldMonitoredItems);
+
+    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) {
+        throw new Error("no session");
+    }
+
+    debugLog("Recreating ", itemsToCreate.length, " monitored items");
+
+    const response = await createMonitoredItemsAndRespectOperationalLimits(
+                        session,
+                        createMonitorItemsRequest);
+    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");
+    }
+}