node-opcua-server 2.70.3 → 2.72.1

package/source/server_capabilities.ts

@@ -2,8 +2,10 @@
  * @module node-opcua-server
  */
 // tslint:disable:max-classes-per-file
-import { Certificate } from "node-opcua-crypto";
+import { UInt32 } from "node-opcua-basic-types";
+import { QualifiedName } from "node-opcua-data-model";
 import { SignedSoftwareCertificate } from "node-opcua-types";
+import { OPCUAServer } from "./opcua_server";
 
 /**
  */
@@ -37,86 +39,162 @@ export class OperationLimits {
     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 interface IServerCapabilities {
+    maxBrowseContinuationPoints: number;
+    maxHistoryContinuationPoints: number;
+    maxStringLength: number;
+    maxArrayLength: number;
+    maxByteStringLength: number;
+    maxQueryContinuationPoints: number;
+    minSupportedSampleRate: number;
+    operationLimits: OperationLimitsOptions;
+
+    serverProfileArray: string[];
+    localeIdArray: string[];
+    softwareCertificates: SignedSoftwareCertificate[];
+
+    // new in 1.05
+    /**
+     * MaxSessions is an integer specifying the maximum number of concurrent
+     * Sessions the Server can support. The value specifies the
+     * maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support
+     * the maximum.
+     */
+    maxSessions: UInt32;
+
+    /**
+     * MaxSubscriptions is an integer specifying the maximum number of
+     * Subscriptions the Server can support. The value specifies the
+     * maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support
+     * the maximum.
+     */
+    maxSubscriptions: UInt32;
+
+    /**
+     * MaxMonitoredItems is an integer specifying the maximum number of
+     * MonitoredItems the Server can support. The value specifies the
+     * maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support
+     * the maximum.
+     */
+    maxMonitoredItems: UInt32;
+
+    /**
+     * MaxSubscriptionsPerSession is an integer specifying the maximum number of
+     * Subscriptions per Session the Server can support. The value specifies the
+     * maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support
+     * the maximum.
+     */
+    maxSubscriptionsPerSession: UInt32;
+
+    /**
+     * MaxMonitoredItemsPerSubscription is an integer specifying the maximum number of
+     * MonitoredItems per Subscription the Server can support. The value specifies the
+     * maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support
+     * the maximum
+     */
+    maxMonitoredItemsPerSubscription: UInt32;
+
+    /**
+     * MaxSelectClauseParameters is an integer specifying the maximum number of
+     * EventField SelectClause Parameters the Server can support for an EventFilter.
+     * The value specifies the maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support
+     * the maximum.
+     */
+    maxSelectClauseParameters: UInt32;
+
+    /**
+     * MaxWhereClauseParameters is an integer specifying the maximum number of
+     * EventField WhereClause Parameters the Server can support for an EventFilter.
+     * The value specifies the maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support the maximum
+     */
+    maxWhereClauseParameters: UInt32;
+
+    /**
+     * (draft)
+     * MaxMonitoredItemsQueueSize is an integer specifying the maximum size of MonitoredItem
+     * queues. The value specifies the maximum the Server can support under normal circumstances,
+     * therefore there is no guarantee the Server can always support the maximum.
+     *
+     */
+    maxMonitoredItemsQueueSize: UInt32;
+
+    /**
+     *
+     * ConformanceUnits is a QualifiedName array specifying the set of conformance units
+     * the Server supports. This list should be limited to the ConformanceUnits the Server
+     * supports in its current configuration.
+     *
+     */
+    conformanceUnits: QualifiedName[];
 }
+export type ServerCapabilitiesOptions = Partial<IServerCapabilities>;
+
+export const defaultServerCapabilities: IServerCapabilities = {
+    maxBrowseContinuationPoints: 0,
+    maxHistoryContinuationPoints: 0,
+    maxStringLength: 65535,
+    maxArrayLength: 65535,
+    maxByteStringLength: 65535,
+    maxQueryContinuationPoints: 0,
+
+    minSupportedSampleRate: 100,
+
+    operationLimits: {
+        maxNodesPerBrowse: 0,
+        maxNodesPerHistoryReadData: 0,
+        maxNodesPerHistoryReadEvents: 0,
+        maxNodesPerHistoryUpdateData: 0,
+        maxNodesPerHistoryUpdateEvents: 0,
+        maxNodesPerMethodCall: 0,
+        maxNodesPerNodeManagement: 0,
+        maxNodesPerRead: 0,
+        maxNodesPerRegisterNodes: 0,
+        maxNodesPerWrite: 0,
+        maxNodesPerTranslateBrowsePathsToNodeIds: 0,
+        maxMonitoredItemsPerCall: 0
+    },
+
+    serverProfileArray: [],
+    localeIdArray: [],
+    softwareCertificates: [],
+
+    maxSessions: 10,
+    maxSubscriptions: 100,
+    maxMonitoredItems: 1000000, // 1 million
+    maxSubscriptionsPerSession: 10,
+    maxMonitoredItemsPerSubscription: 100000, // one hundred thousand
+    maxSelectClauseParameters: 100,
+    maxWhereClauseParameters: 100,
+    maxMonitoredItemsQueueSize: 60000,
+
+    conformanceUnits: []
+};
 
 /**
  */
-export class ServerCapabilities {
+export class ServerCapabilities implements IServerCapabilities {
     public maxBrowseContinuationPoints: number;
     public maxHistoryContinuationPoints: number;
     public maxStringLength: number;
@@ -130,6 +208,18 @@ export class ServerCapabilities {
     public localeIdArray: string[];
     public softwareCertificates: SignedSoftwareCertificate[];
 
+    // new in 1.05
+    public maxSessions: UInt32;
+    public maxSubscriptions: UInt32;
+    public maxMonitoredItems: UInt32;
+    public maxSubscriptionsPerSession: UInt32;
+    public maxMonitoredItemsPerSubscription: UInt32;
+    public maxSelectClauseParameters: UInt32;
+    public maxWhereClauseParameters: UInt32;
+    public maxMonitoredItemsQueueSize: UInt32;
+    public conformanceUnits: QualifiedName[];
+
+    // eslint-disable-next-line complexity
     constructor(options: ServerCapabilitiesOptions) {
         options = options || {};
         options.operationLimits = options.operationLimits || {};
@@ -137,36 +227,33 @@ export class ServerCapabilities {
         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.maxArrayLength = options.maxArrayLength || defaultServerCapabilities.maxArrayLength;
+        this.maxStringLength = options.maxStringLength || defaultServerCapabilities.maxStringLength;
+        this.maxByteStringLength = options.maxByteStringLength || defaultServerCapabilities.maxByteStringLength;
+        this.maxBrowseContinuationPoints =
+            options.maxBrowseContinuationPoints || defaultServerCapabilities.maxBrowseContinuationPoints;
+        this.maxQueryContinuationPoints =
+            options.maxQueryContinuationPoints || defaultServerCapabilities.maxQueryContinuationPoints;
+        this.maxHistoryContinuationPoints =
+            options.maxHistoryContinuationPoints || defaultServerCapabilities.maxHistoryContinuationPoints;
+
         this.operationLimits = new OperationLimits(options.operationLimits);
 
-        this.minSupportedSampleRate = 100; // to do adjust me
+        this.minSupportedSampleRate = options.minSupportedSampleRate || defaultServerCapabilities.minSupportedSampleRate; // to do adjust me
+
+        // new in 1.05
+        this.maxSessions = options.maxSessions || defaultServerCapabilities.maxSessions;
+
+        this.maxSubscriptionsPerSession = options.maxSubscriptionsPerSession || defaultServerCapabilities.maxSubscriptionsPerSession;
+        this.maxSubscriptions = options.maxSubscriptions || defaultServerCapabilities.maxSubscriptions;
+        this.maxMonitoredItems = options.maxMonitoredItems || defaultServerCapabilities.maxMonitoredItems;
+        this.maxMonitoredItemsPerSubscription =
+            options.maxMonitoredItemsPerSubscription || defaultServerCapabilities.maxMonitoredItemsPerSubscription;
+        this.maxSelectClauseParameters = options.maxSelectClauseParameters || defaultServerCapabilities.maxSelectClauseParameters;
+        this.maxWhereClauseParameters = options.maxWhereClauseParameters || defaultServerCapabilities.maxWhereClauseParameters;
+        this.maxMonitoredItemsQueueSize =
+            options.maxMonitoredItemsQueueSize || defaultServerCapabilities.maxMonitoredItemsQueueSize;
+        this.conformanceUnits = options.conformanceUnits || defaultServerCapabilities.conformanceUnits;
     }
 }

package/source/server_end_point.ts

@@ -11,7 +11,7 @@ import * as async from "async";
 import { assert } from "node-opcua-assert";
 import { ICertificateManager, OPCUACertificateManager } from "node-opcua-certificate-manager";
 import { Certificate, convertPEMtoDER, makeSHA1Thumbprint, PrivateKeyPEM, split_der } from "node-opcua-crypto";
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { getFullyQualifiedDomainName, resolveFullyQualifiedDomainName } from "node-opcua-hostname";
 import {
     fromURI,
@@ -32,6 +32,7 @@ import { ISocketData } from "./i_socket_data";
 
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
+const warningLog = make_warningLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 
 const default_transportProfileUri = "http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary";
@@ -704,14 +705,14 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
 
         const establish_connection = () => {
             const nbConnections = Object.keys(this._channels).length;
-            debugLog(
-                " nbConnections ",
-                nbConnections,
-                " self._server.maxConnections",
-                this._server!.maxConnections,
-                this.maxConnections
-            );
             if (nbConnections >= this.maxConnections) {
+                warningLog(
+                    " nbConnections ",
+                    nbConnections,
+                    " self._server.maxConnections",
+                    this._server!.maxConnections,
+                    this.maxConnections
+                );
                 deny_connection();
                 return;
             }

package/source/server_engine.ts

@@ -314,6 +314,7 @@ export class ServerEngine extends EventEmitter {
     private _applicationUri: string;
     private _expectedShutdownTime!: Date;
     private _serverStatus: ServerStatusDataType;
+    private _globalCounter: { totalMonitoredItemCount: number } = { totalMonitoredItemCount: 0 };
 
     constructor(options: ServerEngineOptions) {
         super();
@@ -964,6 +965,32 @@ export class ServerEngine extends EventEmitter {
                     return this.serverCapabilities.maxHistoryContinuationPoints;
                 });
 
+                // new in 1.05
+                bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxSessions, DataType.UInt32, () => {
+                    return this.serverCapabilities.maxSessions;
+                });
+                bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxSubscriptions, DataType.UInt32, () => {
+                    return this.serverCapabilities.maxSubscriptions;
+                });
+                bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxMonitoredItems, DataType.UInt32, () => {
+                    return this.serverCapabilities.maxMonitoredItems;
+                });
+                bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxSubscriptionsPerSession, DataType.UInt32, () => {
+                    return this.serverCapabilities.maxSubscriptionsPerSession;
+                });
+                bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxSelectClauseParameters, DataType.UInt32, () => {
+                    return this.serverCapabilities.maxSelectClauseParameters;
+                });
+                bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxWhereClauseParameters, DataType.UInt32, () => {
+                    return this.serverCapabilities.maxWhereClauseParameters;
+                });
+                //bindStandardArray(VariableIds.Server_ServerCapabilities_ConformanceUnits, DataType.QualifiedName, () => {
+                //    return this.serverCapabilities.conformanceUnits;
+                //});
+                bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxMonitoredItemsPerSubscription, DataType.UInt32, () => {
+                    return this.serverCapabilities.maxMonitoredItemsPerSubscription;
+                });
+
                 // added by DI : Server-specific period of time in milliseconds until the Server will revoke a lock.
                 // TODO bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxInactiveLockTime,
                 // TODO     DataType.UInt16, function () {
@@ -2010,7 +2037,9 @@ export class ServerEngine extends EventEmitter {
             publishingEnabled: request.publishingEnabled,
             publishingInterval,
             // -------------------
-            sessionId: NodeId.nullNodeId
+            sessionId: NodeId.nullNodeId,
+            globalCounter: this._globalCounter,
+            serverCapabilities: this.serverCapabilities // shared
         });
 
         // add subscriptionDiagnostics

package/source/server_session.ts

@@ -105,6 +105,7 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
     public nodeId: NodeId;
     public sessionName = "";
 
+    
     public publishEngine: ServerSidePublishEngine;
     public sessionObject: any;
     public readonly creationDate: Date;

package/source/server_subscription.ts

@@ -10,7 +10,7 @@ import { AddressSpace, BaseNode, Duration, UAObjectType } from "node-opcua-addre
 import { checkSelectClauses } from "node-opcua-address-space";
 import { SessionContext } from "node-opcua-address-space";
 import { assert } from "node-opcua-assert";
-import { Byte } from "node-opcua-basic-types";
+import { Byte, UInt32 } from "node-opcua-basic-types";
 import { SubscriptionDiagnosticsDataType } from "node-opcua-common";
 import { NodeClass, AttributeIds, isValidDataEncoding } from "node-opcua-data-model";
 import { TimestampsToReturn } from "node-opcua-data-value";
@@ -312,6 +312,10 @@ function createSubscriptionDiagnostics(subscription: Subscription): Subscription
     return subscriptionDiagnostics as SubscriptionDiagnosticsDataTypePriv;
 }
 
+interface IGlobalMonitoredItemCounter {
+    totalMonitoredItemCount: number;
+}
+
 export interface SubscriptionOptions {
     sessionId?: NodeId;
     /**
@@ -342,6 +346,9 @@ export interface SubscriptionOptions {
      *  a unique identifier
      */
     id?: number;
+
+    serverCapabilities: ServerCapabilitiesPartial;
+    globalCounter: IGlobalMonitoredItemCounter;
 }
 
 let g_monitoredItemId = Math.ceil(Math.random() * 100000);
@@ -435,6 +442,11 @@ export interface MonitoredItemBase {
 export type CreateMonitoredItemHook = (subscription: Subscription, monitoredItem: MonitoredItemBase) => Promise<StatusCode>;
 export type DeleteMonitoredItemHook = (subscription: Subscription, monitoredItem: MonitoredItemBase) => Promise<StatusCode>;
 
+export interface ServerCapabilitiesPartial {
+    maxMonitoredItems: UInt32;
+    maxMonitoredItemsPerSubscription: UInt32;
+}
+
 /**
  * The Subscription class used in the OPCUA server side.
  */
@@ -443,7 +455,19 @@ export class Subscription extends EventEmitter {
     public static defaultPublishingInterval = 1000; // one second
     public static maximumPublishingInterval: number = 1000 * 60 * 60 * 24 * 15; // 15 days
     public static maxNotificationPerPublishHighLimit = 1000;
-    public static maxMonitoredItemCount = 20000;
+
+    /**
+     * maximum number of monitored item in a subscription to be used
+     * when serverCapacity.maxMonitoredItems and serverCapacity.maxMonitoredItemsPerSubscription are not set.
+     */
+    public static defaultMaxMonitoredItemCount = 20000;
+    
+    /**
+     * @deprecated use serverCapacity.maxMonitoredItems and serverCapacity.maxMonitoredItemsPerSubscription instead
+     */
+    protected static get maxMonitoredItemCount() {
+        return Subscription.defaultMaxMonitoredItemCount;
+    }
 
     public static registry = new ObjectRegistry();
 
@@ -507,6 +531,9 @@ export class Subscription extends EventEmitter {
     private timerId: any;
     private _hasUncollectedMonitoredItemNotifications = false;
 
+    private globalCounter: IGlobalMonitoredItemCounter;
+    private serverCapabilities: ServerCapabilitiesPartial;
+
     constructor(options: SubscriptionOptions) {
         super();
 
@@ -566,6 +593,12 @@ export class Subscription extends EventEmitter {
         this._start_timer();
 
         debugLog(chalk.green(`creating subscription ${this.id}`));
+
+        this.serverCapabilities = options.serverCapabilities;
+        this.serverCapabilities.maxMonitoredItems = this.serverCapabilities.maxMonitoredItems || Subscription.defaultMaxMonitoredItemCount;
+        this.serverCapabilities.maxMonitoredItemsPerSubscription =
+            this.serverCapabilities.maxMonitoredItemsPerSubscription || Subscription.defaultMaxMonitoredItemCount;
+        this.globalCounter = options.globalCounter;
     }
 
     public getSessionId(): NodeId {
@@ -968,12 +1001,16 @@ export class Subscription extends EventEmitter {
         if (statusCodeFilter !== StatusCodes.Good) {
             return handle_error(statusCodeFilter);
         }
-        // xx var monitoringMode      = monitoredItemCreateRequest.monitoringMode; // Disabled, Sampling, Reporting
-        // xx var requestedParameters = monitoredItemCreateRequest.requestedParameters;
+
         // do we have enough room for new monitored items ?
-        if (this.monitoredItemCount >= Subscription.maxMonitoredItemCount) {
+        if (this.monitoredItemCount >= this.serverCapabilities.maxMonitoredItemsPerSubscription) {
+            return handle_error(StatusCodes.BadTooManyMonitoredItems);
+        }
+
+        if (this.globalCounter.totalMonitoredItemCount >= this.serverCapabilities.maxMonitoredItems) {
             return handle_error(StatusCodes.BadTooManyMonitoredItems);
         }
+
         const createResult = this._createMonitoredItemStep2(timestampsToReturn, monitoredItemCreateRequest, node);
 
         assert(createResult.statusCode === StatusCodes.Good);
@@ -1052,6 +1089,7 @@ export class Subscription extends EventEmitter {
         this.emit("removeMonitoredItem", monitoredItem);
 
         delete this.monitoredItems[monitoredItemId];
+        this.globalCounter.totalMonitoredItemCount -= 1;
 
         this._removePendingNotificationsFor(monitoredItemId);
         // flush pending notifications
@@ -1724,7 +1762,10 @@ export class Subscription extends EventEmitter {
         monitoredItem.$subscription = this;
 
         assert(monitoredItem.monitoredItemId === monitoredItemId);
+
         this.monitoredItems[monitoredItemId] = monitoredItem;
+        this.globalCounter.totalMonitoredItemCount += 1;
+
         assert(monitoredItem.clientHandle !== 4294967295);
 
         const filterResult = _process_filter(node, requestedParameters.filter);