fix(opcuaclient): native alarms translate RawPath <-> upstream source/condition ids (#619)

The host subscribes alarms with RawPaths and routes transitions on (driver, RawPath), but the driver filtered upstream SourceNode ids against the RawPaths and reported the upstream condition NodeId as ConditionId, so no opc-plc (or any upstream) alarm could ever reach a condition node. Claude-Session: https://claude.ai/code/session_01Ef2ozxS7QPanGT8uoATbTe
2026-10-08 16:54:44 -04:00
parent a8b07ae12d
commit e56926dc47
2 changed files with 131 additions and 15 deletions
@@ -92,6 +92,12 @@ public sealed class OpcUaClientDriver : IDriver, ITagDiscovery, IReadable, IWrit
    // ---- IAlarmSource state ----

    private readonly System.Collections.Concurrent.ConcurrentDictionary<long, RemoteAlarmSubscription> _alarmSubscriptions = new();
+
+    /// <summary>#619: RawPath → the upstream condition NodeId last seen for it. The host acknowledges by
+    /// RawPath (its only identity for the condition) but Part 9 Acknowledge must be called on the CONDITION
+    /// node, which differs from the authored source node.</summary>
+    private readonly System.Collections.Concurrent.ConcurrentDictionary<string, string> _alarmConditionByRawPath =
+        new(StringComparer.Ordinal);
    private long _nextAlarmSubscriptionId;

    /// <summary>Occurs when an alarm event is received from the remote OPC UA server.</summary>
@@ -1635,7 +1641,14 @@ public sealed class OpcUaClientDriver : IDriver, ITagDiscovery, IReadable, IWrit

        // Pre-resolve the source-node filter set so the per-event notification handler can
        // match in O(1) without re-parsing on every event.
-        var sourceFilter = new HashSet<string>(sourceNodeIds, StringComparer.Ordinal);
+        // #619: under v3 the host passes RawPaths, never upstream node ids. Translate each to the upstream
+        // source id its tag authored (TagConfig.nodeId) so the per-event match compares like with like.
+        var sessionForResolve = Session;
+        var sourceFilter = BuildAlarmSourceIndex(sourceNodeIds, raw =>
+        {
+            if (sessionForResolve is null || !TryResolveTagNode(sessionForResolve, raw, out var live)) return null;
+            return live.ToString();
+        });

        var subscription = new Subscription(telemetry: null!, new SubscriptionOptions
        {
@@ -1767,7 +1780,10 @@ public sealed class OpcUaClientDriver : IDriver, ITagDiscovery, IReadable, IWrit
            {
                // ConditionId is an upstream condition-node id captured from the alarm event (not a
                // tag RawPath), so it re-binds directly against the session via the static resolve.
-                if (!NamespaceMap.TryResolve(session, ack.ConditionId, out var conditionId)) continue;
+                // #619: the host acks by RawPath; Acknowledge must hit the upstream CONDITION node last seen for it.
+                var upstreamCondition = _alarmConditionByRawPath.TryGetValue(ack.ConditionId, out var seen)
+                    ? seen : ack.ConditionId;
+                if (!NamespaceMap.TryResolve(session, upstreamCondition, out var conditionId)) continue;
                callRequests.Add(new CallMethodRequest
                {
                    ObjectId = conditionId,
@@ -1831,30 +1847,69 @@ public sealed class OpcUaClientDriver : IDriver, ITagDiscovery, IReadable, IWrit

    private void OnEventNotification(
        OpcUaAlarmSubscriptionHandle handle,
-        HashSet<string> sourceFilter,
+        IReadOnlyDictionary<string, string> sourceFilter,
        MonitoredItem item,
        MonitoredItemNotificationEventArgs args)
    {
        if (args.NotificationValue is not EventFieldList efl) return;
-        if (efl.EventFields.Count <= AlarmFieldConditionId) return;
+        var e = ProjectEvent(efl.EventFields, sourceFilter, handle,
+            (raw, cond) => _alarmConditionByRawPath[raw] = cond);
+        if (e is not null) OnAlarmEvent?.Invoke(this, e);
+    }

-        var sourceNode = efl.EventFields[AlarmFieldSourceNode].Value?.ToString() ?? string.Empty;
-        if (sourceFilter.Count > 0 && !sourceFilter.Contains(sourceNode)) return;
+    /// <summary>
+    ///     #619 — index an alarm subscription's source refs by UPSTREAM source id. The host (v3) subscribes with
+    ///     the alarm tags' <b>RawPaths</b>; an upstream event carries its own source NodeId, so the match key is
+    ///     the upstream id the tag authored and the value is the RawPath to report back. A ref
+    ///     <paramref name="resolveUpstream"/> cannot resolve is kept verbatim (direct upstream-id use).
+    /// </summary>
+    /// <param name="refs">The refs handed to <c>SubscribeAlarmsAsync</c>.</param>
+    /// <param name="resolveUpstream">RawPath → serialized live upstream NodeId, or null when unknown.</param>
+    /// <returns>Upstream source id → ref to report.</returns>
+    internal static Dictionary<string, string> BuildAlarmSourceIndex(
+        IReadOnlyList<string> refs, Func<string, string?> resolveUpstream)
+    {
+        var index = new Dictionary<string, string>(StringComparer.Ordinal);
+        foreach (var r in refs)
+            index[resolveUpstream(r) ?? r] = r;
+        return index;
+    }

-        var eventType = efl.EventFields[AlarmFieldEventType].Value?.ToString() ?? "BaseEventType";
-        var message = (efl.EventFields[AlarmFieldMessage].Value as LocalizedText)?.Text ?? string.Empty;
-        var severity = efl.EventFields[AlarmFieldSeverity].Value is ushort sev ? sev : (ushort)0;
-        var time = efl.EventFields[AlarmFieldTime].Value is DateTime t ? t : DateTime.UtcNow;
-        var conditionId = efl.EventFields[AlarmFieldConditionId].Value?.ToString() ?? string.Empty;
+    /// <summary>
+    ///     #619 — project one upstream event into an <see cref="AlarmEventArgs"/>. <c>ConditionId</c> and
+    ///     <c>SourceNodeId</c> are the authored RawPath, because <c>DriverHostActor</c> routes native alarms on
+    ///     (driver, RawPath); the upstream condition node (needed to acknowledge) is handed to
+    ///     <paramref name="rememberCondition"/>. Null when the event's source is not an authored one.
+    /// </summary>
+    internal static AlarmEventArgs? ProjectEvent(
+        IReadOnlyList<Variant> fields,
+        IReadOnlyDictionary<string, string> sourceIndex,
+        IAlarmSubscriptionHandle handle,
+        Action<string, string> rememberCondition)
+    {
+        if (fields.Count <= AlarmFieldConditionId) return null;

-        OnAlarmEvent?.Invoke(this, new AlarmEventArgs(
+        var sourceNode = fields[AlarmFieldSourceNode].Value?.ToString() ?? string.Empty;
+        string reported;
+        if (sourceIndex.Count == 0) reported = sourceNode;
+        else if (!sourceIndex.TryGetValue(sourceNode, out reported!)) return null;
+
+        var eventType = fields[AlarmFieldEventType].Value?.ToString() ?? "BaseEventType";
+        var message = (fields[AlarmFieldMessage].Value as LocalizedText)?.Text ?? string.Empty;
+        var severity = fields[AlarmFieldSeverity].Value is ushort sev ? sev : (ushort)0;
+        var time = fields[AlarmFieldTime].Value is DateTime t ? t : DateTime.UtcNow;
+        var upstreamCondition = fields[AlarmFieldConditionId].Value?.ToString() ?? string.Empty;
+
+        if (sourceIndex.Count != 0 && upstreamCondition.Length > 0) rememberCondition(reported, upstreamCondition);
+
+        return new AlarmEventArgs(
            SubscriptionHandle: handle,
-            SourceNodeId: sourceNode,
-            ConditionId: conditionId,
+            SourceNodeId: reported,
+            ConditionId: sourceIndex.Count == 0 ? upstreamCondition : reported,
            AlarmType: eventType,
            Message: message,
            Severity: MapSeverity(severity),
-            SourceTimestampUtc: time));
+            SourceTimestampUtc: time);
    }

    /// <summary>