node-opcua-transport 2.51.0

package/dist/test_helpers/fake_server.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeServer = void 0;
+const events_1 = require("events");
+const net = require("net");
+const node_opcua_assert_1 = require("node-opcua-assert");
+const port = 5678;
+class FakeServer extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.port = port;
+        this.url = "opc.tcp://localhost:" + port;
+        this.tcpServer = new net.Server();
+        this._serverSocket = undefined;
+        this.tcpServer.on("connection", (socket) => {
+            (0, node_opcua_assert_1.assert)(!this._serverSocket, " already connected");
+            this._serverSocket = socket;
+            this._serverSocket.on("data", (data) => {
+                const func = this.popResponse();
+                if (func) {
+                    func(this._serverSocket, data);
+                }
+            });
+            this._serverSocket.on("err", (err) => {
+                // console.log(" @@@@ socket err ",err);
+            });
+            this._serverSocket.on("close", (err) => {
+                // console.log(" @@@@ socket closed ",err);
+            });
+            this._serverSocket.on("end", (err) => {
+                // console.log(" @@@@ socket end ",err);
+                this.emit("end", err);
+            });
+        });
+    }
+    initialize(done) {
+        this.tcpServer.listen(this.port, () => {
+            done();
+        });
+    }
+    shutdown(callback) {
+        this.tcpServer.close(callback);
+    }
+    popResponse() {
+        if (!this._responses) {
+            return null;
+        }
+        return this._responses.shift();
+    }
+    pushResponse(func) {
+        this._responses = this._responses || [];
+        this._responses.push(func);
+    }
+}
+exports.FakeServer = FakeServer;
+//# sourceMappingURL=fake_server.js.map

package/dist/test_helpers/fake_server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake_server.js","sourceRoot":"","sources":["../../test_helpers/fake_server.ts"],"names":[],"mappings":";;;AAAA,mCAAsC;AACtC,2BAA4B;AAC5B,yDAA2C;AAE3C,MAAM,IAAI,GAAG,IAAI,CAAC;AAElB,MAAa,UAAW,SAAQ,qBAAY;IAQxC;QACI,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAEjB,IAAI,CAAC,GAAG,GAAG,sBAAsB,GAAG,IAAI,CAAC;QAEzC,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;QAElC,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QAE/B,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,MAAkB,EAAE,EAAE;YACnD,IAAA,0BAAM,EAAC,CAAC,IAAI,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;YAClD,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;YAE5B,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;gBAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;gBAChC,IAAI,IAAI,EAAE;oBACN,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;iBAClC;YACL,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAU,EAAE,EAAE;gBACxC,wCAAwC;YAC5C,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAW,EAAE,EAAE;gBAC3C,2CAA2C;YAC/C,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAW,EAAE,EAAE;gBACzC,wCAAwC;gBACxC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAC1B,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,UAAU,CAAC,IAAgB;QAE9B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE;YAClC,IAAI,EAAE,CAAC;QACX,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,QAAQ,CAAC,QAA+B;QAC3C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACnC,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,IAAS;QACzB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC;QACxC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;CAEJ;AAhED,gCAgEC"}

package/dist/test_helpers/half_com_channel.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+export declare class HalfComChannel extends EventEmitter {
+    _hasEnded: boolean;
+    constructor();
+    write(data: string | Buffer): void;
+    end(): void;
+    destroy(): void;
+    setTimeout(): void;
+}

package/dist/test_helpers/half_com_channel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HalfComChannel = void 0;
+// tslint:disable:no-empty
+// tslint:disable:unused-variable
+const events_1 = require("events");
+const node_opcua_assert_1 = require("node-opcua-assert");
+class HalfComChannel extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this._hasEnded = false;
+    }
+    write(data) {
+        if (typeof data === "string") {
+            data = Buffer.from(data);
+        }
+        (0, node_opcua_assert_1.assert)(data instanceof Buffer, "HalfComChannel.write expecting a buffer");
+        const copy = Buffer.concat([data]);
+        this.emit("send_data", copy);
+    }
+    end() {
+        if (!this._hasEnded) {
+            (0, node_opcua_assert_1.assert)(!this._hasEnded, "half communication channel has already ended !");
+            this._hasEnded = true;
+            this.emit("ending");
+            this.emit("end");
+        }
+    }
+    destroy() {
+    }
+    setTimeout() {
+    }
+}
+exports.HalfComChannel = HalfComChannel;
+//# sourceMappingURL=half_com_channel.js.map

package/dist/test_helpers/half_com_channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"half_com_channel.js","sourceRoot":"","sources":["../../test_helpers/half_com_channel.ts"],"names":[],"mappings":";;;AAAA,0BAA0B;AAC1B,iCAAiC;AACjC,mCAAsC;AACtC,yDAA2C;AAE3C,MAAa,cAAe,SAAQ,qBAAY;IAG5C;QACI,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IAC3B,CAAC;IAEM,KAAK,CAAC,IAAqB;QAE9B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;YAC1B,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC5B;QACD,IAAA,0BAAM,EAAC,IAAI,YAAY,MAAM,EAAE,yCAAyC,CAAC,CAAC;QAC1E,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAEM,GAAG;QACN,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACjB,IAAA,0BAAM,EAAC,CAAC,IAAI,CAAC,SAAS,EAAE,gDAAgD,CAAC,CAAC;YAC1E,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpB;IACL,CAAC;IAEM,OAAO;IACd,CAAC;IAEM,UAAU;IACjB,CAAC;CACJ;AAhCD,wCAgCC"}

package/dist/test_helpers/index.d.ts

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

package/dist/test_helpers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fake_server"), exports);
+__exportStar(require("./direct_transport"), exports);
+__exportStar(require("./socket_transport"), exports);
+__exportStar(require("./half_com_channel"), exports);
+//# sourceMappingURL=index.js.map

package/dist/test_helpers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../test_helpers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,gDAA8B;AAC9B,qDAAmC;AACnC,qDAAmC;AACnC,qDAAmC"}

package/dist/test_helpers/socket_transport.d.ts

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

package/dist/test_helpers/socket_transport.js

@@ -0,0 +1,30 @@
+"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() {
+        super();
+        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

@@ -0,0 +1 @@
+{"version":3,"file":"socket_transport.js","sourceRoot":"","sources":["../../test_helpers/socket_transport.ts"],"names":[],"mappings":";;;AAAA,0BAA0B;AAC1B,2BAA4B;AAC5B,+CAA2C;AAE3C,MAAa,eAAgB,SAAQ,wBAAU;IAK3C;QAEI,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,GAAW,EAAE,EAAE;QAC/C,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;AA7BD,0CA6BC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "node-opcua-transport",
+    "version": "2.51.0",
+    "description": "pure nodejs OPCUA SDK - module -transport",
+    "main": "./dist/source/index.js",
+    "types": "./dist/source/index.d.ts",
+    "scripts": {
+        "build": "tsc -b",
+        "test": "mocha",
+        "clean": "node -e \"require('rimraf').sync('dist');\""
+    },
+    "dependencies": {
+        "chalk": "4.1.2",
+        "node-opcua-assert": "2.51.0",
+        "node-opcua-basic-types": "2.51.0",
+        "node-opcua-binary-stream": "2.51.0",
+        "node-opcua-buffer-utils": "2.51.0",
+        "node-opcua-chunkmanager": "2.51.0",
+        "node-opcua-debug": "2.51.0",
+        "node-opcua-factory": "2.51.0",
+        "node-opcua-nodeid": "2.51.0",
+        "node-opcua-object-registry": "2.51.0",
+        "node-opcua-packet-assembler": "2.51.0",
+        "node-opcua-status-code": "2.51.0",
+        "node-opcua-types": "2.51.0",
+        "node-opcua-utils": "2.51.0"
+    },
+    "devDependencies": {
+        "@types/node": "16.7.10",
+        "node-opcua-debug": "2.42.0",
+        "should": "^13.2.3",
+        "sinon": "^11.1.2"
+    },
+    "author": "Etienne Rossignon",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/node-opcua/node-opcua.git"
+    },
+    "keywords": [
+        "OPCUA",
+        "opcua",
+        "m2m",
+        "iot",
+        "opc ua",
+        "internet of things"
+    ],
+    "homepage": "http://node-opcua.github.io/",
+    "gitHead": "75feb111daf7ec65fa0111e4fa5beb8987fd4945"
+}

package/source/AcknowledgeMessage.ts

@@ -0,0 +1,112 @@
+/**
+ * @module node-opcua-transport
+ */
+import { decodeUInt32, encodeUInt32, UInt32 } from "node-opcua-basic-types";
+import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import {
+    BaseUAObject,
+    buildStructuredType, check_options_correctness_against_schema,
+    initialize_field,
+    parameters,
+    StructuredTypeSchema
+} from "node-opcua-factory";
+
+const schemaAcknowledgeMessage: StructuredTypeSchema = buildStructuredType({
+    name: "AcknowledgeMessage",
+
+    baseType: "BaseObjectType",
+
+    fields: [
+        {
+            name: "protocolVersion",
+
+            fieldType: "UInt32",
+
+            documentation: "The latest version of the OPC UA TCP protocol supported by the Server."
+        },
+        { name: "receiveBufferSize", fieldType: "UInt32" },
+        { name: "sendBufferSize", fieldType: "UInt32" },
+        { name: "maxMessageSize", fieldType: "UInt32", documentation: "The maximum size for any request message." },
+        {
+            name: "maxChunkCount",
+
+            fieldType: "UInt32",
+
+            documentation: "The maximum number of chunks in any request message."
+        }
+    ]
+});
+
+interface AcknowledgeMessageOptions {
+    protocolVersion?: UInt32;
+    receiveBufferSize?: UInt32;
+    sendBufferSize?: UInt32;
+    maxMessageSize?: UInt32;
+    maxChunkCount?: UInt32;
+}
+
+export class AcknowledgeMessage extends BaseUAObject {
+
+    public static possibleFields: string[] = [
+        "protocolVersion",
+        "receiveBufferSize",
+        "sendBufferSize",
+        "maxMessageSize",
+        "maxChunkCount"
+    ];
+    public static schema = schemaAcknowledgeMessage;
+
+    public protocolVersion: UInt32;
+    public receiveBufferSize: UInt32;
+    public sendBufferSize: UInt32;
+    public maxMessageSize: UInt32;
+    public maxChunkCount: UInt32;
+
+    constructor(options?: AcknowledgeMessageOptions) {
+
+        options = options || {};
+
+        super();
+        const schema = schemaAcknowledgeMessage;
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+
+        this.protocolVersion = initialize_field(schema.fields[0], options.protocolVersion);
+        this.receiveBufferSize = initialize_field(schema.fields[1], options.receiveBufferSize);
+        this.sendBufferSize = initialize_field(schema.fields[2], options.sendBufferSize);
+        this.maxMessageSize = initialize_field(schema.fields[3], options.maxMessageSize);
+        this.maxChunkCount = initialize_field(schema.fields[4], options.maxChunkCount);
+    }
+
+    public encode(stream: OutputBinaryStream): void {
+
+        super.encode(stream);
+        encodeUInt32(this.protocolVersion, stream);
+        encodeUInt32(this.receiveBufferSize, stream);
+        encodeUInt32(this.sendBufferSize, stream);
+        encodeUInt32(this.maxMessageSize, stream);
+        encodeUInt32(this.maxChunkCount, stream);
+    }
+
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        super.decode(stream);
+        this.protocolVersion = decodeUInt32(stream);
+        this.receiveBufferSize = decodeUInt32(stream);
+        this.sendBufferSize = decodeUInt32(stream);
+        this.maxMessageSize = decodeUInt32(stream);
+        this.maxChunkCount = decodeUInt32(stream);
+    }
+
+    public toString(): string {
+        let str = "";
+        str += 'protocolVersion   = ' + this.protocolVersion +'\n';
+        str += 'receiveBufferSize = ' + this.receiveBufferSize +'\n';
+        str += 'sendBufferSize    = ' + this.sendBufferSize +'\n';
+        str += 'maxMessageSize    = ' + this.maxMessageSize +'\n';
+        str += 'maxChunkCount     = ' + this.maxChunkCount +'\n'; 
+        return str;
+    }
+}

package/source/HelloMessage.ts

@@ -0,0 +1,133 @@
+/**
+ * @module node-opcua-transport
+ */
+import {
+    decodeUAString, decodeUInt32, encodeUAString,
+    encodeUInt32, UAString, UInt32
+} from "node-opcua-basic-types";
+import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import {
+    BaseUAObject,
+    buildStructuredType, check_options_correctness_against_schema,
+    initialize_field,
+    parameters, StructuredTypeSchema
+} from "node-opcua-factory";
+
+const schemaHelloMessage: StructuredTypeSchema = buildStructuredType({
+    name: "HelloMessage",
+
+    baseType: "BaseUAObject",
+
+    fields: [
+        {
+            name: "protocolVersion",
+
+            fieldType: "UInt32",
+
+            documentation: "The latest version of the OPC UA TCP protocol supported by the Client"
+        },
+        {
+            name: "receiveBufferSize",
+
+            fieldType: "UInt32",
+
+            documentation: "The largest message that the sender can receive."
+        },
+        {
+            name: "sendBufferSize",
+
+            fieldType: "UInt32",
+
+            documentation: "The largest message that the sender will send."
+        },
+        { name: "maxMessageSize", fieldType: "UInt32", documentation: "The maximum size for any response message." },
+        {
+            name: "maxChunkCount",
+
+            fieldType: "UInt32",
+
+            documentation: "The maximum number of chunks in any response message"
+        },
+        {
+            name: "endpointUrl",
+
+            fieldType: "UAString",
+
+            documentation: "The URL of the Endpoint which the Client wished to connect to."
+        }
+    ]
+});
+
+export interface HelloMessageOptions {
+    protocolVersion?: UInt32;
+    receiveBufferSize?: UInt32;
+    sendBufferSize?: UInt32;
+    maxMessageSize?: UInt32;
+    maxChunkCount?: UInt32;
+    endpointUrl?: UAString;
+}
+
+export class HelloMessage extends BaseUAObject {
+
+    public static possibleFields: string[] = [
+        "protocolVersion",
+        "receiveBufferSize",
+        "sendBufferSize",
+        "maxMessageSize",
+        "maxChunkCount",
+        "endpointUrl"
+    ];
+    public protocolVersion: UInt32;
+    public receiveBufferSize: UInt32;
+    public sendBufferSize: UInt32;
+    public maxMessageSize: UInt32;
+    public maxChunkCount: UInt32;
+    public endpointUrl: UAString;
+
+    constructor(options?: HelloMessageOptions) {
+        options = options || {};
+        super();
+        const schema = schemaHelloMessage;
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+
+        this.protocolVersion = initialize_field(schema.fields[0], options.protocolVersion);
+        this.receiveBufferSize = initialize_field(schema.fields[1], options.receiveBufferSize);
+        this.sendBufferSize = initialize_field(schema.fields[2], options.sendBufferSize);
+        this.maxMessageSize = initialize_field(schema.fields[3], options.maxMessageSize);
+        this.maxChunkCount = initialize_field(schema.fields[4], options.maxChunkCount);
+        this.endpointUrl = initialize_field(schema.fields[5], options.endpointUrl);
+    }
+
+    public encode(stream: OutputBinaryStream): void {
+        super.encode(stream);
+        encodeUInt32(this.protocolVersion, stream);
+        encodeUInt32(this.receiveBufferSize, stream);
+        encodeUInt32(this.sendBufferSize, stream);
+        encodeUInt32(this.maxMessageSize, stream);
+        encodeUInt32(this.maxChunkCount, stream);
+        encodeUAString(this.endpointUrl, stream);
+    }
+
+    public decode(stream: BinaryStream): void {
+        super.decode(stream);
+        this.protocolVersion = decodeUInt32(stream);
+        this.receiveBufferSize = decodeUInt32(stream);
+        this.sendBufferSize = decodeUInt32(stream);
+        this.maxMessageSize = decodeUInt32(stream);
+        this.maxChunkCount = decodeUInt32(stream);
+        this.endpointUrl = decodeUAString(stream);
+    }
+    public toString() {
+        let str = "";
+        str += 'protocolVersion   = ' + this.protocolVersion +'\n';
+        str += 'receiveBufferSize = ' + this.receiveBufferSize +'\n';
+        str += 'sendBufferSize    = ' + this.sendBufferSize +'\n';
+        str += 'maxMessageSize    = ' + this.maxMessageSize +'\n';
+        str += 'maxChunkCount     = ' + this.maxChunkCount +'\n';
+        str += 'endpointUrl       = ' + this.endpointUrl +'\n';
+        return str;
+    }
+}

package/source/TCPErrorMessage.ts

@@ -0,0 +1,57 @@
+/**
+ * @module node-opcua-transport
+ */
+import { decodeString, encodeString, UAString } from "node-opcua-basic-types";
+import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import {
+    BaseUAObject,
+    buildStructuredType, check_options_correctness_against_schema,
+    initialize_field,
+    parameters
+} from "node-opcua-factory";
+import { decodeStatusCode, encodeStatusCode, StatusCode } from "node-opcua-status-code";
+
+// TCP Error Message  OPC Unified Architecture, Part 6 page 46
+// the server always close the connection after sending the TCPError message
+const schemaTCPErrorMessage = buildStructuredType({
+    name: "TCPErrorMessage",
+
+    baseType: "BaseUAObject",
+
+    fields: [
+        {name: "statusCode", fieldType: "StatusCode"},
+        {name: "reason", fieldType: "String"} // A more verbose description of the error.
+    ]
+});
+
+export class TCPErrorMessage extends BaseUAObject {
+    public static possibleFields: string[] = ["statusCode", "reason"];
+    public statusCode: StatusCode;
+    public reason: UAString;
+    constructor(options?: { statusCode?: StatusCode, reason?: string}) {
+        options = options || {};
+        const schema = schemaTCPErrorMessage;
+
+        super();
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.statusCode = initialize_field(schema.fields[0], options.statusCode);
+        this.reason = initialize_field(schema.fields[1], options.reason);
+    }
+
+    public encode(stream: OutputBinaryStream): void {
+        // call base class implementation first
+        super.encode(stream);
+        encodeStatusCode(this.statusCode, stream);
+        encodeString(this.reason, stream);
+    }
+
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        super.decode(stream);
+        this.statusCode = decodeStatusCode(stream);
+        this.reason = decodeString(stream);
+    }
+}