node-opcua-server 2.51.0

package/source/register_server_manager_hidden.ts

@@ -0,0 +1,33 @@
+/**
+ * @module node-opcua-server
+ */
+import { EventEmitter } from "events";
+import { IRegisterServerManager } from "./i_register_server_manager";
+
+/**
+ * a IRegisterServerManager that hides the server from any local discover server
+ *
+ */
+export class RegisterServerManagerHidden
+  extends EventEmitter
+  implements IRegisterServerManager {
+
+    public discoveryServerEndpointUrl: string = "";
+
+    constructor(options?: any) {
+        super();
+    }
+
+    public stop(callback: () => void) {
+        setImmediate(callback);
+    }
+
+    public start(callback: () => void) {
+        setImmediate(callback);
+    }
+
+    public dispose() {
+        //
+    }
+
+}

package/source/register_server_manager_mdns_only.ts

@@ -0,0 +1,69 @@
+/**
+ * @module node-opcua-server
+ */
+// RegisterServerManagerMDNSONLY
+
+import { EventEmitter } from "events";
+import { assert } from "node-opcua-assert";
+import {
+    BonjourHolder
+} from "node-opcua-service-discovery";
+import { OPCUABaseServer } from "./base_server";
+import { IRegisterServerManager } from "./i_register_server_manager";
+
+/**
+ * a RegisterServerManager that declare the server the OPCUA Bonjour service
+ * available on the current computer
+ */
+export class RegisterServerManagerMDNSONLY
+  extends EventEmitter
+    implements IRegisterServerManager {
+
+    public discoveryServerEndpointUrl: string = "";
+
+    private server?: OPCUABaseServer;
+    private bonjour: BonjourHolder;
+
+    constructor(options: any) {
+        super();
+        this.server = options.server;
+        assert(this.server);
+        assert(this.server instanceof OPCUABaseServer);
+        this.bonjour = new BonjourHolder();
+    }
+
+    public stop(callback: () => void) {
+        if (this.bonjour) {
+            this.bonjour._stop_announcedOnMulticastSubnet();
+        }
+        setImmediate(() => {
+            this.emit("serverUnregistered");
+            setImmediate(callback);
+        });
+    }
+
+    public start(callback: () => void) {
+        // istanbul ignore next
+        if (!this.server) {
+            throw new Error("internal error");
+        }
+        assert(this.server instanceof OPCUABaseServer);
+
+        this.bonjour._announcedOnMulticastSubnet({
+            capabilities: this.server.capabilitiesForMDNS,
+            name: this.server.serverInfo.applicationUri!,
+            path: "/", // <- to do
+            port: this.server.endpoints[0].port,
+        });
+        setImmediate(() => {
+            this.emit("serverRegistered");
+            setImmediate(callback);
+        });
+    }
+
+    public dispose() {
+        assert(!this.bonjour.isStarted());
+        assert(this.server);
+        this.server = undefined;
+    }
+}

package/source/server_capabilities.ts

@@ -0,0 +1,177 @@
+/**
+ * @module node-opcua-server
+ */
+// tslint:disable:max-classes-per-file
+import { Certificate } from "node-opcua-crypto";
+import { SignedSoftwareCertificate } from "node-opcua-types";
+
+/**
+ */
+export interface OperationLimitsOptions {
+    maxNodesPerRead?: number;
+    maxNodesPerBrowse?: number;
+    maxNodesPerWrite?: number;
+    maxNodesPerMethodCall?: number;
+    maxNodesPerRegisterNodes?: number;
+    maxNodesPerNodeManagement?: number;
+    maxMonitoredItemsPerCall?: number;
+    maxNodesPerHistoryReadData?: number;
+    maxNodesPerHistoryReadEvents?: number;
+    maxNodesPerHistoryUpdateData?: number;
+    maxNodesPerHistoryUpdateEvents?: number;
+    maxNodesPerTranslateBrowsePathsToNodeIds?: number;
+}
+
+export class OperationLimits {
+
+    public maxNodesPerRead: number;
+    public maxNodesPerBrowse: number;
+    public maxNodesPerWrite: number;
+    public maxNodesPerMethodCall: number;
+    public maxNodesPerRegisterNodes: number;
+    public maxNodesPerNodeManagement: number;
+    public maxMonitoredItemsPerCall: number;
+    public maxNodesPerHistoryReadData: number;
+    public maxNodesPerHistoryReadEvents: number;
+    public maxNodesPerHistoryUpdateData: number;
+    public maxNodesPerHistoryUpdateEvents: number;
+    public maxNodesPerTranslateBrowsePathsToNodeIds: number;
+
+    constructor(options: OperationLimitsOptions) {
+
+        /**
+         * @property maxNodesPerRead
+         * @default 0
+         */
+        this.maxNodesPerRead = options.maxNodesPerRead || 0;
+        /**
+         * @property maxNodesPerWrite
+         * @default 0
+         */
+        this.maxNodesPerWrite = options.maxNodesPerWrite || 0;
+        /**
+         * @property maxNodesPerMethodCall
+         * @default 0
+         */
+        this.maxNodesPerMethodCall = options.maxNodesPerMethodCall || 0;
+        /**
+         * @property maxNodesPerBrowse
+         * @default 0
+         */
+        this.maxNodesPerBrowse = options.maxNodesPerBrowse || 0;
+        /**
+         * @property maxNodesPerRegisterNodes
+         * @default 0
+         */
+        this.maxNodesPerRegisterNodes = options.maxNodesPerRegisterNodes || 0;
+        /**
+         * @property maxNodesPerNodeManagement
+         * @default 0
+         */
+        this.maxNodesPerNodeManagement = options.maxNodesPerNodeManagement || 0;
+        /**
+         * @property maxMonitoredItemsPerCall
+         * @default 0
+         */
+        this.maxMonitoredItemsPerCall = options.maxMonitoredItemsPerCall || 0;
+        /**
+         * @property maxNodesPerHistoryReadData
+         */
+        this.maxNodesPerHistoryReadData = options.maxNodesPerHistoryReadData || 0;
+        /**
+         * @property maxNodesPerHistoryReadEvents
+         * @default 0
+         */
+        this.maxNodesPerHistoryReadEvents = options.maxNodesPerHistoryReadEvents || 0;
+        /**
+         * @property maxNodesPerHistoryUpdateData
+         * @default 0
+         */
+        this.maxNodesPerHistoryUpdateData = options.maxNodesPerHistoryUpdateData || 0;
+        /**
+         * @property maxNodesPerHistoryUpdateEvents
+         * @default 0
+         */
+        this.maxNodesPerHistoryUpdateEvents = options.maxNodesPerHistoryUpdateEvents || 0;
+        /**
+         * @property maxNodesPerTranslateBrowsePathsToNodeIds
+         * @default 0
+         */
+        this.maxNodesPerTranslateBrowsePathsToNodeIds = options.maxNodesPerTranslateBrowsePathsToNodeIds || 0;
+
+    }
+}
+
+export interface ServerCapabilitiesOptions {
+    maxBrowseContinuationPoints?: number;
+    maxHistoryContinuationPoints?: number;
+    maxStringLength?: number;
+    maxArrayLength?: number;
+    maxByteStringLength?: number;
+    maxQueryContinuationPoints?: number;
+    minSupportedSampleRate?: number;
+    operationLimits?: OperationLimitsOptions;
+
+    serverProfileArray?: string[];
+    localeIdArray?: string[];
+    softwareCertificates?: SignedSoftwareCertificate[];
+}
+
+/**
+ */
+export class ServerCapabilities {
+
+    public maxBrowseContinuationPoints: number;
+    public maxHistoryContinuationPoints: number;
+    public maxStringLength: number;
+    public maxArrayLength: number;
+    public maxByteStringLength: number;
+    public maxQueryContinuationPoints: number;
+    public minSupportedSampleRate: number;
+    public operationLimits: OperationLimits;
+
+    public serverProfileArray: string[];
+    public localeIdArray: string[];
+    public softwareCertificates: SignedSoftwareCertificate[];
+
+    constructor(options: ServerCapabilitiesOptions) {
+
+        options = options || {};
+        options.operationLimits = options.operationLimits || {};
+
+        this.serverProfileArray = options.serverProfileArray || [];
+        this.localeIdArray = options.localeIdArray || [];
+        this.softwareCertificates = options.softwareCertificates || [];
+        /**
+         * @property maxArrayLength
+         */
+        this.maxArrayLength = options.maxArrayLength || 0;
+        /**
+         * @property maxStringLength
+         */
+        this.maxStringLength = options.maxStringLength || 0;
+        /**
+         * @property maxByteStringLength
+         */
+        this.maxByteStringLength = options.maxByteStringLength || 0;
+        /**
+         * @property maxBrowseContinuationPoints
+         */
+        this.maxBrowseContinuationPoints = options.maxBrowseContinuationPoints || 0;
+        /**
+         * @property maxQueryContinuationPoints
+         */
+        this.maxQueryContinuationPoints = options.maxQueryContinuationPoints || 0;
+        /**
+         * @property maxHistoryContinuationPoints
+         */
+        this.maxHistoryContinuationPoints = options.maxHistoryContinuationPoints || 0;
+
+        /**
+         * @property operationLimits
+         */
+        this.operationLimits = new OperationLimits(options.operationLimits);
+
+        this.minSupportedSampleRate = 100; // to do adjust me
+    }
+}