node-opcua-transport 2.51.0

package/source/client_tcp_transport.ts

@@ -0,0 +1,366 @@
+/**
+ * @module node-opcua-transport
+ */
+// tslint:disable:class-name
+// system
+import * as os from "os";
+import * as chalk from "chalk";
+
+import { createConnection, Socket } from "net";
+import { assert } from "node-opcua-assert";
+import { BinaryStream } from "node-opcua-binary-stream";
+import { readMessageHeader } from "node-opcua-chunkmanager";
+import { ErrorCallback } from "node-opcua-status-code";
+
+import { getFakeTransport, TCP_transport } from "./tcp_transport";
+import { decodeMessage, packTcpMessage, parseEndpointUrl } from "./tools";
+
+import * as debug from "node-opcua-debug";
+import { AcknowledgeMessage } from "./AcknowledgeMessage";
+import { HelloMessage } from "./HelloMessage";
+import { TCPErrorMessage } from "./TCPErrorMessage";
+import { doTraceHelloAck } from "./utils";
+
+const doDebug = debug.checkDebugFlag(__filename);
+const debugLog = debug.make_debugLog(__filename);
+const errorLog = debug.make_errorLog(__filename);
+const gHostname = os.hostname();
+
+function createClientSocket(endpointUrl: string): Socket {
+    // create a socket based on Url
+    const ep = parseEndpointUrl(endpointUrl);
+    const port = parseInt(ep.port!, 10);
+    const hostname = ep.hostname!;
+    let socket: Socket;
+    switch (ep.protocol) {
+        case "opc.tcp:":
+            socket = createConnection({ host: hostname, port });
+
+            //        // Setting true for noDelay will immediately fire off data each time socket.write() is called.
+            socket.setNoDelay(true);
+
+            return socket;
+        case "fake:":
+            socket = getFakeTransport();
+            assert(ep.protocol === "fake:", " Unsupported transport protocol");
+            process.nextTick(() => socket.emit("connect"));
+            return socket;
+
+        case "websocket:":
+        case "http:":
+        case "https:FF":
+        default: {
+            const msg = "[NODE-OPCUA-E05] this transport protocol is not supported :" + ep.protocol;
+            errorLog(msg);
+            throw new Error(msg);
+        }
+    }
+}
+export interface ClientTCP_transport {
+    on(eventName: "message", eventHandler: (message: Buffer) => void): this;
+    once(eventName: "message", eventHandler: (message: Buffer) => void): this;
+    on(eventName: "socket_closed", eventHandler: (err: Error | null) => void): this;
+    once(eventName: "socket_closed", eventHandler: (err: Error | null) => void): this;
+    on(eventName: "close", eventHandler: (err: Error | null) => void): this;
+    once(eventName: "close", eventHandler: (err: Error | null) => void): this;
+//
+    on(eventName: "connection_break", eventHandler: () => void): this;
+    once(eventName: "connection_break", eventHandler: () => void): this;
+}
+
+/**
+ * a ClientTCP_transport connects to a remote server socket and
+ * initiates a communication with a HEL/ACK transaction.
+ * It negotiates the communication parameters with the other end.
+ *
+ * @class ClientTCP_transport
+ * @extends TCP_transport
+ * @constructor
+ * @example
+ *
+ *    ```javascript
+ *    const transport = ClientTCP_transport(url);
+ *
+ *    transport.timeout = 10000;
+ *
+ *    transport.connect(function(err)) {
+ *         if (err) {
+ *            // cannot connect
+ *         } else {
+ *            // connected
+ *
+ *         }
+ *    });
+ *    ....
+ *
+ *    transport.write(message_chunk,'F');
+ *
+ *    ....
+ *
+ *    transport.on("message",function(message_chunk) {
+ *        // do something with message from server...
+ *    });
+ *
+ *
+ *    ```
+ *
+ *
+ */
+export class ClientTCP_transport extends TCP_transport {
+    public endpointUrl: string;
+    public serverUri: string;
+    public numberOfRetry: number;
+    public parameters?: AcknowledgeMessage;
+
+    private connected: boolean;
+    private _counter: number;
+
+    constructor() {
+        super();
+        this.connected = false;
+        this.endpointUrl = "";
+        this.serverUri = "";
+        this._counter = 0;
+        this.numberOfRetry = 0;
+    }
+
+    public dispose() {
+        /* istanbul ignore next */
+        if (doDebug) {
+            debugLog(" ClientTCP_transport disposed");
+        }
+        super.dispose();
+    }
+
+    public connect(endpointUrl: string, callback: ErrorCallback) {
+        assert(arguments.length === 2);
+        assert(typeof callback === "function");
+
+        const ep = parseEndpointUrl(endpointUrl);
+
+        this.endpointUrl = endpointUrl;
+
+        this.serverUri = "urn:" + gHostname + ":Sample";
+        /* istanbul ignore next */
+        if (doDebug) {
+            debugLog(chalk.cyan("ClientTCP_transport#connect(endpointUrl = " + endpointUrl + ")"));
+        }
+        try {
+            this._socket = createClientSocket(endpointUrl);
+        } catch (err) {
+            /* istanbul ignore next */
+            if (doDebug) {
+                debugLog("CreateClientSocket has failed");
+            }
+            return callback(err as Error);
+        }
+
+        const _on_socket_error_after_connection = (err: Error) => {
+            /* istanbul ignore next */
+            if (doDebug) {
+                debugLog(" _on_socket_error_after_connection ClientTCP_transport Socket Error", err.message);
+            }
+            // EPIPE : EPIPE (Broken pipe): A write on a pipe, socket, or FIFO for which there is no process to read the
+            // data. Commonly encountered at the net and http layers, indicative that the remote side of the stream
+            // being written to has been closed.
+
+            // ECONNRESET (Connection reset by peer): A connection was forcibly closed by a peer. This normally results
+            // from a loss of the connection on the remote socket due to a timeout or reboot. Commonly encountered
+            // via the http and net module
+            if (err.message.match(/ECONNRESET|EPIPE/)) {
+                /**
+                 * @event connection_break
+                 *
+                 */
+                this.emit("connection_break");
+            }
+        };
+
+        const _on_socket_connect = () => {
+            /* istanbul ignore next */
+            if (doDebug) {
+                debugLog("entering _on_socket_connect");
+            }
+            _remove_connect_listeners();
+            this._perform_HEL_ACK_transaction((err?: Error) => {
+                if (!err) {
+                    /* istanbul ignore next */
+                    if (!this._socket) {
+                        throw new Error("internal error");
+                    }
+                    // install error handler to detect connection break
+                    this._socket.on("error", _on_socket_error_after_connection);
+
+                    this.connected = true;
+                    /**
+                     * notify the observers that the transport is connected (the socket is connected and the the HEL/ACK
+                     * transaction has been done)
+                     * @event connect
+                     *
+                     */
+                    this.emit("connect");
+                } else {
+                    debugLog("_perform_HEL_ACK_transaction has failed with err=", err.message);
+                }
+                callback(err);
+            });
+        };
+
+        const _on_socket_error_for_connect = (err: Error) => {
+            // this handler will catch attempt to connect to an inaccessible address.
+            /* istanbul ignore next */
+            if (doDebug) {
+                debugLog(chalk.cyan("ClientTCP_transport#connect - _on_socket_error_for_connect"), err.message);
+            }
+            assert(err instanceof Error);
+            _remove_connect_listeners();
+            callback(err);
+        };
+
+        const _on_socket_end_for_connect = (err: Error | null) => {
+            /* istanbul ignore next */
+            if (doDebug) {
+                debugLog(
+                    chalk.cyan("ClientTCP_transport#connect -> _on_socket_end_for_connect Socket has been closed by server"),
+                    err
+                );
+            }
+        };
+
+        const _remove_connect_listeners = () => {
+            /* istanbul ignore next */
+            if (!this._socket) {
+                return;
+            }
+            this._socket.removeListener("error", _on_socket_error_for_connect);
+            this._socket.removeListener("end", _on_socket_end_for_connect);
+        };
+
+        this._socket.once("error", _on_socket_error_for_connect);
+        this._socket.once("end", _on_socket_end_for_connect);
+        this._socket.once("connect", _on_socket_connect);
+        this._install_socket(this._socket);
+    }
+
+    protected on_socket_ended(err: Error | null) {
+        debugLog("on_socket_ended", this.name, err ? err.message : "");
+        if (this.connected) {
+            super.on_socket_ended(err);
+        }
+        //  if (this._socket) {
+        //      this._socket.removeAllListeners();
+        // }
+    }
+
+    private _handle_ACK_response(messageChunk: Buffer, callback: ErrorCallback) {
+        const _stream = new BinaryStream(messageChunk);
+        const messageHeader = readMessageHeader(_stream);
+        let err;
+        /* istanbul ignore next */
+        if (messageHeader.isFinal !== "F") {
+            err = new Error(" invalid ACK message");
+            return callback(err);
+        }
+
+        let responseClass;
+        let response;
+
+        if (messageHeader.msgType === "ERR") {
+            responseClass = TCPErrorMessage;
+            _stream.rewind();
+            response = decodeMessage(_stream, responseClass) as TCPErrorMessage;
+
+            err = new Error("ACK: ERR received " + response.statusCode.toString() + " : " + response.reason);
+            (err as any).statusCode = response.statusCode;
+            // istanbul ignore next
+            if (doTraceHelloAck) {
+                console.log("receiving ERR instead of Ack", response.toString());
+            }
+            callback(err);
+        } else {
+            responseClass = AcknowledgeMessage;
+            _stream.rewind();
+            response = decodeMessage(_stream, responseClass);
+            this.parameters = response as AcknowledgeMessage;
+
+            // istanbul ignore next
+            if (doTraceHelloAck) {
+                console.log("receiving Ack\n", response.toString());
+            }
+    
+            callback();
+        }
+    }
+
+    private _send_HELLO_request() {
+        /* istanbul ignore next */
+        if (doDebug) {
+            debugLog("entering _send_HELLO_request");
+        }
+        assert(this._socket);
+        assert(isFinite(this.protocolVersion));
+        assert(this.endpointUrl.length > 0, " expecting a valid endpoint url");
+
+        // Write a message to the socket as soon as the client is connected,
+        // the server will receive it as message from the client
+        const helloMessage = new HelloMessage({
+            endpointUrl: this.endpointUrl,
+            maxChunkCount: 0, // 0 - no limits
+            maxMessageSize: 0, // 0 - no limits
+
+            protocolVersion: this.protocolVersion,
+            receiveBufferSize: 1024 * 64 * 10,
+            sendBufferSize: 1024 * 64 * 10 // 8192 min,
+        });
+        // istanbul ignore next
+        if (doTraceHelloAck) {
+            console.log(`sending Hello\n ${helloMessage.toString()}`);
+        }
+
+        const messageChunk = packTcpMessage("HEL", helloMessage);
+        this._write_chunk(messageChunk);
+    }
+
+    private _on_ACK_response(externalCallback: ErrorCallback, err: Error | null, data?: Buffer) {
+        /* istanbul ignore next */
+        if (doDebug) {
+            debugLog("entering _on_ACK_response");
+        }
+
+        assert(typeof externalCallback === "function");
+        assert(this._counter === 0, "Ack response should only be received once !");
+        this._counter += 1;
+
+        if (err || !data) {
+            externalCallback(err || new Error("no data"));
+            if (this._socket) {
+                this._socket.end();
+                // Xx this._socket.removeAllListeners();
+            }
+        } else {
+            this._handle_ACK_response(data, externalCallback);
+        }
+    }
+
+    private _perform_HEL_ACK_transaction(callback: ErrorCallback) {
+        /* istanbul ignore next */
+        if (!this._socket) {
+            return callback(new Error("No socket available to perform HEL/ACK transaction"));
+        }
+        assert(this._socket, "expecting a valid socket to send a message");
+        assert(typeof callback === "function");
+        this._counter = 0;
+        /* istanbul ignore next */
+        if (doDebug) {
+            debugLog("entering _perform_HEL_ACK_transaction");
+        }
+        this._install_one_time_message_receiver((err: Error | null, data?: Buffer) => {
+            /* istanbul ignore next */
+            if (doDebug) {
+                debugLog("before  _on_ACK_response ", err ? err.message : "");
+            }
+            this._on_ACK_response(callback, err, data);
+        });
+        this._send_HELLO_request();
+    }
+}

package/source/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @module node-opcua-transport
+ */
+export * from "./HelloMessage";
+export * from "./AcknowledgeMessage";
+export * from "./TCPErrorMessage";
+export * from "./client_tcp_transport";
+export * from "./server_tcp_transport";
+export * from "./tcp_transport";
+export * from "./tools";
+export * from "./message_builder_base";

package/source/message_builder_base.ts

@@ -0,0 +1,263 @@
+/**
+ * @module node-opcua-transport
+ */
+import { EventEmitter } from "events";
+import { assert } from "node-opcua-assert";
+
+import { BinaryStream } from "node-opcua-binary-stream";
+import { createFastUninitializedBuffer } from "node-opcua-buffer-utils";
+import { readMessageHeader, SequenceHeader } from "node-opcua-chunkmanager";
+import { make_errorLog, make_debugLog } from "node-opcua-debug";
+import { MessageHeader, PacketAssembler, PacketInfo } from "node-opcua-packet-assembler";
+import { get_clock_tick } from "node-opcua-utils";
+
+const doPerfMonitoring = process.env.NODEOPCUADEBUG && process.env.NODEOPCUADEBUG.indexOf("PERF") >= 0;
+
+const errorLog = make_errorLog("MessageBuilder");
+const debugLog = make_debugLog("MessageBuilder");
+
+export function readRawMessageHeader(data: Buffer): PacketInfo {
+    const messageHeader = readMessageHeader(new BinaryStream(data));
+    return {
+        extra: "",
+        length: messageHeader.length,
+        messageHeader
+    };
+}
+
+/**
+ * @class MessageBuilderBase
+ * @extends EventEmitter
+ * @uses PacketAssembler
+ * @constructor
+ * @param options {Object}
+ * @param [options.signatureLength=0] {number}
+ *
+ */
+export class MessageBuilderBase extends EventEmitter {
+    public readonly signatureLength: number;
+    public readonly options: { signatureLength?: number };
+    public readonly _packetAssembler: PacketAssembler;
+    public channelId: number;
+    public totalMessageSize: number;
+    public sequenceHeader: SequenceHeader | null;
+
+    public _tick0: number;
+    public _tick1: number;
+
+    protected id: string;
+
+    protected totalBodySize: number;
+    protected messageChunks: Buffer[];
+    protected messageHeader?: MessageHeader;
+
+    private _securityDefeated: boolean;
+    private _hasReceivedError: boolean;
+    private blocks: Buffer[];
+    private readonly _expectedChannelId: number;
+    private offsetBodyStart: number;
+
+    constructor(options?: { signatureLength?: number }) {
+        super();
+
+        this.id = "";
+
+        this._tick0 = 0;
+        this._tick1 = 0;
+        this._hasReceivedError = false;
+        this.blocks = [];
+        this.messageChunks = [];
+        this._expectedChannelId = 0;
+
+        options = options || {};
+
+        this.signatureLength = options.signatureLength || 0;
+
+        this.options = options;
+
+        this._packetAssembler = new PacketAssembler({
+            minimumSizeInBytes: 0,
+            readMessageFunc: readRawMessageHeader
+        });
+
+        this._packetAssembler.on("message", (messageChunk) => this._feed_messageChunk(messageChunk));
+
+        this._packetAssembler.on("newMessage", (info, data) => {
+            if (doPerfMonitoring) {
+                // record tick 0: when the first data is received
+                this._tick0 = get_clock_tick();
+            }
+            /**
+             *
+             * notify the observers that a new message is being built
+             * @event start_chunk
+             * @param info
+             * @param data
+             */
+            this.emit("start_chunk", info, data);
+        });
+
+        this._securityDefeated = false;
+        this.totalBodySize = 0;
+        this.totalMessageSize = 0;
+        this.channelId = 0;
+        this.offsetBodyStart = 0;
+        this.sequenceHeader = null;
+        this._init_new();
+    }
+
+    public dispose() {
+        this.removeAllListeners();
+    }
+
+    /**
+     * Feed message builder with some data
+     * @method feed
+     * @param data
+     */
+    public feed(data: Buffer) {
+        if (!this._securityDefeated && !this._hasReceivedError) {
+            this._packetAssembler.feed(data);
+        }
+    }
+
+    protected _decodeMessageBody(fullMessageBody: Buffer): boolean {
+        return true;
+    }
+
+    protected _read_headers(binaryStream: BinaryStream): boolean {
+        try {
+            this.messageHeader = readMessageHeader(binaryStream);
+            assert(binaryStream.length === 8, "expecting message header to be 8 bytes");
+
+            this.channelId = binaryStream.readUInt32();
+            assert(binaryStream.length === 12);
+
+            // verifying secure ChannelId
+            if (this._expectedChannelId && this.channelId !== this._expectedChannelId) {
+                return this._report_error("Invalid secure channel Id");
+            }
+            return true;
+        } catch (err) {
+            return false;
+        }
+    }
+
+    protected _report_error(errorMessage: string): false {
+        this._hasReceivedError = true;
+        /**
+         * notify the observers that an error has occurred
+         * @event error
+         * @param error the error to raise
+         */
+        debugLog("Error  ", this.id, errorMessage);
+        // xx errorLog(new Error());
+        this.emit("error", new Error(errorMessage), this.sequenceHeader ? this.sequenceHeader.requestId : null);
+        return false;
+    }
+
+    private _init_new() {
+        this._securityDefeated = false;
+        this._hasReceivedError = false;
+        this.totalBodySize = 0;
+        this.totalMessageSize = 0;
+        this.blocks = [];
+        this.messageChunks = [];
+    }
+
+    /**
+     * append a message chunk
+     * @method _append
+     * @param chunk
+     * @private
+     */
+    private _append(chunk: Buffer): boolean {
+        if (this._hasReceivedError) {
+            // the message builder is in error mode and further message chunks should be discarded.
+            return false;
+        }
+
+        this.messageChunks.push(chunk);
+        this.totalMessageSize += chunk.length;
+
+        const binaryStream = new BinaryStream(chunk);
+
+        if (!this._read_headers(binaryStream)) {
+            return this._report_error(`Invalid message header detected`);
+        }
+
+        assert(binaryStream.length >= 12);
+
+        // verify message chunk length
+        if (this.messageHeader!.length !== chunk.length) {
+            // tslint:disable:max-line-length
+            return this._report_error(
+                `Invalid messageChunk size: the provided chunk is ${chunk.length} bytes long but header specifies ${
+                    this.messageHeader!.length
+                }`
+            );
+        }
+
+        // the start of the message body block
+        const offsetBodyStart = binaryStream.length;
+
+        // the end of the message body block
+        const offsetBodyEnd = binaryStream.buffer.length;
+
+        this.totalBodySize += offsetBodyEnd - offsetBodyStart;
+        this.offsetBodyStart = offsetBodyStart;
+
+        // add message body to a queue
+        // note : Buffer.slice create a shared memory !
+        //        use Buffer.clone
+        const sharedBuffer = chunk.slice(this.offsetBodyStart, offsetBodyEnd);
+        const clonedBuffer = createFastUninitializedBuffer(sharedBuffer.length);
+
+        sharedBuffer.copy(clonedBuffer, 0, 0);
+        this.blocks.push(clonedBuffer);
+
+        return true;
+    }
+
+    private _feed_messageChunk(chunk: Buffer) {
+        assert(chunk);
+        const messageHeader = readMessageHeader(new BinaryStream(chunk));
+        /**
+         * notify the observers that new message chunk has been received
+         * @event chunk
+         * @param messageChunk the raw message chunk
+         */
+        this.emit("chunk", chunk);
+
+        if (messageHeader.isFinal === "F") {
+            // last message
+            this._append(chunk);
+            if (this._hasReceivedError) {
+                return false;
+            }
+
+            const fullMessageBody: Buffer = this.blocks.length === 1 ? this.blocks[0] : Buffer.concat(this.blocks);
+
+            if (doPerfMonitoring) {
+                // record tick 1: when a complete message has been received ( all chunks assembled)
+                this._tick1 = get_clock_tick();
+            }
+            /**
+             * notify the observers that a full message has been received
+             * @event full_message_body
+             * @param full_message_body the full message body made of all concatenated chunks.
+             */
+            this.emit("full_message_body", fullMessageBody);
+
+            this._decodeMessageBody(fullMessageBody);
+            // be ready for next block
+            this._init_new();
+            return true;
+        } else if (messageHeader.isFinal === "A") {
+            return this._report_error("received and Abort Message");
+        } else if (messageHeader.isFinal === "C") {
+            return this._append(chunk);
+        }
+        return false;
+    }
+}