node-opcua-client 2.72.1 → 2.73.1

package/dist/private/client_base_impl.js

@@ -195,7 +195,9 @@ class ClockAdjustment {
  *
  *    "connecting"    ---[lost of connection]-----------> "reconnecting" ->[reconnection]
  *
- *    "reconnecting"  ---[reconnection successful]------> "connected"
+ *    "reconnecting"  ---[reconnection successful]------> "reconnecting_newchannel_connected"
+ *
+ *    "reconnecting_newchannel_connected" --(session failure) -->"reconnecting"
  *
  *    "reconnecting"  ---[reconnection failure]---------> [reconnection] ---> "reconnecting"
  *
@@ -216,6 +218,7 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         options.certificateFile =
             options.certificateFile || path.join(options.clientCertificateManager.rootDir, "own/certs/client_certificate.pem");
         super(options);
+        this._inside_repairConnection = false;
         this._instanceNumber = g_ClientCounter++;
         this._internalState = "uninitialized";
         this.applicationName = options.applicationName || "NodeOPCUA-Client";
@@ -226,7 +229,7 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         this.disconnecting = false;
         this.clientCertificateManager = options.clientCertificateManager;
         this._secureChannel = null;
-        this.reconnectionIsCanceled = false;
+        this._reconnectionIsCanceled = false;
         this.endpointUrl = "";
         this.clientName = options.clientName || "ClientSession";
         // must be ZERO with Spec 1.0.2
@@ -253,59 +256,46 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         this.keepPendingSessionsOnDisconnect = options.keepPendingSessionsOnDisconnect || false;
         this.discoveryUrl = options.discoveryUrl || "";
         this._setInternalState("disconnected");
+        this._transportSettings = options.transportSettings || {};
     }
     /**
      * total number of requests that been canceled due to timeout
-     * @property timedOutRequestCount
-     * @type {Number}
      */
     get timedOutRequestCount() {
         return this._timedOutRequestCount + (this._secureChannel ? this._secureChannel.timedOutRequestCount : 0);
     }
     /**
      * total number of transactions performed by the client
-     * @property transactionsPerformed
-     * @type {Number}
-     */
+   x  */
     get transactionsPerformed() {
         return this._transactionsPerformed + (this._secureChannel ? this._secureChannel.transactionsPerformed : 0);
     }
     /**
      * is true when the client has already requested the server end points.
-     * @property knowsServerEndpoint
-     * @type boolean
      */
     get knowsServerEndpoint() {
         return this._serverEndpoints && this._serverEndpoints.length > 0;
     }
     /**
      * true if the client is trying to reconnect to the server after a connection break.
-     * @property isReconnecting
-     * @type {Boolean}
      */
     get isReconnecting() {
         return !!(this._secureChannel && this._secureChannel.isConnecting) || this._internalState !== "connected";
     }
     /**
      * true if the connection strategy is set to automatically try to reconnect in case of failure
-     * @property reconnectOnFailure
-     * @type {Boolean}
      */
     get reconnectOnFailure() {
         return this.connectionStrategy.maxRetry > 0 || this.connectionStrategy.maxRetry === -1;
     }
     /**
      * total number of bytes read by the client
-     * @property bytesRead
-     * @type {Number}
      */
     get bytesRead() {
         return this._byteRead + (this._secureChannel ? this._secureChannel.bytesRead : 0);
     }
     /**
      * total number of bytes written by the client
-     * @property bytesWritten
-     * @type {Number}
      */
     get bytesWritten() {
         return this._byteWritten + (this._secureChannel ? this._secureChannel.bytesWritten : 0);
@@ -326,8 +316,11 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
     _cancel_reconnection(callback) {
         // _cancel_reconnection is invoked during disconnection
         // when we detect that a reconnection is in progress..
-        (0, node_opcua_assert_1.assert)(this.isReconnecting);
-        this.reconnectionIsCanceled = true;
+        if (!this.isReconnecting) {
+            warningLog("internal error : _cancel_reconnection should be used when reconnecting is in progress");
+        }
+        debugLog("canceling reconnection");
+        this._reconnectionIsCanceled = true;
         // istanbul ignore next
         if (!this._secureChannel) {
             debugLog("_cancel_reconnection:  Nothing to do !");
@@ -342,52 +335,66 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         });
     }
     _recreate_secure_channel(callback) {
-        debugLog("_recreate_secure_channel...", this._internalState);
+        debugLog("_recreate_secure_channel... while internalState is", this._internalState);
         if (!this.knowsServerEndpoint) {
             debugLog("Cannot reconnect , server endpoint is unknown");
             return callback(new Error("Cannot reconnect, server endpoint is unknown"));
         }
         (0, node_opcua_assert_1.assert)(this.knowsServerEndpoint);
-        // xx ???        assert(!this.isReconnecting);
-        /**
-         * notifies the observer that the OPCUA is now trying to reestablish the connection
-         * after having received a connection break...
-         * @event start_reconnection
-         *
-         */
         this._setInternalState("reconnecting");
         this.emit("start_reconnection"); // send after callback
-        this._destroy_secure_channel();
-        (0, node_opcua_assert_1.assert)(!this._secureChannel);
         const infiniteConnectionRetry = {
             initialDelay: this.connectionStrategy.initialDelay,
             maxDelay: this.connectionStrategy.maxDelay,
             maxRetry: -1
         };
-        const failAndRetry = (err, message) => {
+        const _when_internal_error = (err, callback) => {
+            errorLog("INTERNAL ERROR", err.message);
+            callback(err);
+        };
+        const _when_reconnectionIsCanceled = (callback) => {
+            warningLog("attempt to recreate a new secure channel : suspended becasue reconnection is canceled !");
+            this.emit("reconnection_canceled");
+            return callback(new Error("Reconnection has been canceled - " + this.clientName));
+        };
+        const _failAndRetry = (err, message, callback) => {
             debugLog("failAndRetry; ", message);
-            if (this.reconnectionIsCanceled) {
-                this.emit("reconnection_canceled");
-                return callback(new Error("Reconnection has been canceled - " + this.clientName));
+            if (this._reconnectionIsCanceled) {
+                return _when_reconnectionIsCanceled(callback);
             }
+            this._destroy_secure_channel();
             warningLog("client = ", this.clientName, message, err.message);
             // else
             // let retry a little bit later
             this.emit("reconnection_attempt_has_failed", err, message); // send after callback
-            setTimeout(_attempt_to_recreate_secure_channel, 100);
+            setImmediate(_attempt_to_recreate_secure_channel, callback);
         };
-        const _attempt_to_recreate_secure_channel = () => {
-            if (this.reconnectionIsCanceled) {
-                this.emit("reconnection_canceled");
-                return callback(new Error("Reconnection has been canceled - " + this.clientName));
+        const _when_connected = (callback) => {
+            this.emit("after_reconnection", null); // send after callback
+            (0, node_opcua_assert_1.assert)(this._secureChannel, "expecting a secureChannel here ");
+            // a new channel has be created and a new connection is established
+            debugLog(chalk.bgWhite.red("ClientBaseImpl:  RECONNECTED                !!!"));
+            this._setInternalState("reconnecting_newchannel_connected");
+            return callback();
+        };
+        const _attempt_to_recreate_secure_channel = (callback) => {
+            debugLog("attempt to recreate a new secure channel");
+            if (this._reconnectionIsCanceled) {
+                return _when_reconnectionIsCanceled(callback);
             }
+            (0, node_opcua_assert_1.assert)(!this._secureChannel, "_attempt_to_recreate_secure_channel,  expecting this._secureChannel not to exist");
             this._internal_create_secure_channel(infiniteConnectionRetry, (err) => {
                 if (err) {
+                    // istanbul ignore next
+                    if (this._secureChannel) {
+                        const err = new Error("_internal_create_secure_channel failed, expecting this._secureChannel not to exist");
+                        return _when_internal_error(err, callback);
+                    }
                     if (err.message.match(/ECONNREFUSED|ECONNABORTED/)) {
-                        return callback(err);
+                        return _failAndRetry(err, "create secure channel failed with ECONNREFUSED|ECONNABORTED", callback);
                     }
                     if (err.message.match("Backoff aborted.")) {
-                        return failAndRetry(err, "cannot create secure channel (backoff aborted)");
+                        return _failAndRetry(err, "cannot create secure channel (backoff aborted)", callback);
                     }
                     if (err.message.match("BadCertificateInvalid") ||
                         err.message.match(/_socket has been disconnected by third party/)) {
@@ -396,51 +403,36 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
                         // the server may have shut down the channel because its certificate
                         // has changed ....
                         // let request the server certificate again ....
-                        debugLog(chalk.bgWhite.red("ClientBaseImpl: Server Certificate has changed." + " we need to retrieve server certificate again"));
                         return this.fetchServerCertificate(this.endpointUrl, (err1) => {
                             if (err1) {
-                                errorLog("Failing to fetch new server certificate: ", err1.message);
-                                return failAndRetry(err1, "trying to fetch new server certificate");
+                                return _failAndRetry(err1, "Failing to fetch new server certificate", callback);
                             }
                             warningLog("new server certificate ", (0, node_opcua_crypto_1.makeSHA1Thumbprint)(this.serverCertificate).toString("hex"));
                             this._internal_create_secure_channel(infiniteConnectionRetry, (err3) => {
                                 if (err3) {
-                                    return failAndRetry(err3, "trying to create new channel with new certificate");
+                                    return _failAndRetry(err3, "trying to create new channel with new certificate", callback);
                                 }
-                                this._setInternalState("connected");
-                                this.emit("connected");
-                                callback();
+                                return _when_connected(callback);
                             });
                         });
                     }
-                    debugLog(chalk.bgWhite.red("ClientBaseImpl: cannot reconnect .."));
-                    failAndRetry(err, "cannot create secure channel");
+                    else {
+                        return _failAndRetry(err, "cannot create secure channel", callback);
+                    }
                 }
                 else {
-                    /**
-                     * notify the observers that the reconnection process has been completed
-                     * @event after_reconnection
-                     * @param err
-                     */
-                    this.emit("after_reconnection", err); // send after callback
-                    (0, node_opcua_assert_1.assert)(this._secureChannel, "expecting a secureChannel here ");
-                    // a new channel has be created and a new connection is established
-                    debugLog(chalk.bgWhite.red("ClientBaseImpl:  RECONNECTED                !!!"));
-                    this._setInternalState("connected");
-                    return callback();
+                    return _when_connected(callback);
                 }
             });
         };
         // create a secure channel
         // a new secure channel must be established
-        setImmediate(() => {
-            _attempt_to_recreate_secure_channel();
-        });
+        _attempt_to_recreate_secure_channel(callback);
     }
     _internal_create_secure_channel(connectionStrategy, callback) {
         (0, node_opcua_assert_1.assert)(this._secureChannel === null);
         (0, node_opcua_assert_1.assert)(typeof this.endpointUrl === "string");
-        debugLog("_internal_create_secure_channel creating new ClientSecureChannelLayer");
+        debugLog("_internal_create_secure_channel creating new ClientSecureChannelLayer _internalState =", this._internalState);
         const secureChannel = new node_opcua_secure_channel_1.ClientSecureChannelLayer({
             connectionStrategy,
             defaultSecureTokenLifetime: this.defaultSecureTokenLifetime,
@@ -448,36 +440,33 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
             securityMode: this.securityMode,
             securityPolicy: this.securityPolicy,
             serverCertificate: this.serverCertificate,
-            tokenRenewalInterval: this.tokenRenewalInterval
+            tokenRenewalInterval: this.tokenRenewalInterval,
+            transportSettings: this._transportSettings
             // transportTimeout:
         });
+        secureChannel.on("backoff", (count, delay) => {
+            this.emit("backoff", count, delay);
+        });
+        secureChannel.on("abort", () => {
+            this.emit("abort");
+        });
         secureChannel.protocolVersion = this.protocolVersion;
         this._secureChannel = secureChannel;
         async.series([
             // ------------------------------------------------- STEP 2 : OpenSecureChannel
-            (_innerCallback) => {
+            (innerCallback) => {
                 debugLog("_internal_create_secure_channel before secureChannel.create");
                 secureChannel.create(this.endpointUrl, (err) => {
                     debugLog("_internal_create_secure_channel after secureChannel.create");
                     if (!this._secureChannel) {
                         debugLog("_secureChannel has been closed during the transaction !");
-                        return _innerCallback(new Error("Secure Channel Closed"));
+                        (0, node_opcua_assert_1.assert)(this.disconnecting);
+                        return innerCallback(new Error("Secure Channel Closed"));
                     }
-                    if (err) {
-                        debugLog(chalk.yellow("Cannot create secureChannel"), err.message ? chalk.cyan(err.message) : "");
-                        this._destroy_secure_channel();
-                    }
-                    else {
-                        (0, node_opcua_assert_1.assert)(this._secureChannel !== null);
+                    if (!err) {
                         this._install_secure_channel_event_handlers(secureChannel);
                     }
-                    _innerCallback(err);
-                });
-                secureChannel.on("backoff", (count, delay) => {
-                    this.emit("backoff", count, delay);
-                });
-                secureChannel.on("abort", () => {
-                    this.emit("abort");
+                    innerCallback(err);
                 });
             },
             // ------------------------------------------------- STEP 3 : GetEndpointsRequest
@@ -485,9 +474,10 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
                 (0, node_opcua_assert_1.assert)(this._secureChannel !== null);
                 if (!this.knowsServerEndpoint) {
                     this.getEndpoints((err /*, endpoints?: EndpointDescription[]*/) => {
-                        if (this._secureChannel === null) {
+                        if (!this._secureChannel) {
+                            debugLog("_secureChannel has been closed during the transaction ! (while getEndpoints)");
                             (0, node_opcua_assert_1.assert)(this.disconnecting);
-                            innerCallback(new Error("disconnecting"));
+                            return innerCallback(new Error("Secure Channel Closed"));
                         }
                         innerCallback(err ? err : undefined);
                     });
@@ -500,8 +490,15 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         ], (err) => {
             if (err) {
                 debugLog("Inner create secure channel has failed", err.message);
-                this._secureChannel = null;
-                callback(err);
+                if (this._secureChannel) {
+                    this._secureChannel.abortConnection(() => {
+                        this._destroy_secure_channel();
+                        callback(err);
+                    });
+                }
+                else {
+                    callback(err);
+                }
             }
             else {
                 (0, node_opcua_assert_1.assert)(this._secureChannel !== null);
@@ -714,10 +711,16 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         if (!this._secureChannel) {
             // this may happen if the Server has closed the connection abruptly for some unknown reason
             // or if the tcp connection has been broken.
-            return callback(new Error("No SecureChannel , connection may have been canceled abruptly by server"));
+            return callback(new Error("performMessageTransaction: No SecureChannel , connection may have been canceled abruptly by server"));
         }
-        if (this._internalState !== "connected" && this._internalState !== "connecting") {
-            return callback(new Error("Invalid client state " + this._internalState));
+        if (this._internalState !== "connected" &&
+            this._internalState !== "reconnecting_newchannel_connected" &&
+            this._internalState !== "connecting" &&
+            this._internalState !== "reconnecting") {
+            return callback(new Error("performMessageTransaction: Invalid client state " +
+                this._internalState +
+                " while performing a transaction " +
+                request.constructor.name));
         }
         (0, node_opcua_assert_1.assert)(this._secureChannel);
         (0, node_opcua_assert_1.assert)(request);
@@ -914,7 +917,8 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
             }
             return callback();
         }
-        this.reconnectionIsCanceled = true;
+        debugLog("disconnecting client! (will set reconnectionIsCanceled to true");
+        this._reconnectionIsCanceled = true;
         this.disconnecting = true;
         if (this._tmpClient) {
             this._tmpClient.disconnect((err) => {
@@ -926,7 +930,7 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
             return;
         }
         debugLog("ClientBaseImpl#disconnect", this.endpointUrl);
-        if (this.isReconnecting && !this.reconnectionIsCanceled) {
+        if (this.isReconnecting && !this._reconnectionIsCanceled) {
             debugLog("ClientBaseImpl#disconnect called while reconnection is in progress");
             // let's abort the reconnection process
             this._cancel_reconnection((err) => {
@@ -1112,9 +1116,10 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
                 debugLog(" DESTROYING SECURE CHANNEL (isTransactionInProgress ?", this._secureChannel.isTransactionInProgress(), ")");
             }
             this._accumulate_statistics();
-            this._secureChannel.dispose();
-            this._secureChannel.removeAllListeners();
+            const secureChannel = this._secureChannel;
             this._secureChannel = null;
+            secureChannel.dispose();
+            secureChannel.removeAllListeners();
         }
     }
     _close_pending_sessions(callback) {
@@ -1194,6 +1199,7 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         });
         secureChannel.on("close", (err) => {
             debugLog(chalk.yellow.bold(" ClientBaseImpl emitting close"), err === null || err === void 0 ? void 0 : err.message);
+            this._destroy_secure_channel();
             if (!err || !this.reconnectOnFailure) {
                 // this is a normal close operation initiated by us
                 /**
@@ -1201,14 +1207,17 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
                  * @param error
                  */
                 this.emit("close", err);
-                setImmediate(() => this._destroy_secure_channel());
             }
             else {
                 /**
                  * @event connection_lost
                  */
-                this.emit("connection_lost", err === null || err === void 0 ? void 0 : err.message); // instead of "close"
-                this._repairConnection();
+                // this.emit("close", err);
+                if (this.reconnectOnFailure && this._internalState !== "reconnecting") {
+                    debugLog(" ClientBaseImpl emitting connection_lost");
+                    this.emit("connection_lost", err === null || err === void 0 ? void 0 : err.message); // instead of "close"
+                    this._repairConnection();
+                }
             }
         });
         secureChannel.on("timed_out_request", (request) => {
@@ -1221,44 +1230,48 @@ class ClientBaseImpl extends node_opcua_common_1.OPCUASecureObject {
         });
     }
     _repairConnection() {
-        setImmediate(() => {
-            debugLog("recreating new secure channel ");
-            this._recreate_secure_channel((err1) => {
-                debugLog("secureChannel#on(close) => _recreate_secure_channel returns ", err1 ? err1.message : "OK");
-                if (err1) {
-                    // xx assert(!this._secureChannel);
-                    debugLog("_recreate_secure_channel has failed");
-                    this.emit("close", err1);
-                    this._setInternalState("disconnected");
-                    return;
-                }
-                else {
-                    this._finalReconnectionStep((err2) => {
-                        if (err2) {
-                            // istanbul ignore next
-                            if (doDebug) {
-                                debugLog("connection_reestablished has failed");
-                                debugLog("err= ", err2);
-                            }
-                            this.disconnect(() => {
-                                // we still need to retry connecting here !!!
-                                warningLog("Disconnected following reconnection failure", err2.message);
-                                warningLog("I will retry OPCUA client reconnection in 5 seconds");
-                                setTimeout(() => this._repairConnection(), 5000);
-                            });
-                            return;
-                        }
-                        else {
-                            /**
-                             * @event connection_reestablished
-                             *        send when the connection is reestablished after a connection break
-                             */
-                            this.emit("connection_reestablished");
-                            this._setInternalState("connected");
+        if (this._inside_repairConnection) {
+            errorLog("_repairConnection already in progress ", this._internalState);
+            return;
+        }
+        this._inside_repairConnection = true;
+        debugLog("recreating new secure channel ", this._internalState);
+        this._recreate_secure_channel((err1) => {
+            debugLog("secureChannel#on(close) => _recreate_secure_channel returns ", err1 ? err1.message : "OK");
+            if (err1) {
+                errorLog("_recreate_secure_channel has failed: err = ", err1.message);
+                this.emit("close", err1);
+                this._setInternalState("disconnected");
+                this._inside_repairConnection = false;
+                return;
+            }
+            else {
+                this._finalReconnectionStep((err2) => {
+                    if (err2) {
+                        // istanbul ignore next
+                        if (doDebug) {
+                            debugLog("connection_reestablished has failed");
+                            debugLog("err= ", err2.message);
                         }
-                    });
-                }
-            });
+                        // we still need to retry connecting here !!!
+                        debugLog("Disconnected following reconnection failure", err2.message);
+                        debugLog(`I will retry OPCUA client reconnection in ${client_base_1.OPCUAClientBase.retryDelay / 1000} seconds`);
+                        this._inside_repairConnection = false;
+                        this._destroy_secure_channel();
+                        setTimeout(() => this._repairConnection(), client_base_1.OPCUAClientBase.retryDelay);
+                        return;
+                    }
+                    else {
+                        /**
+                         * @event connection_reestablished
+                         *        send when the connection is reestablished after a connection break
+                         */
+                        this.emit("connection_reestablished");
+                        this._setInternalState("connected");
+                        this._inside_repairConnection = false;
+                    }
+                });
+            }
         });
     }
     _finalReconnectionStep(callback) {