node-opcua-server 2.72.0 → 2.73.0

package/source/helper.ts

@@ -0,0 +1,87 @@
+import * as util from "util";
+import { OPCUAServer } from "./opcua_server";
+import { ServerEngine } from "./server_engine";
+import { ServerSession } from "./server_session";
+import { Subscription, SubscriptionState } from "./server_subscription";
+
+const consolelog = (...args: any) => {
+    const d = new Date();
+    const t = d.toTimeString().split(" ")[0] + "." + d.getMilliseconds().toString().padStart(3, "0");
+    console.log.apply(console, [t, ...args]);
+};
+const doDebug = false;
+
+/**
+ *
+ * @private
+ */
+export function installSessionLogging(server: OPCUAServer) {
+    installSessionLoggingOnEngine(server.engine);
+}
+
+const info = (subscription: Subscription) => {
+    return util.format(
+        subscription.subscriptionId,
+        SubscriptionState[subscription.state].padEnd(9),
+        subscription.state,
+        "kac=",
+        subscription.currentKeepAliveCount.toString().padStart(3)+
+        "/"+
+        subscription.maxKeepAliveCount.toString().padStart(3),
+        "ltc=",
+        subscription.currentLifetimeCount.toString().padStart(3)+
+        "/"+
+        subscription.lifeTimeCount.toString().padStart(3),
+        "prc=",
+        subscription.publishEngine?.pendingPublishRequestCount.toString().padStart(3),
+        "pi=",
+        subscription.publishingInterval
+    );
+};
+
+export function installSubscriptionMonitoring(subscription: Subscription) {
+    consolelog("new_subscription", subscription.subscriptionId, info(subscription));
+    subscription.on("lifeTimeExpired", () => {
+        consolelog("lifeTimeExpired".padEnd(45), info(subscription));
+    });
+    if (true || doDebug) {
+        subscription.on("lifeTimeCounterChanged", (ltc: number) => {
+            consolelog("subscription lifeTimeCounterChanged".padEnd(45), info(subscription));
+        });
+    }
+    subscription.on("expired", () => {
+        consolelog("subscription expired".padEnd(45), info(subscription));
+    });
+    subscription.on("stateChanged", (state: SubscriptionState) => {
+        consolelog("subscription stateChanged".padEnd(45), info(subscription));
+    });
+    subscription.on("terminate", () => {
+        consolelog("subscription terminated".padEnd(45), info(subscription));
+    });
+    subscription.on("keepalive", () => {
+        consolelog("subscription keepalive".padEnd(45), info(subscription));
+    });
+}
+export function installSessionLoggingOnEngine(serverEngine: ServerEngine) {
+    function on_create_session(session: ServerSession) {
+        try {
+            session.on("activate_session", function () {
+                consolelog("activate_session");
+            });
+
+            session.on("statusChanged", (status) => {
+                consolelog("session status changed: ", status);
+            });
+            session.on("new_subscription", function (subscription) {
+                installSubscriptionMonitoring(subscription);
+            });
+        } catch (err) {
+            consolelog((err as any).message);
+        }
+    }
+    serverEngine.on("create_session", on_create_session);
+    serverEngine.once("session_closed", function (session) {
+        consolelog("session is closed");
+        serverEngine.removeListener("create_session", on_create_session);
+    });
+}

package/source/index.ts

@@ -12,4 +12,5 @@ export * from "./server_capabilities";
 export * from "./server_engine";
 export * from "./opcua_server";
 export * from "./monitored_item";
-export * from "./user_manager";
+export * from "./user_manager";
+export * from "./helper";

package/source/monitored_item.ts

@@ -25,7 +25,7 @@ import {
     coerceTimestampsToReturn,
     sameStatusCode
 } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { NodeId } from "node-opcua-nodeid";
 import { NumericalRange0, NumericRange } from "node-opcua-numeric-range";
@@ -71,6 +71,7 @@ const defaultItemToMonitor: ReadValueIdOptions = new ReadValueId({
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
+const warningLog = make_warningLog(__filename);
 
 function _adjust_sampling_interval(samplingInterval: number, node_minimumSamplingInterval: number): number {
     assert(typeof node_minimumSamplingInterval === "number", "expecting a number");
@@ -216,7 +217,7 @@ function apply_dataChange_filter(this: MonitoredItem, newDataValue: DataValue, o
                 debugLog("timestampHasChanged ", timestampHasChanged(newDataValue.sourceTimestamp, oldDataValue.sourceTimestamp));
             }
         } catch (err) {
-            console.log(err);
+            warningLog(err);
         }
     }
     switch (trigger) {

package/source/opcua_server.ts

@@ -203,6 +203,7 @@ const default_build_info: BuildInfoOptions = {
 const minSessionTimeout = 100; // 100 milliseconds
 const defaultSessionTimeout = 1000 * 30; // 30 seconds
 const maxSessionTimeout = 1000 * 60 * 50; // 50 minutes
+let unnamed_session_count = 0;
 
 type ResponseClassType =
     | typeof BrowseResponse
@@ -252,7 +253,7 @@ function moveSessionToChannel(session: ServerSession, channel: ServerSecureChann
 }
 
 async function _attempt_to_close_some_old_unactivated_session(server: OPCUAServer) {
-    const session = server.engine!.getOldestUnactivatedSession();
+    const session = server.engine!.getOldestInactiveSession();
     if (session) {
         await server.engine!.closeSession(session.authenticationToken, false, "Forcing");
     }
@@ -1786,7 +1787,7 @@ export class OPCUAServer extends OPCUABaseServer {
         assert(session.sessionTimeout === revisedSessionTimeout);
 
         session.clientDescription = request.clientDescription;
-        session.sessionName = request.sessionName || "<unknown session name>";
+        session.sessionName = request.sessionName || `<unknown session name ${unnamed_session_count++}>`;
 
         // Depending upon on the  SecurityPolicy  and the  SecurityMode  of the  SecureChannel,  the exchange of
         // ApplicationInstanceCertificates   and  Nonces  may be optional and the signatures may be empty. See
@@ -2239,6 +2240,7 @@ export class OPCUAServer extends OPCUABaseServer {
                 }
                 return channel.send_response("MSG", response1, message);
             } catch (err) {
+                warningLog(err);
                 // istanbul ignore next
                 if (err instanceof Error) {
                     // istanbul ignore next
@@ -3136,7 +3138,7 @@ export class OPCUAServer extends OPCUABaseServer {
 
                     sendResponse(response);
                 } catch (err) {
-                    console.log(err);
+                    warningLog(err);
                     return sendError(StatusCodes.BadInternalError);
                 }
             }

package/source/server_capabilities.ts

@@ -154,9 +154,9 @@ export type ServerCapabilitiesOptions = Partial<IServerCapabilities>;
 export const defaultServerCapabilities: IServerCapabilities = {
     maxBrowseContinuationPoints: 0,
     maxHistoryContinuationPoints: 0,
-    maxStringLength: 65535,
-    maxArrayLength: 65535,
-    maxByteStringLength: 65535,
+    maxStringLength: 16 * 1024 * 1024,
+    maxArrayLength: 1024 * 1024,
+    maxByteStringLength: 16 * 1024 * 1024,
     maxQueryContinuationPoints: 0,
 
     minSupportedSampleRate: 100,
@@ -245,7 +245,8 @@ export class ServerCapabilities implements IServerCapabilities {
         // new in 1.05
         this.maxSessions = options.maxSessions || defaultServerCapabilities.maxSessions;
 
-        this.maxSubscriptionsPerSession = options.maxSubscriptionsPerSession || defaultServerCapabilities.maxSubscriptionsPerSession;
+        this.maxSubscriptionsPerSession =
+            options.maxSubscriptionsPerSession || defaultServerCapabilities.maxSubscriptionsPerSession;
         this.maxSubscriptions = options.maxSubscriptions || defaultServerCapabilities.maxSubscriptions;
         this.maxMonitoredItems = options.maxMonitoredItems || defaultServerCapabilities.maxMonitoredItems;
         this.maxMonitoredItemsPerSubscription =

package/source/server_engine.ts

@@ -5,7 +5,7 @@ import { EventEmitter } from "events";
 import * as async from "async";
 import * as chalk from "chalk";
 import { assert } from "node-opcua-assert";
-
+import { BinaryStream} from "node-opcua-binary-stream";
 import {
     addElement,
     AddressSpace,
@@ -399,6 +399,8 @@ export class ServerEngine extends EventEmitter {
             Object.values(this._sessions).forEach((session: ServerSession) => {
                 counter += session.currentSubscriptionCount;
             });
+            // we also need to add the orphan subscriptions
+            counter += this._orphanPublishEngine ? this._orphanPublishEngine .subscriptions.length : 0;
             return counter;
         });
 
@@ -1007,15 +1009,15 @@ export class ServerEngine extends EventEmitter {
                 );
 
                 bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxArrayLength, DataType.UInt32, () => {
-                    return this.serverCapabilities.maxArrayLength;
+                    return Math.min(this.serverCapabilities.maxArrayLength, Variant.maxArrayLength);
                 });
 
                 bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxStringLength, DataType.UInt32, () => {
-                    return this.serverCapabilities.maxStringLength;
+                    return Math.min(this.serverCapabilities.maxStringLength, BinaryStream.maxStringLength);
                 });
 
                 bindStandardScalar(VariableIds.Server_ServerCapabilities_MaxByteStringLength, DataType.UInt32, () => {
-                    return this.serverCapabilities.maxByteStringLength;
+                    return Math.min(this.serverCapabilities.maxByteStringLength, BinaryStream.maxByteStringLength);
                 });
 
                 const bindOperationLimits = (operationLimits: OperationLimits) => {
@@ -1598,13 +1600,17 @@ export class ServerEngine extends EventEmitter {
         });
     }
 
-    public getOldestUnactivatedSession(): ServerSession | null {
-        const tmp = Object.values(this._sessions).filter((session1: ServerSession) => {
-            return session1.status === "new";
-        });
+    public getOldestInactiveSession(): ServerSession | null {
+        // search screwed or closed session first
+        let tmp = Object.values(this._sessions).filter(
+            (session1: ServerSession) =>
+                session1.status === "screwed" || session1.status === "disposed" || session1.status === "closed"
+        );
         if (tmp.length === 0) {
-            return null;
+            // if none available, tap into the session that are not yet activated
+            tmp = Object.values(this._sessions).filter((session1: ServerSession) => session1.status === "new");
         }
+        if (tmp.length === 0) return null;
         let session = tmp[0];
         for (let i = 1; i < tmp.length; i++) {
             const c = tmp[i];
@@ -1812,10 +1818,6 @@ export class ServerEngine extends EventEmitter {
         if (!subscription) {
             return new TransferResult({ statusCode: StatusCodes.BadSubscriptionIdInvalid });
         }
-        // istanbul ignore next
-        if (!subscription.$session) {
-            return new TransferResult({ statusCode: StatusCodes.BadInternalError });
-        }
 
         // check that session have same userIdentity
         if (!sessionsCompatibleForTransfer(subscription.$session, session)) {
@@ -1846,9 +1848,11 @@ export class ServerEngine extends EventEmitter {
 
         const nbSubscriptionBefore = session.publishEngine.subscriptionCount;
 
-        subscription.$session._unexposeSubscriptionDiagnostics(subscription);
+        if (subscription.$session) {
+            subscription.$session._unexposeSubscriptionDiagnostics(subscription);
+        }
+        
         await ServerSidePublishEngine.transferSubscription(subscription, session.publishEngine, sendInitialValues);
-
         subscription.$session = session;
 
         session._exposeSubscriptionDiagnostics(subscription);
@@ -1983,7 +1987,7 @@ export class ServerEngine extends EventEmitter {
     }
 
     private _exposeSubscriptionDiagnostics(subscription: Subscription): void {
-        debugLog("ServerEngine#_exposeSubscriptionDiagnostics");
+        debugLog("ServerEngine#_exposeSubscriptionDiagnostics", subscription.subscriptionId);
         const subscriptionDiagnosticsArray = this._getServerSubscriptionDiagnosticsArrayNode();
         const subscriptionDiagnostics = subscription.subscriptionDiagnostics;
         assert((subscriptionDiagnostics as any).$subscription === subscription);
@@ -1995,19 +1999,19 @@ export class ServerEngine extends EventEmitter {
     }
 
     protected _unexposeSubscriptionDiagnostics(subscription: Subscription): void {
-        const subscriptionDiagnosticsArray = this._getServerSubscriptionDiagnosticsArrayNode();
+        const serverSubscriptionDiagnosticsArray = this._getServerSubscriptionDiagnosticsArrayNode();
         const subscriptionDiagnostics = subscription.subscriptionDiagnostics;
         assert(subscriptionDiagnostics instanceof SubscriptionDiagnosticsDataType);
-        if (subscriptionDiagnostics && subscriptionDiagnosticsArray) {
-            const node = (subscriptionDiagnosticsArray as any)[subscription.id];
-            removeElement(subscriptionDiagnosticsArray, subscriptionDiagnostics);
+        if (subscriptionDiagnostics && serverSubscriptionDiagnosticsArray) {
+            const node = (serverSubscriptionDiagnosticsArray as any)[subscription.id];
+            removeElement(serverSubscriptionDiagnosticsArray, subscriptionDiagnostics);
             /*assert(
                 !(subscriptionDiagnosticsArray as any)[subscription.id],
                 " subscription node must have been removed from subscriptionDiagnosticsArray"
             );
             */
         }
-        debugLog("ServerEngine#_unexposeSubscriptionDiagnostics");
+        debugLog("ServerEngine#_unexposeSubscriptionDiagnostics", subscription.subscriptionId);
     }
 
     /**
@@ -2200,16 +2204,14 @@ export class ServerEngine extends EventEmitter {
     private _getServerSubscriptionDiagnosticsArrayNode(): UADynamicVariableArray<SubscriptionDiagnosticsDataType> | null {
         // istanbul ignore next
         if (!this.addressSpace) {
-            if (doDebug) {
-                console.warn("ServerEngine#_getServerSubscriptionDiagnosticsArray : no addressSpace");
-            }
+            doDebug && debugLog("ServerEngine#_getServerSubscriptionDiagnosticsArray : no addressSpace");
+
             return null; // no addressSpace
         }
         const subscriptionDiagnosticsType = this.addressSpace.findVariableType("SubscriptionDiagnosticsType");
         if (!subscriptionDiagnosticsType) {
-            if (doDebug) {
-                console.warn("ServerEngine#_getServerSubscriptionDiagnosticsArray " + ": cannot find SubscriptionDiagnosticsType");
-            }
+            doDebug &&
+                debugLog("ServerEngine#_getServerSubscriptionDiagnosticsArray " + ": cannot find SubscriptionDiagnosticsType");
         }
 
         // SubscriptionDiagnosticsArray = i=2290

package/source/server_publish_engine.ts

@@ -116,7 +116,7 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
         subscription: Subscription,
         destPublishEngine: ServerSidePublishEngine,
         sendInitialValues: boolean
-    ): Promise<void> {
+    ): Promise<Subscription> {
         const srcPublishEngine = subscription.publishEngine as any as ServerSidePublishEngine;
 
         assert(!destPublishEngine.getSubscriptionById(subscription.id));
@@ -135,7 +135,9 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
         //  to the old Session.
         subscription.notifyTransfer();
 
-        destPublishEngine.add_subscription(srcPublishEngine.detach_subscription(subscription));
+        const tmp = srcPublishEngine.detach_subscription(subscription);
+        destPublishEngine.add_subscription(tmp);
+        
         subscription.resetLifeTimeCounter();
         if (sendInitialValues) {
             /*  A Boolean parameter with the following values:
@@ -158,6 +160,8 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
 
         assert(destPublishEngine.getSubscriptionById(subscription.id));
         assert(!srcPublishEngine.getSubscriptionById(subscription.id));
+
+        return subscription;
     }
 
     public maxPublishRequestInQueue = 0;
@@ -321,16 +325,16 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
     }
 
     public on_close_subscription(subscription: IClosedOrTransferredSubscription): void {
-        debugLog("ServerSidePublishEngine#on_close_subscription", subscription.id);
+        doDebug && debugLog("ServerSidePublishEngine#on_close_subscription", subscription.id);
         if (subscription.hasPendingNotifications) {
-            debugLog(
+            doDebug && debugLog(
                 "ServerSidePublishEngine#on_close_subscription storing subscription",
                 subscription.id,
                 " to _closed_subscriptions because it has pending notification"
             );
             this._closed_subscriptions.push(subscription);
         } else {
-            debugLog("ServerSidePublishEngine#on_close_subscription disposing subscription", subscription.id);
+            doDebug && debugLog("ServerSidePublishEngine#on_close_subscription disposing subscription", subscription.id);
             // subscription is no longer needed
             subscription.dispose();
         }
@@ -357,7 +361,7 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
     public findLateSubscriptions(): Subscription[] {
         const subscriptions = Object.values(this._subscriptions);
         return subscriptions.filter((subscription: Subscription) => {
-            return subscription.state === SubscriptionState.LATE && subscription.publishingEnabled;
+            return (subscription.state === SubscriptionState.LATE || !subscription.messageSent) && subscription.publishingEnabled;
         });
     }
 
@@ -479,6 +483,9 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
                                 s.timeToKeepAlive +
                                 " m?=" +
                                 s.hasUncollectedMonitoredItemNotifications +
+                                " " + 
+                                SubscriptionState[s.state] +
+                                " " + s.messageSent + 
                                 "]"
                         )
                         .join(" \n")
@@ -493,6 +500,7 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
         const starving_subscription = /* this.findSubscriptionWaitingForFirstPublish() || */ findLateSubscriptionSortedByPriority();
         return starving_subscription;
     }
+
     private _feed_late_subscription() {
         setImmediate(() => {
             if (!this.pendingPublishRequestCount) {
@@ -500,7 +508,7 @@ export class ServerSidePublishEngine extends EventEmitter implements IServerSide
             }
             const starving_subscription = this._find_starving_subscription();
             if (starving_subscription) {
-                debugLog(chalk.bgWhite.red("feeding most late subscription subscriptionId  = "), starving_subscription.id);
+                doDebug && debugLog(chalk.bgWhite.red("feeding most late subscription subscriptionId  = "), starving_subscription.id);
                 starving_subscription.process_subscription();
             }
         });

package/source/server_publish_engine_for_orphan_subscriptions.ts

@@ -5,6 +5,7 @@
 import * as chalk from "chalk";
 
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { NodeId } from "node-opcua-nodeid";
 
 import { ServerSidePublishEngine, ServerSidePublishEngineOptions } from "./server_publish_engine";
 import { Subscription } from "./server_subscription";
@@ -28,6 +29,10 @@ export class ServerSidePublishEngineForOrphanSubscription extends ServerSidePubl
 
     public add_subscription(subscription: Subscription): Subscription {
         debugLog(chalk.bgCyan.yellow.bold(" adding live subscription with id="), subscription.id, " to orphan");
+
+        // detach subscription from old seession
+        subscription.$session = undefined;
+        
         super.add_subscription(subscription);
         // also add an event handler to detected when the subscription has ended
         // so we can automatically remove it from the orphan table
@@ -38,7 +43,7 @@ export class ServerSidePublishEngineForOrphanSubscription extends ServerSidePubl
             // xx publish_engine.detach_subscription(subscription);
             // Xx subscription.dispose();
         };
-        subscription.on("expired", (subscription as any)._expired_func);
+        subscription.once("expired", (subscription as any)._expired_func);
         return subscription;
     }
 

package/source/server_session.ts

@@ -72,6 +72,7 @@ interface SessionSecurityDiagnosticsDataTypeEx extends SessionSecurityDiagnostic
     $session: any;
 }
 
+export type SessionStatus = "new" | "active" | "screwed" | "disposed" | "closed";
 /**
  *
  * A Server session object.
@@ -99,13 +100,12 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
     public static registry = new ObjectRegistry();
     public static maxPublishRequestInQueue = 100;
 
-    public __status = "";
+    public __status: SessionStatus = "new";
     public parent: ServerEngine;
     public authenticationToken: NodeId;
     public nodeId: NodeId;
     public sessionName = "";
 
-    
     public publishEngine: ServerSidePublishEngine;
     public sessionObject: any;
     public readonly creationDate: Date;
@@ -227,18 +227,21 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
      * the first transaction is the creation of the session
      */
     public get clientLastContactTime(): number {
-        const lastSeen =  this._watchDogData ? this._watchDogData.lastSeen : minOPCUADate.getTime();
+        const lastSeen = this._watchDogData ? this._watchDogData.lastSeen : minOPCUADate.getTime();
         return WatchDog.lastSeenToDuration(lastSeen);
     }
 
-    public get status(): string {
+    public get status(): SessionStatus {
         return this.__status;
     }
 
-    public set status(value: string) {
+    public set status(value: SessionStatus) {
         if (value === "active") {
             this._createSessionObjectInAddressSpace();
         }
+        if (this.__status !== value) {
+            this.emit("statusChanged", value);
+        }
         this.__status = value;
     }
 
@@ -304,7 +307,7 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
             const propName = lowerFirstLetter(counterName + "Count");
             // istanbul ignore next
             if (!Object.prototype.hasOwnProperty.call(this._sessionDiagnostics, propName)) {
-               errorLog("incrementRequestTotalCounter: cannot find", propName);
+                errorLog("incrementRequestTotalCounter: cannot find", propName);
                 // xx return;
             } else {
                 (this._sessionDiagnostics as any)[propName].totalCount += 1;
@@ -444,7 +447,7 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
         assert(this.currentSubscriptionCount === 0);
 
         this.status = "closed";
-        
+
         this._detach_channel();
 
         /**
@@ -559,10 +562,10 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
 
     public _detach_channel(): void {
         const channel = this.channel;
-        
+
         // istanbul ignore next
         if (!channel) {
-            return; 
+            return;
             // already detached !
             // throw new Error("expecting a valid channel");
         }
@@ -682,13 +685,13 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
 
                 Object.defineProperty(this._sessionDiagnostics, "sessionId", {
                     get(this: SessionDiagnosticsDataTypeEx) {
-                        return this.$session?.nodeId;
+                        return this.$session ? this.$session.nodeId : NodeId.nullNodeId;
                     }
                 });
 
                 Object.defineProperty(this._sessionDiagnostics, "sessionName", {
                     get(this: SessionDiagnosticsDataTypeEx) {
-                        return this.$session?.sessionName.toString();
+                        return this.$session ? this.$session.sessionName.toString() : "";
                     }
                 });
 
@@ -910,8 +913,7 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
         assert(this.nodeId instanceof NodeId);
 
         subscription.$session = this;
-
-        subscription.sessionId = this.nodeId;
+        assert(subscription.sessionId === this.nodeId);
 
         this._cumulatedSubscriptionCount += 1;