node-opcua-address-space 2.187.8 → 2.187.11

package/impl/base_node_private.ts

@@ -811,7 +811,7 @@ function _clone_collection_new(
 
             // also clone or instantiate interface members that may be required in the optionals
             extraInfo.level++;
-            _cloneInterface(nodeToClone, newParent, node, optionalFilter, extraInfo, browseNameMap);
+            _cloneInterface(nodeToClone, clonedNode, node, optionalFilter, extraInfo, browseNameMap);
             extraInfo.level--;
             // === clone);
             // extraInfo.registerClonedObject(clone, node);
@@ -898,7 +898,7 @@ function _extractInterfaces2(typeDefinitionNode: UAObjectType | UAVariableType,
 
 function _cloneInterface(
     nodeToClone: UAObject | UAVariable | UAMethod | UAObjectType | UAVariableType,
-    _newParent: BaseNode,
+    clonedNode: BaseNode,
     node: UAObject | UAVariable | UAMethod,
     optionalFilter: CloneFilter,
     extraInfo: CloneExtraInfo,
@@ -936,7 +936,10 @@ function _cloneInterface(
     const localFilter = optionalFilter.filterFor(node);
 
     for (const iface of interfaces) {
-        const aggregates = iface.findReferencesEx("Aggregates", BrowseDirection.Forward);
+        // a member the clone already has (the type declares it itself) is not cloned a second time
+        const aggregates = iface
+            .findReferencesEx("Aggregates", BrowseDirection.Forward)
+            .filter((r) => !r.node || !clonedNode.getChildByName(r.node.browseName));
         if (aggregates.length === 0) continue;
         // c8 ignore next
         doTrace &&
@@ -946,7 +949,7 @@ function _cloneInterface(
                 `\n${extraInfo?.pad()}`,
                 aggregates.map((r) => r.toString({ addressSpace })).join(`\n${extraInfo?.pad()}`)
             );
-        _clone_collection_new(nodeToClone, node, aggregates, false, localFilter, extraInfo, browseNameMap);
+        _clone_collection_new(nodeToClone, clonedNode, aggregates, false, localFilter, extraInfo, browseNameMap);
     }
 }
 

package/impl/ua_variable_impl.ts

@@ -255,7 +255,12 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
      * it, as the Read service does for the others, evaluates the getter twice for nothing.
      */
     declare public _refreshFuncWrapsGetter?: boolean;
-    declare public __waiting_callbacks?: CallbackT<DataValue>[];
+    // the read that started the refresh in progress, and the reads that came while it was (an array only then):
+    // a sampled variable is read once per sample, and one at a time
+    declare private __waiting_callback?: CallbackT<DataValue>;
+    declare private __more_waiting_callbacks?: CallbackT<DataValue>[];
+    // set by _readValueAsync for the next asyncRefresh when its clock is shared by a sampler (see asyncRefresh)
+    declare private __sharedReadClock?: boolean;
     // the variant types already found to fit the DataType below (bit k: DataType k), set on the first write
     declare private _validatedForDataType?: NodeId;
     declare private _validatedVariantTypes?: number;
@@ -553,40 +558,35 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             this.verifyVariantCompatibility(this.$dataValue.value);
         }
 
-        const lessOrEqual = (a: PreciseClock, b: PreciseClock) => {
-            return (
-                a.timestamp.getTime() < b.timestamp.getTime() ||
-                (a.timestamp.getTime() === b.timestamp.getTime() && a.picoseconds <= b.picoseconds)
-            );
-        };
-
         if (!this.refreshFunc) {
             // no refresh func
             const dataValue = this.readValue();
             dataValue.serverTimestamp = oldestDate.timestamp;
             dataValue.serverPicoseconds = oldestDate.picoseconds;
-            const serverClock = coerceClock(dataValue.serverTimestamp, dataValue.serverPicoseconds);
-            if (lessOrEqual(oldestDate, serverClock)) {
-                cb(null, dataValue);
-                return;
-            } else {
-                // fake
-                cb(null, dataValue);
-                return;
-            }
+            cb(null, dataValue);
+            return;
         }
 
-        const c1 = this.$dataValue.serverTimestamp
-            ? coerceClock(this.$dataValue.serverTimestamp, this.$dataValue.serverPicoseconds)
-            : null;
-
-        if (c1 && lessOrEqual(oldestDate, c1)) {
+        // the value held is recent enough for this read: it is answered without a refresh
+        const held = this.$dataValue;
+        if (held.serverTimestamp && clockNotAfter(oldestDate, held.serverTimestamp, held.serverPicoseconds)) {
             const dataValue = this.readValue().clone();
             dataValue.serverTimestamp = oldestDate.timestamp;
             dataValue.serverPicoseconds = oldestDate.picoseconds;
             cb(null, dataValue);
             return;
         }
+        // a refreshed value without a server timestamp is stamped with the time the server obtained it
+        // (OPC 10000-4 7.11), read from the clock once the refreshFunc has answered, so it is never earlier
+        // than a source timestamp the refreshFunc took. Left unset, it inherited the previous value's server
+        // timestamp, which never moved on. A sampler that reads many variables in one go shares one clock
+        // read between them: their values get that clock's Date (the sampler recognises it by identity and
+        // stamps them all with one clock read made once they have all answered).
+        const sharedClock = this.__sharedReadClock === true;
+        this.__sharedReadClock = false;
+        const requestedAt = oldestDate.timestamp;
+        const requestedAtPicoseconds = oldestDate.picoseconds;
+        let answeredAtOnce = true;
         try {
             this.refreshFunc.call(this, (err: Error | null, dataValue?: DataValueLike) => {
                 // c8 ignore next
@@ -600,10 +600,22 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
                     dataValue = { statusCode: StatusCodes.BadNoDataAvailable };
                 }
                 if (dataValue && dataValue !== this.$dataValue) {
-                    this._internal_set_dataValue(coerceDataValue(dataValue), null);
+                    const refreshed = coerceDataValue(dataValue);
+                    if (!refreshed.serverTimestamp) {
+                        if (answeredAtOnce && sharedClock) {
+                            refreshed.serverTimestamp = requestedAt;
+                            refreshed.serverPicoseconds = requestedAtPicoseconds;
+                        } else {
+                            const now = getCurrentClock();
+                            refreshed.serverTimestamp = now.timestamp;
+                            refreshed.serverPicoseconds = now.picoseconds;
+                        }
+                    }
+                    this._internal_set_dataValue(refreshed, null);
                 }
                 cb(err, this.$dataValue);
             });
+            answeredAtOnce = false;
         } catch (err) {
             errorLog("-------------- refresh call failed 2", this.browseName.toString(), this.nodeId.toString());
             errorLog(err);
@@ -1314,13 +1326,17 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     /**
 
      */
-    public readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>): void;
+    public readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>, clock?: PreciseClock): void;
     public readValueAsync(context: ISessionContext | null): Promise<DataValue>;
-    public readValueAsync(context: ISessionContext | null, callback?: CallbackT<DataValue>): Promise<DataValue> | undefined {
+    public readValueAsync(
+        context: ISessionContext | null,
+        callback?: CallbackT<DataValue>,
+        clock?: PreciseClock
+    ): Promise<DataValue> | undefined {
         // written out rather than wrapped with thenify-ex: every sample of a monitored item comes
         // through here with a callback, and the generic wrapper forwarded it with apply(arguments)
         if (callback) {
-            this._readValueAsync(context, callback);
+            this._readValueAsync(context, callback, clock);
             return undefined;
         }
         return new Promise<DataValue>((resolve, reject) => {
@@ -1328,14 +1344,13 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         });
     }
 
-    private _readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>): void {
+    private _readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>, readAt?: PreciseClock): void {
         context = context || SessionContext.defaultContext;
 
-        this.__waiting_callbacks = this.__waiting_callbacks || [];
-        this.__waiting_callbacks.push(callback);
-
-        const _readValueAsync_in_progress = this.__waiting_callbacks.length >= 2;
-        if (_readValueAsync_in_progress) {
+        if (this.__waiting_callback) {
+            // a refresh is in progress: its value answers this read too
+            this.__more_waiting_callbacks ??= [];
+            this.__more_waiting_callbacks.push(callback);
             return;
         }
 
@@ -1343,6 +1358,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             callback?.(null, new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown }));
             return;
         }
+        this.__waiting_callback = callback;
 
         // runs once per sample of every monitored item, so nothing here allocates a closure or
         // binds a function: the denial (if any) is a StatusCode, and the callback that releases
@@ -1371,11 +1387,16 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         }
 
         this.__satisfy_waiting_callbacks ??= (err: Error | null, dataValue?: DataValue) => {
-            // now call all pending callbacks
-            const callbacks = this.__waiting_callbacks || [];
-            this.__waiting_callbacks = [];
-            for (const callback1 of callbacks) {
-                callback1.call(this, err, dataValue);
+            // now call all pending callbacks, in the order of the reads
+            const first = this.__waiting_callback;
+            const more = this.__more_waiting_callbacks;
+            this.__waiting_callback = undefined;
+            this.__more_waiting_callbacks = undefined;
+            first?.call(this, err, dataValue);
+            if (more) {
+                for (const callback1 of more) {
+                    callback1.call(this, err, dataValue);
+                }
             }
         };
         const satisfy_callbacks = this.__satisfy_waiting_callbacks;
@@ -1386,13 +1407,16 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
                 // on a Bad result too (FEAT-34)
                 satisfy_callbacks(null, makeNowDataValue({ statusCode: denied }));
             } else if (typeof this.refreshFunc === "function") {
-                const clock = getCurrentClock();
+                const clock = readAt ?? getCurrentClock();
+                this.__sharedReadClock = readAt !== undefined;
                 if (this.asyncRefresh === wrappedAsyncRefresh) {
                     // the thenified wrapper adds nothing when a callback is given
                     asyncRefreshImpl.call(this, clock, satisfy_callbacks);
                 } else {
                     this.asyncRefresh(clock, satisfy_callbacks);
                 }
+                // consumed by asyncRefresh on entry; cleared here for an overridden one that never reads it
+                this.__sharedReadClock = false;
             } else {
                 assert(this.$dataValue instanceof DataValue);
                 satisfy_callbacks(null, this.readValue(context));
@@ -2327,6 +2351,13 @@ function coerceDataValue(dataValue: DataValue | DataValueLike): DataValue {
     return new DataValue(dataValue);
 }
 
+/** `clock` is not later than the time given as a Date and picoseconds (compared as they are, with no clock object made) */
+function clockNotAfter(clock: PreciseClock, timestamp: Date, picoseconds: number): boolean {
+    const a = clock.timestamp.getTime();
+    const b = timestamp.getTime();
+    return a < b || (a === b && clock.picoseconds <= (picoseconds || 0));
+}
+
 // variation #3 :
 function _Variable_bind_with_async_refresh(
     this: UAVariableImpl,
@@ -2611,10 +2642,11 @@ export class UAVariableImplT<T, DT extends DataType> extends UAVariableImpl impl
     }
 
     public readValueAsync(context: ISessionContext | null): Promise<DataValueT<T, DT>>;
-    public readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValueT<T, DT>>): void;
+    public readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValueT<T, DT>>, clock?: PreciseClock): void;
     public readValueAsync(
         context: ISessionContext | null,
-        callback?: CallbackT<DataValueT<T, DT>>
+        callback?: CallbackT<DataValueT<T, DT>>,
+        clock?: PreciseClock
     ): Promise<DataValueT<T, DT>> | undefined {
         // forward the arguments we were actually given: the base method picks the promise or the
         // callback form from the callback it receives (writeValue below, still thenified, picks
@@ -2622,7 +2654,7 @@ export class UAVariableImplT<T, DT extends DataType> extends UAVariableImpl impl
         if (callback === undefined) {
             return super.readValueAsync(context) as Promise<DataValueT<T, DT>>;
         }
-        super.readValueAsync(context, callback as CallbackT<DataValue>);
+        super.readValueAsync(context, callback as CallbackT<DataValue>, clock);
         return undefined;
     }
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "node-opcua-address-space",
     "type": "module",
-    "version": "2.187.8",
+    "version": "2.187.11",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/api/index.js",
     "types": "./dist/api/index.d.ts",
@@ -23,34 +23,34 @@
         "@types/semver": "7.8.0",
         "chalk": "6.0.1",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space-base": "2.187.8",
-        "node-opcua-address-space-store": "2.187.8",
+        "node-opcua-address-space-base": "2.187.9",
+        "node-opcua-address-space-store": "2.187.9",
         "node-opcua-assert": "2.186.7",
         "node-opcua-basic-types": "2.187.0",
         "node-opcua-binary-stream": "2.187.0",
-        "node-opcua-client-dynamic-extension-object": "2.187.8",
+        "node-opcua-client-dynamic-extension-object": "2.187.9",
         "node-opcua-constants": "2.185.0",
         "node-opcua-crypto": "6.2.3",
-        "node-opcua-data-access": "2.187.0",
+        "node-opcua-data-access": "2.187.9",
         "node-opcua-data-model": "2.187.0",
-        "node-opcua-data-value": "2.187.0",
+        "node-opcua-data-value": "2.187.9",
         "node-opcua-date-time": "2.187.0",
         "node-opcua-debug": "2.186.7",
         "node-opcua-enum": "2.187.0",
         "node-opcua-extension-object": "2.187.0",
         "node-opcua-factory": "2.187.0",
         "node-opcua-nodeid": "2.187.0",
-        "node-opcua-nodeset-ua": "2.187.8",
+        "node-opcua-nodeset-ua": "2.187.9",
         "node-opcua-numeric-range": "2.187.0",
         "node-opcua-object-registry": "2.186.7",
-        "node-opcua-pseudo-session": "2.187.8",
-        "node-opcua-service-browse": "2.187.0",
-        "node-opcua-service-call": "2.187.0",
-        "node-opcua-service-history": "2.187.0",
-        "node-opcua-service-translate-browse-path": "2.187.0",
-        "node-opcua-service-write": "2.187.0",
+        "node-opcua-pseudo-session": "2.187.9",
+        "node-opcua-service-browse": "2.187.9",
+        "node-opcua-service-call": "2.187.9",
+        "node-opcua-service-history": "2.187.9",
+        "node-opcua-service-translate-browse-path": "2.187.9",
+        "node-opcua-service-write": "2.187.9",
         "node-opcua-status-code": "2.187.0",
-        "node-opcua-types": "2.187.0",
+        "node-opcua-types": "2.187.9",
         "node-opcua-utils": "2.187.0",
         "node-opcua-variant": "2.187.0",
         "node-opcua-xml2json": "2.187.0",
@@ -65,7 +65,7 @@
         "node-opcua-nodesets": "2.187.4",
         "node-opcua-packet-analyzer": "2.187.0",
         "node-opcua-schemas": "2.187.0",
-        "node-opcua-service-filter": "2.187.8",
+        "node-opcua-service-filter": "2.187.9",
         "node-opcua-test-fixtures": "2.184.0",
         "node-opcua-test-helpers": "2.184.0"
     },
@@ -84,7 +84,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "88fe3c715fa67b2d077410362503df22a2414e9f",
+    "gitHead": "da8e4d922c74b877e62f5abbd7530354b0e92ee2",
     "files": [
         "dist",
         "distHelpers",