node-opcua-server 2.119.2 → 2.121.0

package/source/monitored_item.ts

@@ -255,22 +255,21 @@ function apply_dataChange_filter(this: MonitoredItem, newDataValue: DataValue, o
 
 const s = (a: any) => JSON.stringify(a, null, "  ");
 
-function safeGuardRegiter(monitoredItem: MonitoredItem) {
-
+function safeGuardRegister(monitoredItem: MonitoredItem) {
     (monitoredItem.oldDataValue as any)._$monitoredItem = monitoredItem.node?.nodeId?.toString();
     (monitoredItem as any)._$safeGuard = s((monitoredItem as any).oldDataValue);
 }
 function safeGuardVerify(monitoredItem: MonitoredItem) {
     if ((monitoredItem as any)._$safeGuard) {
-        const verif = s(monitoredItem.oldDataValue|| "");
+        const verif = s(monitoredItem.oldDataValue || "");
         if (verif !== (monitoredItem as any)._$safeGuard) {
             errorLog(verif, (monitoredItem as any)._$safeGuard);
-            throw new Error("Internal error: DataValue has been altereed !!!");
+            throw new Error("Internal error: DataValue has been altered !!!");
         }
     }
 }
 function apply_filter(this: MonitoredItem, newDataValue: DataValue) {
-    if (!this.oldDataValue) {
+    if (this.oldDataValue === badDataUnavailable) {
         return true; // keep
     }
 
@@ -365,6 +364,7 @@ function isSourceNewerThan(a: DataValue, b?: DataValue): boolean {
     return at > bt;
 }
 
+const badDataUnavailable = new DataValue({ statusCode: StatusCodes.BadDataUnavailable }); // unset initially
 /**
  * a server side monitored item
  *
@@ -391,7 +391,7 @@ export class MonitoredItem extends EventEmitter {
     public samplingInterval = -1;
     public monitoredItemId: number;
     public overflow: boolean;
-    public oldDataValue?: DataValue;
+    public oldDataValue: DataValue;
     public monitoringMode: MonitoringMode;
     public timestampsToReturn: TimestampsToReturn;
     public itemToMonitor: any;
@@ -404,7 +404,7 @@ export class MonitoredItem extends EventEmitter {
     public samplingFunc: SamplingFunc | null = null;
 
     private _node: BaseNode | null;
-    private queue: QueueItem[];
+    public queue: QueueItem[];
     private _semantic_version: number;
     private _is_sampling = false;
     private _on_opcua_event_received_callback: any;
@@ -433,7 +433,7 @@ export class MonitoredItem extends EventEmitter {
         this.queue = [];
         this.overflow = false;
 
-        this.oldDataValue = new DataValue({ statusCode: StatusCodes.BadDataUnavailable }); // unset initially
+        this.oldDataValue = badDataUnavailable;
 
         // user has to call setMonitoringMode
         this.monitoringMode = MonitoringMode.Invalid;
@@ -522,7 +522,7 @@ export class MonitoredItem extends EventEmitter {
         }
 
         // x assert(this._samplingId === null,"Sampling Id must be null");
-        this.oldDataValue = undefined;
+        this.oldDataValue = badDataUnavailable;
         this.queue = [];
         this.itemToMonitor = null;
         this.filter = null;
@@ -580,7 +580,7 @@ export class MonitoredItem extends EventEmitter {
      *
      */
     // eslint-disable-next-line complexity, max-statements
-    public recordValue(dataValue: DataValue, skipChangeTest: boolean, indexRange?: NumericRange): boolean {
+    public recordValue(dataValue: DataValue, skipChangeTest?: boolean, indexRange?: NumericRange): boolean {
         if (!this.itemToMonitor) {
             // we must have a valid itemToMonitor(have this monitoredItem been disposed already ?)
             // istanbul ignore next
@@ -588,18 +588,13 @@ export class MonitoredItem extends EventEmitter {
             return false;
         }
 
-        assert(dataValue !== this.oldDataValue, "recordValue expects different dataValue to be provided");
-
-        assert(
-            !dataValue.value || !this.oldDataValue || dataValue.value !== this.oldDataValue!.value,
-            "recordValue expects different dataValue.value to be provided"
-        );
-
-        assert(!dataValue.value || dataValue.value.isValid(), "expecting a valid variant value");
+        if (dataValue === this.oldDataValue) {
+            errorLog("recordValue expects different dataValue to be provided");
+        }
+        doDebug && assert(!dataValue.value || dataValue.value.isValid(), "expecting a valid variant value");
 
         const hasSemanticChanged = this.node && (this.node as any).semantic_version !== this._semantic_version;
 
-       
         if (!hasSemanticChanged && indexRange && this.itemToMonitor.indexRange) {
             // we just ignore changes that do not fall within our range
             // ( unless semantic bit has changed )
@@ -655,13 +650,13 @@ export class MonitoredItem extends EventEmitter {
             }
         }
 
-        if (!apply_filter.call(this, dataValue)) {
+        if (!skipChangeTest && !apply_filter.call(this, dataValue)) {
             // istanbul ignore next
             if (doDebug) {
                 debugLog("recordValue => Rejected ", this.node?.browseName.toString(), " because apply_filter");
                 debugLog("current Value =>", this.oldDataValue?.toString());
-                debugLog("propoped Value =>", dataValue?.toString());
-                debugLog("propoped Value =>", dataValue == this.oldDataValue, dataValue.value === this.oldDataValue?.value);
+                debugLog("proposed Value =>", dataValue?.toString());
+                debugLog("proposed Value =>", dataValue == this.oldDataValue, dataValue.value === this.oldDataValue?.value);
             }
             return false;
         }
@@ -672,12 +667,12 @@ export class MonitoredItem extends EventEmitter {
 
             // istanbul ignore next
             if (doDebug) {
-                debugLog("Current : ", this.oldDataValue!.toString());
+                debugLog("Current : ", this.oldDataValue?.toString());
                 debugLog("New : ", dataValue.toString());
                 debugLog("indexRange=", indexRange);
             }
 
-            if (sameVariant(dataValue.value, this.oldDataValue!.value)) {
+            if (this.oldDataValue !== badDataUnavailable && sameVariant(dataValue.value, this.oldDataValue.value)) {
                 // istanbul ignore next
                 doDebug &&
                     debugLog("recordValue => Rejected ", this.node?.browseName.toString(), " because useIndexRange && sameVariant");
@@ -791,13 +786,24 @@ export class MonitoredItem extends EventEmitter {
         return notifications;
     }
 
-    public modify(timestampsToReturn: TimestampsToReturn, monitoringParameters: MonitoringParameters): MonitoredItemModifyResult {
+    public modify(
+        timestampsToReturn: TimestampsToReturn | null,
+        monitoringParameters: MonitoringParameters | null
+    ): MonitoredItemModifyResult {
         assert(monitoringParameters instanceof MonitoringParameters);
 
         const old_samplingInterval = this.samplingInterval;
 
         this.timestampsToReturn = timestampsToReturn || this.timestampsToReturn;
 
+        if (!monitoringParameters) {
+            return new MonitoredItemModifyResult({
+                revisedQueueSize: this.queueSize,
+                revisedSamplingInterval: this.samplingInterval,
+                filterResult: null,
+                statusCode: StatusCodes.Good
+            });
+        }
         if (old_samplingInterval !== 0 && monitoringParameters.samplingInterval === 0) {
             monitoringParameters.samplingInterval = MonitoredItem.minimumSamplingInterval; // fastest possible
         }
@@ -831,13 +837,30 @@ export class MonitoredItem extends EventEmitter {
         });
     }
 
-    public async resendInitialValues(): Promise<void> {
+    public async resendInitialValue(): Promise<void> {
         // the first Publish response(s) after the TransferSubscriptions call shall contain the current values of all
         // Monitored Items in the Subscription where the Monitoring Mode is set to Reporting.
         // the first Publish response after the TransferSubscriptions call shall contain only the value changes since
         // the last Publish response was sent.
         // This parameter only applies to MonitoredItems used for monitoring Attribute changes.
-        return this._start_sampling(true);
+
+        // istanbul ignore next
+        if (!this.node) return;
+
+        const sessionContext = this.getSessionContext() || SessionContext.defaultContext;
+
+        // istanbul ignore next
+        if (!sessionContext) return;
+
+        // no need to resend if a value is already in the queue
+        if (this.queue.length > 0) return;
+
+        const theValueToResend =
+            this.oldDataValue !== badDataUnavailable
+                ? this.oldDataValue
+                : this.node.readAttribute(sessionContext, this.itemToMonitor.attributeId);
+        this.oldDataValue = badDataUnavailable;
+        this._enqueue_value(theValueToResend);
     }
 
     private getSessionContext(): ISessionContext | null {
@@ -857,8 +880,11 @@ export class MonitoredItem extends EventEmitter {
             return;
         }
 
-        const sessionContext = this.getSessionContext();
+        // Use default context if session is not available
+        const sessionContext = this.getSessionContext() || SessionContext.defaultContext;
+
         if (!sessionContext) {
+            warningLog("MonitoredItem#_on_sampling_timer : ", this.node?.nodeId.toString(), "cannot find session");
             return;
         }
         // istanbul ignore next
@@ -893,13 +919,13 @@ export class MonitoredItem extends EventEmitter {
 
             this._is_sampling = true;
 
-            this.samplingFunc.call(this, sessionContext, this.oldDataValue!, (err: Error | null, newDataValue?: DataValue) => {
+            this.samplingFunc.call(this, sessionContext, this.oldDataValue, (err: Error | null, newDataValue?: DataValue) => {
                 if (!this._samplingId) {
                     // item has been disposed. The monitored item has been disposed while the async sampling func
                     // was taking place ... just ignore this
                     return;
                 }
-                // istanbull ignore next
+                // istanbul ignore next
                 if (err) {
                     errorLog(" SAMPLING ERROR =>", err);
                 } else {
@@ -1022,13 +1048,14 @@ export class MonitoredItem extends EventEmitter {
     private _start_sampling(recordInitialValue: boolean): void {
         // istanbul ignore next
         if (!this.node) {
-            throw new Error("Internal Error");
+            return; // we just want to ignore here ...
         }
+        this.oldDataValue = badDataUnavailable;
         setImmediate(() => this.__start_sampling(recordInitialValue));
     }
 
     private __acquireInitialValue(sessionContext: ISessionContext, callback: CallbackT<DataValue>): void {
-        // aquire initial value from the variable/object not itself or from the last known value if we have
+        // acquire initial value from the variable/object not itself or from the last known value if we have
         // one already
         assert(this.itemToMonitor.attributeId === AttributeIds.Value);
         assert(this.node);
@@ -1036,16 +1063,16 @@ export class MonitoredItem extends EventEmitter {
             return callback(new Error("Invalid "));
         }
         const variable = this.node as UAVariable;
-        if (!this.oldDataValue || this.oldDataValue.statusCode.value == StatusCodes.BadDataUnavailable.value) {
+        if (this.oldDataValue == badDataUnavailable) {
             variable.readValueAsync(sessionContext, (err: Error | null, dataValue?: DataValue) => {
                 callback(err, dataValue);
             });
         } else {
             const o = this.oldDataValue;
-            this.oldDataValue = new DataValue({ statusCode: StatusCodes.BadDataUnavailable });
+            this.oldDataValue = badDataUnavailable;
             // istanbul ignore next
             if (doDebug) {
-                safeGuardRegiter(this);
+                safeGuardRegister(this);
             }
             callback(null, o);
         }
@@ -1056,7 +1083,7 @@ export class MonitoredItem extends EventEmitter {
             return; // we just want to ignore here ...
         }
 
-        const sessionContext = this.getSessionContext();
+        const sessionContext = this.getSessionContext() || SessionContext.defaultContext;
         // istanbul ignore next
         if (!sessionContext) {
             return;
@@ -1241,34 +1268,20 @@ export class MonitoredItem extends EventEmitter {
      * @param dataValue {DataValue} the dataValue to enqueue
      * @private
      */
-    private _enqueue_value(dataValue: DataValue) {
+    public _enqueue_value(dataValue: DataValue) {
         // preconditions:
-        if (doDebug) {
-            debugLog("_enqueue_value = ", dataValue.toString());
-        }
+        doDebug && debugLog("_enqueue_value = ", dataValue.toString());
 
-        assert(dataValue instanceof DataValue);
         // lets verify that, if status code is good then we have a valid Variant in the dataValue
-        assert(!dataValue.statusCode.isGoodish() || dataValue.value instanceof Variant);
-        // xx assert(isGoodish(dataValue.statusCode) || util.isNullOrUndefined(dataValue.value) );
+        doDebug && assert(!dataValue.statusCode.isGoodish() || dataValue.value instanceof Variant);
         // let's check that data Value is really a different object
         // we may end up with corrupted queue if dataValue are recycled and stored as is in notifications
-        assert(dataValue !== this.oldDataValue, "dataValue cannot be the same object twice!");
-
-        // Xx // todo ERN !!!! PLEASE CHECK this !!!
-        // Xx // let make a clone, so we have a snapshot
-        // Xx dataValue = dataValue.clone();
+        doDebug && assert(dataValue !== this.oldDataValue, "dataValue cannot be the same object twice!");
 
         // let's check that data Value is really a different object
         // we may end up with corrupted queue if dataValue are recycled and stored as is in notifications
-        assert(
-            !this.oldDataValue || !dataValue.value || dataValue.value !== this.oldDataValue.value,
-            "dataValue cannot be the same object twice!"
-        );
-
         if (
             !(
-                !this.oldDataValue ||
                 !this.oldDataValue.value ||
                 !dataValue.value ||
                 !(dataValue.value.value instanceof Object) ||
@@ -1294,7 +1307,7 @@ export class MonitoredItem extends EventEmitter {
         this.oldDataValue = dataValue.clone();
         // istanbul ignore next
         if (doDebug) {
-            safeGuardRegiter(this);
+            safeGuardRegister(this);
         }
 
         const notification = this._makeDataChangeNotification(this.oldDataValue);
@@ -1302,7 +1315,6 @@ export class MonitoredItem extends EventEmitter {
     }
 
     private _makeEventFieldList(eventFields: any[]): EventFieldList {
-        assert(Array.isArray(eventFields));
         return new EventFieldList({
             clientHandle: this.clientHandle,
             eventFields

package/source/opcua_server.ts

@@ -165,7 +165,7 @@ import { RegisterServerManager } from "./register_server_manager";
 import { RegisterServerManagerHidden } from "./register_server_manager_hidden";
 import { RegisterServerManagerMDNSONLY } from "./register_server_manager_mdns_only";
 import { ServerCapabilitiesOptions } from "./server_capabilities";
-import { EndpointDescriptionEx, OPCUAServerEndPoint } from "./server_end_point";
+import { EndpointDescriptionEx, IServerTransportSettings, OPCUAServerEndPoint } from "./server_end_point";
 import { ClosingReason, CreateSessionOption, ServerEngine } from "./server_engine";
 import { ServerSession } from "./server_session";
 import { CreateMonitoredItemHook, DeleteMonitoredItemHook, Subscription } from "./server_subscription";
@@ -926,6 +926,12 @@ export interface OPCUAServerOptions extends OPCUABaseServerOptions, OPCUAServerE
      * @default false
      */
     skipOwnNamespace?: boolean;
+
+    /**
+     * @private
+     * @optional
+     */
+    transportSettings?: IServerTransportSettings;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
@@ -1473,8 +1479,9 @@ export class OPCUAServer extends OPCUABaseServer {
     /**
      * retrieve a session by authentication token
      * @internal
+     * @private
      */
-    protected getSession(authenticationToken: NodeId, activeOnly?: boolean): ServerSession | null {
+    public getSession(authenticationToken: NodeId, activeOnly?: boolean): ServerSession | null {
         return this.engine ? this.engine.getSession(authenticationToken, activeOnly) : null;
     }
 
@@ -1615,8 +1622,7 @@ export class OPCUAServer extends OPCUABaseServer {
                     case StatusCodes.BadCertificateIssuerTimeInvalid:
                         this.raiseEvent("AuditCertificateExpiredEventType", {
                             certificate: { dataType: DataType.ByteString, value: certificate },
-                            sourceName: { dataType: DataType.String, value: "Security/Certificate" },
-                            comment: { dataType: DataType.String, value: certificateStatus.toString() }
+                            sourceName: { dataType: DataType.String, value: "Security/Certificate" }
                         });
                         break;
                     case StatusCodes.BadCertificateRevoked:
@@ -1624,8 +1630,7 @@ export class OPCUAServer extends OPCUABaseServer {
                     case StatusCodes.BadCertificateIssuerRevocationUnknown:
                         this.raiseEvent("AuditCertificateRevokedEventType", {
                             certificate: { dataType: DataType.ByteString, value: certificate },
-                            sourceName: { dataType: DataType.String, value: "Security/Certificate" },
-                            comment: { dataType: DataType.String, value: certificateStatus.toString() }
+                            sourceName: { dataType: DataType.String, value: "Security/Certificate" }
                         });
                         break;
                     case StatusCodes.BadCertificateIssuerUseNotAllowed:
@@ -1633,8 +1638,7 @@ export class OPCUAServer extends OPCUABaseServer {
                     case StatusCodes.BadSecurityChecksFailed:
                         this.raiseEvent("AuditCertificateMismatchEventType", {
                             certificate: { dataType: DataType.ByteString, value: certificate },
-                            sourceName: { dataType: DataType.String, value: "Security/Certificate" },
-                            comment: { dataType: DataType.String, value: certificateStatus.toString() }
+                            sourceName: { dataType: DataType.String, value: "Security/Certificate" }
                         });
                         break;
                 }
@@ -2341,8 +2345,8 @@ export class OPCUAServer extends OPCUABaseServer {
         let response: any;
         /* istanbul ignore next */
         if (!message.session || message.session_statusCode !== StatusCodes.Good) {
-            const errMessage = "INVALID SESSION  !! ";
-            response = new ResponseClass({ responseHeader: { serviceResult: message.session_statusCode } });
+            const errMessage = "=>" + message.session_statusCode?.toString();
+            response = new ServiceFault({ responseHeader: { serviceResult: message.session_statusCode } });
             debugLog(chalk.red.bold(errMessage), chalk.yellow(message.session_statusCode!.toString()), response.constructor.name);
             return sendResponse(response);
         }
@@ -2445,23 +2449,28 @@ export class OPCUAServer extends OPCUABaseServer {
                     return sendError(StatusCodes.BadNothingToDo);
                 }
 
-                const results: any[] = subscriptionIds.map((subscriptionId: number) => actionToPerform(session, subscriptionId));
-
-                // resolve potential pending promises ....
-                for (let i = 0; i < results.length; i++) {
-                    if (results[i].then) {
-                        results[i] = await results[i];
-                    }
+                // check minimal
+                if (
+                    request.subscriptionIds.length >
+                    Math.min(
+                        this.engine.serverCapabilities.maxSubscriptionsPerSession,
+                        this.engine.serverCapabilities.maxSubscriptions
+                    )
+                ) {
+                    return sendError(StatusCodes.BadTooManyOperations);
                 }
 
+                const promises: Promise<T>[] = subscriptionIds.map((subscriptionId: number) =>
+                    actionToPerform(session, subscriptionId)
+                );
+                const results: T[] = await Promise.all(promises);
+
+                const serviceResult: StatusCode = StatusCodes.Good;
                 const response = new ResponseClass({
                     responseHeader: {
-                        serviceResult:
-                            request.subscriptionIds.length > this.engine.serverCapabilities.maxSubscriptionsPerSession
-                                ? StatusCodes.BadTooManyOperations
-                                : StatusCodes.Good
+                        serviceResult
                     },
-                    results
+                    results: results as any
                 });
                 sendResponse(response);
             }
@@ -3544,7 +3553,12 @@ export class OPCUAServer extends OPCUABaseServer {
 
     private createEndpoint(
         port1: number,
-        serverOptions: { defaultSecureTokenLifetime?: number; timeout?: number; host?:string }
+        serverOptions: {
+            defaultSecureTokenLifetime?: number;
+            timeout?: number;
+            host?: string;
+            transportSettings?: IServerTransportSettings;
+        }
     ): OPCUAServerEndPoint {
         // add the tcp/ip endpoint with no security
         const endPoint = new OPCUAServerEndPoint({
@@ -3560,7 +3574,8 @@ export class OPCUAServer extends OPCUABaseServer {
 
             maxConnections: this.maxConnectionsPerEndpoint,
             objectFactory: this.objectFactory,
-            serverInfo: this.serverInfo
+            serverInfo: this.serverInfo,
+            transportSettings: serverOptions.transportSettings
         });
         return endPoint;
     }

package/source/server_end_point.ts

@@ -28,6 +28,8 @@ import { UserTokenType } from "node-opcua-service-endpoints";
 import { EndpointDescription } from "node-opcua-service-endpoints";
 import { ApplicationDescription } from "node-opcua-service-endpoints";
 import { UserTokenPolicyOptions } from "node-opcua-types";
+import { IHelloAckLimits } from "node-opcua-transport";
+
 import { IChannelData } from "./i_channel_data";
 import { ISocketData } from "./i_socket_data";
 
@@ -157,6 +159,12 @@ export interface OPCUAServerEndPointOptions {
     serverInfo: ApplicationDescription;
 
     objectFactory?: any;
+
+    transportSettings?: IServerTransportSettings;
+}
+
+export interface IServerTransportSettings {
+    adjustTransportLimits: (hello: IHelloAckLimits) => IHelloAckLimits;
 }
 
 export interface EndpointDescriptionParams {
@@ -238,6 +246,8 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
     private _started = false;
     private _counter = OPCUAServerEndPointCounter++;
     private _policy_deduplicator: { [key: string]: number } = {};
+
+    private transportSettings?: IServerTransportSettings;
     constructor(options: OPCUAServerEndPointOptions) {
         super();
 
@@ -279,6 +289,8 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
 
         this.serverInfo = options.serverInfo;
         assert(this.serverInfo !== null && typeof this.serverInfo === "object");
+
+        this.transportSettings = options.transportSettings;
     }
 
     public dispose(): void {
@@ -746,7 +758,8 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                 defaultSecureTokenLifetime: this.defaultSecureTokenLifetime,
                 // objectFactory: this.objectFactory,
                 parent: this,
-                timeout: this.timeout
+                timeout: this.timeout,
+                adjustTransportLimits: this.transportSettings?.adjustTransportLimits
             });
 
             debugLog("channel Timeout = >", channel.timeout);
@@ -840,8 +853,9 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         } else {
             debugLog("OPCUAServerEndPoint#_registerChannel called when end point is shutdown !");
             debugLog("  -> channel will be forcefully terminated");
-            channel.close();
-            channel.dispose();
+            channel.close(() => {
+                channel.dispose();
+            });
         }
     }
 
@@ -914,17 +928,22 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
             errorLog(chalk.bgRed.white("PREVENTING DDOS ATTACK => maxConnection =" + this.maxConnections));
 
             const unused_channels: ServerSecureChannelLayer[] = this.getChannels().filter((channel1: ServerSecureChannelLayer) => {
-                return !channel1.isOpened && !channel1.hasSession;
+                return !channel1.hasSession;
             });
             if (unused_channels.length === 0) {
+                doDebug && console.log(
+                    this.getChannels()
+                        .map(({ status, isOpened, hasSession }) => `${status} ${isOpened} ${hasSession}\n`)
+                        .join(" ")
+                );
                 // all channels are in used , we cannot get any
-                errorLog("All channels are in used ! let cancel some");
+                errorLog(`All channels are in used ! we cannot cancel any ${this.getChannels().length}`);
                 // istanbul ignore next
                 if (doDebug) {
                     console.log("  - all channels are used !!!!");
-                    dumpChannelInfo(this.getChannels());
+                    false && dumpChannelInfo(this.getChannels());
                 }
-                setTimeout(deny_connection, 10);
+                setTimeout(deny_connection, 1000);
                 return;
             }
             // istanbul ignore next
@@ -935,7 +954,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                 );
             }
             const channel = unused_channels[0];
-            errorLog("Closing channel ", channel.hashKey);
+            errorLog(`${unused_channels.length} : Forcefully closing oldest channel that have no session: ${channel.hashKey}`);
             channel.close(() => {
                 // istanbul ignore next
                 if (doDebug) {

package/source/server_engine.ts

@@ -338,7 +338,7 @@ export interface ServerEngineOptions {
 export interface CreateSessionOption {
     clientDescription?: ApplicationDescription;
     sessionTimeout?: number;
-    server: IServerBase;
+    server?: IServerBase;
 }
 
 export type ClosingReason = "Timeout" | "Terminated" | "CloseSession" | "Forcing";
@@ -374,7 +374,7 @@ export class ServerEngine extends EventEmitter implements IAddressSpaceAccessor
     private _serverStatus: ServerStatusDataType;
     private _globalCounter: { totalMonitoredItemCount: number } = { totalMonitoredItemCount: 0 };
 
-    constructor(options: ServerEngineOptions) {
+    constructor(options?: ServerEngineOptions) {
         super();
 
         options = options || ({ applicationUri: "" } as ServerEngineOptions);
@@ -1423,7 +1423,7 @@ export class ServerEngine extends EventEmitter implements IAddressSpaceAccessor
      * @param  [options.clientDescription] {ApplicationDescription}
      * @return {ServerSession}
      */
-    public createSession(options: CreateSessionOption): ServerSession {
+    public createSession(options?: CreateSessionOption): ServerSession {
         options = options || {};
         options.server = options.server || {};
         debugLog("createSession : increasing serverDiagnosticsSummary cumulatedSessionCount/currentSessionCount ");
@@ -1645,9 +1645,10 @@ export class ServerEngine extends EventEmitter implements IAddressSpaceAccessor
             subscription.$session._unexposeSubscriptionDiagnostics(subscription);
         }
 
-        await ServerSidePublishEngine.transferSubscription(subscription, session.publishEngine, sendInitialValues);
         subscription.$session = session;
-
+    
+        await ServerSidePublishEngine.transferSubscription(subscription, session.publishEngine, sendInitialValues);
+    
         session._exposeSubscriptionDiagnostics(subscription);
 
         assert((subscription.publishEngine as any) === session.publishEngine);