node-opcua-client 2.118.0 → 2.119.0

package/source/alarms_and_conditions/client_alarm_list.ts

@@ -1,112 +0,0 @@
-import { EventEmitter } from "events";
-import { assert } from "node-opcua-assert";
-import { DataType } from "node-opcua-basic-types";
-import { NodeId } from "node-opcua-nodeid";
-import { ClientAlarm, EventStuff } from "./client_alarm";
-
-export interface ClientAlarmList {
-    on(eventName: "alarmChanged", handler: (alarm: ClientAlarm) => void): this;
-    on(eventName: "alarmDeleted", handler: (alarm: ClientAlarm) => void): this;
-    on(eventName: "newAlarm", handler: (alarm: ClientAlarm) => void): this;
-
-    emit(eventName: "alarmChanged", alarm: ClientAlarm): boolean;
-    emit(eventName: "newAlarm", alarm: ClientAlarm): boolean;
-    emit(eventName: "alarmDeleted", alarm: ClientAlarm): boolean;
-}
-// maintain a set of alarm list for a client
-export class ClientAlarmList extends EventEmitter implements Iterable<ClientAlarm> {
-    private _map: { [key: string]: ClientAlarm } = {};
-
-    public constructor() {
-        super();
-    }
-
-    public [Symbol.iterator](): Iterator<ClientAlarm> {
-        let pointer = 0;
-        const components = Object.values(this._map);
-        return {
-            next(): IteratorResult<ClientAlarm> {
-                if (pointer >= components.length) {
-                    return {
-                        done: true,
-                        value: components[pointer++]
-                    };
-                } else {
-                    return {
-                        done: false,
-                        value: components[pointer++]
-                    };
-                }
-            }
-        };
-    }
-
-    public alarms(): ClientAlarm[] {
-        return Object.values(this._map);
-    }
-
-    public update(eventField: EventStuff): void {
-        // Spec says:
-        // Clients shall check for multiple Event Notifications for a ConditionBranch to avoid
-        // overwriting a new state delivered together with an older state from the Refresh
-        // process.
-
-        const { conditionId, eventType } = eventField;
-        assert(conditionId, "must have a valid conditionId ( verify that event is a acknodweldgeable type");
-        const alarm = this.findAlarm(conditionId.value, eventType.value);
-
-        if (!alarm) {
-            const key = this.makeKey(conditionId.value, eventType.value);
-            const newAlarm = new ClientAlarm(eventField);
-            this._map[key] = newAlarm;
-            this.emit("newAlarm", newAlarm);
-            this.emit("alarmChanged", newAlarm);
-        } else {
-            alarm.update(eventField);
-            this.emit("alarmChanged", alarm);
-        }
-    }
-    public removeAlarm(eventField: EventStuff): void {
-        const { conditionId, eventType } = eventField;
-        const alarm = this.findAlarm(conditionId.value, eventType.value);
-        if (alarm) {
-            alarm.update(eventField);
-            this._removeAlarm(alarm);
-        }
-    }
-
-    public get length(): number {
-        return Object.keys(this._map).length;
-    }
-    public purgeUnusedAlarms(): void {
-        const alarms = this.alarms();
-        for (const alarm of alarms) {
-            if (!alarm.getRetain()) {
-                this._removeAlarm(alarm);
-            }
-        }
-    }
-
-    private _removeAlarm(alarm: ClientAlarm) {
-        this.emit("alarmDeleted", alarm);
-        this.deleteAlarm(alarm.conditionId, alarm.eventType);
-    }
-
-    private makeKey(conditionId: NodeId, eventType: NodeId) {
-        return conditionId.toString() + "|" + eventType.toString();
-    }
-    private findAlarm(conditionId: NodeId, eventType: NodeId): ClientAlarm | null {
-        const key = this.makeKey(conditionId, eventType);
-        const _c = this._map[key];
-        return _c || null;
-    }
-    private deleteAlarm(conditionId: NodeId, eventType: NodeId): boolean {
-        const key = this.makeKey(conditionId, eventType);
-        const _c = this._map[key];
-        if (_c) {
-            delete this._map[key];
-            return true;
-        }
-        return false;
-    }
-}

package/source/alarms_and_conditions/client_alarm_tools_acknowledge_all_conditions.ts

@@ -1,187 +0,0 @@
-import { resolveNodeId } from "node-opcua-nodeid";
-import { constructEventFilter } from "node-opcua-service-filter";
-import { AttributeIds, ReadValueIdOptions, TimestampsToReturn } from "node-opcua-service-read";
-import { CreateSubscriptionRequestOptions, MonitoringParametersOptions } from "node-opcua-service-subscription";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, Variant } from "node-opcua-variant";
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { ClientSession } from "../client_session";
-import { EventStuff, fieldsToJson } from "./client_alarm";
-import { extractConditionFields } from "./client_alarm_tools_extractConditionFields";
-import { callConditionRefresh } from "./client_tools";
-
-const doDebug = checkDebugFlag(__filename);
-const debugLog = make_debugLog(__filename);
-const errorLog = make_errorLog(__filename);
-
-/**
- *
- * @param session
- * @param eventStuff
- * @param comment
- */
-export async function acknowledgeCondition(session: ClientSession, eventStuff: EventStuff, comment: string): Promise<StatusCode> {
-    try {
-        const conditionId = eventStuff.conditionId.value;
-        const eventId = eventStuff.eventId.value;
-        return await session.acknowledgeCondition(conditionId, eventId, comment);
-    } catch (err) {
-        errorLog("Acknowledging alarm has failed !", err);
-        return StatusCodes.BadInternalError;
-    }
-}
-export async function confirmCondition(session: ClientSession, eventStuff: EventStuff, comment: string): Promise<StatusCode> {
-    try {
-        const conditionId = eventStuff.conditionId.value;
-        const eventId = eventStuff.eventId.value;
-        return await session.confirmCondition(conditionId, eventId, comment);
-    } catch (err) {
-        errorLog("Acknowledging alarm has failed !", err);
-        return StatusCodes.BadInternalError;
-    }
-}
-
-/**
- * Enumerate all events
- * @param session
- */
-export async function findActiveConditions(session: ClientSession): Promise<EventStuff[]> {
-    const request: CreateSubscriptionRequestOptions = {
-        maxNotificationsPerPublish: 10000,
-        priority: 6,
-        publishingEnabled: true,
-        requestedLifetimeCount: 1000,
-        requestedMaxKeepAliveCount: 100,
-        requestedPublishingInterval: 100
-    };
-
-    const subscription = await session.createSubscription2(request);
-
-    const itemToMonitor: ReadValueIdOptions = {
-        attributeId: AttributeIds.EventNotifier,
-        nodeId: resolveNodeId("Server") // i=2253
-    };
-
-    const fields = await extractConditionFields(session, "AcknowledgeableConditionType");
-
-    // note: we may want to have this select clause
-    //  Or(OfType("AcknowledgeableConditionType"), OfType("RefreshStartEventType"), OfType("RefreshEndEventType"))
-    const eventFilter = constructEventFilter(fields);
-
-    const monitoringParameters: MonitoringParametersOptions = {
-        discardOldest: false,
-        filter: eventFilter,
-        queueSize: 100,
-        samplingInterval: 0
-    };
-
-    const event_monitoringItem = await subscription.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
-
-    const acknowledgeableConditions: EventStuff[] = [];
-
-    let refreshStartEventHasBeenReceived = false;
-    let RefreshEndEventHasBeenReceived = false;
-
-    const RefreshStartEventType = resolveNodeId("RefreshStartEventType").toString();
-    const RefreshEndEventType = resolveNodeId("RefreshEndEventType").toString();
-
-    const promise: Promise<void> = new Promise((resolve, reject) => {
-        // now create a event monitored Item
-        event_monitoringItem.on("changed", (_eventFields: any) => {
-            const eventFields = _eventFields as Variant[];
-
-            try {
-                if (RefreshEndEventHasBeenReceived) {
-                    return;
-                }
-
-                // dumpEvent(session, fields, eventFields);
-                const pojo = fieldsToJson(fields, eventFields) as any;
-
-                // make sure we only start recording event after the RefreshStartEvent has been received
-                if (!refreshStartEventHasBeenReceived) {
-                    if (pojo.eventType.value.toString() === RefreshStartEventType) {
-                        refreshStartEventHasBeenReceived = true;
-                    }
-                    return;
-                }
-                if (pojo.eventType.value.toString() === RefreshEndEventType) {
-                    RefreshEndEventHasBeenReceived = true;
-                    resolve();
-                    return;
-                }
-                if (!pojo.conditionId.value) {
-                    // not a Acknowledgeable condition
-                    return;
-                }
-
-                if (pojo.ackedState.id.dataType === DataType.Boolean) {
-                    acknowledgeableConditions.push(pojo as EventStuff);
-                }
-            } catch (err) {
-                errorLog("Error !!", err);
-            }
-        });
-        // async call without waiting !
-        try {
-            callConditionRefresh(subscription);
-        } catch (err) {
-            // it is possible that server do not implement conditionRefresh ...
-            debugLog("Server may not implement conditionRefresh", err);
-        }
-    });
-
-    await promise;
-
-    // now shut down subscription
-    await subscription.terminate();
-
-    return acknowledgeableConditions;
-}
-
-export async function acknowledgeAllConditions(session: ClientSession, message: string): Promise<void> {
-    try {
-        let conditions = await findActiveConditions(session);
-        if (conditions.length === 0) {
-            debugLog("Warning: cannot find conditions ");
-        }
-
-        // filter acknowledgeable conditions (no acked yet)
-        conditions = conditions.filter((pojo) => pojo.ackedState.id.value === false);
-
-        const promises: Array<Promise<StatusCode>> = [];
-        for (const eventStuff of conditions) {
-            promises.push(acknowledgeCondition(session, eventStuff, message));
-        }
-        const result = await Promise.all(promises);
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog("Acked all results: ", result.map((e) => e.toString()).join(" "));
-        }
-    } catch (err) {
-        errorLog("Error", err);
-    }
-}
-export async function confirmAllConditions(session: ClientSession, message: string): Promise<void> {
-    try {
-        let conditions = await findActiveConditions(session);
-        if (conditions.length === 0) {
-            debugLog("Warning: cannot find conditions ");
-        }
-
-        // filter acknowledgeable conditions (no acked yet)
-        conditions = conditions.filter((pojo) => pojo.confirmedState.id.value === false);
-
-        const promises: Array<Promise<any>> = [];
-        for (const eventStuff of conditions) {
-            promises.push(confirmCondition(session, eventStuff, message));
-        }
-        const result = await Promise.all(promises);
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog("Confirm all results: ", result.map((e) => e.toString()).join(" "));
-        }
-    } catch (err) {
-        errorLog("Error", err);
-    }
-}

package/source/alarms_and_conditions/client_alarm_tools_dump_event.ts

@@ -1,67 +0,0 @@
-import chalk from "chalk";
-import { AttributeIds } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
-import { IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
-
-import { make_warningLog } from "node-opcua-debug";
-
-const warningLog = make_warningLog("ClientAlarmTool");
-
-/**
- *
- * @param session
- * @param fields
- * @param eventFields
- */
-export async function dumpEvent(session: IBasicSessionReadAsyncSimple, fields: string[], eventFields: Variant[]): Promise<void> {
-    async function getBrowseName(_session: IBasicSessionReadAsyncSimple, nodeId: NodeId): Promise<string> {
-        const dataValue = await _session.read({
-            attributeId: AttributeIds.BrowseName,
-            nodeId
-        });
-        if (dataValue.statusCode.isGood()) {
-            const browseName = dataValue.value.value.name!;
-            return browseName;
-        } else {
-            return "???";
-        }
-    }
-    function w(str: string, l: number): string {
-        return (str || "").toString().padEnd(l, " ").substring(0, l);
-    }
-    async function __dumpEvent1(_session: IBasicSessionReadAsyncSimple, _fields: any, variant: VariantLike, index: number) {
-        if (variant.dataType === DataType.Null) {
-            return;
-        }
-        if (variant.dataType === DataType.NodeId) {
-            const name = await getBrowseName(_session, variant.value);
-            warningLog(
-                chalk.yellow(w(name, 30), w(_fields[index], 25)),
-                chalk.cyan(w(DataType[variant.dataType], 10).toString()),
-                chalk.cyan.bold(name),
-                "(",
-                w(variant.value, 20),
-                ")"
-            );
-        } else {
-            // tslint:disable-next-line: no-console
-            warningLog(
-                chalk.yellow(w("", 30), w(_fields[index], 25)),
-                chalk.cyan(w(DataType[variant.dataType as number], 10).toString()),
-                variant.value
-            );
-        }
-    }
-
-    async function __dumpEvent(_session: IBasicSessionReadAsyncSimple, _fields: string[], _eventFields: Variant[]) {
-        let index = 0;
-        const promises = [];
-        for (const variant of _eventFields) {
-            promises.push(__dumpEvent1(_session, _fields, variant, index));
-            index++;
-        }
-        await Promise.all(promises);
-    }
-    await __dumpEvent(session, fields, eventFields);
-}

package/source/alarms_and_conditions/client_alarm_tools_extractConditionFields.ts

@@ -1,12 +0,0 @@
-import { NodeIdLike } from "node-opcua-nodeid";
-import { simpleBrowsePathsToString, extractFields, ISessionForExtractField } from "node-opcua-pseudo-session";
-
-export async function extractConditionFields(session: ISessionForExtractField, conditionNodeId: NodeIdLike): Promise<string[]> {
-    // conditionNodeId could be a Object of type ConditionType
-    // or it could be directly a ObjectType which is a subType of ConditionType
-    const p = await extractFields(session, conditionNodeId);
-    const fields1 = simpleBrowsePathsToString(p.map((a) => a.path));
-    // add this field which will always be added
-    fields1.push("ConditionId");
-    return fields1;
-}