node-opcua-server 2.156.0 → 2.158.0

package/dist/register_server_manager.js

@@ -3,13 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegisterServerManager = exports.RegisterServerManagerStatus = void 0;
+exports.RegisterServerManager = void 0;
 /**
  * @module node-opcua-server
  */
 // tslint:disable:no-console
 const events_1 = require("events");
-const async_1 = __importDefault(require("async"));
 const chalk_1 = __importDefault(require("chalk"));
 const node_opcua_assert_1 = require("node-opcua-assert");
 const node_opcua_client_1 = require("node-opcua-client");
@@ -19,17 +18,10 @@ const node_opcua_secure_channel_1 = require("node-opcua-secure-channel");
 const node_opcua_service_discovery_1 = require("node-opcua-service-discovery");
 const node_opcua_types_1 = require("node-opcua-types");
 const web_1 = require("node-opcua-crypto/web");
-const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
-const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
-const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
-var RegisterServerManagerStatus;
-(function (RegisterServerManagerStatus) {
-    RegisterServerManagerStatus[RegisterServerManagerStatus["INACTIVE"] = 1] = "INACTIVE";
-    RegisterServerManagerStatus[RegisterServerManagerStatus["INITIALIZING"] = 2] = "INITIALIZING";
-    RegisterServerManagerStatus[RegisterServerManagerStatus["REGISTERING"] = 3] = "REGISTERING";
-    RegisterServerManagerStatus[RegisterServerManagerStatus["WAITING"] = 4] = "WAITING";
-    RegisterServerManagerStatus[RegisterServerManagerStatus["UNREGISTERING"] = 5] = "UNREGISTERING";
-})(RegisterServerManagerStatus || (exports.RegisterServerManagerStatus = RegisterServerManagerStatus = {}));
+const i_register_server_manager_1 = require("./i_register_server_manager");
+const doDebug = (0, node_opcua_debug_1.checkDebugFlag)("REGISTER_LDS");
+const debugLog = (0, node_opcua_debug_1.make_debugLog)("REGISTER_LDS");
+const warningLog = (0, node_opcua_debug_1.make_warningLog)("REGISTER_LDS");
 const g_DefaultRegistrationServerTimeout = 8 * 60 * 1000; // 8 minutes
 function securityPolicyLevel(securityPolicy) {
     switch (securityPolicy) {
@@ -100,7 +92,7 @@ function findSecureEndpoint(endpoints) {
 }
 function constructRegisteredServer(server, isOnline) {
     const discoveryUrls = server.getDiscoveryUrls();
-    (0, node_opcua_assert_1.assert)(!isOnline || discoveryUrls.length >= 1, "expecting some discoveryUrls if we go online ....");
+    (0, node_opcua_assert_1.assert)(!isOnline || discoveryUrls.length >= 1, "expecting some discoveryUrls if we go online .... ");
     const info = (0, web_1.exploreCertificate)(server.getCertificate());
     const commonName = info.tbsCertificate.subject.commonName;
     const serverUri = info.tbsCertificate.extensions?.subjectAltName.uniformResourceIdentifier[0];
@@ -150,9 +142,9 @@ function constructRegisterServer2Request(serverB, isOnline) {
         server
     });
 }
-const no_reconnect_connectivity_strategy = {
-    initialDelay: 2000,
-    maxDelay: 50000,
+const no_retry_connectivity_strategy = {
+    initialDelay: 1000,
+    maxDelay: 2000,
     maxRetry: 1, // NO RETRY !!!
     randomisationFactor: 0
 };
@@ -162,17 +154,17 @@ const infinite_connectivity_strategy = {
     maxRetry: 10000000,
     randomisationFactor: 0
 };
-function sendRegisterServerRequest(server, client, isOnline, callback) {
+const pause = async (duration) => await new Promise((resolve) => setTimeout(resolve, duration));
+async function sendRegisterServerRequest(server, client, isOnline) {
     // try to send a RegisterServer2Request
     const request = constructRegisterServer2Request(server, isOnline);
-    client.performMessageTransaction(request, (err, response) => {
-        if (!err) {
-            // RegisterServerResponse
-            debugLog("RegisterServerManager#_registerServer sendRegisterServer2Request has succeeded (isOnline", isOnline, ")");
-            (0, node_opcua_assert_1.assert)(response instanceof node_opcua_service_discovery_1.RegisterServer2Response);
-            callback(err);
-        }
-        else {
+    await new Promise((resolve, reject) => {
+        client.performMessageTransaction(request, (err, response) => {
+            if (!err) {
+                // RegisterServerResponse
+                debugLog("RegisterServerManager#_registerServer sendRegisterServer2Request has succeeded (isOnline", isOnline, ")");
+                return resolve();
+            }
             debugLog("RegisterServerManager#_registerServer sendRegisterServer2Request has failed " + "(isOnline", isOnline, ")");
             debugLog("RegisterServerManager#_registerServer" + " falling back to using sendRegisterServerRequest instead");
             // fall back to
@@ -180,26 +172,24 @@ function sendRegisterServerRequest(server, client, isOnline, callback) {
             client.performMessageTransaction(request1, (err1, response1) => {
                 if (!err1) {
                     debugLog("RegisterServerManager#_registerServer sendRegisterServerRequest " + "has succeeded (isOnline", isOnline, ")");
-                    (0, node_opcua_assert_1.assert)(response1 instanceof node_opcua_service_discovery_1.RegisterServerResponse);
-                }
-                else {
-                    debugLog("RegisterServerManager#_registerServer sendRegisterServerRequest " + "has failed (isOnline", isOnline, ")");
+                    return resolve();
                 }
-                callback(err1);
+                debugLog("RegisterServerManager#_registerServer sendRegisterServerRequest " + "has failed (isOnline", isOnline, ")");
+                reject(err1);
             });
-        }
+        });
     });
 }
 let g_registeringClientCounter = 0;
 /**
  * RegisterServerManager is responsible to Register an opcua server on a LDS or LDS-ME server
  * This class takes in charge :
- *  - the initial registration of a server
- *  - the regular registration renewal (every 8 minutes or so ...)
- *  - dealing with cases where LDS is not up and running when server starts.
- *    ( in this case the connection will be continuously attempted using the infinite
- *    back-off strategy
- *  - the un-registration of the server ( during shutdown for instance)
+ * - the initial registration of a server
+ * - the regular registration renewal (every 8 minutes or so ...)
+ * - dealing with cases where LDS is not up and running when server starts.
+ * ( in this case the connection will be continuously attempted using the infinite
+ * back-off strategy
+ * - the un-registration of the server ( during shutdown for instance)
  *
  * Events:
  *
@@ -223,13 +213,21 @@ let g_registeringClientCounter = 0;
  * (LDS => Local Discovery Server)
  */
 class RegisterServerManager extends events_1.EventEmitter {
+    discoveryServerEndpointUrl;
+    timeout;
+    server;
+    _registrationTimerId;
+    state = i_register_server_manager_1.RegisterServerManagerStatus.INACTIVE;
+    _registration_client = null;
+    selectedEndpoint;
+    _serverEndpoints = [];
+    getState() {
+        return this.state;
+    }
     constructor(options) {
         super();
-        this.state = RegisterServerManagerStatus.INACTIVE;
-        this._registration_client = null;
-        this._serverEndpoints = [];
         this.server = options.server;
-        this._setState(RegisterServerManagerStatus.INACTIVE);
+        this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.INACTIVE);
         this.timeout = g_DefaultRegistrationServerTimeout;
         this.discoveryServerEndpointUrl = options.discoveryServerEndpointUrl || "opc.tcp://localhost:4840";
         (0, node_opcua_assert_1.assert)(typeof this.discoveryServerEndpointUrl === "string");
@@ -238,7 +236,6 @@ class RegisterServerManager extends events_1.EventEmitter {
     dispose() {
         this.server = null;
         debugLog("RegisterServerManager#dispose", this.state.toString());
-        (0, node_opcua_assert_1.assert)(this.state === RegisterServerManagerStatus.INACTIVE);
         if (this._registrationTimerId) {
             clearTimeout(this._registrationTimerId);
             this._registrationTimerId = null;
@@ -246,335 +243,327 @@ class RegisterServerManager extends events_1.EventEmitter {
         (0, node_opcua_assert_1.assert)(this._registrationTimerId === null, "stop has not been called");
         this.removeAllListeners();
     }
-    _emitEvent(eventName) {
+    #_emitEvent(eventName) {
         setImmediate(() => {
+            debugLog("emiting event", eventName);
             this.emit(eventName);
         });
     }
-    _setState(status) {
-        const previousState = this.state || RegisterServerManagerStatus.INACTIVE;
-        debugLog("RegisterServerManager#setState : ", RegisterServerManagerStatus[previousState], " => ", RegisterServerManagerStatus[status]);
+    #_setState(status) {
+        const previousState = this.state || i_register_server_manager_1.RegisterServerManagerStatus.INACTIVE;
+        debugLog("RegisterServerManager#setState : ", i_register_server_manager_1.RegisterServerManagerStatus[previousState], " => ", i_register_server_manager_1.RegisterServerManagerStatus[status]);
         this.state = status;
     }
-    start(callback) {
+    /**
+     * The start method initiates the registration process in a non-blocking way.
+     * It immediately returns while the actual work is performed in a background task.
+     */
+    async start() {
         debugLog("RegisterServerManager#start");
-        if (this.state !== RegisterServerManagerStatus.INACTIVE) {
-            return callback(new Error("RegisterServer process already started")); // already started
+        if (this.state !== i_register_server_manager_1.RegisterServerManagerStatus.INACTIVE) {
+            throw new Error("RegisterServer process already started: " + i_register_server_manager_1.RegisterServerManagerStatus[this.state]);
         }
         this.discoveryServerEndpointUrl = (0, node_opcua_hostname_1.resolveFullyQualifiedDomainName)(this.discoveryServerEndpointUrl);
-        // perform initial registration + automatic renewal
-        this._establish_initial_connection((err) => {
-            if (err) {
-                debugLog("RegisterServerManager#start => _establish_initial_connection has failed");
-                return callback(err);
-            }
-            if (this.state !== RegisterServerManagerStatus.INITIALIZING) {
-                debugLog("RegisterServerManager#start => _establish_initial_connection has failed");
-                return callback();
-            }
-            this._registerServer(true, (err1) => {
-                if (this.state !== RegisterServerManagerStatus.REGISTERING) {
-                    debugLog("RegisterServerManager#start )=> Registration has been cancelled");
-                    return callback(new Error("Registration has been cancelled"));
+        // Immediately set the state to INITIALIZING and run the process in the background.
+        this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZING);
+        // This method is called without await to ensure it is non-blocking.
+        // The catch block handles any synchronous errors.
+        this.#_runRegistrationProcess().catch((err) => {
+            warningLog("Synchronous error in #_runRegistrationProcess: ", (err?.message));
+        });
+    }
+    /**
+     * Private method to run the entire registration process in the background.
+     * It handles the state machine transitions and re-connection logic.
+     * @private
+     */
+    async #_runRegistrationProcess() {
+        while (this.getState() !== i_register_server_manager_1.RegisterServerManagerStatus.WAITING && !this.#_isTerminating()) {
+            debugLog("RegisterServerManager#_runRegistrationProcess - state =", i_register_server_manager_1.RegisterServerManagerStatus[this.state], "isTerminating =", this.#_isTerminating());
+            try {
+                if (this.getState() === i_register_server_manager_1.RegisterServerManagerStatus.INACTIVE) {
+                    this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZING);
+                }
+                await this.#_establish_initial_connection();
+                if (this.getState() !== i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZING) {
+                    debugLog("RegisterServerManager#_runRegistrationProcess: aborted during initialization");
+                    return;
                 }
-                if (err1) {
-                    warningLog("RegisterServerManager#start - registering server has failed ! \n" +
-                        "please check that your server certificate is accepted by the LDS");
-                    this._setState(RegisterServerManagerStatus.INACTIVE);
-                    this._emitEvent("serverRegistrationFailure");
+                this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZED);
+                this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.REGISTERING);
+                this.#_emitEvent("serverRegistrationPending");
+                await this.#_registerOrUnregisterServer(true);
+                if (this.getState() !== i_register_server_manager_1.RegisterServerManagerStatus.REGISTERING) {
+                    debugLog("RegisterServerManager#_runRegistrationProcess: aborted during registration");
+                    return;
                 }
-                else {
-                    this._emitEvent("serverRegistered");
-                    this._setState(RegisterServerManagerStatus.WAITING);
-                    this._trigger_next();
+                this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.REGISTERED);
+                this.#_emitEvent("serverRegistered");
+                this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.WAITING);
+                this.#_trigger_next();
+                return;
+            }
+            catch (err) {
+                debugLog("RegisterServerManager#_runRegistrationProcess - operation failed!", (err.message));
+                if (!this.#_isTerminating()) {
+                    this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.INACTIVE);
+                    this.#_emitEvent("serverRegistrationFailure");
+                    await pause(Math.min(5000, this.timeout));
                 }
-                callback();
-            });
-        });
+            }
+        }
     }
-    _establish_initial_connection(outer_callback) {
-        /* istanbul ignore next */
+    #_isTerminating() {
+        return this.getState() === i_register_server_manager_1.RegisterServerManagerStatus.UNREGISTERING || this.getState() === i_register_server_manager_1.RegisterServerManagerStatus.DISPOSING;
+    }
+    /**
+     * Establish the initial connection with the Discovery Server to extract best endpoint to use.
+     * @private
+     */
+    async #_establish_initial_connection() {
         if (!this.server) {
-            throw new Error("Internal Error");
+            this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.DISPOSING);
+            return;
+        }
+        if (this.state !== i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZING) {
+            debugLog("RegisterServerManager#_establish_initial_connection: aborting due to state change");
+            return;
         }
         debugLog("RegisterServerManager#_establish_initial_connection");
         (0, node_opcua_assert_1.assert)(!this._registration_client);
         (0, node_opcua_assert_1.assert)(typeof this.discoveryServerEndpointUrl === "string");
-        (0, node_opcua_assert_1.assert)(this.state === RegisterServerManagerStatus.INACTIVE);
-        this._setState(RegisterServerManagerStatus.INITIALIZING);
+        (0, node_opcua_assert_1.assert)(this.state === i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZING);
         this.selectedEndpoint = undefined;
         const applicationName = (0, node_opcua_client_1.coerceLocalizedText)(this.server.serverInfo.applicationName)?.text || undefined;
-        // Retry Strategy must be set
         this.server.serverCertificateManager.referenceCounter++;
-        const prefix = "Client-" + g_registeringClientCounter++ + " - ";
+        const server = this.server;
+        const prefix = `Client-${g_registeringClientCounter++}`;
+        const action = "initializing";
+        const ldsInfo = this.discoveryServerEndpointUrl;
+        const serverInfo = this.server?.serverInfo.applicationUri;
+        const clientName = `${prefix} for server ${serverInfo} to LDS ${ldsInfo} for ${action}`;
         const registrationClient = node_opcua_client_1.OPCUAClientBase.create({
-            clientName: prefix + " Registering Client for Server " + this.server.serverInfo.applicationUri,
+            clientName,
             applicationName,
-            applicationUri: this.server.serverInfo.applicationUri,
+            applicationUri: server.serverInfo.applicationUri,
             connectionStrategy: infinite_connectivity_strategy,
-            clientCertificateManager: this.server.serverCertificateManager,
-            certificateFile: this.server.certificateFile,
-            privateKeyFile: this.server.privateKeyFile
+            clientCertificateManager: server.serverCertificateManager,
+            certificateFile: server.certificateFile,
+            privateKeyFile: server.privateKeyFile
         });
-        this._registration_client = registrationClient;
         registrationClient.on("backoff", (nbRetry, delay) => {
+            if (this.state !== i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZING)
+                return; // Ignore event if state has changed
             debugLog("RegisterServerManager - received backoff");
-            warningLog(registrationClient.clientName, chalk_1.default.bgWhite.cyan("contacting discovery server backoff "), this.discoveryServerEndpointUrl, " attempt #", nbRetry, " retrying in ", delay / 1000.0, " seconds");
-            this._emitEvent("serverRegistrationPending");
+            debugLog(registrationClient.clientName, chalk_1.default.bgWhite.cyan("contacting discovery server backoff "), this.discoveryServerEndpointUrl, " attempt #", nbRetry, " retrying in ", delay / 1000.0, " seconds");
+            this.#_emitEvent("serverRegistrationPending");
         });
-        async_1.default.series([
-            //  do_initial_connection_with_discovery_server
-            (callback) => {
-                registrationClient.connect(this.discoveryServerEndpointUrl, (err) => {
-                    if (err) {
-                        debugLog("RegisterServerManager#_establish_initial_connection " + ": initial connection to server has failed");
-                        // xx debugLog(err);
-                    }
-                    return callback(err);
-                });
-            },
-            // getEndpoints_on_discovery_server
-            (callback) => {
-                registrationClient.getEndpoints((err, endpoints) => {
-                    if (!err) {
-                        const endpoint = findSecureEndpoint(endpoints);
-                        if (!endpoint) {
-                            throw new Error("Cannot find Secure endpoint");
-                        }
-                        if (endpoint.serverCertificate) {
-                            (0, node_opcua_assert_1.assert)(endpoint.serverCertificate);
-                            this.selectedEndpoint = endpoint;
-                        }
-                        else {
-                            this.selectedEndpoint = undefined;
-                        }
-                    }
-                    else {
-                        debugLog("RegisterServerManager#_establish_initial_connection " + ": getEndpointsRequest has failed");
-                        debugLog(err);
-                    }
-                    callback(err);
-                });
-            },
-            // function closing_discovery_server_connection
-            (callback) => {
-                this._serverEndpoints = registrationClient._serverEndpoints;
-                registrationClient.disconnect((err) => {
-                    this._registration_client = null;
-                    callback(err);
-                });
-            },
-            // function wait_a_little_bit
-            (callback) => {
-                setTimeout(callback, 10);
-            }
-        ], (err) => {
-            debugLog("-------------------------------", !!err);
-            if (this.state !== RegisterServerManagerStatus.INITIALIZING) {
-                debugLog("RegisterServerManager#_establish_initial_connection has been interrupted ", RegisterServerManagerStatus[this.state]);
-                this._setState(RegisterServerManagerStatus.INACTIVE);
-                if (this._registration_client) {
-                    this._registration_client.disconnect((err2) => {
-                        this._registration_client = null;
-                        outer_callback(new Error("Initialization has been canceled"));
-                    });
-                }
-                else {
-                    outer_callback(new Error("Initialization has been canceled"));
-                }
+        // Keep track of the client to allow cancellation during connect()
+        this._registration_client = registrationClient;
+        try {
+            await registrationClient.connect(this.discoveryServerEndpointUrl);
+            if (!this._registration_client)
+                return;
+            // Re-check state after the long-running connect operation
+            if (this.state !== i_register_server_manager_1.RegisterServerManagerStatus.INITIALIZING) {
+                debugLog("RegisterServerManager#_establish_initial_connection: aborted after connection");
                 return;
             }
-            if (err) {
-                this._setState(RegisterServerManagerStatus.INACTIVE);
-                if (this._registration_client) {
-                    this._registration_client.disconnect((err1) => {
-                        this._registration_client = null;
-                        debugLog("#######", !!err1);
-                        outer_callback(err);
-                    });
-                    return;
+            const endpoints = await registrationClient.getEndpoints();
+            const endpoint = findSecureEndpoint(endpoints);
+            if (!endpoint) {
+                throw new Error("Cannot find Secure endpoint");
+            }
+            if (endpoint.serverCertificate) {
+                (0, node_opcua_assert_1.assert)(endpoint.serverCertificate);
+                this.selectedEndpoint = endpoint;
+            }
+            else {
+                this.selectedEndpoint = undefined;
+            }
+            this._serverEndpoints = registrationClient._serverEndpoints;
+        }
+        catch (err) {
+            // Do not set state to INACTIVE or rethrow here, let the caller handle it.
+            throw err;
+        }
+        finally {
+            if (this._registration_client) {
+                const tmp = this._registration_client;
+                this._registration_client = null;
+                try {
+                    await tmp.disconnect();
+                }
+                catch (err) {
+                    warningLog("RegisterServerManager#_establish_initial_connection: error disconnecting client", err);
                 }
             }
-            outer_callback();
-        });
+        }
     }
-    _trigger_next() {
+    #_trigger_next() {
         (0, node_opcua_assert_1.assert)(!this._registrationTimerId);
-        (0, node_opcua_assert_1.assert)(this.state === RegisterServerManagerStatus.WAITING);
-        // from spec 1.04 part 4:
-        // The registration process is designed to be platform independent, robust and able to minimize
-        // problems created by configuration errors. For that reason, Servers shall register themselves more
-        // than once.
-        //     Under normal conditions, manually launched Servers shall periodically register with the Discovery
-        // Server as long as they are able to receive connections from Clients. If a Server goes offline then it
-        // shall register itself once more and indicate that it is going offline. The registration frequency
-        // should be configurable; however, the maximum is 10 minutes. If an error occurs during registration
-        // (e.g. the Discovery Server is not running) then the Server shall periodically re-attempt registration.
-        //     The frequency of these attempts should start at 1 second but gradually increase until the
-        // registration frequency is the same as what it would be if no errors occurred. The recommended
-        // approach would be to double the period of each attempt until reaching the maximum.
-        //     When an automatically launched Server (or its install program) registers with the Discovery Server
-        // it shall provide a path to a semaphore file which the Discovery Server can use to determine if the
-        //     Server has been uninstalled from the machine. The Discovery Server shall have read access to
-        // the file system that contains the file
-        // install a registration
+        (0, node_opcua_assert_1.assert)(this.state === i_register_server_manager_1.RegisterServerManagerStatus.WAITING);
         debugLog("RegisterServerManager#_trigger_next " + ": installing timeout to perform registerServer renewal (timeout =", this.timeout, ")");
+        if (this._registrationTimerId)
+            clearTimeout(this._registrationTimerId);
         this._registrationTimerId = setTimeout(() => {
             if (!this._registrationTimerId) {
                 debugLog("RegisterServerManager => cancelling re registration");
                 return;
             }
             this._registrationTimerId = null;
+            if (this.#_isTerminating()) {
+                debugLog("RegisterServerManager#_trigger_next : cancelling re registration");
+                return;
+            }
             debugLog("RegisterServerManager#_trigger_next : renewing RegisterServer");
-            this._registerServer(true, (err) => {
-                if (this.state !== RegisterServerManagerStatus.INACTIVE &&
-                    this.state !== RegisterServerManagerStatus.UNREGISTERING) {
-                    debugLog("RegisterServerManager#_trigger_next : renewed !", err);
-                    this._setState(RegisterServerManagerStatus.WAITING);
-                    this._emitEvent("serverRegistrationRenewed");
-                    this._trigger_next();
+            const after_register = (err) => {
+                if (!this.#_isTerminating()) {
+                    debugLog("RegisterServerManager#_trigger_next : renewed ! err:", err?.message);
+                    this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.WAITING);
+                    this.#_emitEvent("serverRegistrationRenewed");
+                    this.#_trigger_next();
                 }
-            });
+            };
+            // State transition before the call
+            this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.REGISTERING);
+            this.#_emitEvent("serverRegistrationPending");
+            this.#_registerOrUnregisterServer(/*isOnline=*/ true)
+                .then(() => after_register())
+                .catch((err) => after_register(err));
         }, this.timeout);
     }
-    stop(callback) {
+    async stop() {
         debugLog("RegisterServerManager#stop");
+        if (this.#_isTerminating()) {
+            debugLog("Already stopping  or stopped...");
+            return;
+        }
+        // make sure we don't have any timer running
+        // so a registration renewal won't happen while we are stopping
         if (this._registrationTimerId) {
-            debugLog("RegisterServerManager#stop :clearing timeout");
             clearTimeout(this._registrationTimerId);
             this._registrationTimerId = null;
         }
-        this._cancel_pending_client_if_any(() => {
-            debugLog("RegisterServerManager#stop  _cancel_pending_client_if_any done ", this.state);
-            if (!this.selectedEndpoint || this.state === RegisterServerManagerStatus.INACTIVE) {
-                this.state = RegisterServerManagerStatus.INACTIVE;
-                (0, node_opcua_assert_1.assert)(this._registrationTimerId === null);
-                return callback();
+        // Immediately set state to signal a stop
+        this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.UNREGISTERING);
+        // Cancel any pending client connections
+        await this.#_cancel_pending_client_if_any();
+        if (this.selectedEndpoint) {
+            try {
+                await this.#_registerOrUnregisterServer(/* isOnline= */ false);
+                this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.UNREGISTERED);
+                this.#_emitEvent("serverUnregistered");
             }
-            this._registerServer(false, () => {
-                this._setState(RegisterServerManagerStatus.INACTIVE);
-                this._emitEvent("serverUnregistered");
-                callback();
-            });
-        });
+            catch (err) {
+                warningLog(err);
+                warningLog("RegisterServerManager#stop: Unregistration failed.", err.message);
+            }
+        }
+        // Final state transition to INACTIVE
+        this.#_setState(i_register_server_manager_1.RegisterServerManagerStatus.DISPOSING);
     }
     /**
-     * @param isOnline
-     * @param outer_callback
+     * Handles the actual registration/unregistration request.
+     * It is designed to be interruptible by checking the state.
+     * @param isOnline - true for registration, false for unregistration
      * @private
      */
-    _registerServer(isOnline, outer_callback) {
-        (0, node_opcua_assert_1.assert)(typeof outer_callback === "function");
-        debugLog("RegisterServerManager#_registerServer isOnline:", isOnline, "selectedEndpoint: ", this.selectedEndpoint?.endpointUrl);
-        (0, node_opcua_assert_1.assert)(this.selectedEndpoint, "must have a selected endpoint => please call _establish_initial_connection");
+    async #_registerOrUnregisterServer(isOnline) {
+        const expectedState = isOnline ? i_register_server_manager_1.RegisterServerManagerStatus.REGISTERING : i_register_server_manager_1.RegisterServerManagerStatus.UNREGISTERING;
+        if (this.getState() !== expectedState) {
+            debugLog("RegisterServerManager#_registerServer: aborting due to state change");
+            return;
+        }
+        debugLog("RegisterServerManager#_registerServer isOnline:", isOnline);
+        (0, node_opcua_assert_1.assert)(this.selectedEndpoint, "must have a selected endpoint");
         (0, node_opcua_assert_1.assert)(this.server.serverType !== undefined, " must have a valid server Type");
-        // construct connection
         const server = this.server;
         const selectedEndpoint = this.selectedEndpoint;
         if (!selectedEndpoint) {
-            warningLog("Warning : cannot register server - no endpoint available");
-            return outer_callback(new Error("Cannot registerServer"));
+            warningLog("Warning: cannot register server - no endpoint available");
+            // Do not rethrow here, let the caller handle it.
+            return;
         }
         server.serverCertificateManager.referenceCounter++;
         const applicationName = (0, node_opcua_client_1.coerceLocalizedText)(server.serverInfo.applicationName)?.text || undefined;
-        const theStatus = isOnline ? RegisterServerManagerStatus.REGISTERING : RegisterServerManagerStatus.UNREGISTERING;
-        if (theStatus === this.state) {
-            warningLog(`Warning the server is already in the ${RegisterServerManagerStatus[theStatus]} state`);
-            return outer_callback();
-        }
-        if (!(this.state === RegisterServerManagerStatus.INITIALIZING || this.state === RegisterServerManagerStatus.WAITING)) {
-            warningLog("Warning : cannot register server - wrong state ", RegisterServerManagerStatus[this.state]);
-            return outer_callback();
-        }
-        this._setState(theStatus);
-        if (this._registration_client) {
-            warningLog(`Warning there is already a registering/un-registering task taking place:  ${RegisterServerManagerStatus[this.state]} state`);
-        }
-        const options = {
+        const prefix = `Client-${g_registeringClientCounter++}`;
+        const action = isOnline ? "registering" : "unregistering";
+        const ldsInfo = this.discoveryServerEndpointUrl;
+        const serverInfo = server.serverInfo.applicationUri;
+        const clientName = `${prefix} for server ${serverInfo} to LDS ${ldsInfo} for ${action}`;
+        const client = node_opcua_client_1.OPCUAClientBase.create({
+            clientName,
+            applicationName,
+            applicationUri: server.serverInfo.applicationUri,
+            connectionStrategy: no_retry_connectivity_strategy,
+            clientCertificateManager: server.serverCertificateManager,
             securityMode: selectedEndpoint.securityMode,
             securityPolicy: (0, node_opcua_secure_channel_1.coerceSecurityPolicy)(selectedEndpoint.securityPolicyUri),
             serverCertificate: selectedEndpoint.serverCertificate,
-            clientCertificateManager: server.serverCertificateManager,
             certificateFile: server.certificateFile,
             privateKeyFile: server.privateKeyFile,
-            // xx clientName: server.serverInfo.applicationUri!,
-            applicationName,
-            applicationUri: server.serverInfo.applicationUri,
-            connectionStrategy: no_reconnect_connectivity_strategy,
-            clientName: "server client to LDS " + RegisterServerManagerStatus[theStatus]
-        };
-        const client = node_opcua_client_1.OPCUAClientBase.create(options);
-        const tmp = this._serverEndpoints;
-        client._serverEndpoints = tmp;
+        });
+        client.on("backoff", (nbRetry, delay) => {
+            debugLog(client.clientCertificateManager, "backoff trying to connect to the LDS has failed", nbRetry, delay);
+        });
         this._registration_client = client;
-        debugLog("                      lds endpoint uri : ", selectedEndpoint.endpointUrl);
-        debugLog("                      securityMode     : ", node_opcua_secure_channel_1.MessageSecurityMode[selectedEndpoint.securityMode]);
-        debugLog("                      securityPolicy   : ", selectedEndpoint.securityPolicyUri);
-        async_1.default.series([
-            // establish_connection_with_lds
-            (callback) => {
-                client.connect(selectedEndpoint.endpointUrl, (err) => {
-                    debugLog("establish_connection_with_lds => err = ", err);
-                    if (err) {
-                        debugLog("RegisterServerManager#_registerServer connection to client has failed");
-                        debugLog("RegisterServerManager#_registerServer  " +
-                            "=> please check that you server certificate is trusted by the LDS");
-                        warningLog("RegisterServer to the LDS  has failed during secure connection  " +
-                            "=> please check that you server certificate is trusted by the LDS.", "\nerr: " + err.message, "\nLDS endpoint    :", selectedEndpoint.endpointUrl, "\nsecurity mode   :", node_opcua_secure_channel_1.MessageSecurityMode[selectedEndpoint.securityMode], "\nsecurity policy :", (0, node_opcua_secure_channel_1.coerceSecurityPolicy)(selectedEndpoint.securityPolicyUri));
-                        // xx debugLog(options);
-                        client.disconnect(() => {
-                            this._registration_client = null;
-                            debugLog("RegisterServerManager#_registerServer client disconnected");
-                            callback( /* intentionally no error propagation*/);
-                        });
-                    }
-                    else {
-                        callback();
-                    }
-                });
-            },
-            (callback) => {
-                if (!this._registration_client) {
-                    callback();
-                    return;
+        debugLog("lds endpoint uri : ", selectedEndpoint.endpointUrl);
+        const state = isOnline ? "UnRegisterServer" : "RegisterServer";
+        try {
+            await client.connect(selectedEndpoint.endpointUrl);
+            // Check state again after connection is established
+            if (this.getState() === expectedState) {
+                try {
+                    await sendRegisterServerRequest(server, client, isOnline);
                 }
-                sendRegisterServerRequest(this.server, client, isOnline, (err) => {
-                    callback( /* intentionally no error propagation*/);
-                });
-            },
-            // close_connection_with_lds
-            (callback) => {
-                if (!this._registration_client) {
-                    callback();
-                    return;
+                catch (err) {
+                    if (this.getState() !== expectedState) {
+                        warningLog(`${state} '${this.server.serverInfo.applicationUri}' to the LDS has failed during secure connection to the LDS server`);
+                        warningLog(chalk_1.default.red("  Error message:"), err.message); // Do not rethrow here, let the caller 
+                    }
                 }
-                client.disconnect(callback);
             }
-        ], (err) => {
-            if (!this._registration_client) {
-                debugLog("RegisterServerManager#_registerServer end (isOnline", isOnline, ") has been interrupted");
-                outer_callback();
-                return;
+            else {
+                debugLog("RegisterServerManager#_registerServer: aborted ");
+            }
+        }
+        catch (err) {
+            if (this.getState() !== expectedState) {
+                warningLog(`${state} '${this.server.serverInfo.applicationUri}' cannot connect to LDS at endpoint ${client.clientName}, ${selectedEndpoint.endpointUrl} :`);
+                warningLog(chalk_1.default.red("  Error message:"), err.message);
             }
-            this._registration_client.disconnect(() => {
-                debugLog("RegisterServerManager#_registerServer end (isOnline", isOnline, ")");
+        }
+        finally {
+            if (this._registration_client) {
+                const tmp = this._registration_client;
                 this._registration_client = null;
-                outer_callback(err);
-            });
-        });
+                await tmp.disconnect();
+            }
+        }
     }
-    _cancel_pending_client_if_any(callback) {
+    /**
+     * Cancels any pending client connections.
+     * This is crucial for a clean shutdown.
+     * @private
+     */
+    async #_cancel_pending_client_if_any() {
         debugLog("RegisterServerManager#_cancel_pending_client_if_any");
         if (this._registration_client) {
-            debugLog("RegisterServerManager#_cancel_pending_client_if_any " + "=> wee need to disconnect  _registration_client");
-            this._registration_client.disconnect(() => {
-                this._registration_client = null;
-                this._cancel_pending_client_if_any(callback);
-            });
+            const client = this._registration_client;
+            this._registration_client = null;
+            debugLog("RegisterServerManager#_cancel_pending_client_if_any "
+                + "=> wee need to disconnect_registration_client");
+            try {
+                await client.disconnect();
+            }
+            catch (err) {
+                warningLog("Error disconnecting registration client:", err.message);
+            }
+            await this.#_cancel_pending_client_if_any(); // Recursive call to ensure all are handled
         }
         else {
             debugLog("RegisterServerManager#_cancel_pending_client_if_any : done (nothing to do)");
-            callback();
         }
     }
 }