node-opcua / node-opcua / 28389643215

/**

 * @module node-opcua-server

 */

// tslint:disable:no-console

import { EventEmitter } from "node:events";

import chalk from "chalk";

import {

    type BaseNode,

    type Duration,

    type IAddressSpace,

    type ISessionContext,

    SessionContext,

    type UAMethod,

    type UAObject,

    type UAObjectType,

    type UAVariable

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

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

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

import { SubscriptionDiagnosticsDataType } from "node-opcua-common";

import { AttributeIds, isValidDataEncoding, NodeClass, type QualifiedNameLike } from "node-opcua-data-model";

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

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

import { NodeId } from "node-opcua-nodeid";

import type { NumericRange } from "node-opcua-numeric-range";

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

import { SequenceNumberGenerator } from "node-opcua-secure-channel";

import { checkSelectClauses, EventFilter } from "node-opcua-service-filter";

import {

    AggregateFilter,

    DataChangeFilter,

    DataChangeNotification,

    EventNotificationList,

    MonitoredItemCreateRequest,

    MonitoredItemCreateResult,

    MonitoredItemNotification,

    MonitoringMode,

    NotificationMessage,

    PublishResponse,

    StatusChangeNotification

} from "node-opcua-service-subscription";

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

import {

    AggregateFilterResult,

    ContentFilterResult,

    EventFieldList,

    EventFilterResult,

    type MonitoringFilter

} from "node-opcua-types";

import { type IServerSidePublishEngine, TransferredSubscription } from "./i_server_side_publish_engine";

import { MonitoredItem, type MonitoredItemOptions, type QueueItem } from "./monitored_item";

import { Queue } from "./queue";

import type { ServerSession } from "./server_session";

import { validateFilter } from "./validate_filter";

const debugLog = make_debugLog(__filename);

const doDebug = checkDebugFlag(__filename);

const warningLog = make_warningLog(__filename);

const maxNotificationMessagesInQueue = 100;

export interface SubscriptionDiagnosticsDataTypePriv extends SubscriptionDiagnosticsDataType {

    $subscription: Subscription;

}

export enum SubscriptionState {

    CLOSED = 1, // The Subscription has not yet been created or has terminated.

    CREATING = 2, // The Subscription is being created

    NORMAL = 3, // The Subscription is cyclically checking for Notifications from its MonitoredItems.

    // The keep-alive counter is not used in this state.

    LATE = 4, // The publishing timer has expired and there are Notifications available or a keep-alive Message is

    // ready to be sent, but there are no Publish requests queued. When in this state, the next Publish

    // request is processed when it is received. The keep-alive counter is not used in this state.

    KEEPALIVE = 5, // The Subscription is cyclically checking for Notification

    // alive counter to count down to 0 from its maximum.

    TERMINATED = 6

}

function _adjust_publishing_interval(publishingInterval?: number): number {

    publishingInterval =

        publishingInterval === undefined || Number.isNaN(publishingInterval)

            ? Subscription.defaultPublishingInterval

            : publishingInterval;

    publishingInterval = Math.max(publishingInterval, Subscription.minimumPublishingInterval);

    publishingInterval = Math.min(publishingInterval, Subscription.maximumPublishingInterval);

    return publishingInterval;

}

const minimumMaxKeepAliveCount = 2;

const maximumMaxKeepAliveCount = 12000;

function _adjust_maxKeepAliveCount(maxKeepAliveCount?: number /*,publishingInterval*/): number {

    maxKeepAliveCount = maxKeepAliveCount || minimumMaxKeepAliveCount;

    maxKeepAliveCount = Math.max(maxKeepAliveCount, minimumMaxKeepAliveCount);

    maxKeepAliveCount = Math.min(maxKeepAliveCount, maximumMaxKeepAliveCount);

    return maxKeepAliveCount;

}

const MaxUint32 = 0xffffffff;

function _adjust_lifeTimeCount(lifeTimeCount: number, maxKeepAliveCount: number, publishingInterval: number): number {

    lifeTimeCount = lifeTimeCount || 1;

    const minTicks = Math.ceil(Subscription.minimumLifetimeDuration / publishingInterval);

    const maxTicks = Math.floor(Subscription.maximumLifetimeDuration / publishingInterval);

    lifeTimeCount = Math.max(minTicks, lifeTimeCount);

    lifeTimeCount = Math.min(maxTicks, lifeTimeCount);

    // let's make sure that lifeTimeCount is at least three time maxKeepAliveCount

    // Note : the specs say ( part 3  - CreateSubscriptionParameter )

    //        "The lifetime count shall be a minimum of three times the keep keep-alive count."

    lifeTimeCount = Math.max(lifeTimeCount, Math.min(maxKeepAliveCount * 3, MaxUint32));

    return lifeTimeCount;

}

function _adjust_publishingEnable(publishingEnabled?: boolean | null): boolean {

    return publishingEnabled === null || publishingEnabled === undefined ? true : !!publishingEnabled;

}

function _adjust_maxNotificationsPerPublish(maxNotificationsPerPublish?: number): number {

    assert(Subscription.maxNotificationPerPublishHighLimit > 0, "Subscription.maxNotificationPerPublishHighLimit must be positive");

    maxNotificationsPerPublish = maxNotificationsPerPublish || 0;

    assert(typeof maxNotificationsPerPublish === "number");

    // must be strictly positive

    if (maxNotificationsPerPublish === 0) {

        // if zero then => use our HighLimit

        maxNotificationsPerPublish = Subscription.maxNotificationPerPublishHighLimit;

    } else {

        // if not zero then should be capped by maxNotificationPerPublishHighLimit

        maxNotificationsPerPublish = Math.min(Subscription.maxNotificationPerPublishHighLimit, maxNotificationsPerPublish);

    }

    assert(maxNotificationsPerPublish !== 0 && maxNotificationsPerPublish <= Subscription.maxNotificationPerPublishHighLimit);

    return maxNotificationsPerPublish;

}

function _getSequenceNumbers(arr: NotificationMessage[]): number[] {

    return arr.map((notificationMessage) => notificationMessage.sequenceNumber);

}

function analyzeEventFilterResult(node: BaseNode, eventFilter: EventFilter): EventFilterResult {

    /* c8 ignore next */

    if (!(eventFilter instanceof EventFilter)) {

    const whereClauseResult = new ContentFilterResult();

    return new EventFilterResult({

        selectClauseDiagnosticInfos: [],

        selectClauseResults,

        whereClauseResult

    });

}

function analyzeDataChangeFilterResult(_node: BaseNode, dataChangeFilter: DataChangeFilter): null {

    assert(dataChangeFilter instanceof DataChangeFilter);

    // the opcua specification doesn't provide dataChangeFilterResult

    return null;

}

function _process_filter(node: BaseNode, filter: MonitoringFilter | null): EventFilterResult | AggregateFilterResult | null {

    if (!filter) {

        return null;

    }

    if (filter instanceof EventFilter) {

        return analyzeEventFilterResult(node, filter);

    } else if (filter instanceof DataChangeFilter) {

        return analyzeDataChangeFilterResult(node, filter);

    // c8 ignore next

}

/**

 * @private

 */

function createSubscriptionDiagnostics(subscription: Subscription): SubscriptionDiagnosticsDataTypePriv {

    assert(subscription instanceof Subscription);

    const subscriptionDiagnostics = new SubscriptionDiagnosticsDataType({});

    const sd = subscriptionDiagnostics as SubscriptionDiagnosticsDataTypePriv;

    sd.$subscription = subscription;

    const defineGetter = <T>(name: string, getter: (this: SubscriptionDiagnosticsDataTypePriv) => T) => {

        Object.defineProperty(sd, name, { get: getter, configurable: true });

    };

    // "sessionId"

    defineGetter("sessionId", function (this: SubscriptionDiagnosticsDataTypePriv): NodeId {

        return this.$subscription.getSessionId();

    });

    defineGetter("subscriptionId", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.id;

    });

    defineGetter("priority", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.priority;

    });

    defineGetter("publishingInterval", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.publishingInterval;

    });

    defineGetter("maxLifetimeCount", function (this: SubscriptionDiagnosticsDataTypePriv) {

        return this.$subscription.lifeTimeCount;

    });

    defineGetter("maxKeepAliveCount", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.maxKeepAliveCount;

    });

    defineGetter("maxNotificationsPerPublish", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.maxNotificationsPerPublish;

    });

    defineGetter("publishingEnabled", function (this: SubscriptionDiagnosticsDataTypePriv): boolean {

        return this.$subscription.publishingEnabled;

    });

    defineGetter("monitoredItemCount", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.monitoredItemCount;

    });

    defineGetter("nextSequenceNumber", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.futureSequenceNumber;

    });

    defineGetter("disabledMonitoredItemCount", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.disabledMonitoredItemCount;

    });

    /* those member of self.subscriptionDiagnostics are handled directly

   modifyCount

   enableCount,

   disableCount,

   republishRequestCount,

   notificationsCount,

   publishRequestCount,

   dataChangeNotificationsCount,

   eventNotificationsCount,

  */

    /*

   those members are not updated yet in the code :

   "republishMessageRequestCount",

   "republishMessageCount",

   "transferRequestCount",

   "transferredToAltClientCount",

   "transferredToSameClientCount",

   "latePublishRequestCount",

   "unacknowledgedMessageCount",

   "discardedMessageCount",

   "monitoringQueueOverflowCount",

   "eventQueueOverflowCount"

   */

    defineGetter("currentKeepAliveCount", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.currentKeepAliveCount;

    });

    defineGetter("currentLifetimeCount", function (this: SubscriptionDiagnosticsDataTypePriv): number {

        return this.$subscription.currentLifetimeCount;

    });

    // add object in Variable SubscriptionDiagnosticArray (i=2290) ( Array of SubscriptionDiagnostics)

    // add properties in Variable to reflect

    return subscriptionDiagnostics as SubscriptionDiagnosticsDataTypePriv;

}

interface IGlobalMonitoredItemCounter {

    totalMonitoredItemCount: number;

}

export interface SubscriptionOptions {

    sessionId?: NodeId;

    /**

     * (default:1000) the publishing interval.

     */

    publishingInterval?: number;

    /**

     * (default:10) the max Life Time Count

     */

    maxKeepAliveCount?: number;

    lifeTimeCount?: number;

    /**

     * (default:true)

     */

    publishingEnabled?: boolean;

    /**

     * (default:0)

     */

    maxNotificationsPerPublish?: number;

    /**

     * subscription priority Byte:(0-255)

     */

    priority?: number;

    publishEngine?: IServerSidePublishEngine;

    /**

     *  a unique identifier

     */

    id?: number;

    serverCapabilities: ServerCapabilitiesPartial;

    globalCounter: IGlobalMonitoredItemCounter;

}

let g_monitoredItemId = Math.ceil(Math.random() * 100000);

function getNextMonitoredItemId() {

    return g_monitoredItemId++;

}

// function myFilter<T>(t1: any, chunk: any[]): T[] {

//     return chunk.filter(filter_instanceof.bind(null, t1));

// }

// function makeNotificationData(notifications_chunk: QueueItem): NotificationData {

//     const dataChangedNotificationData = myFilter<MonitoredItemNotification>(MonitoredItemNotification, notifications_chunk);

//     const eventNotificationListData = myFilter<EventFieldList>(EventFieldList, notifications_chunk);

//     assert(notifications_chunk.length === dataChangedNotificationData.length + eventNotificationListData.length);

//     const notifications: (DataChangeNotification | EventNotificationList)[] = [];

//     // add dataChangeNotification

//     if (dataChangedNotificationData.length) {

//         const dataChangeNotification = new DataChangeNotification({

//             diagnosticInfos: [],

//             monitoredItems: dataChangedNotificationData

//         });

//         notifications.push(dataChangeNotification);

//     }

//     // add dataChangeNotification

//     if (eventNotificationListData.length) {

//         const eventNotificationList = new EventNotificationList({

//             events: eventNotificationListData

//         });

//         notifications.push(eventNotificationList);

//     }

//     return notifications.length === 0 ? null : notifications;

// }

const INVALID_ID = -1;

export type Notification = DataChangeNotification | EventNotificationList | StatusChangeNotification;

export type Counter = number;

export interface ModifySubscriptionParameters {

    /**

     *     requestedPublishingInterval =0 means fastest possible

     */

    requestedPublishingInterval?: Duration;

    /*

     * requestedLifetimeCount=0 means no change

     */

    requestedLifetimeCount?: Counter;

    /**

     * requestedMaxKeepAliveCount  ===0 means no change

     */

    requestedMaxKeepAliveCount?: Counter;

    maxNotificationsPerPublish?: Counter;

    priority?: Byte;

}

export interface GetMonitoredItemsResult {

    /**

     * array of serverHandles for all MonitoredItems of the subscription

     * identified by subscriptionId.

     */

    serverHandles: Uint32Array;

    /**

     *  array of clientHandles for all MonitoredItems of the subscription

     *  identified by subscriptionId.

     */

    clientHandles: Uint32Array;

    statusCode: StatusCode;

}

export interface InternalNotification {

    monitoredItemId?: number;

    notification: QueueItem | StatusChangeNotification;

    publishTime: Date;

    start_tick: number;

}

export interface InternalCreateMonitoredItemResult {

    monitoredItem?: MonitoredItem;

    monitoredItemCreateRequest: MonitoredItemCreateRequest;

    createResult: MonitoredItemCreateResult;

}

export interface MonitoredItemBase {

    node: UAVariable | UAObject | UAMethod | null;

    // from monitoring parameters

    filter: MonitoringFilter | null;

    monitoringMode: MonitoringMode;

    timestampsToReturn: TimestampsToReturn;

    discardOldest: boolean;

    queueSize: number;

    clientHandle: UInt32;

}

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;

    maxWhereClauseParameters?: UInt32;

    maxSelectClauseParameters?: UInt32;

}

export interface IReadAttributeCapable {

    readAttribute(

        context: ISessionContext | null,

        attributeId: AttributeIds,

        indexRange?: NumericRange,

        dataEncoding?: QualifiedNameLike | null

    ): DataValue;

}

/**

 * The Subscription class used in the OPCUA server side.

 */

export class Subscription extends EventEmitter {

    public static minimumPublishingInterval = 50; // fastest possible

    public static defaultPublishingInterval = 1000; // one second

    public static maximumPublishingInterval: number = 1000 * 60; // one minute

    public static maxNotificationPerPublishHighLimit = 1000;

    public static minimumLifetimeDuration = 5 * 1000; //  // we want 2 seconds minimum lifetime for any subscription

    public static maximumLifetimeDuration = 60 * 60 * 1000; // 1 hour

    /**

     * 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() {

    public static registry = new ObjectRegistry();

    public publishEngine?: IServerSidePublishEngine;

    public id: number;

    public priority: number;

    /**

     * the Subscription publishing interval

     * @default 1000

     */

    public publishingInterval: number;

    /**

     * The keep alive count defines how many times the publish interval need to

     * expires without having notifications available before the server send an

     * empty message.

     * OPCUA Spec says: a value of 0 is invalid.

     * @default 10

     *

     */

    public maxKeepAliveCount: number;

    /**

     * The life time count defines how many times the publish interval expires without

     * having a connection to the client to deliver data.

     * If the life time count reaches maxKeepAliveCount, the subscription will

     * automatically terminate.

     * OPCUA Spec: The life-time count shall be a minimum of three times the keep keep-alive count.

     *

     * Note: this has to be interpreted as without having a PublishRequest available

     * @default 1

     */

    public lifeTimeCount: number;

    /**

     * The maximum number of notifications that the Client wishes to receive in a

     * single Publish response. A value of zero indicates that there is no limit.

     * The number of notifications per Publish is the sum of monitoredItems in the

     * DataChangeNotification and events in the EventNotificationList.

     *

     * @property maxNotificationsPerPublish

     * @default 0

     */

    public maxNotificationsPerPublish: number;

    public publishingEnabled: boolean;

    public subscriptionDiagnostics: SubscriptionDiagnosticsDataTypePriv;

    public publishIntervalCount: number;

    /**

     *  number of monitored Item

     */

    public monitoredItemIdCounter: number;

    private _state: SubscriptionState = -1 as SubscriptionState;

    public set state(value: SubscriptionState) {

        if (this._state !== value) {

            this._state = value;

            this.emit("stateChanged", value);

        }

    }

    public get state(): SubscriptionState {

        return this._state;

    }

    public messageSent: boolean;

    public $session?: ServerSession;

    public get sessionId(): NodeId {

        return this.$session ? this.$session.nodeId : NodeId.nullNodeId;

    }

    // ServerCapabilities filter limits (OPC UA Part 5), exposed for EventFilter validation (e.g. on modify)

    public get maxWhereClauseParameters(): UInt32 | undefined {

        return this.serverCapabilities.maxWhereClauseParameters;

    }

    public get maxSelectClauseParameters(): UInt32 | undefined {

        return this.serverCapabilities.maxSelectClauseParameters;

    }

    public get currentLifetimeCount(): number {

        return this._life_time_counter;

    }

    public get currentKeepAliveCount(): number {

        return this._keep_alive_counter;

    }

    private _life_time_counter: number;

    protected _keep_alive_counter = 0;

    public _pending_notifications: Queue<InternalNotification>;

    private _sent_notification_messages: NotificationMessage[];

    private readonly _sequence_number_generator: SequenceNumberGenerator;

    private readonly monitoredItems: { [key: number]: MonitoredItem };

    private timerId: ReturnType<typeof setTimeout> | null;

    private _hasUncollectedMonitoredItemNotifications = false;

    private globalCounter: IGlobalMonitoredItemCounter;

    private serverCapabilities: ServerCapabilitiesPartial;

    constructor(options: SubscriptionOptions) {

        super();

        Subscription.registry.register(this);

        assert(this.sessionId instanceof NodeId, "expecting a sessionId NodeId");

        this.publishEngine = options.publishEngine;

        this.id = options.id || INVALID_ID;

        this.priority = options.priority || 0;

        this.publishingInterval = _adjust_publishing_interval(options.publishingInterval);

        this.maxKeepAliveCount = _adjust_maxKeepAliveCount(options.maxKeepAliveCount); // , this.publishingInterval);

        this.resetKeepAliveCounter();

        this.lifeTimeCount = _adjust_lifeTimeCount(options.lifeTimeCount || 0, this.maxKeepAliveCount, this.publishingInterval);

        this.maxNotificationsPerPublish = _adjust_maxNotificationsPerPublish(options.maxNotificationsPerPublish);

        this._life_time_counter = 0;

        this.resetLifeTimeCounter();

        // notification message that are ready to be sent to the client

        this._pending_notifications = new Queue<InternalNotification>();

        this._sent_notification_messages = [];

        this._sequence_number_generator = new SequenceNumberGenerator();

        // initial state of the subscription

        this.state = SubscriptionState.CREATING;

        this.publishIntervalCount = 0;

        this.monitoredItems = {}; // monitored item map

        this.monitoredItemIdCounter = 0;

        this.publishingEnabled = _adjust_publishingEnable(options.publishingEnabled);

        this.subscriptionDiagnostics = createSubscriptionDiagnostics(this);

        // A boolean value that is set to TRUE to mean that either a NotificationMessage or a keep-alive

        // Message has been sent on the Subscription. It is a flag that is used to ensure that either a

        // NotificationMessage or a keep-alive Message is sent out the first time the publishing

        // timer expires.

        this.messageSent = false;

        this.timerId = null;

        this._start_timer({ firstTime: true });

        debugLog(chalk.green(`creating subscription ${this.id}`));

        this.serverCapabilities = options.serverCapabilities;

        this.serverCapabilities.maxMonitoredItems =

        this.serverCapabilities.maxMonitoredItemsPerSubscription =

        this.globalCounter = options.globalCounter;

    }

    public getSessionId(): NodeId {

        return this.sessionId;

    }

    public toString(): string {

    public toJSON(): Record<string, string | number | boolean> {

    public [Symbol.for("nodejs.util.inspect.custom")](): string {

    /**

     * modify subscription parameters

     * @param param

     */

    public modify(param: ModifySubscriptionParameters): void {

        // update diagnostic counter

        this.subscriptionDiagnostics.modifyCount += 1;

        const publishingInterval_old = this.publishingInterval;

        param.requestedPublishingInterval = param.requestedPublishingInterval || 0;

        param.requestedMaxKeepAliveCount = param.requestedMaxKeepAliveCount || this.maxKeepAliveCount;

        param.requestedLifetimeCount = param.requestedLifetimeCount || this.lifeTimeCount;

        this.publishingInterval = _adjust_publishing_interval(param.requestedPublishingInterval);

        this.maxKeepAliveCount = _adjust_maxKeepAliveCount(param.requestedMaxKeepAliveCount);

        this.lifeTimeCount = _adjust_lifeTimeCount(param.requestedLifetimeCount, this.maxKeepAliveCount, this.publishingInterval);

        this.maxNotificationsPerPublish = _adjust_maxNotificationsPerPublish(param.maxNotificationsPerPublish || 0);

        this.priority = param.priority || 0;

        this.resetLifeTimeAndKeepAliveCounters();

        if (publishingInterval_old !== this.publishingInterval) {

            // todo

        }

        this._stop_timer();

        this._start_timer({ firstTime: false });

    }

    /**

     * set publishing mode

     * @param publishingEnabled

     */

    public setPublishingMode(publishingEnabled: boolean): StatusCode {

        this.publishingEnabled = !!publishingEnabled;

        // update diagnostics

        if (this.publishingEnabled) {

            this.subscriptionDiagnostics.enableCount += 1;

        } else {

            this.subscriptionDiagnostics.disableCount += 1;

        }

        this.resetLifeTimeCounter();

        if (!publishingEnabled && this.state !== SubscriptionState.CLOSED) {

            this.state = SubscriptionState.NORMAL;

        }

        return StatusCodes.Good;

    }

    /**

     * @private

     */

    public get keepAliveCounterHasExpired(): boolean {

        return this._keep_alive_counter >= this.maxKeepAliveCount || this.state === SubscriptionState.LATE;

    }

    /**

     * Reset the Lifetime Counter Variable to the value specified for the lifetime of a Subscription in

     * the CreateSubscription Service( 5.13.2).

     * @private

     */

    public resetLifeTimeCounter(): void {

        this._life_time_counter = 0;

    }

    /**

     * @private

     */

    public increaseLifeTimeCounter(): void {

        this._life_time_counter += 1;

        if (this._life_time_counter >= this.lifeTimeCount) {

            this.emit("lifeTimeExpired");

        }

        this.emit("lifeTimeCounterChanged", this._life_time_counter);

    }

    /**

     *  True if the subscription life time has expired.

     *

     */

    public get lifeTimeHasExpired(): boolean {

        assert(this.lifeTimeCount > 0);

        return this._life_time_counter >= this.lifeTimeCount;

    }

    /**

     * number of milliseconds before this subscription times out (lifeTimeHasExpired === true);

     */

    public get timeToExpiration(): number {

        return (this.lifeTimeCount - this._life_time_counter) * this.publishingInterval;

    }

    public get timeToKeepAlive(): number {

    /**

     * Terminates the subscription.

     * Calling this method will also remove any monitored items.

     *

     */

    public terminate(): void {

        debugLog("Subscription#terminate status", SubscriptionState[this.state]);

        if (this.state === SubscriptionState.CLOSED) {

            // todo verify if asserting is required here

            return;

        }

        // stop timer

        this._stop_timer();

        debugLog("terminating Subscription  ", this.id, " with ", this.monitoredItemCount, " monitored items");

        // dispose all monitoredItem

        const keys = Object.keys(this.monitoredItems);

        for (const key of keys) {

            const status = this.removeMonitoredItem(parseInt(key, 10));

            assert(status === StatusCodes.Good);

        }

        assert(this.monitoredItemCount === 0);

        if (this.$session?._unexposeSubscriptionDiagnostics) {

            this.$session._unexposeSubscriptionDiagnostics(this);

        }

        this.state = SubscriptionState.CLOSED;

        /**

         * notify the subscription owner that the subscription has been terminated.

         * @event "terminated"

         */

        this.emit("terminated");

        if (this.publishEngine) {

            this.publishEngine.on_close_subscription(this);

        }

    }

    public setTriggering(

        triggeringItemId: number,

        linksToAdd: number[] | null,

        linksToRemove: number[] | null

    ): { statusCode: StatusCode; addResults: StatusCode[]; removeResults: StatusCode[] } {

        /** Bad_NothingToDo, Bad_TooManyOperations,Bad_SubscriptionIdInvalid, Bad_MonitoredItemIdInvalid */

        if (linksToAdd.length === 0 && linksToRemove.length === 0) {

            return { statusCode: StatusCodes.BadNothingToDo, addResults: [], removeResults: [] };

        }

        const triggeringItem = this.getMonitoredItem(triggeringItemId);

        const monitoredItemsToAdd = linksToAdd.map((id) => this.getMonitoredItem(id));

        const monitoredItemsToRemove = linksToRemove.map((id) => this.getMonitoredItem(id));

        if (!triggeringItem) {

            const removeResults1: StatusCode[] = monitoredItemsToRemove.map((m) =>

            );

            const addResults1: StatusCode[] = monitoredItemsToAdd.map((m) =>

            );

            return {

                statusCode: StatusCodes.BadMonitoredItemIdInvalid,

                addResults: addResults1,

                removeResults: removeResults1

            };

        }

        //

        // note: it seems that CTT imposed that we do remove before add

        const removeResults = monitoredItemsToRemove.map((m) =>

            !m ? StatusCodes.BadMonitoredItemIdInvalid : triggeringItem.removeLinkItem(m.monitoredItemId)

        );