node-opcua-client 2.103.0 → 2.105.0

package/source/private/opcua_client_impl.ts

@@ -9,19 +9,11 @@ import * as crypto from "crypto";
 import { createPublicKey } from "crypto";
 import { callbackify } from "util";
 import * as async from "async";
-import * as chalk from "chalk";
+import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
 import { createFastUninitializedBuffer } from "node-opcua-buffer-utils";
-import {
-    Certificate,
-    exploreCertificate,
-    extractPublicKeyFromCertificateSync,
-    Nonce,
-    PrivateKey,
-    PrivateKeyPEM,
-    toPem
-} from "node-opcua-crypto";
+import { Certificate, exploreCertificate, extractPublicKeyFromCertificateSync, Nonce, PrivateKey, toPem } from "node-opcua-crypto";
 
 import { LocalizedText } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
@@ -609,7 +601,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
                             innerCallback();
                         });
                     } catch (err) {
-                        console.log("Exception catch in inner function,  check your code ", err);
+                        errorLog("Exception catch in inner function,  check your code ", err);
                         errorLog("OPCUAClientImpl#withClientSession", (<Error>err).message);
                         the_error = err as Error;
                         innerCallback();
@@ -638,7 +630,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
             ],
             (err1) => {
                 if (err1) {
-                    console.log("err", err1.message);
+                    errorLog("err", err1.message);
                 }
                 if (need_disconnect) {
                     errorLog("Disconnecting client after failure");
@@ -729,7 +721,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
                 const result = await func(session, subscription);
                 return result;
             } catch (err) {
-                console.log("withSubscriptionAsync inner function failed ", (<Error>err).message);
+                errorLog("withSubscriptionAsync inner function failed ", (<Error>err).message);
                 throw err;
             } finally {
                 await subscription.terminate();
@@ -757,9 +749,14 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         if (!this.__resolveEndPoint() || !this.endpoint) {
             return callback!(
                 new Error(
-                    " End point must exist " + this._secureChannel!.endpointUrl +
-                    "  securityMode = " + MessageSecurityMode[this.securityMode] +
-                    "  securityPolicy = " + this.securityPolicy));
+                    " End point must exist " +
+                        this._secureChannel!.endpointUrl +
+                        "  securityMode = " +
+                        MessageSecurityMode[this.securityMode] +
+                        "  securityPolicy = " +
+                        this.securityPolicy
+                )
+            );
         }
 
         assert(
@@ -846,7 +843,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         this.clientNonce = crypto.randomBytes(32);
 
         // recycle session name if already exists
-        const sessionName = session.name
+        const sessionName = session.name;
 
         const request = new CreateSessionRequest({
             clientCertificate: this.getCertificate(),
@@ -856,7 +853,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
             maxResponseMessageSize: 800000,
             requestedSessionTimeout: this.requestedSessionTimeout,
             serverUri: this.serverUri,
-            sessionName,
+            sessionName
         });
 
         // a client Nonce must be provided if security mode is set
@@ -865,10 +862,8 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* istanbul ignore next */
             if (err) {
-                console.log("__createSession_step3 has failed", err.message);
+                debugLog("__createSession_step3 has failed", err.message);
                 return callback(err);
-
-                //  //xxxxxx               qdqsdqsdqsdqsd
                 //                 // we could have an invalid state here or a connection error
                 //                 errorLog("error: ", err.message, " retrying in ... 5 secondes");
                 //                 setTimeout(() => {
@@ -1156,20 +1151,32 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         if (!this.__resolveEndPoint() || !this.endpoint) {
             /* istanbul ignore next */
             if (this._serverEndpoints) {
-                warningLog("server endpoints =",
-                    this._serverEndpoints.map(
-                        (endpoint) =>
-                            endpoint.endpointUrl + " "
-                            + MessageSecurityMode[endpoint.securityMode] + " "
-                            + endpoint.securityPolicyUri + " "
-                            + endpoint.userIdentityTokens?.map((u) => UserTokenType[u.tokenType]).join(",")
-                    ).join('\n')
+                warningLog(
+                    "server endpoints =",
+                    this._serverEndpoints
+                        .map(
+                            (endpoint) =>
+                                endpoint.endpointUrl +
+                                " " +
+                                MessageSecurityMode[endpoint.securityMode] +
+                                " " +
+                                endpoint.securityPolicyUri +
+                                " " +
+                                endpoint.userIdentityTokens?.map((u) => UserTokenType[u.tokenType]).join(",")
+                        )
+                        .join("\n")
                 );
             }
-            return callback(new Error(
-                " End point must exist " + this._secureChannel!.endpointUrl +
-                "  securityMode = " + MessageSecurityMode[this.securityMode] +
-                "  securityPolicy = " + this.securityPolicy));
+            return callback(
+                new Error(
+                    " End point must exist " +
+                        this._secureChannel!.endpointUrl +
+                        "  securityMode = " +
+                        MessageSecurityMode[this.securityMode] +
+                        "  securityPolicy = " +
+                        this.securityPolicy
+                )
+            );
         }
         this.serverUri = this.endpoint.server.applicationUri || "invalid application uri";
         this.endpointUrl = this._secureChannel!.endpointUrl;

package/source/reconnection.ts

@@ -4,7 +4,7 @@
 
 // tslint:disable:only-arrow-functions
 import * as async from "async";
-import * as chalk from "chalk";
+import chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { TransferSubscriptionsRequest, TransferSubscriptionsResponse } from "node-opcua-service-subscription";
@@ -167,7 +167,6 @@ function repair_client_session_by_recreating_a_new_session(
     session: ClientSessionImpl,
     callback: (err?: Error) => void
 ) {
-
     // 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);
@@ -367,8 +366,7 @@ function repair_client_session_by_recreating_a_new_session(
                 //      call Republish
                 return _ask_for_subscription_republish(newSession, (err) => {
                     if (err) {
-                        // tslint:disable-next-line: no-console
-                        console.log("warning: Subscription republished has failed ", err.message);
+                        warningLog("warning: Subscription republished has failed ", err.message);
                     }
                     innerCallback(err);
                 });

package/source/tools/read_history_server_capabilities.ts

@@ -55,18 +55,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",

package/source/verify.ts

@@ -86,6 +86,7 @@ export function verifyIsOPCUAValidCertificate(
                     `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
                     `certificateFile = ${certificateFile}`
             );
+            warningLog(`keyUsage = ${JSON.stringify(keyUsage, null, " ")}`);
         }
     }
     const extKeyUsage = certificateInfo.tbsCertificate.extensions?.extKeyUsage;
@@ -120,21 +121,21 @@ export function verifyIsOPCUAValidCertificate(
 }
 
 export async function performCertificateSanityCheck(
-    this: OPCUASecureObject,
+    secureObject: OPCUASecureObject,
     serverOrClient: "server" | "client",
     certificateManager: OPCUACertificateManager,
     applicationUri: string
 ): Promise<void> {
-    // verify that certificate is matching private key, and inform the developper if not
-    const certificate = this.getCertificate();
-    const privateKey = this.getPrivateKey();
+    // verify that certificate is matching private key, and inform the developer if not
+    const certificate = secureObject.getCertificate();
+    const privateKey = secureObject.getPrivateKey();
     //
     if (!publicKeyAndPrivateKeyMatches(certificate, privateKey)) {
         errorLog("[NODE-OPCUA-E01] Configuration error : the certificate and the private key do not match !");
         errorLog("                  please check the configuration of the OPCUA Server");
-        errorLog("                    privateKey= ", this.privateKeyFile);
+        errorLog("                    privateKey= ", secureObject.privateKeyFile);
         errorLog(" certificateManager.privateKey= ", certificateManager.privateKey);
-        errorLog("               certificateFile= ", this.certificateFile);
+        errorLog("               certificateFile= ", secureObject.certificateFile);
         throw new Error(
             "[NODE-OPCUA-E01] Configuration error : the certificate and the private key do not match ! please fix your configuration"
         );
@@ -154,8 +155,8 @@ export async function performCertificateSanityCheck(
     const status = await certificateManager.verifyCertificateAsync(certificate);
 
     if (status !== "Good") {
-        warningLog("[NODE-OPCUA-W04] Warning: the certificate status is = ", status, " file = ", this.certificateFile);
+        warningLog("[NODE-OPCUA-W04] Warning: the certificate status is = ", status, " file = ", secureObject.certificateFile);
     }
 
-    verifyIsOPCUAValidCertificate(certificate, this.certificateFile, serverOrClient, applicationUri);
+    verifyIsOPCUAValidCertificate(certificate, secureObject.certificateFile, serverOrClient, applicationUri);
 }