node-opcua-server 2.71.0 → 2.72.0

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);