node-opcua-server 2.53.0 → 2.56.1

package/source/queue.ts

@@ -14,7 +14,7 @@ export class Queue<T> {
         if (this.size === 0) {
             return undefined;
         }
-        return this._d.first() as T;  
+        return this._d.first() as T;
     }
     public shift(): T | undefined {
         if (this.size === 0) {
@@ -29,18 +29,16 @@ export class Queue<T> {
         this._d.push(value);
     }
 
-    public filterOut(predicate: (element: T)=> boolean): number {
-
+    public filterOut(predicate: (element: T) => boolean): number {
         let counter = 0;
         let p = this._d.head.next;
-        while(p != this._d.head) {
-
+        while (p != this._d.head) {
             const shouldRemove = predicate(p.data);
             const pPrev = p;
-            p= p.next;
+            p = p.next;
             if (shouldRemove) {
                 this.size -= 1;
-                counter+=1;
+                counter += 1;
                 pPrev.remove();
             }
         }
@@ -48,6 +46,7 @@ export class Queue<T> {
     }
 
     public values(): Iterable<T> {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         const iteratable = {
             [Symbol.iterator]() {

package/source/register_server_manager.ts

@@ -2,9 +2,9 @@
  * @module node-opcua-server
  */
 // tslint:disable:no-console
+import { EventEmitter } from "events";
 import * as async from "async";
 import * as chalk from "chalk";
-import { EventEmitter } from "events";
 
 import { assert } from "node-opcua-assert";
 import { ErrorCallback, UAString } from "node-opcua-basic-types";
@@ -26,9 +26,9 @@ import {
     RegisterServerResponse
 } from "node-opcua-service-discovery";
 import { ApplicationType, EndpointDescription, MdnsDiscoveryConfiguration, RegisteredServerOptions } from "node-opcua-types";
-import { IRegisterServerManager } from "./i_register_server_manager";
 import { exploreCertificate } from "node-opcua-crypto";
 import { OPCUACertificateManager } from "node-opcua-certificate-manager";
+import { IRegisterServerManager } from "./i_register_server_manager";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -314,7 +314,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
         this._registrationTimerId = null;
     }
 
-    public dispose() {
+    public dispose(): void {
         this.server = null;
         debugLog("RegisterServerManager#dispose", this.state.toString());
         assert(this.state === RegisterServerManagerStatus.INACTIVE);
@@ -322,13 +322,13 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
         this.removeAllListeners();
     }
 
-    public _emitEvent(eventName: string) {
+    public _emitEvent(eventName: string): void {
         setImmediate(() => {
             this.emit(eventName);
         });
     }
 
-    public _setState(status: RegisterServerManagerStatus) {
+    public _setState(status: RegisterServerManagerStatus): void {
         const previousState = this.state || RegisterServerManagerStatus.INACTIVE;
         debugLog(
             "RegisterServerManager#setState : ",
@@ -339,7 +339,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
         this.state = status;
     }
 
-    public start(callback: ErrorCallback) {
+    public start(callback: ErrorCallback): void {
         debugLog("RegisterServerManager#start");
         if (this.state !== RegisterServerManagerStatus.INACTIVE) {
             return callback(new Error("RegisterServer process already started")); // already started
@@ -352,7 +352,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
             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();
@@ -367,7 +367,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
                 if (err1) {
                     warningLog(
                         "RegisterServerManager#start - registering server has failed ! \n" +
-                        "please check that your server certificate is accepted by the LDS"
+                            "please check that your server certificate is accepted by the LDS"
                     );
                     this._setState(RegisterServerManagerStatus.INACTIVE);
                     this._emitEvent("serverRegistrationFailure");
@@ -478,14 +478,17 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
                 },
                 // function wait_a_little_bit
                 (callback: ErrorCallback) => {
-                    setTimeout(callback, 100);
+                    setTimeout(callback, 10);
                 }
             ],
             (err?: Error | null) => {
                 debugLog("-------------------------------", !!err);
 
                 if (this.state !== RegisterServerManagerStatus.INITIALIZING) {
-                    debugLog("RegisterServerManager#_establish_initial_connection has been interrupted ", RegisterServerManagerStatus[this.state]);
+                    debugLog(
+                        "RegisterServerManager#_establish_initial_connection has been interrupted ",
+                        RegisterServerManagerStatus[this.state]
+                    );
                     this._setState(RegisterServerManagerStatus.INACTIVE);
                     if (this._registration_client) {
                         this._registration_client.disconnect((err2?: Error) => {
@@ -513,7 +516,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
         );
     }
 
-    public _trigger_next() {
+    public _trigger_next(): void {
         assert(!this._registrationTimerId);
         assert(this.state === RegisterServerManagerStatus.WAITING);
         // from spec 1.04 part 4:
@@ -562,7 +565,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
         }, this.timeout);
     }
 
-    public stop(callback: ErrorCallback) {
+    public stop(callback: ErrorCallback): void {
         debugLog("RegisterServerManager#stop");
 
         if (this._registrationTimerId) {
@@ -592,7 +595,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
      * @param outer_callback
      * @private
      */
-    public _registerServer(isOnline: boolean, outer_callback: ErrorCallback) {
+    public _registerServer(isOnline: boolean, outer_callback: ErrorCallback): void {
         assert(typeof outer_callback === "function");
 
         debugLog(
@@ -626,11 +629,15 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
             return outer_callback();
         }
         assert(this.state === RegisterServerManagerStatus.INITIALIZING || this.state === RegisterServerManagerStatus.WAITING);
-        
+
         this._setState(theStatus);
 
         if (this._registration_client) {
-            warningLog(`Warning there is already a registering/unregistering task taking place:  ${RegisterServerManagerStatus[this.state]} state`);
+            warningLog(
+                `Warning there is already a registering/unregistering task taking place:  ${
+                    RegisterServerManagerStatus[this.state]
+                } state`
+            );
         }
 
         const options: OPCUAClientBaseOptions = {
@@ -651,7 +658,7 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
 
             connectionStrategy: no_reconnect_connectivity_strategy,
 
-            clientName: "server client to LDS " + RegisterServerManagerStatus[theStatus],
+            clientName: "server client to LDS " + RegisterServerManagerStatus[theStatus]
         };
 
         const client = OPCUAClientBase.create(options) as ClientBaseEx;
@@ -668,20 +675,20 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
             [
                 // establish_connection_with_lds
                 (callback: ErrorCallback) => {
-                    client.connect(selectedEndpoint?.endpointUrl!, (err?: Error) => {
+                    client.connect(selectedEndpoint!.endpointUrl!, (err?: Error) => {
                         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"
+                                    "=> 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.",
+                                    "=> please check that you server certificate is trusted by the LDS.",
                                 "\nerr: " + err.message,
                                 "\nLDS endpoint    :",
-                                selectedEndpoint?.endpointUrl!,
+                                selectedEndpoint!.endpointUrl!,
                                 "\nsecurity mode   :",
                                 MessageSecurityMode[selectedEndpoint.securityMode],
                                 "\nsecurity policy :",
@@ -699,14 +706,20 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
                     });
                 },
                 (callback: ErrorCallback) => {
-                    if (!this._registration_client) { callback(); return; }
+                    if (!this._registration_client) {
+                        callback();
+                        return;
+                    }
                     sendRegisterServerRequest(this.server!, client as ClientBaseEx, isOnline, (err?: Error | null) => {
                         callback(/* intentionally no error propagation*/);
                     });
                 },
                 // close_connection_with_lds
                 (callback: ErrorCallback) => {
-                    if (!this._registration_client) { callback(); return; }
+                    if (!this._registration_client) {
+                        callback();
+                        return;
+                    }
                     client.disconnect(callback);
                 }
             ],
@@ -721,7 +734,6 @@ export class RegisterServerManager extends EventEmitter implements IRegisterServ
                     this._registration_client = null;
                     outer_callback(err!);
                 });
-
             }
         );
     }

package/source/register_server_manager_hidden.ts

@@ -8,26 +8,24 @@ import { IRegisterServerManager } from "./i_register_server_manager";
  * a IRegisterServerManager that hides the server from any local discover server
  *
  */
-export class RegisterServerManagerHidden
-  extends EventEmitter
-  implements IRegisterServerManager {
+export class RegisterServerManagerHidden extends EventEmitter implements IRegisterServerManager {
+    public discoveryServerEndpointUrl = "";
 
-    public discoveryServerEndpointUrl: string = "";
-
-    constructor(options?: any) {
+    constructor(options?: {
+        /** */
+    }) {
         super();
     }
 
-    public stop(callback: () => void) {
+    public stop(callback: () => void): void {
         setImmediate(callback);
     }
 
-    public start(callback: () => void) {
+    public start(callback: () => void): void {
         setImmediate(callback);
     }
 
-    public dispose() {
+    public dispose(): void {
         //
     }
-
 }

package/source/register_server_manager_mdns_only.ts

@@ -5,9 +5,7 @@
 
 import { EventEmitter } from "events";
 import { assert } from "node-opcua-assert";
-import {
-    BonjourHolder
-} from "node-opcua-service-discovery";
+import { BonjourHolder } from "node-opcua-service-discovery";
 import { OPCUABaseServer } from "./base_server";
 import { IRegisterServerManager } from "./i_register_server_manager";
 
@@ -15,16 +13,13 @@ import { IRegisterServerManager } from "./i_register_server_manager";
  * a RegisterServerManager that declare the server the OPCUA Bonjour service
  * available on the current computer
  */
-export class RegisterServerManagerMDNSONLY
-  extends EventEmitter
-    implements IRegisterServerManager {
-
-    public discoveryServerEndpointUrl: string = "";
+export class RegisterServerManagerMDNSONLY extends EventEmitter implements IRegisterServerManager {
+    public discoveryServerEndpointUrl = "";
 
     private server?: OPCUABaseServer;
     private bonjour: BonjourHolder;
 
-    constructor(options: any) {
+    constructor(options: { server: OPCUABaseServer }) {
         super();
         this.server = options.server;
         assert(this.server);
@@ -32,7 +27,7 @@ export class RegisterServerManagerMDNSONLY
         this.bonjour = new BonjourHolder();
     }
 
-    public stop(callback: () => void) {
+    public stop(callback: () => void): void {
         if (this.bonjour) {
             this.bonjour._stop_announcedOnMulticastSubnet();
         }
@@ -42,7 +37,7 @@ export class RegisterServerManagerMDNSONLY
         });
     }
 
-    public start(callback: () => void) {
+    public start(callback: () => void): void {
         // istanbul ignore next
         if (!this.server) {
             throw new Error("internal error");
@@ -53,7 +48,7 @@ export class RegisterServerManagerMDNSONLY
             capabilities: this.server.capabilitiesForMDNS,
             name: this.server.serverInfo.applicationUri!,
             path: "/", // <- to do
-            port: this.server.endpoints[0].port,
+            port: this.server.endpoints[0].port
         });
         setImmediate(() => {
             this.emit("serverRegistered");
@@ -61,7 +56,7 @@ export class RegisterServerManagerMDNSONLY
         });
     }
 
-    public dispose() {
+    public dispose(): void {
         assert(!this.bonjour.isStarted());
         assert(this.server);
         this.server = undefined;

package/source/server_capabilities.ts

@@ -23,7 +23,6 @@ export interface OperationLimitsOptions {
 }
 
 export class OperationLimits {
-
     public maxNodesPerRead: number;
     public maxNodesPerBrowse: number;
     public maxNodesPerWrite: number;
@@ -38,7 +37,6 @@ export class OperationLimits {
     public maxNodesPerTranslateBrowsePathsToNodeIds: number;
 
     constructor(options: OperationLimitsOptions) {
-
         /**
          * @property maxNodesPerRead
          * @default 0
@@ -98,7 +96,6 @@ export class OperationLimits {
          * @default 0
          */
         this.maxNodesPerTranslateBrowsePathsToNodeIds = options.maxNodesPerTranslateBrowsePathsToNodeIds || 0;
-
     }
 }
 
@@ -120,7 +117,6 @@ export interface ServerCapabilitiesOptions {
 /**
  */
 export class ServerCapabilities {
-
     public maxBrowseContinuationPoints: number;
     public maxHistoryContinuationPoints: number;
     public maxStringLength: number;
@@ -135,7 +131,6 @@ export class ServerCapabilities {
     public softwareCertificates: SignedSoftwareCertificate[];
 
     constructor(options: ServerCapabilitiesOptions) {
-
         options = options || {};
         options.operationLimits = options.operationLimits || {};
 

package/source/server_end_point.ts

@@ -2,11 +2,11 @@
  * @module node-opcua-server
  */
 // tslint:disable:no-console
-import * as async from "async";
-import * as chalk from "chalk";
 import { EventEmitter } from "events";
 import * as net from "net";
 import { Server, Socket } from "net";
+import * as chalk from "chalk";
+import * as async from "async";
 
 import { assert } from "node-opcua-assert";
 import { ICertificateManager, OPCUACertificateManager } from "node-opcua-certificate-manager";
@@ -213,16 +213,16 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
     private _channels: { [key: string]: ServerSecureChannelLayer };
     private _server?: Server;
     private _endpoints: EndpointDescription[];
-    private _listen_callback: any;
-    private _started: boolean = false;
+    private _listen_callback?: (err?: Error) => void;
+    private _started = false;
     private _counter = OPCUAServerEndPointCounter++;
     private _policy_deduplicator: { [key: string]: number } = {};
     constructor(options: OPCUAServerEndPointOptions) {
         super();
 
-        assert(!Object.prototype.hasOwnProperty.call(options,"certificate"), "expecting a certificateChain instead");
-        assert(Object.prototype.hasOwnProperty.call(options,"certificateChain"), "expecting a certificateChain");
-        assert(Object.prototype.hasOwnProperty.call(options,"privateKey"));
+        assert(!Object.prototype.hasOwnProperty.call(options, "certificate"), "expecting a certificateChain instead");
+        assert(Object.prototype.hasOwnProperty.call(options, "certificateChain"), "expecting a certificateChain");
+        assert(Object.prototype.hasOwnProperty.call(options, "privateKey"));
 
         this.certificateManager = options.certificateManager;
 
@@ -259,7 +259,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         assert(this.serverInfo !== null && typeof this.serverInfo === "object");
     }
 
-    public dispose() {
+    public dispose(): void {
         this._certificateChain = emptyCertificate;
         this._privateKey = emptyPrivateKeyPEM;
 
@@ -272,7 +272,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         this._endpoints = [];
 
         this._server = undefined;
-        this._listen_callback = null;
+        this._listen_callback = undefined;
 
         this.removeAllListeners();
     }
@@ -353,7 +353,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         securityMode: MessageSecurityMode,
         securityPolicy: SecurityPolicy,
         options?: EndpointDescriptionParams
-    ) {
+    ): void {
         if (!options) {
             options = {
                 hostname: getFullyQualifiedDomainName(),
@@ -414,13 +414,13 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         );
     }
 
-    public addRestrictedEndpointDescription(options: EndpointDescriptionParams) {
+    public addRestrictedEndpointDescription(options: EndpointDescriptionParams): void {
         options = { ...options };
         options.restricted = true;
         return this.addEndpointDescription(MessageSecurityMode.None, SecurityPolicy.None, options);
     }
 
-    public addStandardEndpointDescriptions(options?: AddStandardEndpointDescriptionsParam) {
+    public addStandardEndpointDescriptions(options?: AddStandardEndpointDescriptionsParam): void {
         options = options || {};
 
         options.securityModes = options.securityModes || defaultSecurityModes;
@@ -473,7 +473,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
      * @method listen
      * @async
      */
-    public listen(callback: (err?: Error) => void) {
+    public listen(callback: (err?: Error) => void): void {
         assert(typeof callback === "function");
         assert(!this._started, "OPCUAServerEndPoint is already listening");
 
@@ -499,7 +499,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         );
     }
 
-    public killClientSockets(callback: (err?: Error) => void) {
+    public killClientSockets(callback: (err?: Error) => void): void {
         for (const channel of this.getChannels()) {
             const hacked_channel = channel as any;
             if (hacked_channel.transport && hacked_channel.transport._socket) {
@@ -511,7 +511,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         callback();
     }
 
-    public suspendConnection(callback: (err?: Error) => void) {
+    public suspendConnection(callback: (err?: Error) => void): void {
         if (!this._started) {
             return callback(new Error("Connection already suspended !!"));
         }
@@ -530,11 +530,11 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         callback();
     }
 
-    public restoreConnection(callback: (err?: Error) => void) {
+    public restoreConnection(callback: (err?: Error) => void): void {
         this.listen(callback);
     }
 
-    public abruptlyInterruptChannels() {
+    public abruptlyInterruptChannels(): void {
         for (const channel of Object.values(this._channels)) {
             channel.abruptlyInterrupt();
         }
@@ -544,7 +544,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
      * @method shutdown
      * @async
      */
-    public shutdown(callback: (err?: Error) => void) {
+    public shutdown(callback: (err?: Error) => void): void {
         debugLog("OPCUAServerEndPoint#shutdown ");
 
         if (this._started) {
@@ -627,12 +627,10 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
     }
 
     private _dump_statistics() {
-        const self = this;
-
-        self._server!.getConnections((err: Error | null, count: number) => {
+        this._server!.getConnections((err: Error | null, count: number) => {
             debugLog(chalk.cyan("CONCURRENT CONNECTION = "), count);
         });
-        debugLog(chalk.cyan("MAX CONNECTIONS = "), self._server!.maxConnections);
+        debugLog(chalk.cyan("MAX CONNECTIONS = "), this._server!.maxConnections);
     }
 
     private _setup_server() {
@@ -642,7 +640,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         // xx console.log(" Server with max connections ", self.maxConnections);
         this._server.maxConnections = this.maxConnections + 1; // plus one extra
 
-        this._listen_callback = null;
+        this._listen_callback = undefined;
         this._server
             .on("connection", (socket: NodeJS.Socket) => {
                 // istanbul ignore next
@@ -750,7 +748,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         // as they will need to be interrupted when OPCUAServerEndPoint is closed
         assert(this._started, "OPCUAServerEndPoint must be started");
 
-        assert(!this._channels.hasOwnProperty(channel.hashKey), " channel already preregistered!");
+        assert(!Object.prototype.hasOwnProperty.call(this._channels, channel.hashKey), " channel already preregistered!");
 
         this._channels[channel.hashKey] = channel;
 
@@ -810,11 +808,11 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
      */
     private _unregisterChannel(channel: ServerSecureChannelLayer): void {
         debugLog("_un-registerChannel channel.hashKey", channel.hashKey);
-        if (!this._channels.hasOwnProperty(channel.hashKey)) {
+        if (!Object.prototype.hasOwnProperty.call(this._channels, channel.hashKey)) {
             return;
         }
 
-        assert(this._channels.hasOwnProperty(channel.hashKey), "channel is not registered");
+        assert(Object.prototype.hasOwnProperty.call(this._channels, channel.hashKey), "channel is not registered");
 
         /**
          * @event closeChannel
@@ -839,8 +837,8 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
 
     private _end_listen(err?: Error) {
         assert(typeof this._listen_callback === "function");
-        this._listen_callback(err);
-        this._listen_callback = null;
+        this._listen_callback!(err);
+        this._listen_callback = undefined;
     }
 
     /**
@@ -999,8 +997,8 @@ function estimateSecurityLevel(securityMode: MessageSecurityMode, securityPolicy
  */
 function _makeEndpointDescription(options: MakeEndpointDescriptionOptions): EndpointDescriptionEx {
     assert(isFinite(options.port), "expecting a valid port number");
-    assert(Object.prototype.hasOwnProperty.call(options,"serverCertificateChain"));
-    assert(!Object.prototype.hasOwnProperty.call(options,"serverCertificate"));
+    assert(Object.prototype.hasOwnProperty.call(options, "serverCertificateChain"));
+    assert(!Object.prototype.hasOwnProperty.call(options, "serverCertificate"));
     assert(!!options.securityMode); // s.MessageSecurityMode
     assert(!!options.securityPolicy);
     assert(options.server !== null && typeof options.server === "object");