node-opcua-client 2.59.0 → 2.62.1

package/source/private/opcua_client_impl.ts

@@ -278,7 +278,7 @@ function createUserNameIdentityToken(
 
     // istanbul ignore next
     if (!cryptoFactory) {
-        throw new Error(" Unsupported security Policy");
+        throw new Error(" Unsupported security Policy "+  securityPolicy.toString());
     }
 
     identityToken = new UserNameIdentityToken({
@@ -418,6 +418,42 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         });
     }
 
+    /**
+     * createSession2 create a session with persistance
+     *
+     * - if the server returns BadTooManySession, the method will make an other attempt
+     *   unitl create session succeed or connection is closed.
+     *
+     * @experiemental
+     * @param userIdentityInfo
+     */
+    public async createSession2(userIdentityInfo?: UserIdentityInfo): Promise<ClientSession>;
+    public createSession2(userIdentityInfo: UserIdentityInfo, callback: Callback<ClientSession>): void;
+    public createSession2(callback: Callback<ClientSession>): void;
+    public createSession2(...args: any[]): any {
+        if (args.length === 1) {
+            return this.createSession2({ type: UserTokenType.Anonymous }, args[0]);
+        }
+        const userIdentityInfo = args[0] as UserIdentityInfo;
+        const callback = args[1] as Callback<ClientSession>;
+        if (!this._secureChannel) {
+            // we do not have a connection anymore
+            return callback(new Error("Connection is closed"));
+        }
+        return this.createSession(args[0], (err: Error | null, session?: ClientSession) => {
+            if (err && err.message.match(/BadTooManySessions/)) {
+                const delayToRetry = 5; // seconds
+                errorLog(`TooManySession .... we need to retry later  ... in  ${delayToRetry} secondes`);
+                const retryCreateSessionTimer = setTimeout(() => {
+                    errorLog("TooManySession .... now retrying");
+                    this.createSession2(userIdentityInfo, callback);
+                }, delayToRetry * 1000);
+                return;
+            }
+            callback(err, session);
+        });
+    }
+
     /**
      * @method changeSessionIdentity
      * @param session
@@ -471,6 +507,52 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         return str;
     }
 
+    /**
+     *
+     * @example
+     *
+     * ```javascript
+     *
+     * const session = await OPCUAClient.createSession(endpointUrl);
+     * const dataValue = await session.read({ nodeId, attributeId: AttributeIds.Value });
+     * await session.close();
+     *
+     * ```
+     * @stability experimental
+     *
+     * @param endpointUrl
+     * @param userIdentity
+     * @returns session
+     *
+     *
+     * const create
+     */
+    public static async createSession(
+        endpointUrl: string,
+        userIdentity?: UserIdentityInfo,
+        clientOptions?: OPCUAClientOptions
+    ): Promise<ClientSession> {
+        const client = OPCUAClient.create(clientOptions || {});
+
+        await client.connect(endpointUrl);
+        const session = await client.createSession2(userIdentity);
+
+        const oldClose = session.close as any;
+        (session as any).close = thenify.withCallback((...args: any[]): any => {
+            if (args.length === 1) {
+                return session.close(true, args[0]);
+            }
+            const deleteSubscriptions = args[0] as boolean;
+            const callback = args[1] as Callback<void>;
+            session.close = oldClose;
+            oldClose.call(session, deleteSubscriptions, (err?: Error) => {
+                client.disconnect((err?: Error | null) => {
+                    callback(err!);
+                });
+            });
+        });
+        return session;
+    }
     /**
      * @method withSession
      */
@@ -484,7 +566,6 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         inner_func: (session: ClientSession, done: (err?: Error) => void) => void,
         callback: (err?: Error) => void
     ): void;
-
     /**
      * @internal
      * @param args
@@ -514,6 +595,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
                     this.connect(endpointUrl, (err?: Error) => {
                         need_disconnect = true;
                         if (err) {
+                            warningLog(err.message);
                             errorLog(" cannot connect to endpoint :", endpointUrl);
                         }
                         innerCallback(err);
@@ -522,7 +604,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
 
                 // step 2 : createSession
                 (innerCallback: ErrorCallback) => {
-                    this.createSession(userIdentity, (err: Error | null, session?: ClientSession) => {
+                    this.createSession2(userIdentity, (err: Error | null, session?: ClientSession) => {
                         if (err) {
                             return innerCallback(err);
                         }
@@ -570,7 +652,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
             ],
             (err1) => {
                 if (err1) {
-                    console.log("err", err1);
+                    console.log("err", err1.message);
                 }
                 if (need_disconnect) {
                     errorLog("Disconnecting client after failure");
@@ -624,7 +706,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
             typeof connectionPoint === "string" ? { type: UserTokenType.Anonymous } : connectionPoint.userIdentity;
 
         await this.connect(endpointUrl);
-        const session = await this.createSession(userIdentity);
+        const session = await this.createSession2(userIdentity);
 
         let result;
         try {
@@ -673,7 +755,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
 
         assert(typeof callback === "function");
         if (!this._secureChannel) {
-            throw new Error(" client must be connected first");
+            return callback!(new Error(" client must be connected first"));
         }
         // istanbul ignore next
         if (!this.__resolveEndPoint() || !this.endpoint) {
@@ -737,13 +819,15 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         callback: (err: Error | null, session?: ClientSessionImpl) => void
     ): void {
         assert(typeof callback === "function");
-        if (!this._secureChannel) {
-            throw new Error("Invalid channel");
-        }
         assert(this.serverUri !== undefined, " must have a valid server URI " + this.serverUri);
         assert(this.endpointUrl !== undefined, " must have a valid server endpointUrl");
         assert(this.endpoint);
 
+        // istanbul ignore next
+        if (!this._secureChannel) {
+            return callback(new Error("Invalid channel"));
+        }
+
         const applicationUri = this._getApplicationUri();
 
         const applicationDescription: ApplicationDescriptionOptions = {
@@ -777,7 +861,13 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* istanbul ignore next */
             if (err) {
-                return callback(err);
+                // we could have an invalid state here or a connection error
+                errorLog("error: ", err.message, " retrying in ... 5 secondes");
+                setTimeout(() => {
+                    errorLog(" .... now retrying");
+                    this.__createSession_step3(session, callback);
+                }, 5 * 1000);
+                return;
             }
 
             /* istanbul ignore next */
@@ -786,7 +876,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
             }
 
             if (response.responseHeader.serviceResult === StatusCodes.BadTooManySessions) {
-                return callback(new Error("Too Many Sessions : " + response.responseHeader.serviceResult.toString()));
+                return callback(new Error(response.responseHeader.serviceResult.toString()));
             }
 
             if (response.responseHeader.serviceResult !== StatusCodes.Good) {
@@ -848,6 +938,7 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
     public _activateSession(session: ClientSessionImpl, callback: (err: Error | null, session?: ClientSessionImpl) => void): void {
         // see OPCUA Part 4 - $7.35
         assert(typeof callback === "function");
+
         // istanbul ignore next
         if (!this._secureChannel) {
             return callback(new Error(" No secure channel"));
@@ -1169,6 +1260,7 @@ const thenify = require("thenify");
  *
  */
 OPCUAClientImpl.prototype.createSession = thenify.withCallback(OPCUAClientImpl.prototype.createSession);
+OPCUAClientImpl.prototype.createSession2 = thenify.withCallback(OPCUAClientImpl.prototype.createSession2);
 /**
  * @method changeSessionIdentity
  * @async

package/source/reconnection.ts

@@ -8,7 +8,7 @@ import * as 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";
-import { StatusCodes } from "node-opcua-status-code";
+import { CallbackT, StatusCodes } from "node-opcua-status-code";
 import { ErrorCallback } from "node-opcua-status-code";
 
 import { SubscriptionId } from "./client_session";
@@ -133,6 +133,33 @@ function _ask_for_subscription_republish(session: ClientSessionImpl, callback: (
     });
 }
 
+function create_session_and_repeat_if_failed(
+    client: IClientBase,
+    session: ClientSessionImpl,
+    callback: CallbackT<ClientSessionImpl>
+) {
+    if (session.hasBeenClosed()) {
+        return callback(new Error("Cannot complete subscription republish due to session termination"));
+    }
+    debugLog(chalk.bgWhite.red("    => creating a new session ...."));
+    // create new session, based on old session,
+    // so we can reuse subscriptions data
+    client.__createSession_step2(session, (err: Error | null, session1?: ClientSessionImpl) => {
+        debugLog(chalk.bgWhite.cyan("    => creating a new session (based on old session data).... Done"));
+        if (!err && session1) {
+            const newSession = session1;
+            assert(session === session1, "session should have been recycled");
+            callback(err, newSession);
+            return;
+        } else {
+            setTimeout(() => {
+                create_session_and_repeat_if_failed(client, session, callback);
+            }, 1000);
+            return;
+        }
+        callback(err);
+    });
+}
 function repair_client_session_by_recreating_a_new_session(
     client: IClientBase,
     session: ClientSessionImpl,
@@ -164,20 +191,11 @@ function repair_client_session_by_recreating_a_new_session(
             },
 
             function create_new_session(innerCallback: ErrorCallback) {
-                if (session.hasBeenClosed()) {
-                    return innerCallback(new Error("Cannot complete subscription republish due to session termination"));
-                }
-
-                debugLog(chalk.bgWhite.red("    => creating a new session ...."));
-                // create new session, based on old session,
-                // so we can reuse subscriptions data
-                client.__createSession_step2(session, (err: Error | null, session1?: ClientSessionImpl) => {
-                    debugLog(chalk.bgWhite.cyan("    => creating a new session (based on old session data).... Done"));
-                    if (!err && session1) {
-                        newSession = session1;
-                        assert(session === session1, "session should have been recycled");
+                create_session_and_repeat_if_failed(client, session, (err?: Error | null, _newSession?: ClientSessionImpl) => {
+                    if (_newSession) {
+                        newSession = _newSession;
                     }
-                    innerCallback(err ? err : undefined);
+                    innerCallback(err || undefined);
                 });
             },
 
@@ -386,8 +404,8 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
     _repair_client_session(client, session, (err) => {
         privateSession._reconnecting.reconnecting = false;
         if (err) {
-            debugLog(chalk.red("SESSION RESTORED HAS FAILED! retrying"), err.message, session.sessionId.toString());
-            // xx return repair_client_session(client, session, callback);
+            errorLog(chalk.red("SESSION RESTORED HAS FAILED! retrying"), err.message, session.sessionId.toString());
+            return _repair_client_session(client, session, callback);
         }
         debugLog(chalk.yellow("SESSION RESTORED"), session.sessionId.toString());
         session.emit("session_restored");
@@ -413,7 +431,7 @@ export function repair_client_sessions(client: IClientBase, callback: (err?: Err
             repair_client_session(client, session as ClientSessionImpl, next);
         },
         (err) => {
-            debugLog(chalk.red.bgWhite("sessions reactivation completed: err ", err ? err.message : "null"));
+            err && errorLog("sessions reactivation completed: err ", err ? err.message : "null");
             return callback(err!);
         }
     );

package/source/tools/read_history_server_capabilities.ts

@@ -91,7 +91,7 @@ export function readHistoryServerCapabilities(
             const nodeIds = results.map((innerResult: BrowsePathResult) =>
                 innerResult.statusCode === StatusCodes.Good && innerResult.targets
                     ? innerResult.targets[0].targetId
-                    : NodeId.nullNodeId
+                    : new NodeId()
             );
 
             const nodesToRead: ReadValueIdOptions[] = nodeIds.map((nodeId: NodeId) => ({