node-opcua-address-space 2.75.0 → 2.76.2

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -2,10 +2,10 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 import { Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto";
-import { DateTime, minOPCUADate } from "node-opcua-basic-types";
+import { DateTime, minOPCUADate, StatusCodes } from "node-opcua-basic-types";
 import { make_warningLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
-import { DataType, VariantOptions } from "node-opcua-variant";
+import { DataType, Variant, VariantOptions } from "node-opcua-variant";
 import { INamespace, UAObject, UAProperty } from "node-opcua-address-space-base";
 import { ObjectTypeIds } from "node-opcua-constants";
 import { makeAccessLevelExFlag } from "node-opcua-data-model";
@@ -16,97 +16,136 @@ import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 
+const ellipsis = (arg0: string, arg1 = 4) => {
+    arg1 = Math.max(arg1, 4);
+    return arg0.length <= arg1 ? arg0 : arg0.slice(0, arg1 / 2) + "..." + arg0.slice(arg0.length - arg1 / 2);
+};
+const d = (d: Date) => {
+    return d.toISOString();
+};
 export function instantiateCertificateExpirationAlarm(
     namespace: INamespace,
     alarmType: "CertificateExpirationAlarmType",
-    options: InstantiateOffNormalAlarmOptions,
-    data?: Record<string, VariantOptions>
-
+    options: InstantiateOffNormalAlarmOptions
 ): UACertificateExpirationAlarmEx {
-    return UACertificateExpirationAlarmImpl.instantiate(namespace,alarmType, options, data);
+    return UACertificateExpirationAlarmImpl.instantiate(namespace, alarmType, options);
 }
 
-
 interface UACertificateExpirationAlarmImpl {
-    expirationDate: UAProperty<Date, /*z*/DataType.DateTime>;
-    expirationLimit?: UAProperty<number, /*z*/DataType.Double>;
-    certificateType: UAProperty<NodeId, /*z*/DataType.NodeId>;
-    certificate: UAProperty<Buffer, /*z*/DataType.ByteString>;
+    expirationDate: UAProperty<Date, /*z*/ DataType.DateTime>;
+    expirationLimit?: UAProperty<number, /*z*/ DataType.Double>;
+    certificateType: UAProperty<NodeId, /*z*/ DataType.NodeId>;
+    certificate: UAProperty<Buffer, /*z*/ DataType.ByteString>;
 }
+
+// This Simple DataType is a Double that defines an interval of time in milliseconds (fractions can be used to define sub-millisecond values).
+// Negative values are generally invalid but may have special meanings where the Duration is used.
+export const OneDayDuration = 1000 * 60 * 60 * 24;
+export const TwoWeeksDuration = OneDayDuration * 2 * 7;
+
 /**
  * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server’s
  * Certificate is within the ExpirationLimit
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
 class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
-
+    private timer: any;
 
     public static instantiate(
         namespace: INamespace,
         alarmType: "CertificateExpirationAlarmType",
-        options: InstantiateOffNormalAlarmOptions,
-        data?: Record<string, VariantOptions>
+        options: InstantiateOffNormalAlarmOptions
+        // data?: Record<string, VariantOptions>
     ): UACertificateExpirationAlarmImpl {
         const alarm = UASystemOffNormalAlarmImpl.instantiate(
             namespace,
             alarmType || "CertificateExpirationAlarmType",
-            options,
-            data
+            options
+            // data
         ) as UACertificateExpirationAlarmImpl;
-        Object.setPrototypeOf(alarm, UACertificateExpirationAlarmImpl.prototype);
-        alarm._post_initialize();
+        promoteToCertificateExpirationAlarm(alarm);
         return alarm;
     }
 
-    public getExpirationDate(): DateTime {
+    public getExpirationDate(): DateTime | null {
         return this.expirationDate.readValue().value.value;
     }
 
-    public setExpirationDate(expirationDate: Date): void {
-        this.expirationDate.setValueFromSource({
-            dataType: DataType.DateTime,
-            value: expirationDate
+    public updateAlarmState2(isActive: boolean, severity: number, message: string) {
+        //xx console.log(`${message} ${severity} ${d(new Date())}`);
+        isActive ? this.activateAlarm() : this.deactivateAlarm();
+
+        this.raiseNewCondition({
+            message,
+            quality: StatusCodes.Good,
+            retain: isActive ? true : false,
+            severity
         });
+    }
+
+    public update() {
+        this._updateAlarm();
+    }
+
+    private _updateAlarm() {
+        const expirationDate = this.getExpirationDate();
+
         const now = new Date();
+
         const expirationLimit = this.getExpirationLimit();
 
         const checkDate = new Date(now.getTime() + +expirationLimit);
 
-        const thumbprint = makeSHA1Thumbprint(this.getCertificate() || Buffer.alloc(0)).toString("hex");
+        const certificate = this.getCertificate();
 
-        if (expirationDate.getTime() <= checkDate.getTime()) {
-            if (!this.currentBranch().getActiveState()) {
-                warningLog(
-                    `CertificateExpirationAlarm:  becomes active, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()} expirationLimit=${expirationLimit}`
-                );
+        if (!expirationDate || (expirationDate === minOPCUADate && !certificate)) {
+            if (!this.currentBranch() || this.currentBranch().getActiveState()) {
+                this.updateAlarmState2(true, 255, "certificate is missing");
             }
+            return;
+        }
+
+        const thumbprint = ellipsis(makeSHA1Thumbprint(this.getCertificate() || Buffer.alloc(0)).toString("hex"), 10);
+        const info = `| end date: ${d(expirationDate)} | expirationLimit=${expirationLimit}|`;
+        //
+
+        if (expirationDate.getTime() <= checkDate.getTime()) {
             // also raise the event
             if (expirationDate.getTime() <= now.getTime()) {
-                this.updateAlarmState(
-                    true,
-                    `certificate ${thumbprint} has expired : end date is ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
-                );
+                this.updateAlarmState2(true, 250, `certificate ${thumbprint} has expired ${info}`);
             } else {
-                this.updateAlarmState(
-                    true,
-                    `certificate ${thumbprint} is about to expire : end date is ${expirationDate.toString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
-                );
+                //             check--------------------+
+                //       expiry---------------+         |
+                //       today-----+          |         |
+                //                 v          v         v
+                // ----------------+----------+---------+----------+
+                const t1 = checkDate.getTime() - now.getTime();
+                const t2 = checkDate.getTime() - expirationDate.getTime();
+                const severity = t1 === 0 ? 255 : Math.floor((t2 / t1) * 100) + 100;
+                this.updateAlarmState2(true, severity, `certificate ${thumbprint} is about to expire ${info}`);
             }
         } else {
-            if (this.currentBranch().getActiveState()) {
-                warningLog(
-                    `CertificateExpirationAlarm:  becomes desactivated, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} expirationLimit=${expirationLimit}`
-                );
-            }
-            // also raise the event
-            this.updateAlarmState(
-                false,
-                `certificate ${thumbprint} end date is OK: ${expirationDate.toString()} , expirationLimit=${expirationLimit}`
-            );
+            this.updateAlarmState2(false, 0, `certificate ${thumbprint} is OK! ${info}`);
         }
     }
 
+    public setExpirationDate(expirationDate: Date): void {
+        this.expirationDate.setValueFromSource({
+            dataType: DataType.DateTime,
+            value: expirationDate
+        });
+        this._updateAlarm();
+    }
+
     public getExpirationLimit(): number {
+        // This shall be a positive number. If the property is not provided, a default of 2 weeks shall be used.
+        if (!this.expirationLimit) {
+            return TwoWeeksDuration;
+        }
+        const dataValue = this.expirationLimit!.readValue();
+        if ((dataValue as any).dataType === DataType.Null) {
+            return TwoWeeksDuration;
+        }
         return (this.expirationLimit?.readValue().value.value as number) || 0;
     }
 
@@ -115,13 +154,14 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
             dataType: DataType.Double,
             value
         });
+        this._updateAlarm();
     }
 
     public getCertificate(): Certificate | null {
         return (this.certificate.readValue().value.value as Certificate | null) || null;
     }
 
-    public setCertificate(certificate: Certificate | null): void {
+    private _extractAndSetExpiryDate(certificate: Certificate | null): void {
         if (certificate && certificate.length > 0) {
             const info = exploreCertificate(certificate);
             if (info.tbsCertificate.validity.notAfter instanceof Date) {
@@ -132,12 +172,22 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
         } else {
             this.setExpirationDate(minOPCUADate);
         }
+    }
+
+    public setCertificate(certificate: Certificate | null): void {
         this.certificate.setValueFromSource({
             dataType: DataType.ByteString,
             value: certificate
         });
+        this._extractAndSetExpiryDate(certificate);
     }
 
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
     _post_initialize() {
         if (this.expirationLimit) {
             this.expirationLimit.accessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
@@ -148,6 +198,13 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
                 this.setCertificate(certificate);
             });
         }
+        const certificate = this.getCertificate();
+        this._extractAndSetExpiryDate(certificate);
+
+        this.addressSpace.registerShutdownTask(() => {
+            this.stopTimer();
+        });
+        this.timer = setInterval(() => this.update(), OneDayDuration / 48);
     }
 }
 
@@ -160,4 +217,4 @@ export function promoteToCertificateExpirationAlarm(node: UAObject): UACertifica
     _node._post_initialize();
     return _node;
 }
-registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm);
+registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm, true);

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -18,7 +18,7 @@ import {
     QualifiedName
 } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { minDate } from "node-opcua-basic-types";
 import { coerceNodeId, makeNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
@@ -52,6 +52,7 @@ import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 const doDebug = checkDebugFlag(__filename);
+const warningLog = make_warningLog(__filename);
 
 export declare interface UAConditionImpl extends UAConditionEx, UABaseEventImpl {
     on(eventName: string, eventHandler: any): this;
@@ -450,6 +451,8 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
                     node._bubble_up_event(eventData);
                 }
             }
+        } else {
+            warningLog("Condition ", this.nodeId.toString(), "is not linked to a Object with a IsConditionOf(reversed(HasCondition))");
         }
         // xx console.log("MMMMMMMM%%%%%%%%%%%%%%%%%%%%% branch  " +
         // branch.getBranchId().toString() + " eventId = " + branch.getEventId().toString("hex"));

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -104,7 +104,7 @@ export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExc
         }
 
         if (state !== oldState) {
-            this._signalNewCondition(state, isActive, value.toString());
+            this._signalNewCondition(state, isActive, value.toFixed(3));
         }
     }
 }

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -106,7 +106,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
     }
 
     public _calculateConditionInfo(
-        states: string | null,
+        state: string | null,
         isActive: boolean,
         value: string,
         oldConditionInfo: ConditionInfo
@@ -120,7 +120,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
             });
         } else {
             return new ConditionInfoImpl({
-                message: "Condition value is " + value + " and state is " + states,
+                message: "Condition is " + value + " and state is " + state,
                 quality: StatusCodes.Good,
                 retain: true,
                 severity: 150
@@ -196,7 +196,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         });
 
         if (count > 0) {
-            this._signalNewCondition2(states, isActive, value.toString());
+            this._signalNewCondition2(states, isActive, value.toFixed(3));
         }
     }
 }

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -1,11 +1,13 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { INamespace, UAVariable } from "node-opcua-address-space-base";
+import { INamespace, UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+
 import { UAOffNormalAlarm_Base } from "node-opcua-nodeset-ua";
+import { NumericalRangeInvalid } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import * as utils from "node-opcua-utils";
 import { DataType, VariantOptions } from "node-opcua-variant";
@@ -32,11 +34,11 @@ export declare interface UAOffNormalAlarmEx
             | "suppressedState"
         >,
         UADiscreteAlarmEx {
-    getNormalStateNode(): UAVariable | null;
+    getNormalStateNode(): UAVariableT<NodeId, DataType.NodeId> | null;
 
-    getNormalStateValue(): any;
+    getNormalStateValue(): NodeId | null;
 
-    setNormalStateValue(value: any): void;
+    setNormalStateValue(value: NodeIdLike): void;
 }
 
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
@@ -53,7 +55,7 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
      * When the value of inputNode doesn't match the normalState node value, then the alarm is raised.
      *
      */
-    public static instantiate(
+    public static instantiate<T, DT extends DataType>(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
         options: InstantiateOffNormalAlarmOptions,
@@ -136,9 +138,9 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     // Property the Alarm is Active. If this Variable is not in the AddressSpace, a Null NodeId shall
     // be provided.
 
-    public getNormalStateNode(): UAVariable | null {
+    public getNormalStateNode(): UAVariableT<NodeId, DataType.NodeId> | null {
         const nodeId = this.normalState.readValue().value.value;
-        const node = this.addressSpace.findNode(nodeId) as UAVariable;
+        const node = this.addressSpace.findNode(nodeId) as UAVariableT<NodeId, DataType.NodeId>;
         if (!node) {
             return null;
         }
@@ -148,19 +150,19 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     /**
      * @method getNormalStateValue
      */
-    public getNormalStateValue(): any | null {
+    public getNormalStateValue(): NodeId | null {
         const normalStateNode = this.getNormalStateNode();
         if (!normalStateNode) {
             return null;
         }
-        return normalStateNode.readValue().value.value;
+        return normalStateNode.readValue().value.value as NodeId;
     }
 
     /**
      * @method setNormalStateValue
      * @param value
      */
-    public setNormalStateValue(value: any): void {
+    public setNormalStateValue(value: NodeIdLike): void {
         const normalStateNode = this.getNormalStateNode();
         throw new Error("Not Implemented yet");
     }

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -3,7 +3,7 @@
  */
 import { INamespace } from "node-opcua-address-space-base";
 import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
+import { DataType, VariantOptions } from "node-opcua-variant";
 import { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
 import { UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
 

package/src/state_machine/ua_two_state_variable.ts

@@ -5,14 +5,13 @@ import { assert } from "node-opcua-assert";
 
 import { VariableTypeIds } from "node-opcua-constants";
 import { BrowseDirection, coerceLocalizedText, LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
-import { DataValueT, DataValueOptionsT } from "node-opcua-data-value";
+import { DataValueT } from "node-opcua-data-value";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
 import { Variant, VariantLike, VariantT } from "node-opcua-variant";
 import { DataType } from "node-opcua-variant";
 import { BaseNode, BindVariableOptions, INamespace, UAReference, UAVariable, ISessionContext } from "node-opcua-address-space-base";
-import { UATwoStateVariable } from "node-opcua-nodeset-ua";
 import { NumericRange } from "node-opcua-numeric-range";
 import { QualifiedNameLike } from "node-opcua-data-model";
 

package/test_helpers/add_event_generator_object.ts

@@ -62,7 +62,6 @@ export function add_eventGeneratorObject(namespace: INamespace, parentFolder: UA
                 value: severity
             }
         });
-        // console.log(require("util").inspect(context).toString());
         const callMethodResult = {
             outputArguments: [],
             statusCode: StatusCodes.Good