node-opcua-client 2.73.0 → 2.75.0

package/source/alarms_and_conditions/client_alarm_tools.ts

@@ -1,10 +1,10 @@
 import { AttributeIds } from "node-opcua-data-model";
 import { resolveNodeId } from "node-opcua-nodeid";
-import { constructEventFilter } from "node-opcua-service-filter";
+import { constructEventFilter, ofType } from "node-opcua-service-filter";
 import { ReadValueIdOptions, TimestampsToReturn } from "node-opcua-service-read";
 import { CreateSubscriptionRequestOptions, MonitoringParametersOptions } from "node-opcua-service-subscription";
-import { Variant } from "node-opcua-variant";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { DataType, Variant } from "node-opcua-variant";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 
 import { ClientMonitoredItem } from "../client_monitored_item";
 import { ClientSubscription } from "../client_subscription";
@@ -16,6 +16,7 @@ import { callConditionRefresh } from "./client_tools";
 
 const doDebug = checkDebugFlag("A&E");
 const debugLog = make_debugLog("A&E");
+const warningLog = make_warningLog("A&E");
 
 function r(_key: string, o: { dataType?: unknown; value?: unknown }) {
     if (o && o.dataType === "Null") {
@@ -67,7 +68,7 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
     _sessionPriv.$clientAlarmList = clientAlarmList;
 
     const request: CreateSubscriptionRequestOptions = {
-        maxNotificationsPerPublish: 10000,
+        maxNotificationsPerPublish: 100,
         priority: 6,
         publishingEnabled: true,
         requestedLifetimeCount: 10000,
@@ -84,21 +85,20 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
 
     const fields = await extractConditionFields(session, "AlarmConditionType");
 
-    const eventFilter = constructEventFilter(fields, [resolveNodeId("AcknowledgeableConditionType")]);
+    const AcknowledgeableConditionType = resolveNodeId("AcknowledgeableConditionType");
+
+    const eventFilter = constructEventFilter(fields, ofType(AcknowledgeableConditionType));
 
     const monitoringParameters: MonitoringParametersOptions = {
         discardOldest: false,
         filter: eventFilter,
-        queueSize: 10000,
+        queueSize: 1000,
         samplingInterval: 0
     };
 
     // now create a event monitored Item
     const eventMonitoringItem = await subscription.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
 
-    const RefreshStartEventType = resolveNodeId("RefreshStartEventType").toString();
-    const RefreshEndEventType = resolveNodeId("RefreshEndEventType").toString();
-
     const queueEvent: EventStuff[] = [];
     function flushQueue() {
         const q = [...queueEvent];
@@ -110,17 +110,25 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
 
     let inInit = true;
     eventMonitoringItem.on("changed", (eventFields: Variant[]) => {
-        debugLog("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ---- ALARM RECEIVED");
-        const pojo = fieldsToJson(fields, eventFields) as EventStuff;
+        
+        const pojo = fieldsToJson(fields, eventFields);
+        const { eventType, eventId, conditionId, conditionName } = pojo;
+
+        debugLog(
+            "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ---- ALARM RECEIVED " +
+                eventType.value.toString() +
+                " " +
+                eventId.value?.toString("hex")
+        );
         try {
-            if (pojo.eventType.value.toString() === RefreshStartEventType) {
-                return;
-            }
-            if (pojo.eventType.value.toString() === RefreshEndEventType) {
-                return;
-            }
-            if (!pojo.conditionId || !pojo.conditionId.value || pojo.conditionId.dataType === 0) {
+            if (!conditionId || !conditionId.value || conditionId.dataType === DataType.Null) {
                 // not a acknowledgeable condition
+                warningLog(
+                    " not acknowledgeable condition ---- " + eventType.value.toString() + " ",
+                    conditionId,
+                    conditionName?.value,
+                    " " + eventId.value?.toString("hex")
+                );
                 return;
             }
             queueEvent.push(pojo);
@@ -128,10 +136,8 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
                 setTimeout(() => flushQueue(), 10);
             }
         } catch (err) {
-            // tslint:disable-next-line: no-console
-            console.log(JSON.stringify(pojo, r, " "));
-            // tslint:disable-next-line: no-console
-            console.log("Error !!", err);
+            warningLog(JSON.stringify(pojo, r, " "));
+            warningLog("Error !!", err);
         }
 
         // Release 1.04 8 OPC Unified Architecture, Part 9
@@ -150,7 +156,11 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
     try {
         await callConditionRefresh(subscription);
     } catch (err) {
-        console.log("Server may not implement condition refresh", (<Error>err).message);
+        if ((err as Error).message.match(/BadNothingToDo/)) {
+            /** fine! nothing to do */
+        } else {
+            warningLog("Server may not implement condition refresh", (<Error>err).message);
+        }
     }
     _sessionPriv.$monitoredItemForAlarmList = eventMonitoringItem;
 

package/source/alarms_and_conditions/client_alarm_tools_acknowledge_all_conditions.ts

@@ -5,7 +5,6 @@ import { CreateSubscriptionRequestOptions, MonitoringParametersOptions } from "n
 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 { ClientMonitoredItem } from "../client_monitored_item";
 import { ClientSession } from "../client_session";
 import { EventStuff, fieldsToJson } from "./client_alarm";
 import { extractConditionFields } from "./client_alarm_tools_extractConditionFields";
@@ -22,6 +21,7 @@ const errorLog = make_errorLog(__filename);
  * @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;
@@ -65,7 +65,9 @@ export async function findActiveConditions(session: ClientSession): Promise<Even
 
     const fields = await extractConditionFields(session, "AcknowledgeableConditionType");
 
-    const eventFilter = constructEventFilter(fields, [resolveNodeId("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,
@@ -88,13 +90,17 @@ export async function findActiveConditions(session: ClientSession): Promise<Even
         // 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;
-                // console.log(pojo.eventType.value.toString(), RefreshEndEventType, RefreshStartEventType);
+                
+                // console.log(pojo.eventType.value.toString({ addressSpace}), RefreshEndEventType, RefreshStartEventType);
 
                 // make sure we only start recording event after the RefreshStartEvent has been received
                 if (!refreshStartEventHasBeenReceived) {
@@ -147,7 +153,7 @@ export async function acknwoledgeAllConditions(session: ClientSession, message:
         // filter acknowledgable conditions (no acked yet)
         conditions = conditions.filter((pojo) => pojo.ackedState.id.value === false);
 
-        const promises: Array<Promise<any>> = [];
+        const promises: Array<Promise<StatusCode>> = [];
         for (const eventStuff of conditions) {
             promises.push(acknowledgeCondition(session, eventStuff, message));
         }

package/source/alarms_and_conditions/client_alarm_tools_extractConditionFields.ts

@@ -2,15 +2,11 @@ import { BrowseDirection, NodeClassMask, QualifiedName } from "node-opcua-data-m
 import { NodeId, NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { IBasicSession } from "node-opcua-pseudo-session";
 import { BrowseDescriptionOptions } from "node-opcua-service-browse";
+import { NodeClass } from "node-opcua-types";
 
-/**
- *
- * @param session
- * @param conditionNodeId
- */
 export async function extractConditionFields(session: IBasicSession, conditionNodeId: NodeIdLike): Promise<string[]> {
     // conditionNodeId could be a Object of type ConditionType
-    // or it could be directly a ObhectType which is a  subType of ConditionType
+    // or it could be directly a ObjectType which is a subType of ConditionType
 
     const _duplicateMap: any = {};
     const fields1: string[] = [];
@@ -63,7 +59,9 @@ export async function extractConditionFields(session: IBasicSession, conditionNo
 
             for (const ref of result.references) {
                 const n = name + "." + ref.browseName.toString();
-                addField(n);
+                if (ref.nodeClass === NodeClass.Variable) {
+                    addField(n);
+                }
                 deferObjectOrVariableInvestigation(ref.nodeId, n);
             }
         }
@@ -83,8 +81,10 @@ export async function extractConditionFields(session: IBasicSession, conditionNo
         const nodeToBrowse2: BrowseDescriptionOptions = {
             browseDirection: BrowseDirection.Forward,
             includeSubtypes: true,
+
             // tslint:disable-next-line: no-bitwise
             nodeClassMask: NodeClassMask.Object | NodeClassMask.Variable,
+
             nodeId: conditionNodeId,
             referenceTypeId: resolveNodeId("HasChild"),
             resultMask: 63
@@ -92,12 +92,11 @@ export async function extractConditionFields(session: IBasicSession, conditionNo
         const nodesToBrowse = [nodeToBrowse1, nodeToBrowse2];
         const browseResults = await session.browse(nodesToBrowse);
 
-        // console.log(browseResults[0].toString());
-        // console.log(browseResults[1].toString());
-
         if (browseResults[1] && browseResults[1].references) {
             for (const ref of browseResults[1].references) {
-                addField(ref.browseName.toString());
+                if (ref.nodeClass === NodeClass.Variable) {
+                    addField(ref.browseName.toString());
+                }
                 deferObjectOrVariableInvestigation(ref.nodeId, ref.browseName.toString());
             }
         }
@@ -115,5 +114,6 @@ export async function extractConditionFields(session: IBasicSession, conditionNo
 
     // add this field which will always be added
     addField("ConditionId");
+
     return fields1;
 }

package/source/private/client_monitored_item_impl.ts

@@ -8,7 +8,7 @@ import { assert } from "node-opcua-assert";
 
 import { AttributeIds } from "node-opcua-data-model";
 import { DataValue, coerceTimestampsToReturn } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { EventFilter } from "node-opcua-service-filter";
 import { ReadValueId, ReadValueIdOptions, TimestampsToReturn } from "node-opcua-service-read";
@@ -29,6 +29,7 @@ import { ClientSubscription } from "../client_subscription";
 import { ClientMonitoredItem_create, ClientSubscriptionImpl } from "./client_subscription_impl";
 
 const debugLog = make_debugLog(__filename);
+const warningLog = make_warningLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 
 export type PrepareForMonitoringResult =
@@ -216,8 +217,8 @@ export class ClientMonitoredItemImpl extends EventEmitter implements ClientMonit
         try {
             this.emit("changed", eventFields);
         } catch (err) {
-            debugLog("Exception raised inside the event handler called by ClientMonitoredItem.on('change')", err);
-            debugLog("Please verify the application using this node-opcua client");
+            warningLog("Exception raised inside the event handler called by ClientMonitoredItem.on('change')", err);
+            warningLog("Please verify the application using this node-opcua client");
         }
     }
 

package/source/private/client_session_impl.ts

@@ -10,7 +10,7 @@ import {
     ExtraDataTypeManager,
     getExtensionObjectConstructor,
     getExtraDataTypeManager,
-    promoteOpaqueStructure,
+    promoteOpaqueStructure
 } from "node-opcua-client-dynamic-extension-object";
 import { Certificate, Nonce } from "node-opcua-crypto";
 import { attributeNameById, BrowseDirection, LocalizedTextLike } from "node-opcua-data-model";
@@ -82,7 +82,13 @@ import {
 import { WriteRequest, WriteResponse, WriteValue } from "node-opcua-service-write";
 import { StatusCode, StatusCodes, Callback, CallbackT } from "node-opcua-status-code";
 import { ErrorCallback } from "node-opcua-status-code";
-import { BrowseNextRequest, BrowseNextResponse, HistoryReadValueIdOptions, WriteValueOptions } from "node-opcua-types";
+import {
+    BrowseNextRequest,
+    BrowseNextResponse,
+    HistoryReadValueIdOptions,
+    ServiceFault,
+    WriteValueOptions
+} from "node-opcua-types";
 import { buffer_ellipsis, getFunctionParameterNames, isNullOrUndefined, lowerFirstLetter } from "node-opcua-utils";
 import { DataType, Variant, VariantLike } from "node-opcua-variant";
 
@@ -1540,6 +1546,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             if (err && err.message.match(/BadSessionIdInvalid/) && request.constructor.name !== "ActivateSessionRequest") {
                 debugLog("Transaction on Invalid Session ", request.constructor.name);
                 request.requestHeader.requestHandle = requestHandleNotSetValue;
+                warningLog("client is now attempting to recreate a session");
                 this.recreate_session_and_reperform_transaction(request, callback);
                 return;
             }
@@ -1595,6 +1602,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 }
                 return callback(err);
             }
+
             /* istanbul ignore next */
             if (!response) {
                 return callback(new Error("internal Error"));

package/source/private/client_subscription_impl.ts

@@ -471,8 +471,12 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         });
         session.setTriggering(setTriggeringRequest, (err: Error | null, response?: SetTriggeringResponse) => {
             if (err) {
-                // use soft error, no exceptions
-                return callback(null, response);
+                if (response) {
+                    // use soft error, no exceptions
+                    return callback(null, response);
+                } else {
+                    return callback(err);
+                }
             }
             // istanbul ignore next
             if (!response) {