node-opcua-client 2.122.0 → 2.124.0

package/source/private/client_publish_engine.ts

@@ -1,13 +1,11 @@
 /**
  * @module node-opcua-client-private
  */
-import { types } from "util";
-import async from "async";
 import chalk from "chalk";
+import { minDate } from "node-opcua-date-time";
 import { assert } from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
-import { PublishRequest, PublishResponse, RepublishRequest, RepublishResponse } from "node-opcua-service-subscription";
-import { StatusCodes } from "node-opcua-status-code";
+import { PublishRequest, PublishResponse } from "node-opcua-service-subscription";
 
 import { ClientSession, SubscriptionId } from "../client_session";
 import { ClientSubscription } from "../client_subscription";
@@ -41,7 +39,14 @@ export class ClientSidePublishEngine {
     public isSuspended: boolean;
     public session: ClientSession | null;
     private subscriptionAcknowledgements: any[];
-    private readonly subscriptionMap: { [key: number]: ClientSubscriptionImpl };
+
+    /**
+     * @internal
+     * @private
+     */
+    readonly subscriptionMap: { [key: number]: ClientSubscriptionImpl };
+
+    public lastRequestSentTime: Date = minDate;
 
     constructor(session: ClientSession) {
         this.session = session;
@@ -200,31 +205,6 @@ export class ClientSidePublishEngine {
         return Object.prototype.hasOwnProperty.call(this.subscriptionMap, subscriptionId);
     }
 
-    public republish(callback: () => void): void {
-        // After re-establishing the connection the Client shall call Republish in a loop, starting with
-        // the next expected sequence number and incrementing the sequence number until the Server returns
-        // the status BadMessageNotAvailable.
-        // After receiving this status, the Client shall start sending Publish requests with the normal Publish
-        // handling.
-        // This sequence ensures that the lost NotificationMessages queued in the Server are not overwritten
-        // by newPublish responses
-        /**
-         * call Republish continuously until all Notification messages of
-         * un-acknowledged notifications are reprocessed.
-         * @private
-         */
-        const repairSubscription = (
-            subscription: ClientSubscription,
-            subscriptionId: SubscriptionId | string,
-            innerCallback: () => void
-        ) => {
-            subscriptionId = parseInt(subscriptionId as string, 10);
-            this.__repairSubscription(subscription, subscriptionId, innerCallback);
-        };
-
-        async.forEachOf(this.subscriptionMap, repairSubscription, callback);
-    }
-
     public internalSendPublishRequest(): void {
         assert(this.session, "ClientSidePublishEngine terminated ?");
 
@@ -265,7 +245,7 @@ export class ClientSidePublishEngine {
         // in our case:
 
         assert(this.nbPendingPublishRequests > 0);
-        const calculatedTimeout = Math.min(0x7FFFFFFF, this.nbPendingPublishRequests * this.timeoutHint);
+        const calculatedTimeout = Math.min(0x7fffffff, this.nbPendingPublishRequests * this.timeoutHint);
 
         const publishRequest = new PublishRequest({
             requestHeader: { timeoutHint: calculatedTimeout }, // see note
@@ -278,6 +258,8 @@ export class ClientSidePublishEngine {
         session.publish(publishRequest, (err: Error | null, response?: PublishResponse) => {
             this.nbPendingPublishRequests -= 1;
 
+            this.lastRequestSentTime = new Date();
+
             if (err) {
                 debugLog(
                     chalk.cyan("ClientSidePublishEngine.prototype.internalSendPublishRequest callback : "),
@@ -403,102 +385,4 @@ export class ClientSidePublishEngine {
             debugLog(" or because there is no session for the subscription (session terminated ?).");
         }
     }
-
-    private _republish(subscription: any, subscriptionId: SubscriptionId, callback: (err?: Error) => void) {
-        assert(subscription.subscriptionId === +subscriptionId);
-
-        let isDone = false;
-        const session = this.session as ClientSessionImpl;
-
-        const sendRepublishFunc = (callback2: (err?: Error) => void) => {
-            assert(isFinite(subscription.lastSequenceNumber) && subscription.lastSequenceNumber + 1 >= 0);
-
-            const request = new RepublishRequest({
-                retransmitSequenceNumber: subscription.lastSequenceNumber + 1,
-                subscriptionId: subscription.subscriptionId
-            });
-
-            // istanbul ignore next
-            if (doDebug) {
-                // istanbul ignore next
-                debugLog(
-                    chalk.bgCyan.yellow.bold(" republish Request for subscription"),
-                    request.subscriptionId,
-                    " retransmitSequenceNumber=",
-                    request.retransmitSequenceNumber
-                );
-            }
-
-            if (!session || session!._closeEventHasBeenEmitted) {
-                debugLog("ClientPublishEngine#_republish aborted ");
-                // has  client been disconnected in the mean time ?
-                isDone = true;
-                return callback2();
-            }
-            session.republish(request, (err: Error | null, response?: RepublishResponse) => {
-                const statusCode = err ? StatusCodes.Bad : response!.responseHeader.serviceResult;
-                if (!err && (statusCode.equals(StatusCodes.Good) || statusCode.equals(StatusCodes.BadMessageNotAvailable))) {
-                    // reprocess notification message  and keep going
-                    if (statusCode.equals(StatusCodes.Good)) {
-                        subscription.onNotificationMessage(response!.notificationMessage);
-                    }
-                } else {
-                    if (!err) {
-                        err = new Error(response!.responseHeader.serviceResult.toString());
-                    }
-                    debugLog(" _send_republish ends with ", err.message);
-                    isDone = true;
-                }
-                callback2(err ? err : undefined);
-            });
-        };
-
-        setImmediate(() => {
-            assert(typeof callback === "function");
-            async.whilst(
-                (cb: (err: null, truth: boolean) => void) => cb(null, !isDone),
-                sendRepublishFunc,
-                ((err?: Error | null): void => {
-                    debugLog("nbPendingPublishRequest = ", this.nbPendingPublishRequests);
-                    debugLog(" _republish ends with ", err ? err.message : "null");
-                    callback(err!);
-                }) as any // Wait for @type/async bug to be fixed !
-            );
-        });
-    }
-
-    private __repairSubscription(
-        subscription: ClientSubscription,
-        subscriptionId: SubscriptionId,
-        callback: (err?: Error) => void
-    ) {
-        debugLog("__repairSubscription  for SubscriptionId ", subscriptionId);
-
-        this._republish(subscription, subscriptionId, (err?: Error) => {
-            assert(!err || types.isNativeError(err));
-
-            debugLog("__repairSubscription--------------------- err =", err ? err.message : null);
-
-            if (err && err.message.match(/BadSessionInvalid/)) {
-                // _republish failed because session is not valid anymore on server side.
-                return callback(err);
-            }
-            if (err && err.message.match(/SubscriptionIdInvalid/)) {
-                // _republish failed because subscriptionId is not valid anymore on server side.
-                //
-                // This could happen when the subscription has timed out and has been deleted by server
-                // Subscription may time out if the duration of the connection break exceed the max life time
-                // of the subscription.
-                //
-                // In this case, Client must recreate a subscription and recreate monitored item without altering
-                // the event handlers
-                //
-                debugLog(chalk.bgWhite.red("_republish failed " + " subscriptionId is not valid anymore on server side."));
-
-                const subscriptionI = subscription as ClientSubscriptionImpl;
-                return subscriptionI.recreateSubscriptionAndMonitoredItem(callback);
-            }
-            callback();
-        });
-    }
 }

package/source/private/client_session_impl.ts

@@ -124,11 +124,11 @@ import {
     HistoryReadValueIdOptions2,
     ExtraReadHistoryValueParameters
 } from "../client_session";
+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";
-import { UserIdentityInfo } from "../user_identity_info";
+import { repair_client_session } from "./reconnection/reconnection";
 
 import { ClientSidePublishEngine } from "./client_publish_engine";
 import { ClientSubscriptionImpl } from "./client_subscription_impl";
@@ -1012,7 +1012,25 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
      * @param value   {Variant} - the value to write
      * @return {Promise<StatusCode>} - the status code of the write
      *
-     * @deprecated
+     * @deprecated use session.write instead
+     *
+     * @example
+     *     // please use session.write instead of session.writeSingleNode
+     *     // as follow
+     *     const statusCode = await session.write({
+     *          nodeId,
+     *          attributeId: AttributeIds.Value,
+     *          value: {
+     *             statusCode: Good,
+     *             sourceTimestamp: new Date(), // optional, some server may not accept this
+     *             value: {
+     *               dataType: opcua.DataType.Double,
+     *               value: 100.0
+     *             }
+     *          }
+     *     });
+     *
+     *
      */
     public writeSingleNode(nodeId: NodeIdLike, value: VariantLike, callback: ResponseCallback<StatusCode>): void;
 
@@ -1474,28 +1492,12 @@ 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
-        //     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,13 +2016,6 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             .catch(callback);
     }
 
-    public resumePublishEngine(): void {
-        assert(this._publishEngine);
-        if (this._publishEngine && this._publishEngine.subscriptionCount > 0) {
-            this._publishEngine.replenish_publish_request_queue();
-        }
-    }
-
     public async readNamespaceArray(): Promise<string[]>;
     public readNamespaceArray(callback: (err: Error | null, namespaceArray?: string[]) => void): void;
     public readNamespaceArray(...args: any[]): any {
@@ -2205,6 +2200,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         request: Request,
         callback: (err: Error | null, response?: Response) => void
     ) {
+        warningLog("attempt to recreate session to reperform a transation ", request.constructor.name);
         if (this.recursive_repair_detector >= 1) {
             // tslint:disable-next-line: no-console
             warningLog("recreate_session_and_reperform_transaction => Already in Progress");
@@ -2230,10 +2226,7 @@ type promoteOpaqueStructure3WithCallbackFunc = (
     callback: ErrorCallback
 ) => void;
 
-async function promoteOpaqueStructure2(
-    session: IBasicSessionAsync2,
-    callMethodResult: CallMethodResult
-): Promise<void> {
+async function promoteOpaqueStructure2(session: IBasicSessionAsync2, callMethodResult: CallMethodResult): Promise<void> {
     if (!callMethodResult || !callMethodResult.outputArguments || callMethodResult.outputArguments.length === 0) {
         return;
     }