node-opcua / node-opcua / 23088660581

/**

 * @module node-opcua-server

 */

import { EventEmitter } from "node:events";

import { types } from "node:util";

import async from "async";

import chalk from "chalk";

import {

    AddressSpace,

    addElement,

    type BindVariableOptions,

    bindExtObjArrayNode,

    type DTServerStatus,

    ensureObjectIsSecure,

    type IServerBase,

    type ISessionContext,

    type MethodFunctor,

    removeElement,

    type SessionContext,

    type UADynamicVariableArray,

    type UAMethod,

    type UAObject,

    type UAServerDiagnostics,

    type UAServerDiagnosticsSummary,

    type UAServerStatus,

    type UAVariable

} from "node-opcua-address-space";

import { generateAddressSpace } from "node-opcua-address-space/nodeJS";

import { assert } from "node-opcua-assert";

import type { UInt32 } from "node-opcua-basic-types";

import { BinaryStream } from "node-opcua-binary-stream";

import type { CreateSubscriptionRequestLike } from "node-opcua-client";

import {

    ServerDiagnosticsSummaryDataType,

    ServerState,

    ServerStatusDataType,

    SubscriptionDiagnosticsDataType

} from "node-opcua-common";

import { DataTypeIds, MethodIds, ObjectIds, VariableIds } from "node-opcua-constants";

import { AttributeIds, coerceLocalizedText, type LocalizedTextLike, makeAccessLevelFlag, NodeClass } from "node-opcua-data-model";

import type { DataValue } from "node-opcua-data-value";

import { getCurrentClock, getMinOPCUADate } from "node-opcua-date-time";

import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog, traceFromThisProjectOnly } from "node-opcua-debug";

import { coerceNodeId, makeNodeId, NodeId, type NodeIdLike, NodeIdType, resolveNodeId } from "node-opcua-nodeid";

import { nodesets } from "node-opcua-nodesets";

import { ObjectRegistry } from "node-opcua-object-registry";

import type { BrowseResult } from "node-opcua-service-browse";

import { CallMethodResult } from "node-opcua-service-call";

import { ApplicationDescription } from "node-opcua-service-endpoints";

import type { HistoryReadRequest, HistoryReadResult, HistoryReadValueId } from "node-opcua-service-history";

import { TransferResult } from "node-opcua-service-subscription";

import { type CallbackT, type StatusCode, StatusCodes } from "node-opcua-status-code";

import {

    ApplicationType,

    type BrowseDescription,

    type BrowseDescriptionOptions,

    type BrowsePath,

    type BrowsePathResult,

    type BuildInfo,

    type BuildInfoOptions,

    type CallMethodRequest,

    type CallMethodResultOptions,

    ProgramDiagnosticDataType,

    type ReadRequestOptions,

    ReadValueId,

    type SessionDiagnosticsDataType,

    type SessionSecurityDiagnosticsDataType,

    TimeZoneDataType,

    type WriteValue

} from "node-opcua-types";

import { DataType, isValidVariant, Variant, VariantArrayType } from "node-opcua-variant";

import { AddressSpaceAccessor } from "./addressSpace_accessor";

import { HistoryServerCapabilities, type HistoryServerCapabilitiesOptions } from "./history_server_capabilities";

import type { IAddressSpaceAccessor } from "./i_address_space_accessor";

import { MonitoredItem } from "./monitored_item";

import type { OPCUAServerOptions } from "./opcua_server";

import {

    defaultServerCapabilities,

    ServerCapabilities,

    type ServerCapabilitiesOptions,

    type ServerOperationLimits

} from "./server_capabilities";

import { ServerSidePublishEngine } from "./server_publish_engine";

import { ServerSidePublishEngineForOrphanSubscription } from "./server_publish_engine_for_orphan_subscriptions";

import { ServerSession } from "./server_session";

import { Subscription } from "./server_subscription";

import { sessionsCompatibleForTransfer } from "./sessions_compatible_for_transfer";

const debugLog = make_debugLog(__filename);

const errorLog = make_errorLog(__filename);

const warningLog = make_warningLog(__filename);

const doDebug = checkDebugFlag(__filename);

function upperCaseFirst(str: string) {

    return str.slice(0, 1).toUpperCase() + str.slice(1);

}

async function shutdownAndDisposeAddressSpace(this: ServerEngine) {

    if (this.addressSpace) {

        await this.addressSpace.shutdown();

        this.addressSpace.dispose();

        this.addressSpace = null;

    }

}

function requestServerStateChange(

    this: ServerEngine,

    inputArguments: Variant[],

    context: ISessionContext,

    callback: CallbackT<CallMethodResultOptions>

) {

    assert(Array.isArray(inputArguments));

    assert(typeof callback === "function");

    assert(Object.prototype.hasOwnProperty.call(context, "session"), " expecting a session id in the context object");

    const session = context.session as ServerSession;

    return callback(null, { statusCode: StatusCodes.BadNotImplemented });

}

function _getSubscription(

    this: ServerEngine,

    inputArguments: Variant[],

    context: ISessionContext

): { subscription: Subscription; statusCode?: never } | { statusCode: StatusCode; subscription?: never } {

    assert(Array.isArray(inputArguments));

    assert(Object.prototype.hasOwnProperty.call(context, "session"), " expecting a session id in the context object");

    const session = context.session as ServerSession;

    const subscriptionId = inputArguments[0].value;

    const subscription = session.getSubscription(subscriptionId);

    if (!subscription) {

        // subscription may belongs to a different session  that ours

        return { statusCode: StatusCodes.BadSubscriptionIdInvalid };

    }

    return { subscription };

}

function resendData(

    this: ServerEngine,

    inputArguments: Variant[],

    context: ISessionContext,

    callback: CallbackT<CallMethodResultOptions>

): void {

    assert(typeof callback === "function");

    const data = _getSubscription.call(this, inputArguments, context);

    const { subscription } = data;

    subscription

        .resendInitialValues()

        .then(() => {

            callback(null, { statusCode: StatusCodes.Good });

        })

        .catch((err) => callback(err));

}

// binding methods

function getMonitoredItemsId(

    this: ServerEngine,

    inputArguments: Variant[],

    context: ISessionContext,

    callback: CallbackT<CallMethodResultOptions>

) {

    assert(typeof callback === "function");

    const data = _getSubscription.call(this, inputArguments, context);

    if (data.statusCode) return callback(null, { statusCode: data.statusCode });

    const { subscription } = data;

    const result = subscription.getMonitoredItems();

    assert(result.statusCode);

    assert(result.serverHandles.length === result.clientHandles.length);

    const callMethodResult = new CallMethodResult({

        statusCode: result.statusCode,

        outputArguments: [

            { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: result.serverHandles },

            { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: result.clientHandles }

        ]

    });

    callback(null, callMethodResult);

}

function __bindVariable(self: ServerEngine, nodeId: NodeIdLike, options?: BindVariableOptions) {

    const variable = self.addressSpace.findNode(nodeId) as UAVariable;

    if (variable?.bindVariable) {

        variable.bindVariable(options, true);

        assert(typeof variable.asyncRefresh === "function");

        assert(typeof (variable as unknown as Record<string, unknown>).refreshFunc === "function");

}

// note OPCUA 1.03 part 4 page 76

// The Server-assigned identifier for the Subscription (see 7.14 for IntegerId definition). This identifier shall

// be unique for the entire Server, not just for the Session, in order to allow the Subscription to be transferred

// to another Session using the TransferSubscriptions service.

// After Server start-up the generation of subscriptionIds should start from a random IntegerId or continue from

// the point before the restart.

let next_subscriptionId = Math.ceil(Math.random() * 1000000);

export function setNextSubscriptionId(n: number) {

function _get_next_subscriptionId() {

    debugLog(" next_subscriptionId = ", next_subscriptionId);

    return next_subscriptionId++;

}

export type StringGetter = () => string;

export type StringArrayGetter = () => string[];

export type ApplicationTypeGetter = () => ApplicationType;

export type BooleanGetter = () => boolean;

export interface ServerConfigurationOptions {

    applicationUri?: string | StringGetter;

    applicationType?: ApplicationType | ApplicationTypeGetter; // default "Server"

    hasSecureElement?: boolean | BooleanGetter; // default true

    multicastDnsEnabled?: boolean | BooleanGetter; // default true

    productUri?: string | StringGetter;

    // /** @restricted only in professional version */

    // resetToServerDefaults: () => Promise<void>;

    // /** @restricted only in professional version */

    // setAdminPassword?: (password: string) => Promise<void>;

    /**

     * The SupportedPrivateKeyFormats specifies the PrivateKey formats supported by the Server.

     * Possible values include “PEM” (see RFC 5958) or “PFX” (see PKCS #12).

     * @default ["PEM"]

     */

    supportedPrivateKeyFormat: string[] | StringArrayGetter;

    /**

     * The ServerCapabilities Property specifies the capabilities from Annex D

     * ( see https://reference.opcfoundation.org/GDS/v104/docs/D)  which the Server supports. The value is

     * the same as the value reported to the LocalDiscoveryServer when the Server calls the RegisterServer2 Service.

     */

    serverCapabilities?: string[] | StringArrayGetter; // default|"N/A"]

}

export interface ServerEngineOptions {

    applicationUri: string | StringGetter;

    buildInfo?: BuildInfoOptions;

    isAuditing?: boolean;

    /**

     * set to true to enable serverDiagnostics

     */

    serverDiagnosticsEnabled?: boolean;

    serverCapabilities?: ServerCapabilitiesOptions;

    historyServerCapabilities?: HistoryServerCapabilitiesOptions;

    serverConfiguration?: ServerConfigurationOptions;

}

export interface CreateSessionOption {

    clientDescription?: ApplicationDescription;

    sessionTimeout?: number;

    server?: IServerBase;

}

export type ClosingReason = "Timeout" | "Terminated" | "CloseSession" | "Forcing";

export type ServerEngineShutdownTask = (this: ServerEngine) => void | Promise<void>;

/**

 *

 */

export class ServerEngine extends EventEmitter implements IAddressSpaceAccessor {

    public static readonly registry = new ObjectRegistry();

    public isAuditing: boolean;

    public serverDiagnosticsSummary: ServerDiagnosticsSummaryDataType;

    public serverDiagnosticsEnabled: boolean;

    public serverCapabilities: ServerCapabilities;

    public historyServerCapabilities: HistoryServerCapabilities;

    public serverConfiguration: ServerConfigurationOptions;

    public clientDescription?: ApplicationDescription;

    public addressSpace: AddressSpace | null;

    public addressSpaceAccessor: IAddressSpaceAccessor | null = null;

    // pseudo private

    public _internalState: "creating" | "initializing" | "initialized" | "shutdown" | "disposed";

    private _sessions: { [key: string]: ServerSession };

    private _closedSessions: { [key: string]: ServerSession };

    private _orphanPublishEngine?: ServerSidePublishEngineForOrphanSubscription;

    private _shutdownTasks: ServerEngineShutdownTask[];

    private _applicationUri: string;

    private _expectedShutdownTime!: Date;

    private _serverStatus: ServerStatusDataType;

    private _globalCounter: { totalMonitoredItemCount: number } = { totalMonitoredItemCount: 0 };

    constructor(options?: ServerEngineOptions) {

        super();

        options = options || ({ applicationUri: "" } as ServerEngineOptions);

        options.buildInfo = options.buildInfo || {};

        ServerEngine.registry.register(this);

        this._sessions = {};

        this._closedSessions = {};

        this._orphanPublishEngine = undefined; // will be constructed on demand

        this.isAuditing = typeof options.isAuditing === "boolean" ? options.isAuditing : false;

        options.buildInfo.buildDate = options.buildInfo.buildDate || new Date();

        // ---------------------------------------------------- ServerStatusDataType

        this._serverStatus = new ServerStatusDataType({

            buildInfo: options.buildInfo,

            currentTime: new Date(),

            secondsTillShutdown: 0,

            shutdownReason: { text: "" },

            startTime: new Date(),

            state: ServerState.NoConfiguration

        });

        // --------------------------------------------------- ServerCapabilities

        options.serverCapabilities = options.serverCapabilities || {};

        options.serverConfiguration = options.serverConfiguration || {

            supportedPrivateKeyFormat: ["PEM"]

        };

        // https://profiles.opcfoundation.org/profile

        options.serverCapabilities.serverProfileArray = options.serverCapabilities.serverProfileArray || [

            "http://opcfoundation.org/UA-Profile/Server/Standard", // Standard UA Server Profile",

            "http://opcfoundation.org/UA-Profile/Server/DataAccess",

            "http://opcfoundation.org/UA-Profile/Server/ComplexTypes2017",

            "http://opcfoundation.org/UA-Profile/Server/Events",

            "http://opcfoundation.org/UA-Profile/Client/HistoricalAccess",

            "http://opcfoundation.org/UA-Profile/Server/Methods",

            "http://opcfoundation.org/UA-Profile/Server/StandardEventSubscription",

            "http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary",

            "http://opcfoundation.org/UA-Profile/Server/FileAccess",

            "http://opcfoundation.org/UA-Profile/Server/StateMachine"

            // "http://opcfoundation.org/UA-Profile/Transport/wss-uajson",

            // "http://opcfoundation.org/UA-Profile/Transport/wss-uasc-uabinary"

            // "http://opcfoundation.org/UA-Profile/Server/DurableSubscription"

            // "http://opcfoundation.org/UA-Profile/Server/ReverseConnect",

            // "http://opcfoundation.org/UAProfile/Server/NodeManagement",

            //  "Embedded UA Server Profile",

            // "Micro Embedded Device Server Profile",

            // "Nano Embedded Device Server Profile"

        ];

        options.serverCapabilities.localeIdArray = options.serverCapabilities.localeIdArray || ["en-EN", "fr-FR"];

        this.serverCapabilities = new ServerCapabilities(options.serverCapabilities);

        // to do when spec is clear about what goes here!

        // spec 1.04 says (in Part 4 7.33 SignedSoftwareCertificate

        // Note: Details on SoftwareCertificates need to be defined in a future version.

        this.serverCapabilities.softwareCertificates = [

            // new SignedSoftwareCertificate({})

        ];

        // make sure minSupportedSampleRate matches MonitoredItem.minimumSamplingInterval

        Object.defineProperty(this.serverCapabilities, "minSupportedSampleRate", {

            get: () => options.serverCapabilities?.minSupportedSampleRate || MonitoredItem.minimumSamplingInterval,

            configurable: true

        });

        this.serverConfiguration = options.serverConfiguration;

        this.historyServerCapabilities = new HistoryServerCapabilities(options.historyServerCapabilities);

        // --------------------------------------------------- serverDiagnosticsSummary extension Object

        this.serverDiagnosticsSummary = new ServerDiagnosticsSummaryDataType();

        assert(Object.prototype.hasOwnProperty.call(this.serverDiagnosticsSummary, "currentSessionCount"));

        // note spelling is different for serverDiagnosticsSummary.currentSubscriptionCount

        //      and sessionDiagnostics.currentSubscriptionsCount ( with an s)

        assert(Object.prototype.hasOwnProperty.call(this.serverDiagnosticsSummary, "currentSubscriptionCount"));

        Object.defineProperty(this.serverDiagnosticsSummary, "currentSubscriptionCount", {

            get: () => {

                // currentSubscriptionCount returns the total number of subscriptions

                // that are currently active on all sessions

                let counter = 0;

                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;

            },

            configurable: true

        });

        this._internalState = "creating";

        this.setServerState(ServerState.NoConfiguration);

        this.addressSpace = null;

        this._shutdownTasks = [];

        this._applicationUri = "";

        if (typeof options.applicationUri === "function") {

            Object.defineProperty(this, "_applicationUri", {

                get: options.applicationUri,

                configurable: true

            });

        } else {

            this._applicationUri = options.applicationUri || "<unset _applicationUri>";

        }

        options.serverDiagnosticsEnabled = Object.prototype.hasOwnProperty.call(options, "serverDiagnosticsEnable")

            : true;

    }

    public isStarted(): boolean {

        return !!this._serverStatus;

    }

    public dispose(): void {

        this.addressSpace = null;

        assert(Object.keys(this._sessions).length === 0, "ServerEngine#_sessions not empty");

        this._sessions = {};

        // todo fix me

        this._closedSessions = {};

        assert(Object.keys(this._closedSessions).length === 0, "ServerEngine#_closedSessions not empty");

        this._closedSessions = {};

        if (this._orphanPublishEngine) {

            this._orphanPublishEngine.dispose();

            this._orphanPublishEngine = undefined;

        }

        this._shutdownTasks = [];

        this._serverStatus = null as unknown as ServerStatusDataType;

        this._internalState = "disposed";

        this.removeAllListeners();

        ServerEngine.registry.unregister(this);

    }

    public get startTime(): Date {

    public get currentTime(): Date {

    public get buildInfo(): BuildInfo {

        return this._serverStatus.buildInfo;

    }

    /**

     * register a function that will be called when the server will perform its shut down.

     */

    public registerShutdownTask(task: ServerEngineShutdownTask): void {

        assert(typeof task === "function");

        this._shutdownTasks.push(task);

    }

    /**

     */

    public async shutdown(): Promise<void> {

        debugLog("ServerEngine#shutdown");

        this._internalState = "shutdown";

        this.setServerState(ServerState.Shutdown);

        // delete any existing sessions

        const tokens = Object.keys(this._sessions).map((key: string) => {

            const session = this._sessions[key];

            return session.authenticationToken;

        });

        // delete and close any orphan subscriptions

        if (this._orphanPublishEngine) {

            this._orphanPublishEngine.shutdown();

        }

        for (const token of tokens) {

            this.closeSession(token, true, "Terminated");

        }

        // all sessions must have been terminated

        assert(this.currentSessionCount === 0);

        // all subscriptions must have been terminated

        assert(this.currentSubscriptionCount === 0, "all subscriptions must have been terminated");

        this._shutdownTasks.push(shutdownAndDisposeAddressSpace);

        // perform registerShutdownTask

        for (const task of this._shutdownTasks) {

            await task.call(this);

        }

        this.setServerState(ServerState.Invalid);

        this.dispose();

    }

    /**

     * the number of active sessions

     */

    public get currentSessionCount(): number {

        return this.serverDiagnosticsSummary.currentSessionCount;

    }

    /**

     * the cumulated number of sessions that have been opened since this object exists

     */

    public get cumulatedSessionCount(): number {

        return this.serverDiagnosticsSummary.cumulatedSessionCount;

    }

    /**

     * the number of active subscriptions.

     */

    public get currentSubscriptionCount(): number {

        return this.serverDiagnosticsSummary.currentSubscriptionCount;

    }

    /**

     * the cumulated number of subscriptions that have been created since this object exists

     */

    public get cumulatedSubscriptionCount(): number {

        return this.serverDiagnosticsSummary.cumulatedSubscriptionCount;

    }

    public get rejectedSessionCount(): number {

        return this.serverDiagnosticsSummary.rejectedSessionCount;

    }

    public get rejectedRequestsCount(): number {

        return this.serverDiagnosticsSummary.rejectedRequestsCount;

    }

    public get sessionAbortCount(): number {

        return this.serverDiagnosticsSummary.sessionAbortCount;

    }

    public get sessionTimeoutCount(): number {

    public get publishingIntervalCount(): number {

        return this.serverDiagnosticsSummary.publishingIntervalCount;

    }

    public incrementSessionTimeoutCount(): void {

        if (this.serverDiagnosticsSummary && this.serverDiagnosticsEnabled) {

            // The requests include all Services defined in Part 4 of the OPC UA Specification, also requests to create sessions. This number includes the securityRejectedRequestsCount.

            this.serverDiagnosticsSummary.sessionTimeoutCount += 1;

        }

    }

    public incrementSessionAbortCount(): void {

    public incrementRejectedRequestsCount(): void {

        if (this.serverDiagnosticsSummary && this.serverDiagnosticsEnabled) {

            // The requests include all Services defined in Part 4 of the OPC UA Specification, also requests to create sessions. This number includes the securityRejectedRequestsCount.

            this.serverDiagnosticsSummary.rejectedRequestsCount += 1;

        }

    }

    /**

     * increment rejected session count (also increment rejected requests count)

     */

    public incrementRejectedSessionCount(): void {

        if (this.serverDiagnosticsSummary && this.serverDiagnosticsEnabled) {

            // The requests include all Services defined in Part 4 of the OPC UA Specification, also requests to create sessions. This number includes the securityRejectedRequestsCount.

            this.serverDiagnosticsSummary.rejectedSessionCount += 1;

        }

        this.incrementRejectedRequestsCount();

    }

    public incrementSecurityRejectedRequestsCount(): void {

        if (this.serverDiagnosticsSummary && this.serverDiagnosticsEnabled) {

            // The requests include all Services defined in Part 4 of the OPC UA Specification, also requests to create sessions. This number includes the securityRejectedRequestsCount.

            this.serverDiagnosticsSummary.securityRejectedRequestsCount += 1;

        }

        this.incrementRejectedRequestsCount();

    }

    /**

     * increment rejected session count (also increment rejected requests count)

     */

    public incrementSecurityRejectedSessionCount(): void {

        if (this.serverDiagnosticsSummary && this.serverDiagnosticsEnabled) {

            // The requests include all Services defined in Part 4 of the OPC UA Specification, also requests to create sessions. This number includes the securityRejectedRequestsCount.

            this.serverDiagnosticsSummary.securityRejectedSessionCount += 1;

        }

        this.incrementSecurityRejectedRequestsCount();

    }

    public setShutdownTime(date: Date): void {

        this._expectedShutdownTime = date;

    }

    public setShutdownReason(reason: LocalizedTextLike): void {

        const localizedReason = coerceLocalizedText(reason);

        if (!localizedReason) return;

        this.addressSpace?.rootFolder.objects.server.serverStatus.shutdownReason.setValueFromSource({

            dataType: DataType.LocalizedText,

            value: localizedReason

        });

    }

    /**

     * @return the approximate number of seconds until the server will be shut down. The

     * value is only relevant once the state changes into SHUTDOWN.

     */

    public secondsTillShutdown(): number {

        if (!this._expectedShutdownTime) {

            return 0;

        }

        // ToDo: implement a correct solution here

        const now = Date.now();

        return Math.max(0, Math.ceil((this._expectedShutdownTime.getTime() - now) / 1000));

    }

    /**

     * the name of the server

     */

    public get serverName(): string {

    /**

     * the server urn

     */

    public get serverNameUrn(): string {

        return this._applicationUri;

    }

    /**

     * the urn of the server namespace

     */

    public get serverNamespaceUrn(): string {

        return this._applicationUri; // "urn:" + engine.serverName;

    }

    public get serverStatus(): ServerStatusDataType {

        return this._serverStatus;

    }

    public setServerState(serverState: ServerState): void {

        assert(serverState !== null && serverState !== undefined);

        this.addressSpace?.rootFolder?.objects?.server?.serverStatus?.state?.setValueFromSource({

            dataType: DataType.Int32,

            value: serverState

        });

    }

    public getServerState(): ServerState {

    /**

     * Set the `ServerConfiguration.InApplicationSetup` property

     * in the address space.

     *

     * This flag indicates whether the server is currently in

     * its initial application setup phase (e.g. waiting for

     * GDS provisioning).

     */

    public setInApplicationSetup(value: boolean): void {

        const addressSpace = this.addressSpace;

        const serverConfiguration = addressSpace.rootFolder?.objects?.server?.getChildByName(

            "ServerConfiguration"

        ) as UAObject | null;

        let prop = serverConfiguration.getPropertyByName("InApplicationSetup") as UAVariable | null;

        if (!prop) {

            // InApplicationSetup is ModellingRule_Optional on

            // ServerConfigurationType (i=19308) — instantiate

            // it on the instance on first use.

            const ns = addressSpace.getOwnNamespace();

            prop = ns.addVariable({

                browseName: { name: "InApplicationSetup", namespaceIndex: 0 },

                propertyOf: serverConfiguration,

                typeDefinition: "PropertyType",

                dataType: DataType.Boolean,

                minimumSamplingInterval: -1,

                value: { dataType: DataType.Boolean, value }

            });

            return;

        }

        prop.setValueFromSource({

            dataType: DataType.Boolean,

            value

        });

    }

    /**

     * Read the current value of

     * `ServerConfiguration.InApplicationSetup`.

     *

     * Returns `false` if the property does not exist in

     * the address space.

     */

    public getInApplicationSetup(): boolean {

        const serverConfiguration = this.addressSpace?.rootFolder?.objects?.server?.getChildByName(

            "ServerConfiguration"

        ) as UAObject | null;

        const prop = serverConfiguration.getPropertyByName("InApplicationSetup") as UAVariable | null;

        if (!prop) {

            return false;

        }

    }

    public getServerDiagnosticsEnabledFlag(): boolean {

    /**

     *

     */

    public initialize(options: OPCUAServerOptions, callback: (err?: Error | null) => void): void {

        assert(!this.addressSpace); // check that 'initialize' has not been already called

        this._internalState = "initializing";

        assert(typeof callback === "function");

        options.nodeset_filename = options.nodeset_filename || nodesets.standard;

        const startTime = new Date();

        debugLog("Loading ", options.nodeset_filename, "...");

        this.addressSpace = AddressSpace.create();

        this.addressSpaceAccessor = new AddressSpaceAccessor(this.addressSpace);

        if (!options.skipOwnNamespace) {

            // register namespace 1 (our namespace);