node-opcua-transport 2.55.0 → 2.59.0

package/source/tools.ts

@@ -47,18 +47,18 @@ export function decodeMessage(stream: BinaryStream, classNameConstructor: Constr
     }
 }
 
-export function packTcpMessage(msgType: string, encodableObject: BaseUAObject): Buffer {
+export function packTcpMessage(msgType: string, encodeableObject: BaseUAObject): Buffer {
     assert(is_valid_msg_type(msgType));
 
-    const messageChunk = createFastUninitializedBuffer(encodableObject.binaryStoreSize() + 8);
+    const messageChunk = createFastUninitializedBuffer(encodeableObject.binaryStoreSize() + 8);
     // encode encodeableObject in a packet
     const stream = new BinaryStream(messageChunk);
-    encodeMessage(msgType, encodableObject, stream);
+    encodeMessage(msgType, encodeableObject, stream);
 
     return messageChunk;
 }
 
-// opc.tcp://xleuri11022:51210/UA/SampleServer
+// opc.tcp://hostname:51210/UA/SampleServer
 export function parseEndpointUrl(endpointUrl: string): url.Url {
     const _url = url.parse(endpointUrl);
     if (!_url.protocol || !_url.hostname) {

package/source/utils.ts

@@ -1,4 +1,4 @@
-// 
+//
 const transportFlag = (process.env?.NODEOPCUADEBUG?.match(/TRANSPORT{([^}]*)}/) || [])[1] || "";
 export const doTraceHelloAck = transportFlag.match(/HELACK/);
 export const doTraceChunk = transportFlag.match(/CHUNK/);

package/test_helpers/direct_transport.ts

@@ -8,7 +8,7 @@ export class DirectTransport extends EventEmitter {
     public server: HalfComChannel;
     public url: string;
 
-    private _responses?: any[];
+    private _responses?: ((socket: HalfComChannel, data: Buffer) => void)[];
     constructor() {
         super();
 
@@ -66,7 +66,7 @@ export class DirectTransport extends EventEmitter {
         return this._responses.shift();
     }
 
-    public pushResponse(func: any): void {
+    public pushResponse(func: (socket: HalfComChannel, data: Buffer) => void): void {
         this._responses = this._responses || [];
         this._responses.push(func);
     }

package/test_helpers/fake_server.ts

@@ -1,71 +1,69 @@
-import { EventEmitter } from "events";
-import * as  net from "net";
-import { assert } from "node-opcua-assert";
-
-const port = 5678;
- 
-export class FakeServer extends EventEmitter {
-
-    public port: number;
-    public url: string;
-    public tcpServer: net.Server;
-    protected _serverSocket?: net.Socket;
-    private _responses?: any[];
-
-    constructor() {
-        super();
-        this.port = port;
-
-        this.url = "opc.tcp://localhost:" + port;
-
-        this.tcpServer = new net.Server();
-
-        this._serverSocket = undefined;
-
-        this.tcpServer.on("connection", (socket: net.Socket) => {
-            assert(!this._serverSocket, " already connected");
-            this._serverSocket = socket;
-
-            this._serverSocket.on("data", (data: Buffer) => {
-                const func = this.popResponse();
-                if (func) {
-                    func(this._serverSocket, data);
-                }
-            });
-            this._serverSocket.on("err", (err: Error) => {
-                // console.log(" @@@@ socket err ",err);
-            });
-            this._serverSocket.on("close", (err?: Error) => {
-                // console.log(" @@@@ socket closed ",err);
-            });
-            this._serverSocket.on("end", (err?: Error) => {
-                // console.log(" @@@@ socket end ",err);
-                this.emit("end", err);
-            });
-        });
-    }
-
-    public initialize(done: () => void) {
-
-        this.tcpServer.listen(this.port, () => {
-            done();
-        });
-    }
-
-    public shutdown(callback: (err?: Error) => void) {
-        this.tcpServer.close(callback);
-    }
-
-    public popResponse() {
-        if (!this._responses) {
-            return null;
-        }
-        return this._responses.shift();
-    }
-
-    public pushResponse(func: any) {
-        this._responses = this._responses || [];
-        this._responses.push(func);
-    }
-
-}
+import { EventEmitter } from "events";
+import * as net from "net";
+import { assert } from "node-opcua-assert";
+import { HalfComChannel } from "./half_com_channel";
+
+const port = 5678;
+
+export class FakeServer extends EventEmitter {
+    public port: number;
+    public url: string;
+    public tcpServer: net.Server;
+    protected _serverSocket?: net.Socket;
+    private _responses?: any[];
+
+    constructor() {
+        super();
+        this.port = port;
+
+        this.url = "opc.tcp://localhost:" + port;
+
+        this.tcpServer = new net.Server();
+
+        this._serverSocket = undefined;
+
+        this.tcpServer.on("connection", (socket: net.Socket) => {
+            assert(!this._serverSocket, " already connected");
+            this._serverSocket = socket;
+
+            this._serverSocket.on("data", (data: Buffer) => {
+                const func = this.popResponse();
+                if (func && this._serverSocket) {
+                    func(this._serverSocket, data);
+                }
+            });
+            this._serverSocket.on("err", (err: Error) => {
+                // console.log(" @@@@ socket err ",err);
+            });
+            this._serverSocket.on("close", (err?: Error) => {
+                // console.log(" @@@@ socket closed ",err);
+            });
+            this._serverSocket.on("end", (err?: Error) => {
+                // console.log(" @@@@ socket end ",err);
+                this.emit("end", err);
+            });
+        });
+    }
+
+    public initialize(done: () => void): void {
+        this.tcpServer.listen(this.port, () => {
+            done();
+        });
+    }
+
+    public shutdown(callback: (err?: Error) => void): void {
+        this.tcpServer.close(callback);
+    }
+
+    public popResponse(): ((socket: net.Socket, data: Buffer) => void) | null {
+        if (!this._responses) {
+            return null;
+        }
+        return this._responses.shift();
+    }
+
+    public pushResponse(func: (socket: net.Socket, data: Buffer) => void): void {
+        this._responses = this._responses || [];
+        this._responses.push(func);
+    }
+}

package/test_helpers/half_com_channel.ts

@@ -11,7 +11,6 @@ export class HalfComChannel extends EventEmitter {
     }
 
     public write(data: string | Buffer): void {
-
         if (typeof data === "string") {
             data = Buffer.from(data);
         }
@@ -29,9 +28,7 @@ export class HalfComChannel extends EventEmitter {
         }
     }
 
-    public destroy(): void {
-    }
+    public destroy(): void {}
 
-    public setTimeout(): void {
-    }
+    public setTimeout(): void {}
 }

package/test_helpers/index.ts

@@ -1,4 +1,4 @@
-export * from "./fake_server";
-export * from "./direct_transport";
-export * from "./socket_transport";
-export * from "./half_com_channel";
+export * from "./fake_server";
+export * from "./direct_transport";
+export * from "./socket_transport";
+export * from "./half_com_channel";

package/test_helpers/socket_transport.ts

@@ -1,34 +1,33 @@
-// tslint:disable:no-empty
-import * as  net from "net";
-import { FakeServer } from "./fake_server";
-
-export class SocketTransport extends FakeServer {
-
-    private client: net.Socket;
-    private server?: net.Socket;
-
-    constructor() {
-
-        super();
-
-        this.client = new net.Socket();
-        this.client.connect(this.port, (err?: Error) => {
-        });
-    }
-
-    public initialize(done: () => void) {
-        super.initialize(() => {
-            this.tcpServer.on("connection", (socket: net.Socket) => {
-                this.server = this._serverSocket;
-                done();
-            });
-        });
-    }
-
-    public shutdown(done: (err?: Error) => void) {
-        this.client.end();
-        super.shutdown((err?: Error) => {
-            done(err);
-        });
-    }
-}
+// tslint:disable:no-empty
+import * as net from "net";
+import { FakeServer } from "./fake_server";
+
+export class SocketTransport extends FakeServer {
+    private client: net.Socket;
+    private server?: net.Socket;
+
+    constructor() {
+        super();
+
+        this.client = new net.Socket();
+        this.client.connect(this.port, (err?: Error): void => {
+            /** */
+        });
+    }
+
+    public initialize(done: () => void): void {
+        super.initialize(() => {
+            this.tcpServer.on("connection", (socket: net.Socket) => {
+                this.server = this._serverSocket;
+                done();
+            });
+        });
+    }
+
+    public shutdown(done: (err?: Error) => void): void {
+        this.client.end();
+        super.shutdown((err?: Error) => {
+            done(err);
+        });
+    }
+}