node-opcua-client 2.128.0 → 2.130.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-client",
-    "version": "2.128.0",
+    "version": "2.130.0",
     "description": "pure nodejs OPCUA SDK - module client",
     "scripts": {
         "clean": "npx rimraf node_modules dist *.tsbuildinfo certificates",
@@ -17,51 +17,51 @@
         "@types/async": "^3.2.24",
         "async": "^3.2.5",
         "chalk": "4.1.2",
-        "node-opcua-alarm-condition": "2.128.0",
+        "node-opcua-alarm-condition": "2.130.0",
         "node-opcua-assert": "2.120.0",
         "node-opcua-basic-types": "2.128.0",
         "node-opcua-buffer-utils": "2.128.0",
-        "node-opcua-certificate-manager": "2.128.0",
-        "node-opcua-client-dynamic-extension-object": "2.128.0",
-        "node-opcua-common": "2.128.0",
+        "node-opcua-certificate-manager": "2.129.0",
+        "node-opcua-client-dynamic-extension-object": "2.130.0",
+        "node-opcua-common": "2.130.0",
         "node-opcua-constants": "2.125.0",
-        "node-opcua-crypto": "4.8.0",
+        "node-opcua-crypto": "4.9.2",
         "node-opcua-data-model": "2.128.0",
-        "node-opcua-data-value": "2.128.0",
+        "node-opcua-data-value": "2.129.0",
         "node-opcua-date-time": "2.128.0",
         "node-opcua-debug": "2.128.0",
         "node-opcua-extension-object": "2.128.0",
         "node-opcua-hostname": "2.128.0",
         "node-opcua-nodeid": "2.128.0",
         "node-opcua-object-registry": "2.128.0",
-        "node-opcua-pki": "4.10.0",
-        "node-opcua-pseudo-session": "2.128.0",
-        "node-opcua-schemas": "2.128.0",
-        "node-opcua-secure-channel": "2.128.0",
-        "node-opcua-service-browse": "2.128.0",
-        "node-opcua-service-call": "2.128.0",
-        "node-opcua-service-discovery": "2.128.0",
-        "node-opcua-service-endpoints": "2.128.0",
-        "node-opcua-service-filter": "2.128.0",
-        "node-opcua-service-history": "2.128.0",
-        "node-opcua-service-query": "2.128.0",
-        "node-opcua-service-read": "2.128.0",
-        "node-opcua-service-register-node": "2.128.0",
-        "node-opcua-service-secure-channel": "2.128.0",
-        "node-opcua-service-session": "2.128.0",
-        "node-opcua-service-subscription": "2.128.0",
-        "node-opcua-service-translate-browse-path": "2.128.0",
-        "node-opcua-service-write": "2.128.0",
+        "node-opcua-pki": "4.11.1",
+        "node-opcua-pseudo-session": "2.130.0",
+        "node-opcua-schemas": "2.129.0",
+        "node-opcua-secure-channel": "2.130.0",
+        "node-opcua-service-browse": "2.129.0",
+        "node-opcua-service-call": "2.129.0",
+        "node-opcua-service-discovery": "2.129.0",
+        "node-opcua-service-endpoints": "2.129.0",
+        "node-opcua-service-filter": "2.129.0",
+        "node-opcua-service-history": "2.129.0",
+        "node-opcua-service-query": "2.129.0",
+        "node-opcua-service-read": "2.129.0",
+        "node-opcua-service-register-node": "2.129.0",
+        "node-opcua-service-secure-channel": "2.129.0",
+        "node-opcua-service-session": "2.129.0",
+        "node-opcua-service-subscription": "2.130.0",
+        "node-opcua-service-translate-browse-path": "2.129.0",
+        "node-opcua-service-write": "2.129.0",
         "node-opcua-status-code": "2.128.0",
-        "node-opcua-types": "2.128.0",
+        "node-opcua-types": "2.129.0",
         "node-opcua-utils": "2.128.0",
-        "node-opcua-variant": "2.128.0",
+        "node-opcua-variant": "2.129.0",
         "thenify": "^3.3.1"
     },
     "devDependencies": {
         "@types/underscore": "^1.11.15",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space": "2.128.0",
+        "node-opcua-address-space": "2.130.0",
         "node-opcua-binary-stream": "2.128.0",
         "node-opcua-factory": "2.128.0",
         "node-opcua-leak-detector": "2.128.0",
@@ -88,7 +88,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "67a73af6b831d8651a0e66ceb295f159cab4386b",
+    "gitHead": "94bf9012b03dbd4325cd122ce04edfa5466875bc",
     "files": [
         "dist",
         "source"

package/source/client_base.ts

@@ -137,6 +137,10 @@ export interface OPCUAClientBaseOptions {
      */
     transportSettings?: TransportSettings;
     transportTimeout?: number;
+    /**
+     * defaultTransactionTimeout
+     */
+    defaultTransactionTimeout?: number;
 }
 
 export interface GetEndpointsOptions {
@@ -284,7 +288,7 @@ export interface OPCUAClientBase extends EventEmitter {
      * @param event
      * @param eventHandler
      */
-    on(eventName: "security_token_renewed", eventHandler: () => void): this;
+    on(eventName: "security_token_renewed", eventHandler: (channel: ClientSecureChannelLayer, token: ChannelSecurityToken) => void): this;
 
     /**
      * this event is raised when the connection has been broken

package/source/opcua_client.ts

@@ -45,6 +45,7 @@ export interface OPCUAClientOptions extends OPCUAClientBaseOptions {
      * default value : "Auto" : the client will attempt to extract DataTypeDefinition using the most efficient strategy
      */
     dataTypeExtractStrategy?: DataTypeExtractStrategy;
+
 }
 
 export interface OPCUAClient extends OPCUAClientBase {

package/source/private/client_base_impl.ts

@@ -24,8 +24,7 @@ import {
     ConnectionStrategyOptions,
     Request as Request1,
     Response as Response1,
-    SecurityPolicy,
-    SecurityToken
+    SecurityPolicy
 } from "node-opcua-secure-channel";
 import {
     FindServersOnNetworkRequest,
@@ -367,6 +366,7 @@ export class ClientBaseImpl extends OPCUASecureObject implements OPCUAClientBase
     public discoveryUrl: string;
     public readonly applicationName: string;
     private _applicationUri: string;
+    public defaultTransactionTimeout?: number;
 
     /**
      * true if session shall periodically probe the server to keep the session alive and prevent timeout
@@ -468,6 +468,9 @@ export class ClientBaseImpl extends OPCUASecureObject implements OPCUAClientBase
         this._serverEndpoints = [];
 
         this.defaultSecureTokenLifetime = options.defaultSecureTokenLifetime || 600000;
+
+        this.defaultTransactionTimeout = options.defaultTransactionTimeout;
+
         this.tokenRenewalInterval = options.tokenRenewalInterval || 0;
         assert(isFinite(this.tokenRenewalInterval) && this.tokenRenewalInterval >= 0);
         this.securityMode = coerceMessageSecurityMode(options.securityMode);
@@ -686,7 +689,8 @@ export class ClientBaseImpl extends OPCUASecureObject implements OPCUAClientBase
             serverCertificate: this.serverCertificate,
             tokenRenewalInterval: this.tokenRenewalInterval,
             transportSettings: this._transportSettings,
-            transportTimeout: this._transportTimeout
+            transportTimeout: this._transportTimeout,
+            defaultTransactionTimeout: this.defaultTransactionTimeout
         });
         secureChannel.on("backoff", (count: number, delay: number) => {
             this.emit("backoff", count, delay);
@@ -700,6 +704,8 @@ export class ClientBaseImpl extends OPCUASecureObject implements OPCUAClientBase
 
         this._secureChannel = secureChannel;
 
+        this.emit("secure_channel_created", secureChannel);
+
         async.series(
             [
                 // ------------------------------------------------- STEP 2 : OpenSecureChannel
@@ -980,10 +986,6 @@ export class ClientBaseImpl extends OPCUASecureObject implements OPCUAClientBase
         });
     }
 
-    public getClientNonce(): Nonce | null {
-        return this._secureChannel ? this._secureChannel.getClientNonce() : null;
-    }
-
     public performMessageTransaction(request: Request, callback: ResponseCallback<Response>): void {
         if (!this._secureChannel) {
             // this may happen if the Server has closed the connection abruptly for some unknown reason
@@ -1595,9 +1597,9 @@ export class ClientBaseImpl extends OPCUASecureObject implements OPCUAClientBase
             this.emit("lifetime_75", token, secureChannel);
         });
 
-        secureChannel.on("security_token_renewed", () => {
+        secureChannel.on("security_token_renewed", (token: ChannelSecurityToken) => {
             // forward message to upper level
-            this.emit("security_token_renewed", secureChannel);
+            this.emit("security_token_renewed", secureChannel, token);
         });
 
         secureChannel.on("close", (err?: Error | null) => {

package/source/private/client_publish_engine.ts

@@ -281,7 +281,7 @@ export class ClientSidePublishEngine {
                     // the server tells us that there is no subscription for this session
                     // but the client have some active subscription left.
                     // This could happen if the client has missed or not received the StatusChange Notification
-                    debugLog(chalk.bgWhite.red(" WARNING :   SERVER TELLS THAT IT HAS NO SUBSCRIPTION , " + "BUT CLIENT DISAGREE"));
+                    debugLog(chalk.bgWhite.red(" WARNING: server tells that there is no Subscription, but client disagree"));
                     debugLog("this.activeSubscriptionCount =", this.activeSubscriptionCount);
                     active = false;
                 }
@@ -292,7 +292,7 @@ export class ClientSidePublishEngine {
                     // may be the session timeout is shorted than the subscription life time
                     // and the client does not send intermediate keepAlive request to keep the connection working.
                     //
-                    debugLog(chalk.bgWhite.red(" WARNING : SERVER TELLS THAT THE SESSION HAS CLOSED ..."));
+                    debugLog(chalk.bgWhite.red(" WARNING : Server tells that the session has closed ..."));
                     debugLog(
                         "   the ClientSidePublishEngine shall now be disabled," + " as server will reject any further request"
                     );
@@ -313,10 +313,11 @@ export class ClientSidePublishEngine {
                         this.nbMaxPublishRequestsAcceptedByServer
                     );
                     active = false;
-
-                    warningLog(chalk.bgWhite.red(" WARNING : SERVER TELLS THAT TOO MANY" + " PUBLISH REQUEST HAS BEEN SEND ..."));
-                    warningLog(" On our side nbPendingPublishRequests = ", this.nbPendingPublishRequests);
-                    warningLog(" => nbMaxPublishRequestsAcceptedByServer =", this.nbMaxPublishRequestsAcceptedByServer);
+                    if (this.nbPendingPublishRequests < 10) {
+                        warningLog(chalk.bgWhite.red(" warning : server tells that too many publish request has been send ..."));
+                        warningLog(" On our side nbPendingPublishRequests = ", this.nbPendingPublishRequests);
+                        warningLog(" => nbMaxPublishRequestsAcceptedByServer =", this.nbMaxPublishRequestsAcceptedByServer);
+                    }
                 }
             } else {
                 // istanbul ignore next

package/source/private/client_session_impl.ts

@@ -96,9 +96,11 @@ import { WriteRequest, WriteResponse, WriteValue } from "node-opcua-service-writ
 import { StatusCode, StatusCodes, Callback, CallbackT } from "node-opcua-status-code";
 import { ErrorCallback } from "node-opcua-status-code";
 import {
+    ActivateSessionRequest,
     AggregateConfigurationOptions,
     BrowseNextRequest,
     BrowseNextResponse,
+    CloseSessionRequest,
     HistoryReadValueIdOptions,
     UserTokenType,
     WriteValueOptions
@@ -129,11 +131,11 @@ import { UserIdentityInfo } from "../user_identity_info";
 import { ClientSessionKeepAliveManager } from "../client_session_keepalive_manager";
 import { ClientSubscription } from "../client_subscription";
 import { Request, Response } from "../common";
-import { repair_client_session } from "./reconnection/reconnection";
 
 import { ClientSidePublishEngine } from "./client_publish_engine";
 import { ClientSubscriptionImpl } from "./client_subscription_impl";
 import { IClientBase } from "./i_private_client";
+import { repair_client_session } from "./reconnection/reconnection";
 
 const helpAPIChange = process.env.DEBUG && process.env.DEBUG.match(/API/);
 const debugLog = make_debugLog(__filename);
@@ -182,17 +184,18 @@ export interface Reconnectable {
     _reconnecting: {
         reconnecting: boolean;
         pendingCallbacks: EmptyCallback[];
+        pendingTransactions: { request: Request, callback: (err: Error | null, response?: Response) => void }[];
     };
-    pendingTransactions: any[];
-    pendingTransactionsCount: number;
 }
+
 /**
  * @class ClientSession
  * @param client {OPCUAClientImpl}
  * @constructor
  * @private
  */
-export class ClientSessionImpl extends EventEmitter implements ClientSession {
+export class ClientSessionImpl extends EventEmitter implements ClientSession, Reconnectable {
+    static reconnectingElement: WeakMap<ClientSessionImpl, Reconnectable> = new WeakMap();
     public timeout: number;
     public authenticationToken?: NodeId;
     public requestedMaxReferencesPerNode: number;
@@ -202,18 +205,16 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
     public serverCertificate: Certificate;
     public userIdentityInfo?: UserIdentityInfo;
     public name = "";
-
     public serverNonce?: Nonce;
     public serverSignature?: SignatureData; // todo : remove ?
     public serverEndpoints: EndpointDescription[] = [];
     public _client: IClientBase | null;
     public _closed: boolean;
 
-    private _reconnecting: {
+    public _reconnecting: {
         reconnecting: boolean;
         pendingCallbacks: EmptyCallback[];
         pendingTransactions: any[];
-        pendingTransactionsCount: number;
     };
 
     /**
@@ -241,8 +242,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         this._reconnecting = {
             reconnecting: false,
             pendingCallbacks: [],
-            pendingTransactions: [],
-            pendingTransactionsCount: 0
+            pendingTransactions: []
         };
 
         this.requestedMaxReferencesPerNode = 10000;
@@ -1166,7 +1166,6 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
      * @param args
      */
     public read(...args: any[]): any {
-
         if (args.length === 2) {
             return this.read(args[0], 0, args[1]);
         }
@@ -1502,16 +1501,11 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             // 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"));
         }
-
-        this._reconnecting.pendingTransactions = this._reconnecting.pendingTransactions || [];
-        this._reconnecting.pendingTransactionsCount = this._reconnecting.pendingTransactionsCount || 0;
-
-        const isPublishRequest = request instanceof PublishRequest;
-        if (isPublishRequest) {
+        if (request instanceof PublishRequest || request instanceof ActivateSessionRequest || request instanceof CloseSessionRequest) {
             return this._performMessageTransaction(request, callback);
         }
 
-        if (this._reconnecting.pendingTransactionsCount > 0) {
+        if (this._reconnecting.pendingTransactions.length > 0) {
             /* istanbul ignore next */
             if (this._reconnecting.pendingTransactions.length > 10) {
                 if (!pendingTransactionMessageDisplayed) {
@@ -1542,33 +1536,32 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             this._reconnecting.pendingTransactions.push({ request, callback });
             return;
         }
-        this.processTransactionQueue(request, callback);
+        this.#reprocessRequest(0, request, callback);
     }
-    public processTransactionQueue = (request: Request, callback: (err: Error | null, response?: Response) => void): void => {
-        this._reconnecting.pendingTransactionsCount = this._reconnecting.pendingTransactionsCount || 0;
-        this._reconnecting.pendingTransactionsCount++;
+    #reprocessRequest = (attemptCount: number, request: Request, callback: (err: Error | null, response?: Response) => void): void => {
 
+        (attemptCount>0) && warningLog("reprocessRequest => ", request.constructor.name, this._reconnecting.pendingTransactions.length);
         this._performMessageTransaction(request, (err: null | Error, response?: Response) => {
-            this._reconnecting.pendingTransactionsCount--;
-
             if (err && err.message.match(/BadSessionIdInvalid/) && request.constructor.name !== "ActivateSessionRequest") {
-                debugLog("Transaction on Invalid Session ", request.constructor.name);
+                warningLog("Transaction on Invalid Session ", request.constructor.name, err.message, "isReconnecting?=", this.isReconnecting, "q=", this._reconnecting.pendingTransactions.length);
                 request.requestHeader.requestHandle = requestHandleNotSetValue;
-                warningLog("client is now attempting to recreate a session");
-                this.recreate_session_and_reperform_transaction(request, callback);
+                if (this.isReconnecting) {
+                    this.once("session_restored", () => {
+                        warningLog("redoing", request.constructor.name, this.isReconnecting);
+                        this.#reprocessRequest(attemptCount+1,request, callback);
+                    });
+                } else {
+                    this.#_recreate_session_and_reperform_transaction(request, callback);
+                }
                 return;
             }
             callback(err, response);
             const length = this._reconnecting.pendingTransactions.length; // record length before callback is called !
             if (length > 0) {
-                debugLog(
-                    "processTransactionQueue => ",
-                    this._reconnecting.pendingTransactions.length,
-                    " transaction(s) left in queue"
-                );
+                debugLog("reprocessRequest => ", this._reconnecting.pendingTransactions.length, " transaction(s) left in queue");
                 // tslint:disable-next-line: no-shadowed-variable
                 const { request, callback } = this._reconnecting.pendingTransactions.shift();
-                this.processTransactionQueue(request, callback);
+                this.#reprocessRequest(0, request, callback);
             }
         });
     };
@@ -2001,8 +1994,8 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         str += "\n remaining life time...... " + this.evaluateRemainingLifetime();
         str += "\n subscription count....... " + this.subscriptionCount;
         if (this._client && this._client._secureChannel) {
-            if (this._client._secureChannel.securityToken) {
-                str += "\n reviseTokenLifetime...... " + this._client._secureChannel.securityToken.revisedLifetime;
+            if (this._client._secureChannel.activeSecurityToken) {
+                str += "\n reviseTokenLifetime...... " + this._client._secureChannel.activeSecurityToken.revisedLifetime;
             }
         }
         str += "\n keepAlive ................ " + this._keepAliveManager ? true : false;
@@ -2180,29 +2173,29 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             callback(null, response);
         });
     }
-
-    private recreate_session_and_reperform_transaction(
+    #_recreate_session_and_reperform_transaction(
         request: Request,
         callback: (err: Error | null, response?: Response) => void
     ) {
-        warningLog("attempt to recreate session to reperform a transation ", request.constructor.name);
+        warningLog("attempt to recreate session to reperform a transaction ", request.constructor.name);
         if (this.recursive_repair_detector >= 1) {
             // tslint:disable-next-line: no-console
             warningLog("recreate_session_and_reperform_transaction => Already in Progress");
             return callback(new Error("Cannot recreate session"));
         }
         this.recursive_repair_detector += 1;
-        debugLog(chalk.red("----------------> Repairing Client Session as Server believes it is invalid now "));
+        warningLog(chalk.red("----------------> Repairing Client Session as Server believes it is invalid now "));
         repair_client_session(this._client!, this, (err?: Error) => {
             this.recursive_repair_detector -= 1;
             if (err) {
-                debugLog(chalk.red("----------------> session Repaired has failed with error", err.message));
+                warningLog(chalk.red("----------------> session Repaired has failed with error", err.message));
                 return callback(err);
             }
-            debugLog(chalk.red("----------------> session Repaired, now redoing original transaction "));
+            warningLog(chalk.red("----------------> session Repaired, now redoing original transaction "));
             this._performMessageTransaction(request, callback);
         });
     }
+
 }
 
 type promoteOpaqueStructure3WithCallbackFunc = (

package/source/private/opcua_client_impl.ts

@@ -371,10 +371,6 @@ function _adjustRevisedSessionTimeout(revisedSessionTimeout: number, requestedTi
     return revisedSessionTimeout;
 }
 
-/***
- * @constructor
- * @internal
- */
 export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
     public static minimumRevisedSessionTimeout = 100.0;
     private _retryCreateSessionTimer?: NodeJS.Timeout;

package/source/private/reconnection/reconnection.ts

@@ -216,19 +216,19 @@ function repair_client_session_by_recreating_a_new_session(
                 doDebug && debugLog(chalk.red("          => RECREATING SUBSCRIPTION  "), subscriptionId);
                 assert(subscription.session === newSession, "must have the new session");
 
-                recreateSubscriptionAndMonitoredItem(subscription).then(() => {
-                    doDebug &&
-                        debugLog(
-                            chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE subscriptionId="),
-                            subscriptionId
-                        );
-                    next();
-
-                }).catch((err) => {
-                    doDebug && debugLog("_recreateSubscription failed !" + (err as Error).message);
-                    next();
-                });
-
+                recreateSubscriptionAndMonitoredItem(subscription)
+                    .then(() => {
+                        doDebug &&
+                            debugLog(
+                                chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE subscriptionId="),
+                                subscriptionId
+                            );
+                        next();
+                    })
+                    .catch((err) => {
+                        doDebug && debugLog("_recreateSubscription failed !" + (err as Error).message);
+                        next();
+                    });
             },
             (err1?: Error | null) => {
                 // prettier-ignore
@@ -310,18 +310,25 @@ function repair_client_session_by_recreating_a_new_session(
                 if (!client.beforeSubscriptionRecreate) {
                     innerCallback();
                     return;
-
                 }
-                client.beforeSubscriptionRecreate(newSession)
+                client
+                    .beforeSubscriptionRecreate(newSession)
                     .then((err) => {
-                        { const err = _shouldNotContinue(session); if (err) { return innerCallback(err); } }
+                        {
+                            const err = _shouldNotContinue(session);
+                            if (err) {
+                                return innerCallback(err);
+                            }
+                        }
                         if (!err) {
                             innerCallback();
                         } else {
                             innerCallback(err);
                         }
                     })
-                    .catch((err) => { innerCallback(err) });
+                    .catch((err) => {
+                        innerCallback(err);
+                    });
             },
 
             function attempt_subscription_transfer(innerCallback: ErrorCallback) {
@@ -506,7 +513,7 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
     privateSession._reconnecting.reconnecting = true;
 
     // get old transaction queue ...
-    const transactionQueue = privateSession.pendingTransactions ? privateSession.pendingTransactions.splice(0) : [];
+    const transactionQueue =  privateSession._reconnecting.pendingTransactions.splice(0);
 
     const repeatedAction = (callback: EmptyCallback) => {
         // prettier-ignore
@@ -527,6 +534,10 @@ 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); 
+                        } }
                         errorLog(chalk.red("Retrying session repair..."));
                         repeatedAction(callback);
                     }, delay);
@@ -547,13 +558,14 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
     };
     repeatedAction((err) => {
         privateSession._reconnecting.reconnecting = false;
-
-        const otherCallbacks = privateSession._reconnecting.pendingCallbacks;
-        privateSession._reconnecting.pendingCallbacks = [];
+        const otherCallbacks = privateSession._reconnecting.pendingCallbacks.splice(0);
         // re-inject element in queue
+        
         // istanbul ignore next
-        doDebug && debugLog(chalk.yellow("re-injecting transaction queue"), transactionQueue.length);
-        transactionQueue.forEach((e: any) => privateSession.pendingTransactions.push(e));
+        if (transactionQueue.length > 0) {
+            doDebug && debugLog(chalk.yellow("re-injecting transaction queue"), transactionQueue.length);
+            transactionQueue.forEach((e: any) => privateSession._reconnecting.pendingTransactions.push(e));
+        }
         otherCallbacks.forEach((c: EmptyCallback) => c(err));
         callback(err);
     });