node-opcua-client 2.124.0 → 2.126.0

package/source/private/reconnection/client_subscription_reconnection.ts

@@ -1,10 +1,9 @@
-import async from "async";
+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 { ErrorCallback } from "node-opcua-status-code";
 
 import {
     IBasicSessionReadAsync,
@@ -20,128 +19,106 @@ import { _shouldNotContinue } from "./reconnection";
 const debugLog = make_debugLog("RECONNECTION");
 const doDebug = checkDebugFlag("RECONNECTION");
 
-function createMonitoredItemsAndRespectOperationalLimits(
+async 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);
+    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 function recreateSubscriptionAndMonitoredItem(_subscription: ClientSubscription, callback: ErrorCallback): void {
+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 callback();
+        return;
     }
 
     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); } }
+    await promisify(__create_subscription)(subscription);
+    
+    const _err = _shouldNotContinue(subscription.session); 
+    if (_err) { throw _err;  }
 
-                const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
+    const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
 
-                debugLog("recreating ", Object.keys(oldMonitoredItems).length, " monitored Items");
+    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!);
+    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");
+    }
 }

package/source/private/reconnection/reconnection.ts

@@ -216,22 +216,19 @@ function repair_client_session_by_recreating_a_new_session(
                 doDebug && debugLog(chalk.red("          => RECREATING SUBSCRIPTION  "), subscriptionId);
                 assert(subscription.session === newSession, "must have the new session");
 
-                recreateSubscriptionAndMonitoredItem(subscription, (err1?: Error) => {
-                    // prettier-ignore
-                    { const err = _shouldNotContinue(session); if (err) { return next(err); } }
-
-                    if (err1) {
-                        doDebug && debugLog("_recreateSubscription failed !" + err1.message);
-                    }
-
+                recreateSubscriptionAndMonitoredItem(subscription).then(() => {
                     doDebug &&
                         debugLog(
                             chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE subscriptionId="),
                             subscriptionId
                         );
+                    next();
 
+                }).catch((err) => {
+                    doDebug && debugLog("_recreateSubscription failed !" + (err as Error).message);
                     next();
                 });
+
             },
             (err1?: Error | null) => {
                 // prettier-ignore
@@ -495,7 +492,7 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
 
     const repeatedAction = (callback: EmptyCallback) => {
         // prettier-ignore
-        {   const err = _shouldNotContinue(session);   if (err) { return callback(err); }}
+        { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
 
         _repair_client_session(client, session, (err) => {
             // prettier-ignore