Joseph Doherty
2d20aeb779
#519 — a driver's OPC UA status code now reaches a client with its sub-code intact. DriverInstanceActor projected the driver's uint onto a 3-state Good/Uncertain/Bad enum and OtOpcUaNodeManager re-expanded Bad to a bare 0x80000000, so BadNoCommunication, BadTypeMismatch and BadNotSupported were indistinguishable on the wire and every driver's status constants (incl. the 16 #497 had just corrected) were diagnostic in logs only. Resolved by option (b): the raw uint rides AttributeValuePublished -> AttributeValueUpdate -> IOpcUaAddressSpaceSink.WriteValue, OpcUaQuality is deleted, and severity classification is a helper (OpcUaStatus.IsGood/IsUncertain/IsBad). The surface was wider than the issue costed (41 files, not "the sink and 3 implementations"): OpcUaQuality had non-driver producers with no uint to carry. Each got its natural code — BadInternalError for a failed virtual-tag script, BadNoCommunication for driver comms loss — and ScriptedAlarmHostActor's pair of mutually-inverse uint<->enum mappers is deleted, having round-tripped a code the engine already held. AddressSpaceApplier's removal writes deliberately keep the generic Bad: not losing a code the driver had is this issue; inventing one for the deploy path is a separate call. Behaviour change: WriteAlarmQuality fires its Part 9 event on a status-code change rather than a severity-bucket change. While the annotation was 3-state those were the same predicate; now a move between two Bad reasons changes what a subscriber reads. New SDK-free named constants live on Commons.OpcUa.OpcUaStatus, and StatusCodeParityTests is widened to cover them — that guard is reflection-driven, so it can only see a named constant, never an inline literal. #517 — the symptom is real but the issue named the wrong path and its fix was unsafe. ShutdownAsync cannot race: DriverInstanceActor calls it from PostStop, after the mailbox drains. (Core/Hosting/DriverHost, the one class with a concurrent GetHealth, has no production call site.) InitializeAsync can: it runs on a fire-and-forget Task.Run, and MTConnectDriver writes Healthy then starts loops that can throw into a catch which disposes the client before writing Faulted. Moving the write earlier, as suggested, inverts the terminal state — teardown drains in-flight loops that write health as they unwind, so a late loop could leave Healthy at rest with every connection closed. The fix is a bracket (conservative before, terminal after), applied to MTConnect's init-failure path only; shutdown keeps its single trailing write, and the rule plus the reachability table are documented on IDriver.ShutdownAsync. CalculationDriver.GetHealth returned a hard-coded Healthy that consulted nothing — Healthy before initialize, after shutdown and after dispose. Now derived from _running. Its test, named Health_is_always_Connected, asserted the defect and is replaced. Every new guard was falsified by breaking the production code and watching it go red. The two sub-code tests each assert two different Bad codes, since a single-code assertion could pass against a hard-coded constant under the old projection. Pre-existing failures, verified unchanged on a stashed tree and not chased: 4 in Driver.AbLegacy.IntegrationTests (slc500/micrologix/plc5 fixtures not up) and 3 in Host.IntegrationTests. Closes #517 Closes #519 Claude-Session: https://claude.ai/code/session_015p7wGqy3YpZNCpDzTpGMKo
55 lines
3.1 KiB
C#
55 lines
3.1 KiB
C#
namespace ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
|
|
|
|
/// <summary>
|
|
/// Commons-level projection of an alarm's full OPC UA Part 9 condition state, carried from the
|
|
/// Runtime engine to the SDK sink. Commons cannot reference <c>Core.ScriptedAlarms</c> (its
|
|
/// domain enums live there), so this DTO is deliberately primitive: every field is a
|
|
/// <see cref="bool"/>, the Commons-local <see cref="AlarmShelvingKind"/> enum, a
|
|
/// <see cref="ushort"/> severity, or a <see cref="string"/>. The Runtime host maps its Core
|
|
/// <c>AlarmConditionState</c> + <c>AlarmSeverity</c> down to this shape; the SDK
|
|
/// <c>OtOpcUaNodeManager</c> projects it back up onto a real <c>AlarmConditionState</c> node.
|
|
/// </summary>
|
|
/// <param name="Active">Whether the alarm condition is currently active (ActiveState).</param>
|
|
/// <param name="Acknowledged">Whether the active transition has been acknowledged (AckedState).</param>
|
|
/// <param name="Confirmed">Whether the clear transition has been confirmed (ConfirmedState).</param>
|
|
/// <param name="Enabled">Whether the alarm is enabled (EnabledState); a disabled alarm reports no events.</param>
|
|
/// <param name="Shelving">The shelving mode (ShelvingState): unshelved, one-shot, or timed.</param>
|
|
/// <param name="Severity">OPC UA severity on the 1..1000 scale (the SDK <c>SetSeverity</c> input).</param>
|
|
/// <param name="Message">The human-readable condition message (LocalizedText payload).</param>
|
|
/// <param name="StatusCode">
|
|
/// Status code of the condition's source data (Part 9 <c>ConditionType.Quality</c>). Carried so a
|
|
/// comms-lost native source can report a non-<c>Good</c> condition instead of the accidentally-Good
|
|
/// default (issue #477). It is a pure annotation — it never alters Active/Acked/Retain. Defaults to
|
|
/// <see cref="OpcUaStatus.Good"/> so scripted-alarm callers (which stay Good in v1) need not supply it.
|
|
/// Carries the full sub-code since #519, so a comms-lost condition reports
|
|
/// <see cref="OpcUaStatus.BadNoCommunication"/> rather than a bare <see cref="OpcUaStatus.Bad"/>.
|
|
/// </param>
|
|
public sealed record AlarmConditionSnapshot(
|
|
bool Active,
|
|
bool Acknowledged,
|
|
bool Confirmed,
|
|
bool Enabled,
|
|
AlarmShelvingKind Shelving,
|
|
ushort Severity,
|
|
string Message,
|
|
uint StatusCode = OpcUaStatus.Good);
|
|
|
|
/// <summary>
|
|
/// Commons-local mirror of the Core <c>ShelvingKind</c> enum so this assembly carries no
|
|
/// dependency on <c>Core.ScriptedAlarms</c>. <see cref="Unshelved"/> = no suppression,
|
|
/// <see cref="OneShot"/> = suppress the next active transition, <see cref="Timed"/> = suppress
|
|
/// until a configured expiry. The Runtime host maps the Core enum onto these members; the SDK
|
|
/// sink maps them onto the Part 9 <c>SetShelvingState(shelved, oneShot, shelvingTime)</c> flags.
|
|
/// </summary>
|
|
public enum AlarmShelvingKind
|
|
{
|
|
/// <summary>No shelving — the alarm behaves normally.</summary>
|
|
Unshelved,
|
|
|
|
/// <summary>One-shot shelve — suppresses the next active transition, then expires.</summary>
|
|
OneShot,
|
|
|
|
/// <summary>Timed shelve — suppresses until a configured expiry timestamp passes.</summary>
|
|
Timed,
|
|
}
|