node-opcua-client 2.166.0 → 2.167.0

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;

package/source/private/reconnection/reconnection.ts

@@ -6,17 +6,16 @@
 import async from "async";
 import chalk from "chalk";
 import { assert } from "node-opcua-assert";
+import { invalidateExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { TransferSubscriptionsRequest, TransferSubscriptionsResponse } from "node-opcua-service-subscription";
-import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
-import { ErrorCallback } from "node-opcua-status-code";
+import { TransferSubscriptionsRequest, type TransferSubscriptionsResponse } from "node-opcua-service-subscription";
+import { type CallbackT, type ErrorCallback, StatusCode, StatusCodes } 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 "../client_session_impl";
-import { ClientSubscriptionImpl } from "../client_subscription_impl";
-import { IClientBase } from "../i_private_client";
+import type { SubscriptionId } from "../../client_session";
+import type { ClientSessionImpl, Reconnectable } from "../client_session_impl";
+import type { ClientSubscriptionImpl } from "../client_subscription_impl";
+import type { IClientBase } from "../i_private_client";
 import { republish } from "./client_publish_engine_reconnection";
 import { recreateSubscriptionAndMonitoredItem } from "./client_subscription_reconnection";
 
@@ -131,7 +130,12 @@ export function _shouldNotContinue2(subscription: ClientSubscriptionImpl) {
 
 function _ask_for_subscription_republish(session: ClientSessionImpl, callback: (err?: Error) => void) {
     // prettier-ignore
-    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+    {
+        const err = _shouldNotContinue(session);
+        if (err) {
+            return callback(err);
+        }
+    }
 
     doDebug && debugLog(chalk.bgCyan.yellow.bold("_ask_for_subscription_republish "));
     // assert(session.getPublishEngine().nbPendingPublishRequests === 0,
@@ -141,7 +145,12 @@ function _ask_for_subscription_republish(session: ClientSessionImpl, callback: (
     republish(engine, (err?: Error) => {
         doDebug && debugLog("_ask_for_subscription_republish :  republish sent");
         // prettier-ignore
-        { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+        {
+            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) {
@@ -160,14 +169,24 @@ function create_session_and_repeat_if_failed(
     callback: CallbackT<ClientSessionImpl>
 ) {
     // prettier-ignore
-    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+    {
+        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) => {
         // prettier-ignore
-        { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+        {
+            const err = _shouldNotContinue(session);
+            if (err) {
+                return callback(err);
+            }
+        }
 
         if (!err && session1) {
             assert(session === session1, "session should have been recycled");
@@ -186,7 +205,12 @@ function repair_client_session_by_recreating_a_new_session(
     callback: (err?: Error) => void
 ) {
     // prettier-ignore
-    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+    {
+        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
@@ -206,7 +230,12 @@ function repair_client_session_by_recreating_a_new_session(
             subscriptionsToRecreate,
             (subscriptionId: SubscriptionId, next: ErrorCallback) => {
                 // prettier-ignore
-                { const err = _shouldNotContinue(session); if (err) { return next(err); } }
+                {
+                    const err = _shouldNotContinue(session);
+                    if (err) {
+                        return next(err);
+                    }
+                }
 
                 if (!session.getPublishEngine().hasSubscription(subscriptionId)) {
                     doDebug && debugLog(chalk.red("          => CANNOT RECREATE SUBSCRIPTION  "), subscriptionId);
@@ -232,7 +261,12 @@ function repair_client_session_by_recreating_a_new_session(
             },
             (err1?: Error | null) => {
                 // prettier-ignore
-                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                {
+                    const err = _shouldNotContinue(session);
+                    if (err) {
+                        return innerCallback(err);
+                    }
+                }
                 if (!err1) {
                     // prettier-ignore
                 }
@@ -245,7 +279,12 @@ function repair_client_session_by_recreating_a_new_session(
         [
             function suspend_old_session_publish_engine(innerCallback: ErrorCallback) {
                 // prettier-ignore
-                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                {
+                    const err = _shouldNotContinue(session);
+                    if (err) {
+                        return innerCallback(err);
+                    }
+                }
 
                 // c8 ignore next
                 doDebug && debugLog(chalk.bgWhite.red("    => suspend old session publish engine...."));
@@ -256,7 +295,12 @@ 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); } }
+                    {
+                        const err = _shouldNotContinue(session);
+                        if (err) {
+                            return innerCallback(err);
+                        }
+                    }
 
                     if (_newSession) {
                         newSession = _newSession;
@@ -267,7 +311,12 @@ function repair_client_session_by_recreating_a_new_session(
 
             function activate_new_session(innerCallback: ErrorCallback) {
                 // prettier-ignore
-                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                {
+                    const err = _shouldNotContinue(session);
+                    if (err) {
+                        return innerCallback(err);
+                    }
+                }
 
                 doDebug && debugLog(chalk.bgWhite.red("    => activating a new session ...."));
 
@@ -333,7 +382,12 @@ function repair_client_session_by_recreating_a_new_session(
 
             function attempt_subscription_transfer(innerCallback: ErrorCallback) {
                 // prettier-ignore
-                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                {
+                    const err = _shouldNotContinue(session);
+                    if (err) {
+                        return innerCallback(err);
+                    }
+                }
 
                 // get the old subscriptions id from the old session
                 const subscriptionsIds = session.getPublishEngine().getSubscriptionIds();
@@ -359,7 +413,12 @@ function repair_client_session_by_recreating_a_new_session(
                     (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); } }
+                        {
+                            const err = _shouldNotContinue(session);
+                            if (err) {
+                                return innerCallback(err);
+                            }
+                        }
 
                         if (err || !transferSubscriptionsResponse) {
                             warningLog(chalk.bgCyan("May be the server is not supporting this feature"));
@@ -418,7 +477,12 @@ function repair_client_session_by_recreating_a_new_session(
 
             function ask_for_subscription_republish(innerCallback: ErrorCallback) {
                 // prettier-ignore
-                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                {
+                    const err = _shouldNotContinue(session);
+                    if (err) {
+                        return innerCallback(err);
+                    }
+                }
 
                 //  assert(newSession.getPublishEngine().nbPendingPublishRequests === 0, "we should not be publishing here");
                 //      call Republish
@@ -432,7 +496,12 @@ function repair_client_session_by_recreating_a_new_session(
 
             function start_publishing_as_normal(innerCallback: ErrorCallback) {
                 // prettier-ignore
-                { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                {
+                    const err = _shouldNotContinue(session);
+                    if (err) {
+                        return innerCallback(err);
+                    }
+                }
 
                 newSession.getPublishEngine().suspend(false);
 
@@ -467,11 +536,21 @@ function _repair_client_session(client: IClientBase, session: ClientSessionImpl,
     }
 
     // prettier-ignore
-    { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+    {
+        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); } }
+        {
+            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.
@@ -513,15 +592,25 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
     privateSession._reconnecting.reconnecting = true;
 
     // get old transaction queue ...
-    const transactionQueue =  privateSession._reconnecting.pendingTransactions.splice(0);
+    const transactionQueue = privateSession._reconnecting.pendingTransactions.splice(0);
 
     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
-            { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
+            {
+                const err = _shouldNotContinue(session);
+                if (err) {
+                    return callback(err);
+                }
+            }
 
             if (err) {
                 errorLog(
@@ -534,10 +623,13 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
                     const delay = 2000;
                     errorLog(chalk.red(`... will retry session repair... in ${delay} ms`));
                     setTimeout(() => {
-                        { const err = _shouldNotContinue(session); if (err) {
-                            warningLog("cancelling session repair"); 
-                            return callback(err); 
-                        } }
+                        {
+                            const err = _shouldNotContinue(session);
+                            if (err) {
+                                warningLog("cancelling session repair");
+                                return callback(err);
+                            }
+                        }
                         errorLog(chalk.red("Retrying session repair..."));
                         repeatedAction(callback);
                     }, delay);
@@ -560,7 +652,7 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
         privateSession._reconnecting.reconnecting = false;
         const otherCallbacks = privateSession._reconnecting.pendingCallbacks.splice(0);
         // re-inject element in queue
-        
+
         // c8 ignore next
         if (transactionQueue.length > 0) {
             doDebug && debugLog(chalk.yellow("re-injecting transaction queue"), transactionQueue.length);
@@ -585,7 +677,12 @@ 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); } }
+            {
+                const err = _shouldNotContinue3(client);
+                if (err) {
+                    return callback(err);
+                }
+            }
 
             return callback(err!);
         }

package/source/tools/findservers.ts

@@ -1,17 +1,29 @@
 /**
  * @module node-opcua-client
  */
-import async from "async";
 
-import { ErrorCallback } from "node-opcua-status-code";
-import { ServerOnNetwork } from "node-opcua-service-discovery";
-import { ApplicationDescription, EndpointDescription } from "node-opcua-service-endpoints";
+import type { ServerOnNetwork } from "node-opcua-service-discovery";
+import type { ApplicationDescription, EndpointDescription } from "node-opcua-service-endpoints";
+
+
 import { ClientBaseImpl } from "../private/client_base_impl";
 
 export interface FindServerResults {
     servers: ApplicationDescription[];
     endpoints: EndpointDescription[];
 }
+export async function findServersAsync(discoveryServerEndpointUri: string): Promise<FindServerResults> {
+    const client = new ClientBaseImpl({ connectionStrategy: { maxRetry: 3 } });
+    try {
+        await client.connect(discoveryServerEndpointUri);
+        const servers = await client.findServers();
+        const endpoints = await client.getEndpoints({ endpointUrl: undefined });
+        return { servers, endpoints };
+    } finally {
+        await client.disconnect();
+    }
+}
+
 /**
  * extract the server endpoints exposed by a discovery server
  */
@@ -19,52 +31,34 @@ export function findServers(
     discoveryServerEndpointUri: string,
     callback: (err: Error | null, result?: FindServerResults) => void
 ): void;
-export async function findServers(discoveryServerEndpointUri: string): Promise<FindServerResults>;
+export function findServers(discoveryServerEndpointUri: string): Promise<FindServerResults>;
 export function findServers(
     discoveryServerEndpointUri: string,
     callback?: (err: Error | null, result?: FindServerResults) => void
-): any {
+): Promise<FindServerResults> | undefined {
+    if (!callback) {
+        return findServersAsync(discoveryServerEndpointUri);
+    }
+    findServersAsync(discoveryServerEndpointUri)
+        .then((result) => callback(null, result))
+        .catch((err) => callback(err));
+    return undefined;
+}
+export async function findServersOnNetworkAsync(discoveryServerEndpointUri: string): Promise<ServerOnNetwork[]> {
     const client = new ClientBaseImpl({ connectionStrategy: { maxRetry: 3 } });
-
-    let servers: ApplicationDescription[] = [];
-    let endpoints: EndpointDescription[] = [];
-
-    async.series(
-        [
-            (innerCallback: ErrorCallback) => {
-                client.connect(discoveryServerEndpointUri, innerCallback);
-            },
-
-            (innerCallback: ErrorCallback) => {
-                client.findServers((err: Error | null, _servers?: ApplicationDescription[]) => {
-                    if (_servers) {
-                        servers = _servers;
-                    }
-                    innerCallback(err ? err : undefined);
-                });
-            },
-
-            (innerCallback: ErrorCallback) => {
-                client.getEndpoints({ endpointUrl: undefined }, (err: Error | null, _endpoints?: EndpointDescription[]) => {
-                    if (_endpoints) {
-                        endpoints = _endpoints;
-                    }
-                    innerCallback(err ? err : undefined);
-                });
-            }
-        ],
-        (err) => {
-            client.disconnect(() => {
-                callback!(err ? err : null, { servers, endpoints });
-            });
-        }
-    );
+    try {
+        await client.connect(discoveryServerEndpointUri);
+        const servers = await client.findServersOnNetwork();
+        return servers;
+    } finally {
+        await client.disconnect();
+    }
 }
 
 /**
  * extract the server endpoints exposed by a discovery server
  */
-export async function findServersOnNetwork(discoveryServerEndpointUri: string): Promise<ServerOnNetwork[]>;
+export function findServersOnNetwork(discoveryServerEndpointUri: string): Promise<ServerOnNetwork[]>;
 export function findServersOnNetwork(
     discoveryServerEndpointUri: string,
     callback: (err: Error | null, servers?: ServerOnNetwork[]) => void
@@ -72,25 +66,12 @@ export function findServersOnNetwork(
 export function findServersOnNetwork(
     discoveryServerEndpointUri: string,
     callback?: (err: Error | null, servers?: ServerOnNetwork[]) => void
-): any {
-    const client = new ClientBaseImpl({ connectionStrategy: { maxRetry: 3 } });
-
-    client.connect(discoveryServerEndpointUri, (err?: Error) => {
-        if (!err) {
-            client.findServersOnNetwork((err1, servers) => {
-                client.disconnect(() => {
-                    callback!(err1, servers);
-                });
-            });
-        } else {
-            client.disconnect(() => {
-                callback!(err);
-            });
-        }
-    });
+): Promise<ServerOnNetwork[]> | undefined {
+    if (!callback) {
+        return findServersOnNetworkAsync(discoveryServerEndpointUri);
+    }
+    findServersOnNetworkAsync(discoveryServerEndpointUri)
+        .then((servers) => callback(null, servers))
+        .catch((err) => callback(err));
+    return undefined;
 }
-
-// tslint:disable:no-var-requires
-import { withCallback } from "thenify-ex";
-(module.exports as any).findServersOnNetwork = withCallback((module.exports as any).findServersOnNetwork);
-(module.exports as any).findServers = withCallback((module.exports as any).findServers);

package/source/tools/read_history_server_capabilities.ts

@@ -4,15 +4,15 @@
 import { assert } from "node-opcua-assert";
 import { ObjectIds } from "node-opcua-constants";
 import { AttributeIds } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
+import type { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import { ReadValueIdOptions } from "node-opcua-service-read";
-import { BrowsePath, BrowsePathResult, makeBrowsePath } from "node-opcua-service-translate-browse-path";
+import type { ReadValueIdOptions } from "node-opcua-service-read";
+import { type BrowsePath, type BrowsePathResult, makeBrowsePath } from "node-opcua-service-translate-browse-path";
 import { StatusCodes } from "node-opcua-status-code";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { Variant } from "node-opcua-variant";
+import type { Variant } from "node-opcua-variant";
 
-import { ClientSession } from "../client_session";
+import type { ClientSession } from "../client_session";
 
 export interface HistoryServerCapabilities {
     [key: string]: any;
@@ -28,7 +28,14 @@ export function readHistoryServerCapabilities(
     callback?: (err: Error | null, capabilities?: HistoryServerCapabilities) => void
 ): any {
     if (!callback) {
-        throw new Error("Internal error");
+        return new Promise<HistoryServerCapabilities>((resolve, reject) => {
+            readHistoryServerCapabilities(session, (err, capabilities) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(capabilities!);
+            });
+        });
     }
     // display HistoryCapabilities of server
     const browsePath: BrowsePath = makeBrowsePath(ObjectIds.ObjectsFolder, "/Server/ServerCapabilities.HistoryServerCapabilities");
@@ -55,24 +62,24 @@ export function readHistoryServerCapabilities(
         const properties = [
             "AccessHistoryDataCapability",
             "AccessHistoryEventsCapability",
-          
+
             "DeleteAtTimeCapability",
             "DeleteRawCapability",
             "DeleteEventCapability",
-          
+
             "InsertAnnotationCapability",
             "InsertDataCapability",
             "InsertEventCapability",
-          
+
             "ReplaceDataCapability",
             "ReplaceEventCapability",
-          
+
             "UpdateDataCapability",
             "UpdateEventCapability",
-          
+
             "MaxReturnDataValues",
             "MaxReturnEventValues",
-          
+
             "AggregateFunctions/AnnotationCount",
             "AggregateFunctions/Average",
             "AggregateFunctions/Count",
@@ -95,9 +102,7 @@ export function readHistoryServerCapabilities(
             }
 
             const nodeIds = results.map((innerResult: BrowsePathResult) =>
-                innerResult.statusCode.isGood() && innerResult.targets
-                    ? innerResult.targets[0].targetId
-                    : new NodeId()
+                innerResult.statusCode.isGood() && innerResult.targets ? innerResult.targets[0].targetId : new NodeId()
             );
 
             const nodesToRead: ReadValueIdOptions[] = nodeIds.map((nodeId: NodeId) => ({
@@ -125,10 +130,3 @@ export function readHistoryServerCapabilities(
         });
     });
 }
-// tslint:disable:no-var-requires
-import { withCallback } from "thenify-ex";
-const opts = { multiArgs: false };
-(module as any).exports.readHistoryServerCapabilities = withCallback(
-    (module as any).exports.readHistoryServerCapabilities,
-    opts
-);

package/source/user_identity_info.ts

@@ -1,6 +1,6 @@
-export { 
-    UserIdentityInfoUserName, 
-    UserIdentityInfoX509, 
-    AnonymousIdentity, 
-    UserIdentityInfo 
+export {
+    AnonymousIdentity,
+    UserIdentityInfo,
+    UserIdentityInfoUserName,
+    UserIdentityInfoX509
 } from "node-opcua-pseudo-session";