node-opcua-transport 2.99.0 → 2.102.0

package/source/tcp_transport.ts

@@ -1,8 +1,8 @@
+/* eslint-disable @typescript-eslint/ban-types */
 /**
  * @module node-opcua-transport
  */
 import { EventEmitter } from "events";
-import { Socket } from "net";
 import * as chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
@@ -17,37 +17,100 @@ import { doTraceIncomingChunk } from "./utils";
 import { TCPErrorMessage } from "./TCPErrorMessage";
 import { packTcpMessage } from "./tools";
 
-const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
-const errorLog = make_errorLog(__filename);
-const warningLog = make_warningLog(__filename);
+const debugLog = make_debugLog("TRANSPORT");
+const doDebug = checkDebugFlag("TRANSPORT");
+const errorLog = make_errorLog("TRANSPORT");
+const warningLog = make_warningLog("TRANSPORT");
 
-export interface MockSocket {
+const doDebugFlow = false;
+
+export interface ISocketLike extends EventEmitter {
+    remoteAddress?: string;
+    remotePort?: number;
+
+    write(data: string | Buffer, callback?: (err?: Error) => void | undefined): void;
+    end(): void;
+    setKeepAlive(enable?: boolean, initialDelay?: number): this;
+    setNoDelay(noDelay?: boolean): this;
+    setTimeout(timeout: number, callback?: () => void): this;
+
+    destroy(err?: Error): void;
+    destroyed: boolean;
+
+    on(event: "close", listener: (hadError: boolean) => void): this;
+    on(event: "connect", listener: () => void): this;
+    on(event: "data", listener: (data: Buffer) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "timeout", listener: () => void): this;
+    once(event: "close", listener: (hadError: boolean) => void): this;
+    once(event: "connect", listener: () => void): this;
+    once(event: "data", listener: (data: Buffer) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: "timeout", listener: () => void): this;
+    prependListener(event: "close", listener: (hadError: boolean) => void): this;
+    prependListener(event: "connect", listener: () => void): this;
+    prependListener(event: "data", listener: (data: Buffer) => void): this;
+    prependListener(event: "end", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: "timeout", listener: () => void): this;
+}
+
+export interface IMockSocket extends ISocketLike {
     invalid?: boolean;
-    [key: string]: any;
+    // [key: string]: any;
+    write(data: string | Buffer, callback?: (err?: Error) => void | undefined): void;
     destroy(): void;
     end(): void;
+
+    setKeepAlive(enable?: boolean, initialDelay?: number): this;
+    setNoDelay(noDelay?: boolean): this;
+    setTimeout(timeout: number, callback?: () => void): this;
 }
-let fakeSocket: MockSocket = {
-    invalid: true,
 
-    destroy() {
+const defaultFakeSocket = {
+    invalid: true,
+    destroyed: false,
+    destroy(err?: Error) {
+        this.destroyed = true;
         errorLog("MockSocket.destroy");
     },
 
     end() {
         errorLog("MockSocket.end");
+    },
+
+    write(data: string | Buffer, callback?: (err?: Error) => void | undefined): void {
+        /** */
+        if (callback) {
+            callback();
+        }
+    },
+
+    setKeepAlive(enable?: boolean, initialDelay?: number) {
+        return this;
+    },
+    setNoDelay(noDelay?: boolean) {
+        return this;
+    },
+    setTimeout(timeout: number, callback?: () => void) {
+        return this;
     }
 };
 
-export function setFakeTransport(mockSocket: MockSocket): void {
+let fakeSocket: IMockSocket = defaultFakeSocket as IMockSocket;
+
+export function setFakeTransport(mockSocket: IMockSocket): void {
     fakeSocket = mockSocket;
 }
 
-export function getFakeTransport(): any {
+export function getFakeTransport(): ISocketLike {
     if (fakeSocket.invalid) {
         throw new Error("getFakeTransport: setFakeTransport must be called first  - BadProtocolVersionUnsupported");
     }
+    process.nextTick(() => fakeSocket.emit("connect"));
+
     return fakeSocket;
 }
 
@@ -60,12 +123,6 @@ export interface TCP_transport {
      * @param message_chunk the message chunk
      */
     on(eventName: "chunk", eventHandler: (messageChunk: Buffer) => void): this;
-    /**
-     * notify the observers that the transport layer has been disconnected.
-     * @event socket_closed
-     * @param err the Error object or null
-     */
-    on(eventName: "socket_closed", eventHandler: (err: Error | null) => void): this;
     /**
      * notify the observers that the transport layer has been disconnected.
      * @event close
@@ -73,10 +130,8 @@ export interface TCP_transport {
     on(eventName: "close", eventHandler: (err: Error | null) => void): this;
 
     once(eventName: "chunk", eventHandler: (messageChunk: Buffer) => void): this;
-    once(eventName: "socket_closed", eventHandler: (err: Error | null) => void): this;
     once(eventName: "close", eventHandler: (err: Error | null) => void): this;
 
-    emit(eventName: "socket_closed", err?: Error | null): boolean;
     emit(eventName: "close", err?: Error | null): boolean;
     emit(eventName: "chunk", messageChunk: Buffer): boolean;
 }
@@ -100,21 +155,21 @@ export class TCP_transport extends EventEmitter {
     public chunkReadCount: number;
     public name: string;
 
-    public _socket: Socket | null;
+    public _socket: ISocketLike | null;
+    private _closedEmitted: Error | string | undefined = undefined;
 
     /**
      * the size of the header in bytes
      * @default  8
      */
     private readonly headerSize: 8;
-    private _disconnecting: boolean;
     private _timerId: NodeJS.Timer | null;
-    private _onSocketClosedHasBeenCalled: boolean;
-    private _onSocketEndedHasBeenCalled: boolean;
-    private _theCallback?: CallbackWithData;
-    private _on_error_during_one_time_message_receiver: any;
+    private _theCallback?: (err?: Error | null, data?: Buffer) => void;
+    private _on_error_during_one_time_message_receiver: ((hadError: boolean) => void) | undefined;
     private packetAssembler?: PacketAssembler;
     private _timeout: number;
+    private _isDisconnecting = false;
+    protected _theCloseError: Error | null = null;
 
     constructor() {
         super();
@@ -123,7 +178,7 @@ export class TCP_transport extends EventEmitter {
         counter += 1;
 
         this._timerId = null;
-        this._timeout = 30000; // 30 seconds timeout
+        this._timeout = 5000; // 5  seconds timeout
         this._socket = null;
         this.headerSize = 8;
 
@@ -133,8 +188,6 @@ export class TCP_transport extends EventEmitter {
         this.sendBufferSize = 0;
         this.protocolVersion = 0;
 
-        this._disconnecting = false;
-
         this.bytesWritten = 0;
         this.bytesRead = 0;
 
@@ -142,11 +195,25 @@ export class TCP_transport extends EventEmitter {
         this.chunkWrittenCount = 0;
         this.chunkReadCount = 0;
 
-        this._onSocketClosedHasBeenCalled = false;
-        this._onSocketEndedHasBeenCalled = false;
         TCP_transport.registry.register(this);
     }
 
+    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";
+        return str;
+    }
+
     public setLimits({
         receiveBufferSize,
         sendBufferSize,
@@ -163,12 +230,11 @@ export class TCP_transport extends EventEmitter {
         this.maxMessageSize = maxMessageSize;
         this.maxChunkCount = maxChunkCount;
 
-        if(maxMessageSize / sendBufferSize > maxChunkCount || maxMessageSize / receiveBufferSize > maxChunkCount) 
-        {
+        if (maxMessageSize / sendBufferSize > maxChunkCount || maxMessageSize / receiveBufferSize > maxChunkCount) {
             warningLog(`Warning : maxMessageSize / sendBufferSize ${maxMessageSize / sendBufferSize}> maxChunkCount ${maxChunkCount}
                              || maxMessageSize / receiveBufferSize ${maxMessageSize / receiveBufferSize} < maxChunkCount `);
         }
-        
+
         // reinstall packetAssembler with correct limits
         this._install_packetAssembler();
     }
@@ -177,15 +243,17 @@ export class TCP_transport extends EventEmitter {
         return this._timeout;
     }
     public set timeout(value: number) {
+        assert(!this._timerId);
         debugLog("Setting socket " + this.name + " timeout = ", value);
         this._timeout = value;
     }
+
     public dispose(): void {
         this._cleanup_timers();
         assert(!this._timerId);
         if (this._socket) {
             this._socket.destroy();
-            this._socket.removeAllListeners();
+            //         this._socket.removeAllListeners();
             this._socket = null;
         }
         TCP_transport.registry.unregister(this);
@@ -206,8 +274,8 @@ export class TCP_transport extends EventEmitter {
         });
     }
 
-    public get isDisconnecting(): boolean {
-        return this._disconnecting;
+    public isDisconnecting(): boolean {
+        return !this._socket || this._isDisconnecting;
     }
     /**
      * disconnect the TCP layer and close the underlying socket.
@@ -219,33 +287,31 @@ export class TCP_transport extends EventEmitter {
      */
     public disconnect(callback: ErrorCallback): void {
         assert(typeof callback === "function", "expecting a callback function, but got " + callback);
-
-        if (this._disconnecting) {
+        if (!this._socket || this._isDisconnecting) {
+            if (!this._isDisconnecting) {
+                this.dispose();
+            }
             callback();
             return;
         }
+        this._isDisconnecting = true;
 
-        assert(!this._disconnecting, "TCP Transport has already been disconnected");
-        this._disconnecting = true;
-
-        // xx assert(!this._theCallback,
-        //              "disconnect shall not be called while the 'one time message receiver' is in operation");
         this._cleanup_timers();
 
-        if (this._socket) {
-            this._socket.end();
-            this._socket && this._socket.destroy();
-            // xx this._socket.removeAllListeners();
-            this._socket = null;
-        }
-        this.on_socket_ended(null);
-        setImmediate(() => {
-            callback();
+        this._socket.prependOnceListener("close", () => {
+            this._emitClose(null);
+            setImmediate(() => {
+                callback();
+            });
         });
+
+        this._socket.end();
+        this._socket && this._socket.destroy();
+        this._socket = null;
     }
 
     public isValid(): boolean {
-        return this._socket !== null && !this._socket.destroyed && !this._disconnecting;
+        return this._socket !== null && !this._socket.destroyed;
     }
 
     protected _write_chunk(messageChunk: Buffer, callback?: (err?: Error) => void | undefined): void {
@@ -260,15 +326,6 @@ export class TCP_transport extends EventEmitter {
         }
     }
 
-    protected on_socket_ended(err: Error | null): void {
-        if (!this._onSocketEndedHasBeenCalled) {
-            this._onSocketEndedHasBeenCalled = true; // we don't want to send close event twice ...
-            this.emit("close", err || null);
-        } else {
-            debugLog("on_socket_ended has already been called");
-        }
-    }
-
     protected _install_packetAssembler() {
         if (this.packetAssembler) {
             this.packetAssembler.removeAllListeners();
@@ -298,14 +355,24 @@ export class TCP_transport extends EventEmitter {
             this.prematureTerminate(new Error("Packet Assembler : " + err.message), statusCode);
         });
     }
-    /**
-     * @method _install_socket
-     * @param socket {Socket}
-     * @protected
-     */
-    protected _install_socket(socket: Socket): void {
+
+    protected _install_socket(socket: ISocketLike): void {
+        // note: it is possible that a transport may be recycled and re-used again after a connection break
         assert(socket);
+        assert(!this._socket, "already have a socket");
         this._socket = socket;
+        this._closedEmitted = undefined;
+        this._theCloseError = null;
+        assert(this._closedEmitted === undefined, "TCP Transport has already been closed !");
+
+        this._socket.setKeepAlive(true);
+        // 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);
+        // let use a large timeout here to make sure that we not conflict with our internal timeout
+        this._socket.setTimeout(this.timeout);
+
         if (doDebug) {
             debugLog("  TCP_transport#_install_socket ", this.name);
         }
@@ -315,23 +382,14 @@ export class TCP_transport extends EventEmitter {
         this._socket
             .on("data", (data: Buffer) => this._on_socket_data(data))
             .on("close", (hadError) => this._on_socket_close(hadError))
-            .on("end", (err: Error) => this._on_socket_end(err))
-            .on("error", (err: Error) => this._on_socket_error(err));
-
-        // set socket 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 + 2000, () => {
-            debugLog(` _socket ${this.name} has timed out (timeout = ${this.timeout})`);
-            this.prematureTerminate(new Error("socket timeout : timeout=" + this.timeout), StatusCodes2.BadTimeout);
-        });
+            .on("end", () => this._on_socket_end())
+            .on("error", (err: Error) => this._on_socket_error(err))
+            .on("timeout", () => this._on_socket_timeout());
     }
 
     public sendErrorMessage(statusCode: StatusCode, extraErrorDescription: string | null): void {
         // When the Client receives an Error Message it reports the error to the application and closes the TransportConnection gracefully.
         // If a Client encounters a fatal error, it shall report the error to the application and send a CloseSecureChannel Message.
-
         /* istanbul ignore next*/
         if (doDebug) {
             debugLog(chalk.red(" sendErrorMessage        ") + chalk.cyan(statusCode.toString()));
@@ -350,19 +408,18 @@ export class TCP_transport extends EventEmitter {
     public prematureTerminate(err: Error, statusCode: StatusCode): void {
         // https://reference.opcfoundation.org/v104/Core/docs/Part6/6.7.3/
 
-        debugLog("prematureTerminate", err ? err.message : "", statusCode.toString());
+        debugLog("prematureTerminate", err ? err.message : "", statusCode.toString(), "has socket = ", !!this._socket);
+
+        doDebugFlow && console.log("prematureTerminate from", "has socket = ", !!this._socket, new Error().stack);
 
         if (this._socket) {
             err.message = "premature socket termination " + err.message;
             // we consider this as an error
             const _s = this._socket;
-            _s.end();
-            _s.destroy(); // new Error("Socket has timed out"));
-            _s.emit("error", err);
             this._socket = null;
+            _s.destroy(err);
             this.dispose();
         }
-        // this.gracefullShutdown(err);
     }
     /**
      * @method _install_one_time_message_receiver
@@ -381,31 +438,22 @@ export class TCP_transport extends EventEmitter {
     protected _install_one_time_message_receiver(callback: CallbackWithData): void {
         assert(!this._theCallback, "callback already set");
         assert(typeof callback === "function");
-        this._theCallback = callback;
-        this._start_one_time_message_receiver();
+        this._start_one_time_message_receiver(callback);
     }
 
     private _fulfill_pending_promises(err: Error | null, data?: Buffer): boolean {
-        this._cleanup_timers();
-
-        if (this._socket && this._on_error_during_one_time_message_receiver) {
-            this._socket.removeListener("close", this._on_error_during_one_time_message_receiver);
-            this._on_error_during_one_time_message_receiver = null;
-        }
-
+        if (!this._theCallback) return false;
+        doDebugFlow && console.log("_fulfill_pending_promises from", new Error().stack);
         const callback = this._theCallback;
         this._theCallback = undefined;
-
-        if (callback) {
-            callback(err, data);
-            return true;
-        }
-        return false;
+        callback(err, data);
+        return true;
     }
 
     private _on_message_chunk_received(messageChunk: Buffer) {
         if (doTraceIncomingChunk) {
-            console.log(hexDump(messageChunk));
+            warningLog("Transport", this.name);
+            warningLog(hexDump(messageChunk));
         }
         const hadCallback = this._fulfill_pending_promises(null, messageChunk);
         this.chunkReadCount++;
@@ -421,34 +469,49 @@ export class TCP_transport extends EventEmitter {
         }
     }
 
-    private _start_one_time_message_receiver() {
-        assert(!this._timerId, "timer already started");
+    private _start_one_time_message_receiver(callback: CallbackWithData) {
+        assert(!this._timerId && !this._on_error_during_one_time_message_receiver, "timer already started");
 
+        const _cleanUp = () => {
+            this._cleanup_timers();
+            if (this._on_error_during_one_time_message_receiver) {
+                this._socket?.removeListener("close", this._on_error_during_one_time_message_receiver);
+                this._on_error_during_one_time_message_receiver = undefined;
+            }
+        };
+
+        const onTimeout = () => {
+            _cleanUp();
+            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 ....
         this._timerId = setTimeout(() => {
             this._timerId = null;
-            this._fulfill_pending_promises(new Error(`Timeout in waiting for data on socket ( timeout was = ${this.timeout} ms)`));
+            onTimeout();
         }, this.timeout);
 
         // also monitored
         if (this._socket) {
             // to do = intercept socket error as well
-            this._on_error_during_one_time_message_receiver = (err?: Error) => {
-                this._fulfill_pending_promises(
-                    new Error(`ERROR in waiting for data on socket ( timeout was = ${this.timeout} ms) ` + err?.message)
+            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
                 );
+                this._emitClose(err);
+                this._fulfill_pending_promises(err);
             };
-            this._socket.on("close", this._on_error_during_one_time_message_receiver);
+            this._socket.prependOnceListener("close", this._on_error_during_one_time_message_receiver);
         }
-    }
 
-    private on_socket_closed(err?: Error) {
-        if (this._onSocketClosedHasBeenCalled) {
-            return;
-        }
-        assert(!this._onSocketClosedHasBeenCalled);
-        this._onSocketClosedHasBeenCalled = true; // we don't want to send close event twice ...
-        this.emit("socket_closed", err || null);
+        const _callback = callback;
+        this._theCallback = (err?: Error | null, data?: Buffer) => {
+            _cleanUp();
+            this._theCallback = undefined;
+            _callback(err!, data);
+        };
     }
 
     private _on_socket_data(data: Buffer): void {
@@ -465,59 +528,65 @@ export class TCP_transport extends EventEmitter {
     private _on_socket_close(hadError: boolean) {
         // istanbul ignore next
         if (doDebug) {
-            debugLog(chalk.red(" SOCKET CLOSE : "), chalk.yellow("had_error ="), chalk.cyan(hadError.toString()), this.name);
+            debugLog(chalk.red(` SOCKET CLOSE ${this.name}: `), chalk.yellow("had_error ="), chalk.cyan(hadError.toString()));
         }
-        if (this._socket) {
-            debugLog(
-                "  remote address = ",
-                this._socket.remoteAddress,
-                " ",
-                this._socket.remoteFamily,
-                " ",
-                this._socket.remotePort
-            );
-        }
-        if (hadError) {
-            if (this._socket) {
-                this._socket.destroy();
-            }
-        }
-        const err = hadError ? new Error("ERROR IN SOCKET  " + hadError.toString()) : undefined;
-        this.on_socket_closed(err);
         this.dispose();
+        if (this._theCallback) return;
+        // if (hadError) {
+        //     if (this._socket) {
+        //         this._socket.destroy();
+        //     }
+        // }
+        this._emitClose();
     }
 
-    private _on_socket_ended_message(err?: Error) {
-        if (this._disconnecting) {
-            return;
-        }
-
-        debugLog(chalk.red("Transport Connection ended") + " " + this.name);
-        assert(!this._disconnecting);
-        err = err || new Error("_socket has been disconnected by third party");
+    protected _emitClose(err?: Error | null) {
+        err = err || this._theCloseError;
+        doDebugFlow && console.log("_emitClose ", err?.message || "", "from", new Error().stack);
 
-        this.on_socket_ended(err);
-
-        this._disconnecting = true;
-
-        debugLog(" bytesRead    = ", this.bytesRead);
-        debugLog(" bytesWritten = ", this.bytesWritten);
-        this._fulfill_pending_promises(new Error("Connection aborted - ended by server : " + (err ? err.message : "")));
+        if (!this._closedEmitted) {
+            this._closedEmitted = err || "noError";
+            this.emit("close", err || null);
+            // if (this._theCallback) {
+            //     const callback = this._theCallback;
+            //     this._theCallback = undefined;
+            //     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);
+            debugLog("err = ", err?.message, err);
+        }
     }
 
-    private _on_socket_end(err: Error) {
+    private _on_socket_end() {
         // istanbul ignore next
-        if (doDebug) {
-            debugLog(chalk.red(" SOCKET END : err="), chalk.yellow(err ? err.message : "null"), this.name);
+        doDebug && debugLog(chalk.red(` SOCKET END : ${this.name}`), "is disconnecting  ", this.isDisconnecting());
+        if (this.isDisconnecting()) {
+            return;
         }
-        this._on_socket_ended_message(err);
+        //
+        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 : "")));
     }
 
     private _on_socket_error(err: Error) {
         // istanbul ignore next
-        if (doDebug) {
-            debugLog(chalk.red(" SOCKET ERROR : "), chalk.yellow(err.message), this.name);
-        }
+        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}`;
+        doDebug && debugLog(msg);
+        this.prematureTerminate(new Error(msg), StatusCodes2.BadTimeout);
     }
 }

package/dist/test_helpers/direct_transport.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"direct_transport.js","sourceRoot":"","sources":["../../test_helpers/direct_transport.ts"],"names":[],"mappings":";;;AAAA,mCAAsC;AACtC,yDAA2C;AAC3C,sCAA6C;AAC7C,yDAAoD;AAKpD,MAAa,eAAgB,SAAQ,qBAAY;IAM7C;QACI,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,MAAM,GAAG,IAAI,iCAAc,EAAE,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,IAAI,iCAAc,EAAE,CAAC;QAEnC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE;YACjC,IAAA,0BAAM,EAAC,IAAI,YAAY,MAAM,CAAC,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE;YACjC,IAAA,0BAAM,EAAC,IAAI,YAAY,MAAM,CAAC,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YAC1B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC;QACjC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YAC1B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC;QACjC,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAW,EAAE,EAAE;YAClC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;YACpC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;YAChC,IAAI,IAAI,EAAE;gBACN,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;aAC3B;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,GAAG,GAAG,mCAAmC,CAAC;IACnD,CAAC;IAEM,UAAU,CAAC,IAAgB;QAC9B,IAAA,yBAAgB,EAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,IAAI,EAAE,CAAC;IACX,CAAC;IAEM,QAAQ,CAAC,IAAgB;QAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QAClB,IAAI,IAAI,EAAE;YACN,YAAY,CAAC,IAAI,CAAC,CAAC;SACtB;IACL,CAAC;IAEM,WAAW;QACd,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAClB,OAAO,IAAI,CAAC;SACf;QACD,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IACnC,CAAC;IAEM,YAAY,CAAC,IAAoD;QACpE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC;QACxC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;CACJ;AAnED,0CAmEC"}

package/dist/test_helpers/socket_transport.d.ts

@@ -1,10 +0,0 @@
-import { FakeServer } from "./fake_server";
-export declare class SocketTransport extends FakeServer {
-    private client;
-    private server?;
-    constructor({ port }: {
-        port: number;
-    });
-    initialize(done: () => void): void;
-    shutdown(done: (err?: Error) => void): void;
-}

package/dist/test_helpers/socket_transport.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketTransport = void 0;
-// tslint:disable:no-empty
-const net = require("net");
-const fake_server_1 = require("./fake_server");
-class SocketTransport extends fake_server_1.FakeServer {
-    constructor({ port }) {
-        super({ port });
-        this.client = new net.Socket();
-        this.client.connect(this.port, (err) => {
-            /** */
-        });
-    }
-    initialize(done) {
-        super.initialize(() => {
-            this.tcpServer.on("connection", (socket) => {
-                this.server = this._serverSocket;
-                done();
-            });
-        });
-    }
-    shutdown(done) {
-        this.client.end();
-        super.shutdown((err) => {
-            done(err);
-        });
-    }
-}
-exports.SocketTransport = SocketTransport;
-//# sourceMappingURL=socket_transport.js.map

package/dist/test_helpers/socket_transport.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket_transport.js","sourceRoot":"","sources":["../../test_helpers/socket_transport.ts"],"names":[],"mappings":";;;AAAA,0BAA0B;AAC1B,2BAA2B;AAC3B,+CAA2C;AAE3C,MAAa,eAAgB,SAAQ,wBAAU;IAI3C,YAAY,EAAE,IAAI,EAAoB;QAClC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QAEhB,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,GAAW,EAAQ,EAAE;YACjD,MAAM;QACV,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,UAAU,CAAC,IAAgB;QAC9B,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE;YAClB,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,MAAkB,EAAE,EAAE;gBACnD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC;gBACjC,IAAI,EAAE,CAAC;YACX,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,QAAQ,CAAC,IAA2B;QACvC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QAClB,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAW,EAAE,EAAE;YAC3B,IAAI,CAAC,GAAG,CAAC,CAAC;QACd,CAAC,CAAC,CAAC;IACP,CAAC;CACJ;AA5BD,0CA4BC"}