node-opcua-server-discovery 2.156.0 → 2.157.0

package/source/opcua_discovery_server.ts

@@ -4,7 +4,7 @@
 
 import os from "os";
 import path from "path";
-import url from "url";
+import { URL } from "url";
 import { callbackify } from "util";
 
 import chalk from "chalk";
@@ -40,7 +40,7 @@ import {
     RegisterServer2Response,
     RegisterServerRequest,
     RegisterServerResponse,
-    sameService,
+    isSameService,
     serviceToString,
     announcementToServiceConfig,
     ServerOnNetwork
@@ -52,9 +52,9 @@ import { ErrorCallback, StatusCode, StatusCodes } from "node-opcua-status-code";
 
 import { MDNSResponder } from "./mdns_responder";
 
-const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
-const errorLog = make_errorLog(__filename);
+const debugLog = make_debugLog("LDSSERVER");
+const doDebug = checkDebugFlag("LDSSERVER");
+const errorLog = make_errorLog("LDSSERVER");
 
 function hasCapabilities(serverCapabilities: UAString[] | null, serverCapabilityFilter: string): boolean {
     if (serverCapabilities == null) {
@@ -81,9 +81,8 @@ interface RegisteredServerExtended extends RegisteredServer {
     discoveryConfiguration?: MdnsDiscoveryConfiguration[];
 }
 
-interface RegisterServerMap {
-    [key: string]: RegisteredServerExtended;
-}
+type RegisterServerMap = Map<string, RegisteredServerExtended>;
+
 
 const defaultProductUri = "NodeOPCUA-LocalDiscoveryServer";
 const defaultApplicationUri = makeApplicationUrn(os.hostname(), defaultProductUri);
@@ -98,14 +97,23 @@ function getDefaultCertificateManager(): OPCUACertificateManager {
     });
 }
 
+export interface OPCUADiscoveryServer {
+    on(eventName: "onUnregisterServer", eventHandler: (server: RegisteredServer, forced: boolean) => void): this;
+    on(eventName: "onRegisterServer", eventHandler: (server: RegisteredServer, firstTime: boolean) => void): this;
+    once(eventName: "onUnregisterServer", eventHandler: (server: RegisteredServer, forced: boolean) => void): this;
+    once(eventName: "onRegisterServer", eventHandler: (server: RegisteredServer, firstTime: boolean) => void): this;
+
+}
+
+// const weakMap = new WeakMap<MdnsDiscoveryConfiguration, BonjourHolder>;
+
 export class OPCUADiscoveryServer extends OPCUABaseServer {
+    private mDnsLDSAnnouncer?: BonjourHolder;
     public mDnsResponder?: MDNSResponder;
     public readonly registeredServers: RegisterServerMap;
 
-    private bonjourHolder: BonjourHolder;
-    private _delayInit?: () => void;
+    private _delayInit?: () => Promise<void>;
 
-    
     constructor(options: OPCUADiscoveryServerOptions) {
         options.serverInfo = options.serverInfo || {};
         const serverInfo = options.serverInfo;
@@ -118,7 +126,6 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
 
         serverInfo.applicationName = serverInfo.applicationName || {
             text: defaultProductUri,
-
             locale: null
         };
 
@@ -130,14 +137,13 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
 
         super(options);
 
-        this.bonjourHolder = new BonjourHolder();
 
         // see OPC UA Spec 1.2 part 6 : 7.4 Well Known Addresses
         // opc.tcp://localhost:4840/UADiscovery
         const port = options.port || 4840;
 
         this.capabilitiesForMDNS = ["LDS"];
-        this.registeredServers = {};
+        this.registeredServers = new Map();
 
         this.mDnsResponder = undefined;
 
@@ -173,9 +179,7 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
         };
     }
 
-    public async start(): Promise<void>;
-    public start(callback: ErrorCallback): void;
-    public start(callback?: ErrorCallback): any {
+    public async start(): Promise<void> {
         assert(!this.mDnsResponder);
         assert(Array.isArray(this.capabilitiesForMDNS));
 
@@ -183,61 +187,72 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
             await this._delayInit!();
         });
 
-        super.start((err?: Error | null) => {
-            if (err) {
-                return callback!(err);
-            }
-            const endpointUri = this.getEndpointUrl();
-            const { hostname } = url.parse(endpointUri);
-
-            this.mDnsResponder = new MDNSResponder();
-            // declare discovery server in bonjour
-            this.bonjourHolder.announcedOnMulticastSubnetWithCallback(
-                {
-                    capabilities: this.capabilitiesForMDNS,
-                    name: this.serverInfo.applicationUri!,
-                    path: "/DiscoveryServer",
-                    host: hostname || "",
-                    port: this.endpoints[0].port
-                },
-                (err2: Error | null) => {
-                    callback!(err2!);
-                }
-            );
-        });
+        await new Promise<void>((resolve, reject) =>
+            super.start((err?: Error | null) =>
+                err ? reject(err) : resolve()));
+
+        const endpointUri = this.getEndpointUrl();
+        const { hostname } = new URL(endpointUri);
+
+        this.mDnsResponder = new MDNSResponder();
+
+        this.mDnsLDSAnnouncer = new BonjourHolder();
+
+        // declare the discovery server itself in bonjour
+        await this.mDnsLDSAnnouncer.announcedOnMulticastSubnet(
+            {
+                capabilities: this.capabilitiesForMDNS,
+                name: this.serverInfo.applicationUri!,
+                path: "/DiscoveryServer",
+                host: hostname || "",
+                port: this.endpoints[0].port
+            });
     }
 
-    public async shutdown(): Promise<void>;
-    public shutdown(callback: ErrorCallback): void;
-    public shutdown(callback?: ErrorCallback): any {
-        debugLog("stopping announcement of LDS on mDNS");
 
+    #shutting_down = false;
+    public async shutdown(): Promise<void> {
+        if (this.#shutting_down) return;
+        this.#shutting_down = true;
+
+
+
+
+        debugLog("stopping announcement of LDS on mDNS");
+        // 
+        for (const registeredServer of this.registeredServers.values()) {
+            debugLog("LDS is shutting down and is forcefuly unregistering server", registeredServer.serverUri);
+            await this.#internalRegisterServerOffline(registeredServer, true);
+        }   
+        
         if (this.mDnsResponder) {
-            this.mDnsResponder.dispose();
+            debugLog("disposing mDnsResponder");
+            await this.mDnsResponder.dispose();
             this.mDnsResponder = undefined;
+            debugLog(" mDnsResponder disposed");
         }
 
-        this.bonjourHolder.stopAnnouncedOnMulticastSubnetWithCallback((err?: Error | null) => {
-            if (err) {
-                errorLog("stopAnnouncedOnMulticastSubnet Error ", err.message);
-            }
-
-            debugLog("stopping announcement of LDS on mDNS - DONE");
-            debugLog("Shutting down Discovery Server");
+        if (this.mDnsLDSAnnouncer) {
+            debugLog("disposing mDnsLDSAnnouncer of this LDS to the mDNS");
+            await this.mDnsLDSAnnouncer.stopAnnouncedOnMulticastSubnet();
+            this.mDnsLDSAnnouncer = undefined;
+        }
 
-            super.shutdown(() => {
-                setTimeout(() => {
-                    callback!();
-                }, 100);
-            });
-        });
+        debugLog("Shutting down Discovery Server");
+        await new Promise<void>((resolve, reject) =>
+            super.shutdown((err) => err ? reject(err) : resolve())
+        );
+        debugLog("stopping announcement of LDS on mDNS - DONE");
+        // add a extra delay to ensure that the port is really closed
+        // and registered server propagated the fact that LDS is not here anymore
+        await new Promise<void>((resolve) => setTimeout(resolve, 1000));
     }
 
     /**
      * returns the number of registered servers
      */
     public get registeredServerCount(): number {
-        return Object.keys(this.registeredServers).length;
+        return this.registeredServers.size;
     }
 
     public getServers(channel: ServerSecureChannelLayer): ApplicationDescription[] {
@@ -245,7 +260,7 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
 
         const servers: ApplicationDescription[] = [this.serverInfo];
 
-        for (const registered_server of Object.values(this.registeredServers)) {
+        for (const registered_server of this.registeredServers.values()) {
             const serverInfo: ApplicationDescription = new ApplicationDescription(registered_server.serverInfo);
             servers.push(serverInfo);
         }
@@ -260,43 +275,55 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
         assert(request.schema.name === "RegisterServer2Request");
 
         request.discoveryConfiguration = request.discoveryConfiguration || [];
-        this.__internalRegisterServerWithCallback(
+        this.#internalRegisterServer(
             RegisterServer2Response,
             request.server,
             request.discoveryConfiguration as MdnsDiscoveryConfiguration[],
-            (err: Error | null, response?: Response) => {
-                // istanbul ignore next
-                if (err) {
-                    errorLog("What shall I do ?", err.message);
-                    errorLog(err);
-                    let additional_messages = [];
-                    additional_messages.push("EXCEPTION CAUGHT WHILE PROCESSING REQUEST !!! " + request.schema.name);
-                    additional_messages.push(err.message);
-                    if (err.stack) {
-                        additional_messages = additional_messages.concat(err.stack.split("\n"));
-                    }
-
-                    response = OPCUADiscoveryServer.makeServiceFault(StatusCodes.BadInternalError, additional_messages);
-                    channel.send_response("MSG", response, message);
-                } else {
-                    channel.send_response("MSG", response!, message);
-                }
+        ).then((response?: Response) => {
+            channel.send_response("MSG", response!, message);
+        }).catch((err: Error) => {
+            errorLog("What shall I do ?", err.message);
+            errorLog(err);
+            let additional_messages = [];
+            additional_messages.push("EXCEPTION CAUGHT WHILE PROCESSING REQUEST !!! " + request.schema.name);
+            additional_messages.push(err.message);
+            if (err.stack) {
+                additional_messages = additional_messages.concat(err.stack.split("\n"));
             }
-        );
+
+            const response = OPCUADiscoveryServer.makeServiceFault(
+                StatusCodes.BadInternalError,
+                additional_messages
+            );
+            channel.send_response("MSG", response, message);
+        });
+        // istanbul ignore next
     }
 
     protected _on_RegisterServerRequest(message: Message, channel: ServerSecureChannelLayer) {
         assert(message.request instanceof RegisterServerRequest);
         const request = message.request as RegisterServerRequest;
         assert(request.schema.name === "RegisterServerRequest");
-        this.__internalRegisterServerWithCallback(
+        this.#internalRegisterServer(
             RegisterServerResponse,
             request.server,
-            undefined,
-            (err: Error | null, response?: Response) => {
+            undefined).then((response) => {
+
                 channel.send_response("MSG", response!, message);
-            }
-        );
+
+            }).catch((err: Error) => {
+                let additional_messages = [];
+                additional_messages.push("EXCEPTION CAUGHT WHILE PROCESSING REQUEST !!! " + request.schema.name);
+                additional_messages.push(err.message);
+                if (err.stack) {
+                    additional_messages = additional_messages.concat(err.stack.split("\n"));
+                }
+                const response = OPCUADiscoveryServer.makeServiceFault(
+                    StatusCodes.BadInternalError,
+                    additional_messages
+                );
+                channel.send_response("MSG", response, message);
+            });
     }
 
     protected _on_FindServersOnNetworkRequest(message: Message, channel: ServerSecureChannelLayer) {
@@ -328,6 +355,10 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
             return channel.send_response("MSG", response1, message);
         } sendError;
 
+        if(this.#shutting_down) {
+            return sendError(StatusCodes.BadShutdown);
+        }
+
         //     startingRecordId         Counter Only records with an identifier greater than this number will be
         //                              returned.
         //                              Specify 0 to start with the first record in the cache.
@@ -358,27 +389,27 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
         debugLog(" startingRecordId = ", request.startingRecordId);
 
         if (this.mDnsResponder) {
-            for (const server of this.mDnsResponder.registeredServers) {
-                debugLog("Exploring server ", server.serverName);
+            for (const serverOnNetwork of this.mDnsResponder.registeredServers) {
+                debugLog("Exploring server ", serverOnNetwork.serverName);
 
-                if (server.recordId <= request.startingRecordId) {
+                if (serverOnNetwork.recordId <= request.startingRecordId) {
                     continue;
                 }
-                if (!hasCapabilities(server.serverCapabilities, serverCapabilityFilter)) {
+                if (!hasCapabilities(serverOnNetwork.serverCapabilities, serverCapabilityFilter)) {
                     // istanbul ignore next
                     if (doDebug) {
                         debugLog(
                             "   server ",
-                            server.serverName,
-                            server.serverCapabilities ? server.serverCapabilities.join(",") : [],
+                            serverOnNetwork.serverName,
+                            serverOnNetwork.serverCapabilities ? serverOnNetwork.serverCapabilities.join(",") : [],
                             " does not match serverCapabilities ",
                             serverCapabilityFilter
                         );
                     }
                     continue;
                 }
-                debugLog("   server ", server.serverName, " found");
-                servers.push(server);
+                debugLog("   server ", serverOnNetwork.serverName, " found");
+                servers.push(serverOnNetwork);
                 if (servers.length === request.maxRecordsToReturn) {
                     debugLog("max records to return reached", request.maxRecordsToReturn);
                     break;
@@ -392,33 +423,183 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
         channel.send_response("MSG", response, message);
     }
 
-    protected async __internalRegisterServerWithCallback(
-        RegisterServerXResponse: any /* RegisterServer2Response | RegisterServerResponse */,
-        rawServer: RegisteredServer,
-        discoveryConfigurations: MdnsDiscoveryConfiguration[] | undefined,
-        callback: (err: Error | null, response?: Response) => void
-    ) {
-        // istanbul ignore next
-        callback(new Error("internal Error"));
+
+    async #stopAnnouncedOnMulticastSubnet(conf: MdnsDiscoveryConfiguration): Promise<void> {
+        const b = (conf as any).bonjourHolder as BonjourHolder;
+        await b.stopAnnouncedOnMulticastSubnet();
+        (conf as any).bonjourHolder = undefined;
+    }
+
+    async #announcedOnMulticastSubnet(conf: MdnsDiscoveryConfiguration, announcement: Announcement): Promise<void> {
+        const serviceConfig = announcementToServiceConfig(announcement);
+
+        let b = (conf as any).bonjourHolder as BonjourHolder;
+        if (b && b.serviceConfig) {
+            if (isSameService(b.serviceConfig, serviceConfig)) {
+                debugLog("Configuration ", conf.mdnsServerName, " has not changed !");
+                // nothing to do
+                return;
+            } else {
+                // istanbul ignore next
+                if (doDebug) {
+                    debugLog("Configuration ", conf.mdnsServerName, " HAS changed !");
+                    debugLog(" Was ", serviceToString(b.serviceConfig));
+                    debugLog(" is  ", announcement);
+                }
+            }
+            await this.#stopAnnouncedOnMulticastSubnet(conf);
+        }
+        b = new BonjourHolder();
+        (conf as any).bonjourHolder = b;
+        await b.announcedOnMulticastSubnet(announcement);
     }
+    async #dealWithDiscoveryConfiguration(
+        previousConfMap: Map<string, MdnsDiscoveryConfiguration>,
+        server1: RegisteredServer,
+        serverInfo: ApplicationDescriptionOptions,
+        discoveryConfiguration: MdnsDiscoveryConfiguration
+    ): Promise<StatusCode> {
+        // mdnsServerName     String     The name of the Server when it is announced via mDNS.
+        //                               See Part 12 for the details about mDNS. This string shall be 
+        //                               less than 64 bytes.
+        //                               If not specified the first element of the serverNames array 
+        //                               is used (truncated to 63 bytes if necessary).
+        // serverCapabilities [] String  The set of Server capabilities supported by the Server.
+        //                               A Server capability is a short identifier for a feature
+        //                               The set of allowed Server capabilities are defined in Part 12.
+        discoveryConfiguration.mdnsServerName ??= server1.serverNames![0].text;
+
+        serverInfo.discoveryUrls ??= [];
+
+        const endpointUrl = serverInfo.discoveryUrls[0]!;
+        const parsedUrl = new URL(endpointUrl);
+
+        discoveryConfiguration.serverCapabilities = discoveryConfiguration.serverCapabilities || [];
+        const announcement = {
+            capabilities: discoveryConfiguration.serverCapabilities.map((x: UAString) => x!) || ["DA"],
+            name: discoveryConfiguration.mdnsServerName!,
+            host: parsedUrl.hostname || "",
+            path: parsedUrl.pathname || "/",
+            port: parseInt(parsedUrl.port!, 10)
+        };
+
+        if (previousConfMap.has(discoveryConfiguration.mdnsServerName!)) {
+            // configuration already exists
+            debugLog("Configuration ", discoveryConfiguration.mdnsServerName, " already exists !");
+            const prevConf = previousConfMap.get(discoveryConfiguration.mdnsServerName!)!;
+            previousConfMap.delete(discoveryConfiguration.mdnsServerName!);
+            (discoveryConfiguration as any).bonjourHolder = (prevConf as any).bonjourHolder;
+        }
+
+        // let's announce the server on the  multicast DNS
+        await this.#announcedOnMulticastSubnet(discoveryConfiguration, announcement);
+        return StatusCodes.Good;
+    }
+
+
+    /**
+     * 
+     * @param server 
+     * @param forced  true :indicated if the LDS is forcing the Server to be seen as unregistered, false
+     * when the offline comes from the server it self.
+     * @returns 
+     */
+    async #internalRegisterServerOffline(server: RegisteredServerExtended,  forced: boolean) {
+
+        const key = server.serverUri!;
+
+        let configurationResults: StatusCode[] | null = null;
+        // server is announced offline
+        if (this.registeredServers.has(key)) {
+            const serverToUnregister = this.registeredServers.get(key)!;
+            debugLog(chalk.cyan("unregistering server : "), chalk.yellow(serverToUnregister.serverUri!));
+            configurationResults = [];
+
+            const discoveryConfigurations = serverToUnregister.discoveryConfiguration || [];
+
+            for (const conf of discoveryConfigurations) {
+                await this.#stopAnnouncedOnMulticastSubnet(conf);
+                configurationResults.push(StatusCodes.Good);
+            }
+            this.registeredServers.delete(key);
+            serverToUnregister.isOnline= false;
+            this.emit("onUnregisterServer", serverToUnregister, forced);
+        }
+        return configurationResults;
 
+    }
+    async #internalRegisterServerOnline(
+        server: RegisteredServerExtended,
+        discoveryConfigurations: MdnsDiscoveryConfiguration[]
+    ) {
+        assert(discoveryConfigurations);
+
+        const key = server.serverUri!;
+
+        let configurationResults: StatusCode[] | null = null;
+
+        debugLog(chalk.cyan(" registering server : "), chalk.yellow(server.serverUri));
+
+        // prepare serverInfo which will be used by FindServers
+        const serverInfo: ApplicationDescriptionOptions = {
+            applicationName: server.serverNames![0], // which one shall we use ?
+            applicationType: server.serverType,
+            applicationUri: server.serverUri,
+            discoveryUrls: server.discoveryUrls,
+            gatewayServerUri: server.gatewayServerUri,
+            productUri: server.productUri
+            // XXX ?????? serverInfo.discoveryProfileUri = serverInfo.discoveryProfileUri;
+        };
+
+        const previousConfMap: Map<string, MdnsDiscoveryConfiguration> = new Map();
+
+        // let check in the server has already been registed on this LDS 
+        let firstTimeRegistration = true;
+        if (this.registeredServers.has(key)) {
+            // server already exists and must only be updated
+            const previousServer = this.registeredServers.get(key)!;
+            for (const conf of previousServer.discoveryConfiguration!) {
+                previousConfMap.set(conf.mdnsServerName!, conf);
+            }
+            firstTimeRegistration = false;
+        }
+
+        this.registeredServers.set(key, server);
+
+        this.emit("onRegisterServer", server, firstTimeRegistration);
+
+        // xx server.semaphoreFilePath = server.semaphoreFilePath;
+        // xx server.serverNames = server.serverNames;
+        server.serverInfo = serverInfo;
+        server.discoveryConfiguration = discoveryConfigurations;
+
+
+        configurationResults = [];
+        for (const conf of discoveryConfigurations) {
+            const statusCode = await this.#dealWithDiscoveryConfiguration(
+                previousConfMap, 
+                server, 
+                serverInfo, 
+                conf
+            );
+            configurationResults.push(statusCode);
+        }
+        // now also unregister unprocessed
+        if (previousConfMap.size !== 0) {
+            debugLog(" Warning some conf need to be removed !");
+        }
+        return configurationResults;
+
+    }
     // eslint-disable-next-line max-statements
-    protected async __internalRegisterServer(
-        RegisterServerXResponse: any /* RegisterServer2Response | RegisterServerResponse */,
+    async #internalRegisterServer(
+        RegisterServerXResponse:  typeof RegisterServer2Response | typeof RegisterServerResponse,
         rawServer: RegisteredServer,
         discoveryConfigurations?: MdnsDiscoveryConfiguration[]
     ): Promise<Response> {
-        const server = rawServer as any as RegisteredServerExtended;
 
-        if (!discoveryConfigurations) {
-            discoveryConfigurations = [
-                new MdnsDiscoveryConfiguration({
-                    mdnsServerName: undefined,
-                    serverCapabilities: ["NA"]
-                })
-            ];
-        }
 
+        // #region check parameter validity
         function sendError(statusCode: StatusCode): Response {
             debugLog(chalk.red("_on_RegisterServer(2)Request error"), statusCode.toString());
             const response1 = new ServiceFault({
@@ -427,167 +608,57 @@ export class OPCUADiscoveryServer extends OPCUABaseServer {
             return response1;
         }
 
-        async function _stop_announcedOnMulticastSubnet(conf: MdnsDiscoveryConfiguration): Promise<void> {
-            const b = (conf as any).bonjourHolder as BonjourHolder;
-            await b.stopAnnouncedOnMulticastSubnet();
-            (conf as any).bonjourHolder = undefined;
+        if (this.#shutting_down) {
+            return sendError(StatusCodes.BadShutdown);
         }
 
-        async function _announcedOnMulticastSubnet(conf: MdnsDiscoveryConfiguration, announcement: Announcement): Promise<void> {
-            const serviceConfig = announcementToServiceConfig(announcement);
-
-            let b = (conf as any).bonjourHolder as BonjourHolder;
-            if (b && b.serviceConfig) {
-                if (sameService(b.serviceConfig, serviceConfig)) {
-                    debugLog("Configuration ", conf.mdnsServerName, " has not changed !");
-                    // nothing to do
-                    return;
-                } else {
-                    // istanbul ignore next
-                    if (doDebug) {
-                        debugLog("Configuration ", conf.mdnsServerName, " HAS changed !");
-                        debugLog(" Was ", serviceToString(b.serviceConfig));
-                        debugLog(" is  ", announcement);
-                    }
-                }
-                await _stop_announcedOnMulticastSubnet(conf);
-            }
-            b = new BonjourHolder();
-            (conf as any).bonjourHolder = b;
-            await b.announcedOnMulticastSubnet(announcement);
-        }
-
-        async function dealWithDiscoveryConfiguration(
-            previousConfMap: any,
-            server1: RegisteredServer,
-            serverInfo: ApplicationDescriptionOptions,
-            discoveryConfiguration: MdnsDiscoveryConfiguration
-        ): Promise<StatusCode> {
-            // mdnsServerName     String     The name of the Server when it is announced via mDNS.
-            //                               See Part 12 for the details about mDNS. This string shall be less than 64 bytes.
-            //                               If not specified the first element of the serverNames array is used
-            //                               (truncated to 63 bytes if necessary).
-            // serverCapabilities [] String  The set of Server capabilities supported by the Server.
-            //                               A Server capability is a short identifier for a feature
-            //                               The set of allowed Server capabilities are defined in Part 12.
-            discoveryConfiguration.mdnsServerName = discoveryConfiguration.mdnsServerName || server1.serverNames![0].text;
-
-            serverInfo.discoveryUrls = serverInfo.discoveryUrls || [];
-
-            const endpointUrl = serverInfo.discoveryUrls[0]!;
-            const parsedUrl = url.parse(endpointUrl);
-
-            discoveryConfiguration.serverCapabilities = discoveryConfiguration.serverCapabilities || [];
-            const announcement = {
-                capabilities: discoveryConfiguration.serverCapabilities.map((x: UAString) => x!) || ["DA"],
-                name: discoveryConfiguration.mdnsServerName!,
-                host: parsedUrl.hostname || "",
-                path: parsedUrl.pathname || "/",
-                port: parseInt(parsedUrl.port!, 10)
-            };
-
-            if (previousConfMap[discoveryConfiguration.mdnsServerName!]) {
-                // configuration already exists
-                debugLog("Configuration ", discoveryConfiguration.mdnsServerName, " already exists !");
-                const prevConf = previousConfMap[discoveryConfiguration.mdnsServerName!];
-                delete previousConfMap[discoveryConfiguration.mdnsServerName!];
-                (discoveryConfiguration as any).bonjourHolder = prevConf.bonjourHolder;
-            }
-
-            // let's announce the server on the  multicast DNS
-            await _announcedOnMulticastSubnet(discoveryConfiguration, announcement);
-            return StatusCodes.Good;
-        }
+        const server = rawServer as any as RegisteredServerExtended;
 
         // check serverType is valid
         if (!_isValidServerType(server.serverType)) {
             debugLog("Invalid server Type", ApplicationType[server.serverType]);
             return sendError(StatusCodes.BadInvalidArgument);
         }
-
         if (!server.serverUri) {
             debugLog("Missing serverURI");
             return sendError(StatusCodes.BadInvalidArgument);
         }
-
-        // BadServerUriInvalid
-        // TODO
         server.serverNames = server.serverNames || [];
         // BadServerNameMissing
         if (server.serverNames.length === 0 || !server.serverNames[0].text) {
             return sendError(StatusCodes.BadServerNameMissing);
         }
-
         // BadDiscoveryUrlMissing
         server.discoveryUrls = server.discoveryUrls || [];
         if (server.discoveryUrls.length === 0 || !server.discoveryUrls[0]) {
             return sendError(StatusCodes.BadDiscoveryUrlMissing);
         }
 
-        const key = server.serverUri;
-        let configurationResults: StatusCode[] | null = null;
 
-        if (server.isOnline) {
-            debugLog(chalk.cyan(" registering server : "), chalk.yellow(server.serverUri));
-
-            // prepare serverInfo which will be used by FindServers
-            const serverInfo: ApplicationDescriptionOptions = {
-                applicationName: server.serverNames[0], // which one shall we use ?
-                applicationType: server.serverType,
-                applicationUri: server.serverUri,
-                discoveryUrls: server.discoveryUrls,
-                gatewayServerUri: server.gatewayServerUri,
-                productUri: server.productUri
-                // XXX ?????? serverInfo.discoveryProfileUri = serverInfo.discoveryProfileUri;
-            };
-
-            const previousConfMap: any = [];
-            if (this.registeredServers[key]) {
-                // server already exists and must only be updated
-                const previousServer = this.registeredServers[key];
+        // BadServerUriInvalid
+        // TODO
+        // #endregion
 
-                for (const conf of previousServer.discoveryConfiguration!) {
-                    previousConfMap[conf.mdnsServerName!] = conf;
-                }
-            }
-            this.registeredServers[key] = server;
+        if (!discoveryConfigurations) {
+            discoveryConfigurations = [
+                new MdnsDiscoveryConfiguration({
+                    mdnsServerName: undefined,
+                    serverCapabilities: ["NA"]
+                })
+            ];
+        }
 
-            // xx server.semaphoreFilePath = server.semaphoreFilePath;
-            // xx server.serverNames = server.serverNames;
-            server.serverInfo = serverInfo;
-            server.discoveryConfiguration = discoveryConfigurations;
+        const configurationResults = server?.isOnline ?
 
-            assert(discoveryConfigurations);
+            await this.#internalRegisterServerOnline(server, discoveryConfigurations) :
+            await this.#internalRegisterServerOffline(server, false);
 
-            configurationResults = [];
-            for (const conf of discoveryConfigurations) {
-                const statusCode = await dealWithDiscoveryConfiguration(previousConfMap, server, serverInfo, conf);
-                configurationResults.push(statusCode);
-            }
-            // now also unregister unprocessed
-            if (Object.keys(previousConfMap).length !== 0) {
-                debugLog(" Warning some conf need to be removed !");
-            }
-        } else {
-            // server is announced offline
-            if (key in this.registeredServers) {
-                const server1 = this.registeredServers[key];
-                debugLog(chalk.cyan("unregistering server : "), chalk.yellow(server1.serverUri!));
-                configurationResults = [];
-
-                discoveryConfigurations = server1.discoveryConfiguration || [];
-
-                for (const conf of discoveryConfigurations) {
-                    await _stop_announcedOnMulticastSubnet(conf);
-                    configurationResults.push(StatusCodes.Good);
-                }
-                delete this.registeredServers[key];
-            }
-        }
 
         const response = new RegisterServerXResponse({
-            configurationResults
         });
+        if (response instanceof RegisterServer2Response) {
+            response.configurationResults = configurationResults;
+        }
         return response;
     }
 }
@@ -610,12 +681,3 @@ function _isValidServerType(serverType: ApplicationType): boolean {
     return false;
 }
 
-(OPCUADiscoveryServer as any).prototype.__internalRegisterServerWithCallback = callbackify(
-    (OPCUADiscoveryServer as any).prototype.__internalRegisterServer
-);
-
-// tslint:disable-next-line: no-var-requires
-import { withCallback } from "thenify-ex";
-const opts = { multiArgs: false };
-OPCUADiscoveryServer.prototype.start = withCallback(OPCUADiscoveryServer.prototype.start, opts);
-OPCUADiscoveryServer.prototype.shutdown = withCallback(OPCUADiscoveryServer.prototype.shutdown, opts);