node-opcua-client 2.100.0 → 2.102.0

package/source/private/client_session_impl.ts

@@ -2,6 +2,7 @@
  * @module node-opcua-client-private
  */
 import { EventEmitter } from "events";
+import { callbackify } from "util";
 import * as chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { AggregateFunction } from "node-opcua-constants";
@@ -22,7 +23,7 @@ import { ExtensionObject } from "node-opcua-extension-object";
 import { coerceNodeId, NodeId, NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { getBuiltInDataType, getArgumentDefinitionHelper, IBasicSession, IBasicTransportSettings } from "node-opcua-pseudo-session";
 import { AnyConstructorFunc } from "node-opcua-schemas";
-import { requestHandleNotSetValue, SignatureData } from "node-opcua-secure-channel";
+import { ClientSecureChannelLayer, requestHandleNotSetValue, SignatureData } from "node-opcua-secure-channel";
 import { BrowseDescription, BrowseRequest, BrowseResponse, BrowseResult } from "node-opcua-service-browse";
 import { CallMethodRequest, CallMethodResult, CallRequest, CallResponse } from "node-opcua-service-call";
 import { EndpointDescription } from "node-opcua-service-endpoints";
@@ -293,7 +294,6 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         this.timeout = 0;
     }
 
-
     getTransportSettings(): IBasicTransportSettings {
         return this._client!.getTransportSettings();
     }
@@ -546,13 +546,12 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
      * ```javascript
      *     const dataValues = await session.readVariableValue(["ns=1;s=Temperature","ns=1;s=Pressure"]);
      * ```
+     * 
+     * @deprecated
      */
     public readVariableValue(nodeId: NodeIdLike, callback: ResponseCallback<DataValue>): void;
-
     public readVariableValue(nodeIds: NodeIdLike[], callback: ResponseCallback<DataValue[]>): void;
-
     public async readVariableValue(nodeId: NodeIdLike): Promise<DataValue>;
-
     public async readVariableValue(nodeIds: NodeIdLike[]): Promise<DataValue[]>;
     /**
      * @internal
@@ -1556,19 +1555,27 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         return this._client !== null && this._client._secureChannel !== null && this._client._secureChannel.isOpened();
     }
 
+    private requestReconnection() {
+        if (this._client) {
+            this._client.requestReconnection();
+            assert(this._client.isReconnecting === true, "expecting client to be reconnecting now");
+        }
+    }
+
     public performMessageTransaction(request: Request, callback: (err: Error | null, response?: Response) => void): void {
         if (!this._client) {
             // session may have been closed by user ... but is still in used !!
             return callback(new Error("Session has been closed and should not be used to perform a transaction anymore"));
         }
 
-        if (!this.isChannelValid()) {
-            // the secure channel is broken, may be the server has crashed or the network cable has been disconnected
-            // for a long time
-            // we may need to queue this transaction, as a secure token may be being reprocessed
-            debugLog(chalk.bgWhite.red("!!! Performing transaction on invalid channel !!! ", request.constructor.name));
-            return callback(new Error("Invalid Channel after performing transaction on " + request.constructor.name));
-        }
+        // if (!this.isChannelValid()) {
+        //     // the secure channel is broken, may be the server has crashed or the network cable has been disconnected
+        //     // for a long time
+        //     // we may need to queue this transaction, as a secure token may be being reprocessed
+        //     errorLog(chalk.bgWhite.red("!!! Performing transaction on invalid channel !!! ", request.schema.name));
+        //     // this.requestReconnection();
+        //     return callback(new Error("!!! Performing transaction on invalid channel with " + request.schema.name + ": starting reconnection process"));
+        // }
 
         this._reconnecting.pendingTransactions = this._reconnecting.pendingTransactions || [];
         this._reconnecting.pendingTransactionsCount = this._reconnecting.pendingTransactionsCount || 0;
@@ -2014,7 +2021,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         });
         this._keepAliveManager.start();
     }
-    
+
     public stopKeepAliveManager(): void {
         if (this._keepAliveManager) {
             this._keepAliveManager.stop();
@@ -2066,6 +2073,12 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 str += "\n reviseTokenLifetime...... " + this._client._secureChannel.securityToken.revisedLifetime;
             }
         }
+        str += "\n keepAlive ................ " + this._keepAliveManager ? true:  false;
+        if (this._keepAliveManager) {
+            str += "\n keepAlive checkInterval.. " + this._keepAliveManager.checkInterval;
+            str += "\n defaultTransportTimeout.. " + ClientSecureChannelLayer.defaultTransportTimeout;
+
+        } 
         return str;
     }
 
@@ -2300,19 +2313,18 @@ async function promoteOpaqueStructure2(session: IBasicSession, callMethodResult:
 function countOpaqueStructures(callMethodResults: CallMethodResult[]): number {
     const x = (a: Variant[] | null): PseudoDataValue[] => {
         if (a === null) return [] as PseudoDataValue[];
-        return a.map((value) => { return { value: value } });
-    }
-    const opaqueStructureCount = callMethodResults.reduce(
-        (prev, callMethodResult) => {
-            return prev + extractDataValueToPromote(x(callMethodResult.outputArguments)).length;
-        }, 0);
+        return a.map((value) => {
+            return { value: value };
+        });
+    };
+    const opaqueStructureCount = callMethodResults.reduce((prev, callMethodResult) => {
+        return prev + extractDataValueToPromote(x(callMethodResult.outputArguments)).length;
+    }, 0);
     return opaqueStructureCount;
 }
 async function promoteOpaqueStructure3(session: IBasicSession, callMethodResults: CallMethodResult[]): Promise<void> {
-
     const opaqueStructureCount = countOpaqueStructures(callMethodResults);
-    if (0 === opaqueStructureCount)
-        return;
+    if (0 === opaqueStructureCount) return;
 
     // construct dataTypeManager if not already present
     await getExtraDataTypeManager(session);
@@ -2324,11 +2336,11 @@ async function promoteOpaqueStructure3(session: IBasicSession, callMethodResults
 // tslint:disable:no-var-requires
 // tslint:disable:max-line-length
 const thenify = require("thenify");
-const callbackify = require("callbackify");
 const opts = { multiArgs: false };
 
 const promoteOpaqueStructureWithCallback = callbackify(promoteOpaqueStructure);
 const promoteOpaqueStructure3WithCallback = callbackify(promoteOpaqueStructure3) as promoteOpaqueStructure3WithCallbackFunc;
+// ClientSessionImpl.prototype.constructExtensionObject = callbackify(ClientSessionImpl.prototype.constructExtensionObject) as any;
 
 ClientSessionImpl.prototype.browse = thenify.withCallback(ClientSessionImpl.prototype.browse, opts);
 ClientSessionImpl.prototype.browseNext = thenify.withCallback(ClientSessionImpl.prototype.browseNext, opts);
@@ -2367,5 +2379,4 @@ ClientSessionImpl.prototype.registerNodes = thenify.withCallback(ClientSessionIm
 ClientSessionImpl.prototype.unregisterNodes = thenify.withCallback(ClientSessionImpl.prototype.unregisterNodes, opts);
 ClientSessionImpl.prototype.readNamespaceArray = thenify.withCallback(ClientSessionImpl.prototype.readNamespaceArray, opts);
 ClientSessionImpl.prototype.getBuiltInDataType = thenify.withCallback(ClientSessionImpl.prototype.getBuiltInDataType, opts);
-ClientSessionImpl.prototype.constructExtensionObject = callbackify(ClientSessionImpl.prototype.constructExtensionObject);
 ClientSessionImpl.prototype.changeUser = thenify.withCallback(ClientSessionImpl.prototype.changeUser, opts);

package/source/private/i_private_client.ts

@@ -26,4 +26,6 @@ export interface IClientBase {
     _sessions: ClientSessionImpl[];
 
     getTransportSettings(): IBasicTransportSettings;
+
+    requestReconnection(): void;
 }

package/source/private/opcua_client_impl.ts

@@ -755,10 +755,10 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         }
         // istanbul ignore next
         if (!this.__resolveEndPoint() || !this.endpoint) {
-            return callback!(            
+            return callback!(
                 new Error(
-                    " End point must exist " + this._secureChannel!.endpointUrl + 
-                    "  securityMode = " + MessageSecurityMode[this.securityMode] + 
+                    " End point must exist " + this._secureChannel!.endpointUrl +
+                    "  securityMode = " + MessageSecurityMode[this.securityMode] +
                     "  securityPolicy = " + this.securityPolicy));
         }
 
@@ -805,10 +805,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
      * @private
      */
     public _on_connection_reestablished(callback: (err?: Error) => void): void {
-        assert(typeof callback === "function");
-
-        // call base class implementation first
-        ClientBaseImpl.prototype._on_connection_reestablished.call(this, (/*err?: Error*/) => {
+        super._on_connection_reestablished((/*err?: Error*/) => {
             repair_client_sessions(this, callback);
         });
     }
@@ -849,7 +846,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(),
@@ -1163,15 +1160,15 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
                     this._serverEndpoints.map(
                         (endpoint) =>
                             endpoint.endpointUrl + " "
-                             + MessageSecurityMode[endpoint.securityMode] + " " 
-                             + endpoint.securityPolicyUri + " " 
-                             + endpoint.userIdentityTokens?.map((u)=> UserTokenType[u.tokenType]).join(",")
+                            + 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] + 
+                " End point must exist " + this._secureChannel!.endpointUrl +
+                "  securityMode = " + MessageSecurityMode[this.securityMode] +
                 "  securityPolicy = " + this.securityPolicy));
         }
         this.serverUri = this.endpoint.server.applicationUri || "invalid application uri";

package/source/reconnection.ts

@@ -11,6 +11,7 @@ import { TransferSubscriptionsRequest, TransferSubscriptionsResponse } from "nod
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
 import { ErrorCallback } 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 "./private/client_session_impl";
@@ -139,7 +140,7 @@ function create_session_and_repeat_if_failed(
     callback: CallbackT<ClientSessionImpl>
 ) {
     if (session.hasBeenClosed()) {
-        doDebug && debugLog("Cannot complete subscription republish due to session terminatio");
+        doDebug && debugLog("Cannot complete subscription republish due to session termination");
         return callback(new Error("Cannot complete subscription republish due to session termination"));
     }
     doDebug && debugLog(chalk.bgWhite.red("    => creating a new session ...."));
@@ -147,7 +148,7 @@ function create_session_and_repeat_if_failed(
     // so we can reuse subscriptions data
     client.__createSession_step2(session, (err: Error | null, session1?: ClientSessionImpl) => {
         if (err && session.hasBeenClosed()) {
-            doDebug && debugLog("Cannot complete subscription republish due to session terminatio");
+            doDebug && debugLog("Cannot complete subscription republish due to session termination");
             return callback(new Error("Cannot complete subscription republish due to session termination"));
         }
         if (!err && session1) {
@@ -166,6 +167,11 @@ 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);
+
     if (doDebug) {
         doDebug && debugLog(" repairing client session by_recreating a new session for old session ", session.sessionId.toString());
     }
@@ -210,13 +216,17 @@ function repair_client_session_by_recreating_a_new_session(
                     newSession,
                     newSession.userIdentityInfo!,
                     (err: Error | null, session1?: ClientSessionImpl) => {
-                        doDebug && debugLog(chalk.bgWhite.cyan("    =>  activating a new session .... Done err=", err ? err.message : "null"));
-                        if (err) {
-                            doDebug && debugLog(
-                                chalk.bgWhite.cyan(
-                                    "reactivation of the new session has failed: let be smart and close it before failing this repair attempt"
-                                )
+                        doDebug &&
+                            debugLog(
+                                chalk.bgWhite.cyan("    =>  activating a new session .... Done err=", err ? err.message : "null")
                             );
+                        if (err) {
+                            doDebug &&
+                                debugLog(
+                                    chalk.bgWhite.cyan(
+                                        "reactivation of the new session has failed: let be smart and close it before failing this repair attempt"
+                                    )
+                                );
                             // but just on the server side, not on the client side
                             const closeSessionRequest = new CloseSessionRequest({
                                 deleteSubscriptions: true
@@ -277,10 +287,11 @@ function repair_client_session_by_recreating_a_new_session(
 
                         // istanbul ignore next
                         if (doDebug) {
-                            doDebug && debugLog(
-                                chalk.cyan("    =>  transfer subscriptions  done"),
-                                results.map((x: any) => x.statusCode.toString()).join(" ")
-                            );
+                            doDebug &&
+                                debugLog(
+                                    chalk.cyan("    =>  transfer subscriptions  done"),
+                                    results.map((x: any) => x.statusCode.toString()).join(" ")
+                                );
                         }
 
                         const subscriptionsToRecreate = [];
@@ -291,22 +302,24 @@ function repair_client_session_by_recreating_a_new_session(
                             const statusCode = results[i].statusCode;
                             if (statusCode.equals(StatusCodes.BadSubscriptionIdInvalid)) {
                                 // repair subscription
-                                doDebug && debugLog(
-                                    chalk.red("         WARNING SUBSCRIPTION  "),
-                                    subscriptionsIds[i],
-                                    chalk.red(" SHOULD BE RECREATED")
-                                );
+                                doDebug &&
+                                    debugLog(
+                                        chalk.red("         WARNING SUBSCRIPTION  "),
+                                        subscriptionsIds[i],
+                                        chalk.red(" SHOULD BE RECREATED")
+                                    );
 
                                 subscriptionsToRecreate.push(subscriptionsIds[i]);
                             } else {
                                 const availableSequenceNumbers = results[i].availableSequenceNumbers;
 
-                                doDebug && debugLog(
-                                    chalk.green("         SUBSCRIPTION "),
-                                    subscriptionsIds[i],
-                                    chalk.green(" CAN BE REPAIRED AND AVAILABLE "),
-                                    availableSequenceNumbers
-                                );
+                                doDebug &&
+                                    debugLog(
+                                        chalk.green("         SUBSCRIPTION "),
+                                        subscriptionsIds[i],
+                                        chalk.green(" CAN BE REPAIRED AND AVAILABLE "),
+                                        availableSequenceNumbers
+                                    );
                                 // should be Good.
                             }
                         }
@@ -329,10 +342,11 @@ function repair_client_session_by_recreating_a_new_session(
                                         doDebug && debugLog("_recreateSubscription failed !" + err1.message);
                                     }
 
-                                    doDebug && debugLog(
-                                        chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE "),
-                                        subscriptionId
-                                    );
+                                    doDebug &&
+                                        debugLog(
+                                            chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE "),
+                                            subscriptionId
+                                        );
 
                                     next();
                                 });
@@ -379,7 +393,8 @@ function repair_client_session_by_recreating_a_new_session(
 
 function _repair_client_session(client: IClientBase, session: ClientSessionImpl, callback: (err?: Error) => void): void {
     const callback2 = (err2?: Error) => {
-        doDebug && debugLog("Session repair completed with err: ", err2 ? err2.message : "<no error>", session.sessionId.toString());
+        doDebug &&
+            debugLog("Session repair completed with err: ", err2 ? err2.message : "<no error>", session.sessionId.toString());
         session.emit("session_repaired");
         callback(err2);
     };
@@ -433,9 +448,14 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
                 session.sessionId.toString(),
                 " => Let's retry"
             );
-            setTimeout(() => {
-                _repair_client_session(client, session, callback);
-            }, 2000);
+            if (!session.hasBeenClosed()) {
+                setTimeout(() => {
+                    _repair_client_session(client, session, callback);
+                }, 2000);
+            } else {
+                // session does not need to be repaired anymore
+                callback();
+            }
             return;
         }
         doDebug && debugLog(chalk.yellow("session has been restored"), session.sessionId.toString());
@@ -452,9 +472,8 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
 }
 
 export function repair_client_sessions(client: IClientBase, callback: (err?: Error) => void): void {
-    const self = client;
     // repair session
-    const sessions = self.getSessions();
+    const sessions = client.getSessions();
     doDebug && debugLog(chalk.red.bgWhite(" Starting sessions reactivation", sessions.length));
     async.map(
         sessions,