node-opcua-client 2.166.0 → 2.168.0

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";

package/source/verify.ts

@@ -24,8 +24,8 @@ export function verifyIsOPCUAValidCertificate(
         // certificate is not active yet
         warningLog(
             `[NODE-OPCUA-W02] The certificate is not active yet\n` +
-            `notBefore       ${certificateInfo.tbsCertificate.validity.notBefore.toISOString()}\n` +
-            `certificateFile ${certificateFile}`
+                `notBefore       ${certificateInfo.tbsCertificate.validity.notBefore.toISOString()}\n` +
+                `certificateFile ${certificateFile}`
         );
     }
     //  check that certificate has not expired
@@ -33,9 +33,9 @@ export function verifyIsOPCUAValidCertificate(
         // certificate is obsolete
         warningLog(
             `[NODE-OPCUA-W03] The certificate has expired\n` +
-            `Please regenerate a valid certificate\n` +
-            `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
-            `certificateFile= ${certificateFile}`
+                `Please regenerate a valid certificate\n` +
+                `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
+                `certificateFile= ${certificateFile}`
         );
     } else {
         const tenDays = 10 * 24 * 60 * 60 * 1000;
@@ -43,9 +43,9 @@ export function verifyIsOPCUAValidCertificate(
             // certificate is going to expired very soon
             warningLog(
                 `[NODE-OPCUA-W05] The certificate is about to expire in less than 10 days.\n` +
-                `Please regenerate a valid certificate as soon as possible\n` +
-                `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
-                `certificateFile= ${certificateFile}\n`
+                    `Please regenerate a valid certificate as soon as possible\n` +
+                    `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
+                    `certificateFile= ${certificateFile}\n`
             );
         }
     }
@@ -54,18 +54,18 @@ export function verifyIsOPCUAValidCertificate(
     if (!uniformResourceIdentifier) {
         warningLog(
             `[NODE-OPCUA-W14] The certificate subjectAltName uniformResourceIdentifier is missing.\n` +
-            `Please regenerate a specific certificate with a uniformResourceIdentifier that matches your ${type} applicationUri\n` +
-            `applicationUri  = ${applicationUri}\n` +
-            `certificateFile = ${certificateFile}\n`
+                `Please regenerate a specific certificate with a uniformResourceIdentifier that matches your ${type} applicationUri\n` +
+                `applicationUri  = ${applicationUri}\n` +
+                `certificateFile = ${certificateFile}\n`
         );
         return;
     } else if (uniformResourceIdentifier[0] !== applicationUri) {
         warningLog(
             `[NODE-OPCUA-W06] The certificate subjectAltName does not match the ${type} applicationUri\n` +
-            `Please regenerate a specific certificate that matches your ${type} applicationUri\n` +
-            `certificate subjectAltName  = ${uniformResourceIdentifier[0]}\n` +
-            `${type} applicationUri  = ${applicationUri}\n` +
-            `certificateFile         = ${certificateFile}\n`
+                `Please regenerate a specific certificate that matches your ${type} applicationUri\n` +
+                `certificate subjectAltName  = ${uniformResourceIdentifier[0]}\n` +
+                `${type} applicationUri  = ${applicationUri}\n` +
+                `certificateFile         = ${certificateFile}\n`
         );
     }
     const keyUsage = certificateInfo.tbsCertificate.extensions?.keyUsage;
@@ -77,8 +77,8 @@ export function verifyIsOPCUAValidCertificate(
         if (!keyUsage.digitalSignature || !keyUsage.nonRepudiation || !keyUsage.keyEncipherment || !keyUsage.dataEncipherment) {
             warningLog(
                 `[NODE-OPCUA-W16] The certificate keyUsage must include digitalSignature, nonRepudiation, keyEncipherment and dataEncipherment.\n` +
-                `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
-                `certificateFile = ${certificateFile}`
+                    `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
+                    `certificateFile = ${certificateFile}`
             );
             warningLog(`keyUsage = ${JSON.stringify(keyUsage, null, " ")}`);
         }
@@ -92,8 +92,8 @@ export function verifyIsOPCUAValidCertificate(
         if (!extKeyUsage.clientAuth && !extKeyUsage.serverAuth) {
             warningLog(
                 `[NODE-OPCUA-W18] The certificate extKeyUsage must include clientAuth and/or serverAuth.\n` +
-                `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
-                `certificateFile = ${certificateFile}`
+                    `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
+                    `certificateFile = ${certificateFile}`
             );
         }
     }
@@ -102,14 +102,14 @@ export function verifyIsOPCUAValidCertificate(
     if (keyLengthInBits < 1024) {
         errorLog(
             `[NODE-OPCUA-W19] The public key length shall be greater than or equal to 1024 bits. key length is ${keyLengthInBits}.\n` +
-            `see https://reference.opcfoundation.org/v104/GDS/docs/7.6.3/\n` +
-            `certificateFile = ${certificateFile}`
+                `see https://reference.opcfoundation.org/v104/GDS/docs/7.6.3/\n` +
+                `certificateFile = ${certificateFile}`
         );
     } else if (keyLengthInBits < 2048) {
         warningLog(
             `[NODE-OPCUA-W23] key lengths less than 2048 are considered insecure. key length is ${keyLengthInBits}\n` +
-            `see https://reference.opcfoundation.org/v104/Core/docs/Part2/6.8/\n` +
-            `certificateFile = ${certificateFile}`
+                `see https://reference.opcfoundation.org/v104/Core/docs/Part2/6.8/\n` +
+                `certificateFile = ${certificateFile}`
         );
     }
 }
@@ -140,8 +140,8 @@ export async function performCertificateSanityCheck(
     if (keyLengthInBits <= 1024) {
         warningLog(
             `[NODE-OPCUA-W04] The public/private key pair uses a key length which is equal or lower than 1024 bits. ( key length was ${keyLengthInBits} )\n` +
-            `OPCUA version 1.04 requires that security key length are greater or equal to 2048 bits.\n` +
-            `The ${serverOrClient} is operating at risk.                                             `
+                `OPCUA version 1.04 requires that security key length are greater or equal to 2048 bits.\n` +
+                `The ${serverOrClient} is operating at risk.                                             `
         );
     }