node-opcua-client 2.173.1 → 2.175.0

package/source/private/opcua_client_impl.ts

@@ -21,6 +21,7 @@ import {
 import { LocalizedText } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { extractFullyQualifiedDomainName } from "node-opcua-hostname";
+import type { NodeId } from "node-opcua-nodeid";
 import { readNamespaceArray } from "node-opcua-pseudo-session";
 import {
     type ClientSecureChannelLayer,
@@ -48,7 +49,6 @@ import {
 import { type Callback, type CallbackT, type StatusCode, StatusCodes } from "node-opcua-status-code";
 import type { SignatureDataOptions, UserIdentityToken } from "node-opcua-types";
 import { isNullOrUndefined, matchUri, randomBytes } from "node-opcua-utils";
-import type { NodeId } from "node-opcua-nodeid";
 import type { OPCUAClientBaseEvents } from "../client_base";
 import type { ClientSession } from "../client_session";
 import type { ClientSubscriptionOptions } from "../client_subscription";
@@ -563,11 +563,7 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             clearTimeout(this._retryCreateSessionTimer);
             this._retryCreateSessionTimer = undefined;
         }
-        super.closeSession(
-            session as unknown as ClientSessionImpl,
-            deleteSubscriptions,
-            callback as (err?: Error) => void
-        );
+        super.closeSession(session as unknown as ClientSessionImpl, deleteSubscriptions, callback as (err?: Error) => void);
     }
 
     public toJSON(): Record<string, string | number | boolean | undefined> {
@@ -733,11 +729,11 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             return callback?.(
                 new Error(
                     " End point must exist " +
-                    this._secureChannel?.endpointUrl +
-                    "  securityMode = " +
-                    MessageSecurityMode[this.securityMode] +
-                    "  securityPolicy = " +
-                    this.securityPolicy
+                        this._secureChannel?.endpointUrl +
+                        "  securityMode = " +
+                        MessageSecurityMode[this.securityMode] +
+                        "  securityPolicy = " +
+                        this.securityPolicy
                 )
             );
         }
@@ -968,7 +964,9 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
                 // clientCertificate. The SignatureAlgorithm shall be the AsymmetricSignatureAlgorithm
                 // specified in the SecurityPolicy for the Endpoint. The SignatureData type is defined in 7.30.
 
-                clientSignature: this.computeClientSignature(this._secureChannel as ClientSecureChannelLayer, serverCertificate, serverNonce) || undefined,
+                clientSignature:
+                    this.computeClientSignature(this._secureChannel as ClientSecureChannelLayer, serverCertificate, serverNonce) ||
+                    undefined,
 
                 // These are the SoftwareCertificates which have been issued to the Client application.
                 // The productUri contained in the SoftwareCertificates shall match the productUri in the
@@ -1013,7 +1011,7 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             session.lastRequestSentTime = new Date();
 
             this.performMessageTransaction(request, (err1: Error | null, response?: Response) => {
-                if (!err1 && response && response.responseHeader.serviceResult === StatusCodes.Good) {
+                if (!err1 && response && response.responseHeader.serviceResult.isGoodish()) {
                     /* c8 ignore next */
                     if (!(response instanceof ActivateSessionResponse)) {
                         return callback(new Error("Internal Error"));
@@ -1023,6 +1021,9 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
                         return callback(new Error("Invalid server Nonce"));
                     }
                     session._client = this;
+                    // capture the activation outcome (e.g. Good_PasswordChangeRequired,
+                    // OPC 10000-18 §5.2.8) so a Client can react without server access.
+                    session.lastActivateSessionStatusCode = response.responseHeader.serviceResult;
                     session.serverNonce = response.serverNonce;
                     session.lastResponseReceivedTime = new Date();
                     if (this.keepSessionAlive) {
@@ -1152,11 +1153,11 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             return callback(
                 new Error(
                     " End point must exist " +
-                    this._secureChannel?.endpointUrl +
-                    "  securityMode = " +
-                    MessageSecurityMode[this.securityMode] +
-                    "  securityPolicy = " +
-                    this.securityPolicy
+                        this._secureChannel?.endpointUrl +
+                        "  securityMode = " +
+                        MessageSecurityMode[this.securityMode] +
+                        "  securityPolicy = " +
+                        this.securityPolicy
                 )
             );
         }

package/source/private/reconnection/client_publish_engine_reconnection.ts

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import assert from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { StatusCodes } from "node-opcua-status-code";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
 import { RepublishRequest, type RepublishResponse } from "node-opcua-types";
 import type { ClientSidePublishEngine } from "../client_publish_engine";
 import type { ClientSessionImpl } from "../client_session_impl";
@@ -12,6 +12,33 @@ import { _shouldNotContinue2 } from "./reconnection";
 const debugLog = make_debugLog("RECONNECTION");
 const doDebug = checkDebugFlag("RECONNECTION");
 
+/**
+ * Recover the StatusCode carried by a Republish reply, whether it came back as a regular
+ * RepublishResponse (operation-level serviceResult) or as a ServiceFault.
+ *
+ * Precedence:
+ *   1. the explicit `response` argument, when the server answered with a regular RepublishResponse
+ *      (the operation-level serviceResult, e.g. CoDeSys);
+ *   2. otherwise `err.response` — the secure channel layer turns a ServiceFault into an Error and
+ *      attaches the original response there;
+ *   3. otherwise fall back to parsing the error message.
+ */
+function extractStatusCode(err: Error | null | undefined, response?: RepublishResponse): StatusCode {
+    if (response) {
+        return response.responseHeader.serviceResult;
+    }
+    if (err) {
+        const faultResponse = (err as { response?: { responseHeader?: { serviceResult?: StatusCode } } }).response;
+        if (faultResponse?.responseHeader?.serviceResult) {
+            return faultResponse.responseHeader.serviceResult;
+        }
+        if (/BadMessageNotAvailable/.test(err.message)) {
+            return StatusCodes.BadMessageNotAvailable;
+        }
+    }
+    return StatusCodes.Bad;
+}
+
 function _sendRepublish(
     session: ClientSessionImpl,
     subscription: ClientSubscriptionImpl
@@ -41,16 +68,22 @@ function _sendRepublish(
         }
 
         session.republish(request, (err: Error | null, response?: RepublishResponse) => {
+            // BadMessageNotAvailable signals the end of the republish loop: there are no more
+            // queued NotificationMessages to replay and the client must now resume normal Publish
+            // handling (OPC UA Part 4 §6.5/§6.7). A server may report it either as a ServiceFault
+            // (err set, no response) or as the serviceResult of a regular RepublishResponse
+            // (operation-level result, e.g. CoDeSys). Both cases must terminate the loop.
+            const statusCode = extractStatusCode(err, response);
+            if (statusCode.equals(StatusCodes.BadMessageNotAvailable)) {
+                return resolve({ isDone: true });
+            }
             if (!response) {
                 reject(err);
                 return;
             }
-            const statusCode = err ? StatusCodes.Bad : response.responseHeader.serviceResult;
-            if (!err && (statusCode.equals(StatusCodes.Good) || statusCode.equals(StatusCodes.BadMessageNotAvailable))) {
+            if (!err && statusCode.equals(StatusCodes.Good)) {
                 // reprocess notification message and keep going
-                if (statusCode.equals(StatusCodes.Good)) {
-                    subscription.onNotificationMessage(response.notificationMessage);
-                }
+                subscription.onNotificationMessage(response.notificationMessage);
                 return resolve({ isDone: false });
             }
             if (!err) {
@@ -120,8 +153,10 @@ async function __askSubscriptionRepublish(
             await recreateSubscriptionAndMonitoredItem(subscription);
             return;
         }
-        if (error.message.match(/|MessageNotAvailable/)) {
-            // start engine and start monitoring
+        if (error.message.match(/BadMessageNotAvailable/)) {
+            // End of the republish loop: no more queued messages to replay.
+            // Nothing else to do here, the caller will resume normal Publish handling.
+            return;
         }
     }
     // check after successful republish too

package/source/private/reconnection/reconnection.ts

@@ -8,7 +8,6 @@ import { assert } from "node-opcua-assert";
 import { invalidateExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { TransferSubscriptionsRequest, type TransferSubscriptionsResponse } from "node-opcua-service-subscription";
-import { StatusCodes } from "node-opcua-status-code";
 import { CloseSessionRequest } from "node-opcua-types";
 import type { ClientSessionImpl, Reconnectable } from "../client_session_impl";
 import type { ClientSubscriptionImpl } from "../client_subscription_impl";
@@ -162,6 +161,19 @@ function _ask_for_subscription_republish(session: ClientSessionImpl, callback: (
             return repair_client_session_by_recreating_a_new_session(session._client!, session, callback);
         }
 
+        // Republish has completed: resume normal Publish handling. During the connection break the
+        // in-flight PublishRequests have failed and the publish-request queue has drained, so we must
+        // replenish it now, otherwise the client would stop sending PublishRequests and never receive
+        // live notifications again. (https://github.com/node-opcua/node-opcua/issues/1524)
+        // Note: on the new-session repair path the engine is still suspended here, so this is a no-op
+        // there and the queue is replenished later by suspend(false).
+        // Guard on subscriptionCount: with no subscription, send_publish_request() would still emit
+        // spurious PublishRequests (it does not check the subscription count itself), adding useless
+        // round-trips on every reconnection of a subscription-less session.
+        if (engine.subscriptionCount > 0) {
+            engine.replenish_publish_request_queue();
+        }
+
         callback(err);
     });
 }
@@ -174,7 +186,8 @@ function create_session_and_repeat_if_failed(client: IClientBase, session: Clien
         // create new session, based on old session,
         // so we can reuse subscriptions data
         client.__createSession_step2(session, (err: Error | null, session1?: ClientSessionImpl) => {
-            _throwIfShouldNotContinue(session);
+            const abortErr = _shouldNotContinue(session);
+            if (abortErr) return reject(abortErr);
 
             if (!err && session1) {
                 assert(session === session1, "session should have been recycled");
@@ -286,7 +299,8 @@ function attempt_subscription_transfer(
             subscriptionsToTransfer,
             (err: Error | null, transferSubscriptionsResponse?: TransferSubscriptionsResponse) => {
                 // may be the connection with server has been disconnected
-                _throwIfShouldNotContinue(session);
+                const abortErr = _shouldNotContinue(session);
+                if (abortErr) return reject(abortErr);
 
                 if (err || !transferSubscriptionsResponse) {
                     warningLog(chalk.bgCyan("May be the server is not supporting this feature"));
@@ -315,13 +329,19 @@ function attempt_subscription_transfer(
                 // those one need to be recreated and repaired ....
                 for (let i = 0; i < results.length; i++) {
                     const statusCode = results[i].statusCode;
-                    if (statusCode.equals(StatusCodes.BadSubscriptionIdInvalid)) {
-                        // repair subscription
+                    if (statusCode.isNotGood()) {
+                        // the subscription could not be transferred (BadSubscriptionIdInvalid when the
+                        // subscription no longer exists, BadUserAccessDenied when the server refuses the
+                        // transfer per OPC UA Part 4 §5.14.7, ...). Whatever the reason, recreate it here
+                        // directly on the new session instead of relying on the subsequent Republish step
+                        // to notice and repair it (which would otherwise cost an extra failed round-trip).
                         doDebug &&
                             debugLog(
                                 chalk.red("         WARNING SUBSCRIPTION  "),
                                 subscriptionsIds[i],
-                                chalk.red(" SHOULD BE RECREATED")
+                                chalk.red(" SHOULD BE RECREATED ("),
+                                statusCode.toString(),
+                                chalk.red(")")
                             );
 
                         subscriptionsToRecreate.push(subscriptionsIds[i]);