node-opcua-transport 2.167.0 → 2.168.0

package/source/tcp_transport.ts

@@ -2,20 +2,20 @@
 /**
  * @module node-opcua-transport
  */
-import { EventEmitter } from "events";
+
+import { EventEmitter } from "node:events";
 import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
-import { make_debugLog, checkDebugFlag, make_errorLog, hexDump, make_warningLog } from "node-opcua-debug";
+import { checkDebugFlag, hexDump, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { ObjectRegistry } from "node-opcua-object-registry";
 import { PacketAssembler, PacketAssemblerErrorCode } from "node-opcua-packet-assembler";
-import { ErrorCallback, CallbackWithData, StatusCode } from "node-opcua-status-code";
-
-import { StatusCodes2 } from "./status_codes";
+import type { CallbackWithData, ErrorCallback, StatusCode } from "node-opcua-status-code";
 import { readRawMessageHeader } from "./message_builder_base";
-import { doTraceIncomingChunk } from "./utils";
+import { StatusCodes2 } from "./status_codes";
 import { TCPErrorMessage } from "./TCPErrorMessage";
 import { packTcpMessage } from "./tools";
+import { doTraceIncomingChunk } from "./utils";
 
 const debugLog = make_debugLog("TRANSPORT");
 const doDebug = checkDebugFlag("TRANSPORT");
@@ -28,7 +28,7 @@ export interface ISocketLike extends EventEmitter {
     remoteAddress?: string;
     remotePort?: number;
 
-    write(data: string | Buffer, callback?: (err?: Error | null) => void | undefined): void;
+    write(data: string | Buffer, callback?: (err?: Error | null) => undefined | undefined): void;
     end(): void;
     setKeepAlive(enable?: boolean, initialDelay?: number): this;
     setNoDelay(noDelay?: boolean): this;
@@ -60,7 +60,7 @@ export interface ISocketLike extends EventEmitter {
 export interface IMockSocket extends ISocketLike {
     invalid?: boolean;
     // [key: string]: any;
-    write(data: string | Buffer, callback?: (err?: Error) => void | undefined): void;
+    write(data: string | Buffer, callback?: (err?: Error) => void): void;
     destroy(): void;
     end(): void;
 
@@ -72,7 +72,7 @@ export interface IMockSocket extends ISocketLike {
 const defaultFakeSocket = {
     invalid: true,
     destroyed: false,
-    destroy(err?: Error) {
+    destroy(_err?: Error) {
         this.destroyed = true;
         errorLog("MockSocket.destroy");
     },
@@ -81,20 +81,20 @@ const defaultFakeSocket = {
         errorLog("MockSocket.end");
     },
 
-    write(data: string | Buffer, callback?: (err?: Error) => void | undefined): void {
+    write(_data: string | Buffer, callback?: (err?: Error) => undefined | undefined): void {
         /** */
         if (callback) {
             callback();
         }
     },
 
-    setKeepAlive(enable?: boolean, initialDelay?: number) {
+    setKeepAlive(_enable?: boolean, _initialDelay?: number) {
         return this;
     },
-    setNoDelay(noDelay?: boolean) {
+    setNoDelay(_noDelay?: boolean) {
         return this;
     },
-    setTimeout(timeout: number, callback?: () => void) {
+    setTimeout(_timeout: number, _callback?: () => void) {
         return this;
     }
 };
@@ -116,27 +116,20 @@ export function getFakeTransport(): ISocketLike {
 
 let counter = 0;
 
-export interface TCP_transport {
+export interface TCP_transportEvents {
     /**
      * notify the observers that a message chunk has been received
      * @event chunk
      * @param message_chunk the message chunk
      */
-    on(eventName: "chunk", eventHandler: (messageChunk: Buffer) => void): this;
+    chunk: [messageChunk: Buffer];
     /**
      * notify the observers that the transport layer has been disconnected.
      * @event close
      */
-    on(eventName: "close", eventHandler: (err: Error | null) => void): this;
-
-    once(eventName: "chunk", eventHandler: (messageChunk: Buffer) => void): this;
-    once(eventName: "close", eventHandler: (err: Error | null) => void): this;
-
-    emit(eventName: "close", err?: Error | null): boolean;
-    emit(eventName: "chunk", messageChunk: Buffer): boolean;
+    close: [err: Error | null];
 }
-// tslint:disable:class-name
-export class TCP_transport extends EventEmitter {
+export class TCP_transport extends EventEmitter<TCP_transportEvents> {
     private static registry = new ObjectRegistry();
     /**
      * the size of the header in bytes
@@ -200,17 +193,17 @@ export class TCP_transport extends EventEmitter {
 
     public toString() {
         let str = "\n";
-        str += " name.............. = " + this.name + "\n";
-        str += " protocolVersion... = " + this.protocolVersion + "\n";
-        str += " maxMessageSize.... = " + this.maxMessageSize + "\n";
-        str += " maxChunkCount..... = " + this.maxChunkCount + "\n";
-        str += " receiveBufferSize. = " + this.receiveBufferSize + "\n";
-        str += " sendBufferSize.... = " + this.sendBufferSize + "\n";
-        str += " bytesRead......... = " + this.bytesRead + "\n";
-        str += " bytesWritten...... = " + this.bytesWritten + "\n";
-        str += " chunkWrittenCount. = " + this.chunkWrittenCount + "\n";
-        str += " chunkReadCount.... = " + this.chunkReadCount + "\n";
-        str += " closeEmitted ? ....= " + this.#_closedEmitted + "\n";
+        str += ` name.............. = ${this.name}\n`;
+        str += ` protocolVersion... = ${this.protocolVersion}\n`;
+        str += ` maxMessageSize.... = ${this.maxMessageSize}\n`;
+        str += ` maxChunkCount..... = ${this.maxChunkCount}\n`;
+        str += ` receiveBufferSize. = ${this.receiveBufferSize}\n`;
+        str += ` sendBufferSize.... = ${this.sendBufferSize}\n`;
+        str += ` bytesRead......... = ${this.bytesRead}\n`;
+        str += ` bytesWritten...... = ${this.bytesWritten}\n`;
+        str += ` chunkWrittenCount. = ${this.chunkWrittenCount}\n`;
+        str += ` chunkReadCount.... = ${this.chunkReadCount}\n`;
+        str += ` closeEmitted ? ....= ${this.#_closedEmitted}\n`;
         return str;
     }
 
@@ -254,7 +247,7 @@ export class TCP_transport extends EventEmitter {
     }
     public set timeout(value: number) {
         assert(!this.#_timerId);
-        doDebug && debugLog("Setting socket " + this.name + " timeout = ", value);
+        doDebug && debugLog(`Setting socket ${this.name} timeout = ${value}`);
         this.#_timeout = value;
     }
 
@@ -281,13 +274,13 @@ export class TCP_transport extends EventEmitter {
 
      * @param messageChunk
      */
-    public write(messageChunk: Buffer, callback?: (err?: Error | null) => void | undefined): void {
+    public write(messageChunk: Buffer, callback?: (err?: Error | null) => undefined | undefined): void {
         const header = readRawMessageHeader(messageChunk);
         assert(header.length === messageChunk.length);
         const c = header.messageHeader.isFinal;
         assert(c === "F" || c === "C" || c === "A");
         this._write_chunk(messageChunk, (err) => {
-            callback && callback(err);
+            callback?.(err);
         });
     }
 
@@ -300,7 +293,6 @@ export class TCP_transport extends EventEmitter {
      *
      */
     public disconnect(callback: ErrorCallback): void {
-        assert(typeof callback === "function", "expecting a callback function, but got " + callback);
         if (!this._socket || this.#_isDisconnecting) {
             if (!this.#_isDisconnecting) {
                 this.#_isDisconnecting = true;
@@ -320,7 +312,7 @@ export class TCP_transport extends EventEmitter {
             });
         });
 
-        this._socket && this._socket.destroy(new Error("ClientTCP_transport disconnected"));
+        this._socket?.destroy(new Error("ClientTCP_transport disconnected"));
         this._socket = null;
     }
 
@@ -328,15 +320,13 @@ export class TCP_transport extends EventEmitter {
         return this._socket !== null && !this._socket.destroyed;
     }
 
-    protected _write_chunk(messageChunk: Buffer, callback?: (err?: Error | null) => void | undefined): void {
+    protected _write_chunk(messageChunk: Buffer, callback?: (err?: Error | null) => undefined): void {
         if (this._socket !== null) {
             this.bytesWritten += messageChunk.length;
             this.chunkWrittenCount++;
             this._socket.write(messageChunk, callback);
         } else {
-            if (callback) {
-                callback();
-            }
+            callback?.();
         }
     }
 
@@ -366,7 +356,7 @@ export class TCP_transport extends EventEmitter {
             }
 
             this.sendErrorMessage(statusCode, err.message);
-            this.prematureTerminate(new Error("Packet Assembler : " + err.message), statusCode);
+            this.prematureTerminate(new Error(`Packet Assembler : ${err.message}`), statusCode);
         });
     }
 
@@ -383,10 +373,9 @@ export class TCP_transport extends EventEmitter {
         // Setting true for noDelay will immediately fire off data each time socket.write() is called.
         this._socket.setNoDelay(true);
         // set socket timeout
-        debugLog("  TCP_transport#install => setting " + this.name + " _socket.setTimeout to ", this.timeout);
+        debugLog(`  TCP_transport#install => setting ${this.name} _socket.setTimeout to `, this.timeout);
         // let use a large timeout here to make sure that we not conflict with our internal timeout
-        this._socket.setTimeout(this.timeout, () => {
-        });
+        this._socket.setTimeout(this.timeout, () => {});
 
         // c8 ignore next
         doDebug && debugLog("  TCP_transport#_install_socket ", this.name);
@@ -410,7 +399,7 @@ export class TCP_transport extends EventEmitter {
             debugLog(chalk.red(" extraErrorDescription   ") + chalk.cyan(extraErrorDescription));
         }
 
-        const reason = `${statusCode.toString()}:${extraErrorDescription || ""}`;
+        const reason = `${statusCode.toString()}:${extraErrorDescription || ""} `;
         const errorResponse = new TCPErrorMessage({
             statusCode,
             reason
@@ -427,7 +416,7 @@ export class TCP_transport extends EventEmitter {
         doDebugFlow && errorLog("prematureTerminate from", "has socket = ", !!this._socket, new Error().stack);
 
         if (this._socket) {
-            err.message = "premature socket termination " + err.message;
+            err.message = `premature socket termination ${err.message} `;
             // we consider this as an error
             const _s = this._socket;
             this._socket = null;
@@ -450,7 +439,7 @@ export class TCP_transport extends EventEmitter {
      * Rules:
      * * TCP_transport will not emit the ```message``` event, while the "one time message receiver" is in operation.
      * * the TCP_transport will wait for the next complete message chunk and call the provided callback func
-     *   ```callback(null,messageChunk);```
+     *   ```callback(null, messageChunk); ```
      *
      * if a messageChunk is not received within ```TCP_transport.timeout``` or if the underlying socket reports
      * an error, the callback function will be called with an Error.
@@ -503,9 +492,7 @@ export class TCP_transport extends EventEmitter {
 
         const onTimeout = () => {
             _cleanUp();
-            this._fulfill_pending_promises(
-                new Error(`Timeout(A) in waiting for data on socket ( timeout was = ${this.timeout} ms)`)
-            );
+            this._fulfill_pending_promises(new Error(`Timeout(A) in waiting for data on socket(timeout was = ${this.timeout} ms)`));
             this.dispose();
         };
         // Setup timeout detection timer ....
@@ -518,9 +505,7 @@ export class TCP_transport extends EventEmitter {
         if (this._socket) {
             // to do = intercept socket error as well
             this.#_on_error_during_one_time_message_receiver = (hadError: boolean) => {
-                const err = new Error(
-                    `ERROR in waiting for data on socket ( timeout was = ${this.timeout} ms) hadError` + hadError
-                );
+                const err = new Error(`ERROR in waiting for data on socket(timeout was = ${this.timeout} ms) hadError${hadError} `);
                 this._emitClose(err);
                 this._fulfill_pending_promises(err);
             };
@@ -531,7 +516,7 @@ export class TCP_transport extends EventEmitter {
         this.#_theCallback = (err?: Error | null, data?: Buffer) => {
             _cleanUp();
             this.#_theCallback = undefined;
-            _callback(err!, data);
+            _callback(err ?? null, data);
         };
     }
 
@@ -574,39 +559,37 @@ export class TCP_transport extends EventEmitter {
             //     callback(err || null);
             // }
         } else {
-            debugLog("Already emitted close event", (this.#_closedEmitted as any).message);
-            debugLog("err = ", err?.message);
-            debugLog("");
-            debugLog("Already emitted close event", this.#_closedEmitted);
+            const prevClose = this.#_closedEmitted instanceof Error ? this.#_closedEmitted.message : this.#_closedEmitted;
+            debugLog("Already emitted close event", prevClose);
             debugLog("err = ", err?.message, err);
         }
     }
 
     private _on_socket_end() {
         // c8 ignore next
-        doDebug && debugLog(chalk.red(` SOCKET END : ${this.name}`), "is disconnecting  ", this.isDisconnecting());
+        doDebug && debugLog(chalk.red(` SOCKET END: ${this.name} `), "is disconnecting  ", this.isDisconnecting());
         if (this.isDisconnecting()) {
             return;
         }
         //
-        debugLog(chalk.red(" Transport Connection ended") + " " + this.name);
-        const err = new Error(this.name + ": socket has been disconnected by third party");
+        debugLog(`${chalk.red(" Transport Connection ended")} ${this.name} `);
+        const err = new Error(`${this.name}: socket has been disconnected by third party`);
         debugLog(" bytesRead    = ", this.bytesRead);
         debugLog(" bytesWritten = ", this.bytesWritten);
         this._theCloseError = err;
 
-        this._fulfill_pending_promises(new Error("Connection aborted - ended by server : " + (err ? err.message : "")));
+        this._fulfill_pending_promises(new Error(`Connection aborted - ended by server: ${err ? err.message : ""} `));
     }
 
     private _on_socket_error(err: Error) {
         // c8 ignore next
-        debugLog(chalk.red(` _on_socket_error:  ${this.name}`), chalk.yellow(err.message));
+        debugLog(chalk.red(` _on_socket_error:  ${this.name} `), chalk.yellow(err.message));
         // node The "close" event will be called directly following this event.
         // this._emitClose(err);
     }
 
     private _on_socket_timeout() {
-        const msg = `socket timeout : timeout=${this.timeout}  ${this.name}`;
+        const msg = `socket timeout: timeout = ${this.timeout}  ${this.name} `;
         doDebug && debugLog(msg);
         this.prematureTerminate(new Error(msg), StatusCodes2.BadTimeout);
     }

package/source/tools.ts

@@ -3,10 +3,10 @@
  */
 
 import { assert } from "node-opcua-assert";
-import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { BinaryStream, type OutputBinaryStream } from "node-opcua-binary-stream";
 import { createFastUninitializedBuffer } from "node-opcua-buffer-utils";
 import { readMessageHeader } from "node-opcua-chunkmanager";
-import { BaseUAObject } from "node-opcua-factory";
+import type { BaseUAObject } from "node-opcua-factory";
 
 import { TCPErrorMessage } from "./TCPErrorMessage";
 
@@ -20,21 +20,21 @@ function is_valid_msg_type(msgType: string): boolean {
             "MSG",
             "CLO" // OPC Unified Architecture, Part 6 page 36
         ].indexOf(msgType) >= 0,
-        "invalid message type  " + msgType
+        `invalid message type  ${msgType}`
     );
     return true;
 }
 
-export type ConstructorFunc = new (...args: any[]) => BaseUAObject;
+export type ConstructorFunc = new () => BaseUAObject;
 
 export function decodeMessage(stream: BinaryStream, classNameConstructor: ConstructorFunc): BaseUAObject {
     assert(stream instanceof BinaryStream);
-    assert(classNameConstructor instanceof Function, " expecting a function for " + classNameConstructor);
+    assert(classNameConstructor instanceof Function, ` expecting a function for ${classNameConstructor}`);
 
     const header = readMessageHeader(stream);
     assert(stream.length === 8);
 
-    let obj;
+    let obj: BaseUAObject;
     if (header.msgType === "ERR") {
         obj = new TCPErrorMessage();
         obj.decode(stream);
@@ -73,19 +73,19 @@ export function parseEndpointUrl(endpointUrl: string): ParsedEndpointUrl {
     // original protocol in the result.
     const protocolMatch = endpointUrl.match(/^([a-z][a-z0-9.+-]*):/i);
     if (!protocolMatch) {
-        throw new Error("Invalid endpoint url " + endpointUrl);
+        throw new Error(`Invalid endpoint url ${endpointUrl}`);
     }
-    const originalProtocol = protocolMatch[1].toLowerCase() + ":";
+    const originalProtocol = `${protocolMatch[1].toLowerCase()}:`;
     const normalizedUrl = endpointUrl.replace(/^[a-z][a-z0-9.+-]*:/i, "http:");
 
     let parsed: URL;
     try {
         parsed = new URL(normalizedUrl);
     } catch {
-        throw new Error("Invalid endpoint url " + endpointUrl);
+        throw new Error(`Invalid endpoint url ${endpointUrl}`);
     }
     if (!parsed.hostname) {
-        throw new Error("Invalid endpoint url " + endpointUrl);
+        throw new Error(`Invalid endpoint url ${endpointUrl}`);
     }
     return {
         protocol: originalProtocol,
@@ -95,20 +95,14 @@ export function parseEndpointUrl(endpointUrl: string): ParsedEndpointUrl {
         auth: parsed.username ? (parsed.password ? `${parsed.username}:${parsed.password}` : parsed.username) : null,
         href: endpointUrl
     };
-
 }
 
 export function is_valid_endpointUrl(endpointUrl: string): boolean {
     const e = parseEndpointUrl(endpointUrl);
-    return Object.prototype.hasOwnProperty.call(e, "hostname");
+    return Object.hasOwn(e, "hostname");
 }
 
-export function writeTCPMessageHeader(
-    msgType: string,
-    chunkType: string,
-    totalLength: number,
-    stream: OutputBinaryStream
-): void {
+export function writeTCPMessageHeader(msgType: string, chunkType: string, totalLength: number, stream: OutputBinaryStream): void {
     if (stream instanceof Buffer) {
         stream = new BinaryStream(stream);
     }