fix(alarms): atomic snapshot+truncation read; direct tests for the flag plumbing (review)
Review found AlarmDispatcher.SnapshotActiveAlarms reading the snapshot and the truncation verdict through two independent lock acquisitions, defended by a comment claiming read-order made a race "widen only, never narrow". That claim was false: a not-truncated -> truncated poll landing between the two reads pairs a stale false with a capped snapshot, which is exactly the false all-clear the feature exists to prevent. It was safe only because AlarmCommandHandler STA-serializes consumer calls — an accident of the call graph, not an invariant. Made the invariant structural instead of documented. IMxAccessAlarmConsumer now exposes ONE accessor, `IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms( out bool truncated)`, which implementations must satisfy from a single acquisition of the lock guarding the retained snapshot — mirroring the write side, where FoldFetch already updates snapshot and verdict together. The separate LastSnapshotTruncated property is gone from every layer, so there is no second read left to pair badly. `out` over a result struct follows the file's established idiom (FoldFetch, ParseSnapshotXml). The same threading applies one level up: IAlarmCommandHandler.QueryActive now carries `out bool snapshotTruncated`, so MxAccessCommandExecutor stamps the reply payload from the value the records were stamped with rather than reading the state a second time. Direct tests for the three hops that were only covered end-to-end: - AlarmDispatcherTests: truncated consumer snapshot stamps FromTruncatedSnapshot on every mapped record, with a complete-snapshot control, plus an assertion that the independent per-record Degraded flag is not dragged along. - AlarmCommandHandlerTests: the verdict delegates through the dispatcher (Theory over both values), and survives a prefix filter that removes every record — the case the per-record flag cannot cover. - AlarmCommandExecutorTests: the reply payload's SnapshotTruncated comes from the handler (Theory over both values), including the zero-record case. The WnWrapAlarmConsumer truncation tests now assert through SnapshotActiveAlarms(out ...) rather than an internal field, because the pairing is the contract. Also: GatewayAlarmMonitor's _snapshotTruncated comment now says "as of the last full reconcile" rather than implying it tracks the current _alarms contents, which live transitions keep moving via ApplyTransition between passes. Detection heuristic still untouched (fetchedRecordCount >= maxAlarmsPerFetch); no @COUNT parsing, per docs/AlarmProbeFindings.md. Still additive gateway metadata about our fetch mechanics, not MXAccess behavior — not a parity deviation, and no event is synthesized. Gateway: NonWindows.slnx builds clean (0 warnings); ~Alarm filter 107/107 pass. Worker + Worker.Tests are windev-gated; the signature change was reviewed by inspection across all 7 IMxAccessAlarmConsumer implementers, all 3 IAlarmCommandHandler implementers, and every call site.
This commit is contained in:
Joseph Doherty
@@ -58,8 +58,10 @@ public sealed class GatewayAlarmMonitor : BackgroundService, IGatewayAlarmServic
|
||||
private DateTimeOffset _providerSince = DateTimeOffset.UtcNow;
|
||||
|
||||
// Whether the worker's most recent reconcile fetch was capped, guarded by _sync.
|
||||
// Written only by ApplyReconcile, so it always describes the same pass that
|
||||
// produced the current _alarms generation.
|
||||
// Written only by ApplyReconcile (and cleared with the cache), so it describes the last full
|
||||
// reconcile — not necessarily the current _alarms contents, which live transitions keep moving
|
||||
// via ApplyTransition between passes. Read it as "as of the last reconcile, the worker's fetch
|
||||
// was capped", which is the right granularity for a completeness caveat.
|
||||
private bool _snapshotTruncated;
|
||||
|
||||
private volatile GatewayAlarmMonitorState _state = GatewayAlarmMonitorState.Disabled;
|
||||
|
||||
@@ -262,6 +262,72 @@ public sealed class AlarmCommandExecutorTests
|
||||
Assert.Equal("Galaxy!A", handler.LastFilterPrefix);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The reply payload's <c>SnapshotTruncated</c> comes from the handler's
|
||||
/// verdict. This is the last hop before the IPC frame; if the executor
|
||||
/// dropped it, a filtered query returning no records would carry no
|
||||
/// completeness caveat at all.
|
||||
/// </summary>
|
||||
/// <param name="handlerReportsTruncated">The verdict the fake handler reports.</param>
|
||||
[Theory]
|
||||
[InlineData(true)]
|
||||
[InlineData(false)]
|
||||
public void QueryActiveAlarms_StampsSnapshotTruncatedFromHandler(bool handlerReportsTruncated)
|
||||
{
|
||||
FakeAlarmHandler handler = new FakeAlarmHandler
|
||||
{
|
||||
SnapshotTruncated = handlerReportsTruncated,
|
||||
QueryResult = new[]
|
||||
{
|
||||
new ActiveAlarmSnapshot { AlarmFullReference = "Galaxy!A.T1" },
|
||||
},
|
||||
};
|
||||
MxAccessCommandExecutor executor = NewExecutor(handler);
|
||||
|
||||
StaCommand command = new StaCommand(
|
||||
SessionId, CorrelationId,
|
||||
new MxCommand
|
||||
{
|
||||
Kind = MxCommandKind.QueryActiveAlarms,
|
||||
QueryActiveAlarmsCommand = new QueryActiveAlarmsCommand(),
|
||||
});
|
||||
|
||||
MxCommandReply reply = executor.Execute(command);
|
||||
|
||||
Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
|
||||
Assert.NotNull(reply.QueryActiveAlarms);
|
||||
Assert.Equal(handlerReportsTruncated, reply.QueryActiveAlarms.SnapshotTruncated);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A truncated fetch whose records all filtered out still reports the
|
||||
/// caveat on the payload — the case the per-record flag cannot cover.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void QueryActiveAlarms_WithTruncatedFetchAndNoRecords_StillReportsTruncation()
|
||||
{
|
||||
FakeAlarmHandler handler = new FakeAlarmHandler
|
||||
{
|
||||
SnapshotTruncated = true,
|
||||
QueryResult = Array.Empty<ActiveAlarmSnapshot>(),
|
||||
};
|
||||
MxAccessCommandExecutor executor = NewExecutor(handler);
|
||||
|
||||
StaCommand command = new StaCommand(
|
||||
SessionId, CorrelationId,
|
||||
new MxCommand
|
||||
{
|
||||
Kind = MxCommandKind.QueryActiveAlarms,
|
||||
QueryActiveAlarmsCommand = new QueryActiveAlarmsCommand(),
|
||||
});
|
||||
|
||||
MxCommandReply reply = executor.Execute(command);
|
||||
|
||||
Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
|
||||
Assert.Empty(reply.QueryActiveAlarms.Snapshots);
|
||||
Assert.True(reply.QueryActiveAlarms.SnapshotTruncated);
|
||||
}
|
||||
|
||||
/// <summary>Verifies that unsubscribe routes to handler.</summary>
|
||||
[Fact]
|
||||
public void UnsubscribeAlarms_WithHandler_RoutesToHandler()
|
||||
@@ -371,8 +437,8 @@ public sealed class AlarmCommandExecutorTests
|
||||
/// <summary>Gets the last alarm filter prefix.</summary>
|
||||
public string? LastFilterPrefix { get; private set; }
|
||||
|
||||
/// <summary>Gets or sets the truncation verdict the executor stamps onto the reply payload.</summary>
|
||||
public bool LastSnapshotTruncated { get; set; }
|
||||
/// <summary>Gets or sets the truncation verdict this handler reports with its query result.</summary>
|
||||
public bool SnapshotTruncated { get; set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public void Subscribe(SubscribeAlarmsCommand command, string sessionId)
|
||||
@@ -416,9 +482,12 @@ public sealed class AlarmCommandExecutorTests
|
||||
public (string Name, string Provider, string Group)? LastAckByNameTuple { get; private set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> QueryActive(string? alarmFilterPrefix)
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> QueryActive(
|
||||
string? alarmFilterPrefix,
|
||||
out bool snapshotTruncated)
|
||||
{
|
||||
LastFilterPrefix = alarmFilterPrefix;
|
||||
snapshotTruncated = SnapshotTruncated;
|
||||
return QueryResult;
|
||||
}
|
||||
|
||||
|
||||
@@ -151,7 +151,7 @@ public sealed class AlarmCommandHandlerTests
|
||||
() => consumer);
|
||||
handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = handler.QueryActive(null);
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = handler.QueryActive(null, out _);
|
||||
|
||||
Assert.Single(snapshots);
|
||||
Assert.Equal("Galaxy!TestArea.Tag1", snapshots[0].AlarmFullReference);
|
||||
@@ -175,12 +175,66 @@ public sealed class AlarmCommandHandlerTests
|
||||
() => consumer);
|
||||
handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> filtered = handler.QueryActive("Galaxy!AreaA");
|
||||
IReadOnlyList<ActiveAlarmSnapshot> filtered = handler.QueryActive("Galaxy!AreaA", out _);
|
||||
|
||||
Assert.Single(filtered);
|
||||
Assert.Equal("Galaxy!AreaA.Tag1", filtered[0].AlarmFullReference);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The consumer's truncation verdict reaches the caller through the
|
||||
/// handler and its dispatcher. This is the middle hop of the flag's
|
||||
/// journey to the QueryActiveAlarms reply payload; without it the reply
|
||||
/// builder would have nothing to stamp.
|
||||
/// </summary>
|
||||
/// <param name="consumerReportsTruncated">The verdict the fake consumer reports.</param>
|
||||
[Theory]
|
||||
[InlineData(true)]
|
||||
[InlineData(false)]
|
||||
public void QueryActive_ReportsConsumerTruncationVerdict(bool consumerReportsTruncated)
|
||||
{
|
||||
FakeConsumer consumer = new FakeConsumer
|
||||
{
|
||||
SnapshotTruncated = consumerReportsTruncated,
|
||||
SnapshotResult = new[] { NewRecord("Galaxy", "AreaA", "Tag1") },
|
||||
};
|
||||
AlarmCommandHandler handler = new AlarmCommandHandler(
|
||||
new MxAccessEventQueue(),
|
||||
() => consumer);
|
||||
handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = handler.QueryActive(null, out bool snapshotTruncated);
|
||||
|
||||
Assert.Equal(consumerReportsTruncated, snapshotTruncated);
|
||||
Assert.Equal(consumerReportsTruncated, Assert.Single(snapshots).FromTruncatedSnapshot);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A prefix filter that removes every record must not remove the verdict
|
||||
/// with them. This is exactly why the flag rides out separately as well as
|
||||
/// on each record: a scoped query over a truncated fetch can legitimately
|
||||
/// return nothing and still owe the caller the completeness caveat.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void QueryActive_WhenPrefixFiltersOutEveryRecord_StillReportsTruncation()
|
||||
{
|
||||
FakeConsumer consumer = new FakeConsumer
|
||||
{
|
||||
SnapshotTruncated = true,
|
||||
SnapshotResult = new[] { NewRecord("Galaxy", "AreaB", "Tag2") },
|
||||
};
|
||||
AlarmCommandHandler handler = new AlarmCommandHandler(
|
||||
new MxAccessEventQueue(),
|
||||
() => consumer);
|
||||
handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> filtered =
|
||||
handler.QueryActive("Galaxy!AreaA", out bool snapshotTruncated);
|
||||
|
||||
Assert.Empty(filtered);
|
||||
Assert.True(snapshotTruncated);
|
||||
}
|
||||
|
||||
/// <summary>Verifies that dispose unsubscribes and disposes consumer when subscribed.</summary>
|
||||
[Fact]
|
||||
public void Dispose_WhenSubscribed_UnsubscribesAndDisposesConsumer()
|
||||
@@ -227,7 +281,7 @@ public sealed class AlarmCommandHandlerTests
|
||||
handler.AcknowledgeByName("a", "p", "g", "c", "u", "n", "d", "F");
|
||||
Assert.Equal(3, guardInvocations);
|
||||
|
||||
_ = handler.QueryActive(null);
|
||||
_ = handler.QueryActive(null, out _);
|
||||
Assert.Equal(4, guardInvocations);
|
||||
|
||||
handler.PollOnce();
|
||||
@@ -268,7 +322,7 @@ public sealed class AlarmCommandHandlerTests
|
||||
() => handler.Acknowledge(Guid.Empty, "", "", "", "", ""));
|
||||
Assert.Throws<InvalidOperationException>(
|
||||
() => handler.AcknowledgeByName("", "", "", "", "", "", "", ""));
|
||||
Assert.Throws<InvalidOperationException>(() => handler.QueryActive(null));
|
||||
Assert.Throws<InvalidOperationException>(() => handler.QueryActive(null, out _));
|
||||
Assert.Throws<InvalidOperationException>(() => handler.PollOnce());
|
||||
Assert.Throws<InvalidOperationException>(() => handler.Unsubscribe());
|
||||
}
|
||||
@@ -470,11 +524,15 @@ public sealed class AlarmCommandHandlerTests
|
||||
/// <summary>Gets the last acknowledge-by-name parameters.</summary>
|
||||
public (string Name, string Provider, string Group)? LastAckByNameTuple { get; private set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms() => SnapshotResult;
|
||||
/// <summary>Gets or sets the truncation verdict this consumer reports with its snapshot.</summary>
|
||||
public bool SnapshotTruncated { get; set; }
|
||||
|
||||
/// <summary>Gets or sets the truncation verdict reported for the last fetch.</summary>
|
||||
public bool LastSnapshotTruncated { get; set; }
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
truncated = SnapshotTruncated;
|
||||
return SnapshotResult;
|
||||
}
|
||||
|
||||
/// <summary>Gets the number of times polled.</summary>
|
||||
public int PollCount { get; private set; }
|
||||
|
||||
@@ -267,7 +267,7 @@ public sealed class AlarmDispatcherTests
|
||||
new MxAccessAlarmEventSink(new MxAccessEventQueue(), new MxAccessEventMapper()),
|
||||
SessionId);
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = dispatcher.SnapshotActiveAlarms();
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = dispatcher.SnapshotActiveAlarms(out _);
|
||||
Assert.Equal(2, snapshots.Count);
|
||||
|
||||
Assert.Equal("Galaxy!TestArea.Tag1", snapshots[0].AlarmFullReference);
|
||||
@@ -323,7 +323,7 @@ public sealed class AlarmDispatcherTests
|
||||
new MxAccessAlarmEventSink(new MxAccessEventQueue(), new MxAccessEventMapper()),
|
||||
SessionId);
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = dispatcher.SnapshotActiveAlarms();
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = dispatcher.SnapshotActiveAlarms(out _);
|
||||
Assert.Equal(2, snapshots.Count);
|
||||
|
||||
Assert.True(snapshots[0].Degraded);
|
||||
@@ -333,6 +333,82 @@ public sealed class AlarmDispatcherTests
|
||||
Assert.Equal(AlarmProviderMode.Alarmmgr, snapshots[1].SourceProvider);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A truncated consumer snapshot stamps every mapped record with
|
||||
/// <c>FromTruncatedSnapshot</c> and reports the verdict out of the same
|
||||
/// call. Every record carries it because the public QueryActiveAlarms RPC
|
||||
/// streams bare snapshots with no envelope to hold set-level status, so
|
||||
/// a client that reads only one record must still learn the set may be
|
||||
/// incomplete.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void SnapshotActiveAlarms_WhenConsumerReportsTruncated_StampsEveryRecord()
|
||||
{
|
||||
FakeAlarmConsumer consumer = new FakeAlarmConsumer
|
||||
{
|
||||
SnapshotTruncated = true,
|
||||
SnapshotResult = new[]
|
||||
{
|
||||
NewSnapshotRecord("Tag1", degraded: false),
|
||||
NewSnapshotRecord("Tag2", degraded: true),
|
||||
},
|
||||
};
|
||||
using AlarmDispatcher dispatcher = new AlarmDispatcher(
|
||||
consumer,
|
||||
new MxAccessAlarmEventSink(new MxAccessEventQueue(), new MxAccessEventMapper()),
|
||||
SessionId);
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = dispatcher.SnapshotActiveAlarms(out bool truncated);
|
||||
|
||||
Assert.True(truncated);
|
||||
Assert.Equal(2, snapshots.Count);
|
||||
Assert.All(snapshots, snapshot => Assert.True(snapshot.FromTruncatedSnapshot));
|
||||
// Truncation is about the SET; the per-record provider fidelity flag is
|
||||
// independent and must not be dragged along with it.
|
||||
Assert.False(snapshots[0].Degraded);
|
||||
Assert.True(snapshots[1].Degraded);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The control. A complete consumer snapshot must leave every record's
|
||||
/// <c>FromTruncatedSnapshot</c> unset — without this, a field hard-wired
|
||||
/// to true would satisfy the test above and every snapshot would read as
|
||||
/// possibly-incomplete.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void SnapshotActiveAlarms_WhenConsumerReportsComplete_LeavesRecordsUnstamped()
|
||||
{
|
||||
FakeAlarmConsumer consumer = new FakeAlarmConsumer
|
||||
{
|
||||
SnapshotTruncated = false,
|
||||
SnapshotResult = new[] { NewSnapshotRecord("Tag1", degraded: false) },
|
||||
};
|
||||
using AlarmDispatcher dispatcher = new AlarmDispatcher(
|
||||
consumer,
|
||||
new MxAccessAlarmEventSink(new MxAccessEventQueue(), new MxAccessEventMapper()),
|
||||
SessionId);
|
||||
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = dispatcher.SnapshotActiveAlarms(out bool truncated);
|
||||
|
||||
Assert.False(truncated);
|
||||
Assert.False(Assert.Single(snapshots).FromTruncatedSnapshot);
|
||||
}
|
||||
|
||||
private static MxAlarmSnapshotRecord NewSnapshotRecord(string tagName, bool degraded)
|
||||
{
|
||||
return new MxAlarmSnapshotRecord
|
||||
{
|
||||
AlarmGuid = Guid.NewGuid(),
|
||||
ProviderName = "Galaxy",
|
||||
Group = "TestArea",
|
||||
TagName = tagName,
|
||||
Type = "DSC",
|
||||
Priority = 500,
|
||||
State = MxAlarmStateKind.UnackAlm,
|
||||
Degraded = degraded,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Verifies that dispose unsubscribes the handler and disposes the consumer.</summary>
|
||||
[Fact]
|
||||
public void Dispose_WhenSubscribed_UnsubscribesHandlerAndDisposesConsumer()
|
||||
@@ -432,15 +508,16 @@ public sealed class AlarmDispatcherTests
|
||||
/// <summary>Gets the last acknowledge-by-name tuple (alarm name, provider, group).</summary>
|
||||
public (string Name, string Provider, string Group)? LastAckByNameTuple { get; private set; }
|
||||
|
||||
/// <summary>Gets or sets the truncation verdict this consumer reports with its snapshot.</summary>
|
||||
public bool SnapshotTruncated { get; set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms()
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
truncated = SnapshotTruncated;
|
||||
return SnapshotResult;
|
||||
}
|
||||
|
||||
/// <summary>Gets or sets the truncation verdict the dispatcher stamps onto snapshots.</summary>
|
||||
public bool LastSnapshotTruncated { get; set; }
|
||||
|
||||
/// <summary>Gets the count of poll operations.</summary>
|
||||
public int PollCount { get; private set; }
|
||||
|
||||
|
||||
@@ -78,10 +78,14 @@ public sealed class FailoverAlarmConsumerTests
|
||||
public int AcknowledgeByName(string n, string p, string gr, string c, string a, string b, string d, string e) => 11;
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms() => Array.Empty<MxAlarmSnapshotRecord>();
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
truncated = SnapshotTruncated;
|
||||
return Array.Empty<MxAlarmSnapshotRecord>();
|
||||
}
|
||||
|
||||
/// <summary>Gets or sets the truncation verdict this child reports, so delegation is observable.</summary>
|
||||
public bool LastSnapshotTruncated { get; set; }
|
||||
public bool SnapshotTruncated { get; set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public void Dispose() { }
|
||||
@@ -124,7 +128,7 @@ public sealed class FailoverAlarmConsumerTests
|
||||
public int AcknowledgeByName(string n, string p, string gr, string c, string a, string b, string d, string e) => 22;
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms()
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
SnapshotCalls++;
|
||||
if (ThrowOnSnapshot)
|
||||
@@ -132,11 +136,12 @@ public sealed class FailoverAlarmConsumerTests
|
||||
throw new InvalidOperationException("priming snapshot failed");
|
||||
}
|
||||
|
||||
truncated = SnapshotTruncated;
|
||||
return Array.Empty<MxAlarmSnapshotRecord>();
|
||||
}
|
||||
|
||||
/// <summary>Gets or sets the truncation verdict this child reports, so delegation is observable.</summary>
|
||||
public bool LastSnapshotTruncated { get; set; }
|
||||
public bool SnapshotTruncated { get; set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public void Dispose() { }
|
||||
|
||||
@@ -643,9 +643,6 @@ public sealed class MxAccessStaSessionTests
|
||||
get { lock (gate) return lastPollThreadId; }
|
||||
}
|
||||
|
||||
/// <summary>Gets or sets the truncation verdict reported for the last fetch.</summary>
|
||||
public bool LastSnapshotTruncated { get; set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public void Subscribe(SubscribeAlarmsCommand command, string sessionId)
|
||||
{
|
||||
@@ -671,8 +668,13 @@ public sealed class MxAccessStaSessionTests
|
||||
=> 0;
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> QueryActive(string? alarmFilterPrefix)
|
||||
=> Array.Empty<ActiveAlarmSnapshot>();
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> QueryActive(
|
||||
string? alarmFilterPrefix,
|
||||
out bool snapshotTruncated)
|
||||
{
|
||||
snapshotTruncated = false;
|
||||
return Array.Empty<ActiveAlarmSnapshot>();
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public void PollOnce()
|
||||
|
||||
@@ -130,7 +130,7 @@ public sealed class SubtagAlarmConsumerTests
|
||||
|
||||
source.Raise(ActiveSubtag, true, new DateTime(2026, 6, 13, 10, 0, 0, DateTimeKind.Utc));
|
||||
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot = consumer.SnapshotActiveAlarms();
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot = consumer.SnapshotActiveAlarms(out _);
|
||||
|
||||
Assert.Single(snapshot);
|
||||
Assert.True(snapshot[0].Degraded);
|
||||
@@ -150,7 +150,7 @@ public sealed class SubtagAlarmConsumerTests
|
||||
|
||||
source.Raise(ActiveSubtag, true, new DateTime(2026, 6, 13, 10, 0, 0, DateTimeKind.Utc));
|
||||
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot = consumer.SnapshotActiveAlarms();
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot = consumer.SnapshotActiveAlarms(out _);
|
||||
|
||||
Assert.NotNull(emitted);
|
||||
Assert.Single(snapshot);
|
||||
|
||||
@@ -691,23 +691,29 @@ public sealed class WnWrapAlarmConsumerXmlTests
|
||||
// -------------------------------------------------------------------------
|
||||
// Degraded-status signal. The truncation guard above keeps a capped fetch
|
||||
// from broadcasting phantom Clears, but it does so silently: the retained
|
||||
// snapshot simply stops shrinking. LastSnapshotTruncated is what makes that
|
||||
// suppression visible to the QueryActiveAlarms reply and, through it, the
|
||||
// dashboard banner — so its set/reset behaviour is the contract, not detail.
|
||||
// snapshot simply stops shrinking. The truncation verdict SnapshotActiveAlarms
|
||||
// hands back alongside the records is what makes that suppression visible to
|
||||
// the QueryActiveAlarms reply and, through it, the dashboard banner — so its
|
||||
// set/reset behaviour is the contract, not detail.
|
||||
//
|
||||
// These assert through SnapshotActiveAlarms(out ...) rather than any internal
|
||||
// field, because the pairing IS the contract: records and verdict must come
|
||||
// out of one call, produced under one lock acquisition.
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/// <summary>
|
||||
/// A capped fetch sets the retained truncation verdict. Without this the
|
||||
/// signal never leaves the consumer and the reply builder stamps a
|
||||
/// complete-looking snapshot over a capped one.
|
||||
/// A capped fetch sets the truncation verdict handed out with the
|
||||
/// snapshot. Without this the signal never leaves the consumer and the
|
||||
/// reply builder stamps a complete-looking snapshot over a capped one.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void FoldFetch_WhenFetchTruncated_SetsLastSnapshotTruncated()
|
||||
public void SnapshotActiveAlarms_AfterTruncatedFetch_ReportsTruncated()
|
||||
{
|
||||
const int Cap = 8;
|
||||
using WnWrapAlarmConsumer consumer = new WnWrapAlarmConsumer(Cap);
|
||||
|
||||
Assert.False(consumer.LastSnapshotTruncated);
|
||||
consumer.SnapshotActiveAlarms(out bool truncatedBeforeAnyFetch);
|
||||
Assert.False(truncatedBeforeAnyFetch);
|
||||
|
||||
Dictionary<Guid, MxAlarmSnapshotRecord> next =
|
||||
WnWrapAlarmConsumer.ParseSnapshotXml(BuildAlarmXml(Cap), out int fetchedRecordCount);
|
||||
@@ -715,8 +721,14 @@ public sealed class WnWrapAlarmConsumerXmlTests
|
||||
|
||||
consumer.FoldFetch(next, truncated: true, out int retainedCount);
|
||||
|
||||
Assert.True(consumer.LastSnapshotTruncated);
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot =
|
||||
consumer.SnapshotActiveAlarms(out bool truncated);
|
||||
|
||||
Assert.True(truncated);
|
||||
Assert.Equal(Cap, retainedCount);
|
||||
// The verdict describes THIS set — assert they arrive together, not just
|
||||
// that the boolean flipped somewhere.
|
||||
Assert.Equal(Cap, snapshot.Count);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -727,7 +739,7 @@ public sealed class WnWrapAlarmConsumerXmlTests
|
||||
/// it — the opposite of what the signal is for.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void FoldFetch_AfterTruncatedFetch_SubCapFetchClearsLastSnapshotTruncated()
|
||||
public void SnapshotActiveAlarms_AfterSubCapFetchFollowingTruncation_ReportsComplete()
|
||||
{
|
||||
const int Cap = 8;
|
||||
using WnWrapAlarmConsumer consumer = new WnWrapAlarmConsumer(Cap);
|
||||
@@ -735,7 +747,8 @@ public sealed class WnWrapAlarmConsumerXmlTests
|
||||
Dictionary<Guid, MxAlarmSnapshotRecord> capped =
|
||||
WnWrapAlarmConsumer.ParseSnapshotXml(BuildAlarmXml(Cap), out _);
|
||||
consumer.FoldFetch(capped, truncated: true, out _);
|
||||
Assert.True(consumer.LastSnapshotTruncated);
|
||||
consumer.SnapshotActiveAlarms(out bool truncatedAfterCappedFetch);
|
||||
Assert.True(truncatedAfterCappedFetch);
|
||||
|
||||
Dictionary<Guid, MxAlarmSnapshotRecord> complete =
|
||||
WnWrapAlarmConsumer.ParseSnapshotXml(BuildAlarmXml(Cap - 1), out int fetchedRecordCount);
|
||||
@@ -743,11 +756,15 @@ public sealed class WnWrapAlarmConsumerXmlTests
|
||||
|
||||
consumer.FoldFetch(complete, truncated: false, out int retainedCount);
|
||||
|
||||
Assert.False(consumer.LastSnapshotTruncated);
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot =
|
||||
consumer.SnapshotActiveAlarms(out bool truncated);
|
||||
|
||||
Assert.False(truncated);
|
||||
// The complete fetch also replaced the snapshot wholesale, which is what
|
||||
// makes it authoritative about absence — pinned here so a future change
|
||||
// cannot clear the verdict while keeping the merge semantics.
|
||||
Assert.Equal(Cap - 1, retainedCount);
|
||||
Assert.Equal(Cap - 1, snapshot.Count);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -756,7 +773,7 @@ public sealed class WnWrapAlarmConsumerXmlTests
|
||||
/// still see the caveat.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void FoldFetch_WithConsecutiveTruncatedFetches_KeepsLastSnapshotTruncatedSet()
|
||||
public void SnapshotActiveAlarms_WithConsecutiveTruncatedFetches_KeepsReportingTruncated()
|
||||
{
|
||||
const int Cap = 8;
|
||||
using WnWrapAlarmConsumer consumer = new WnWrapAlarmConsumer(Cap);
|
||||
@@ -766,7 +783,9 @@ public sealed class WnWrapAlarmConsumerXmlTests
|
||||
Dictionary<Guid, MxAlarmSnapshotRecord> capped =
|
||||
WnWrapAlarmConsumer.ParseSnapshotXml(BuildAlarmXml(Cap), out _);
|
||||
consumer.FoldFetch(capped, truncated: true, out _);
|
||||
Assert.True(consumer.LastSnapshotTruncated);
|
||||
|
||||
consumer.SnapshotActiveAlarms(out bool truncated);
|
||||
Assert.True(truncated);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -368,7 +368,7 @@ public sealed class AlarmSubtagLiveSmokeTests
|
||||
raiseEvent.Record.AlarmGuid, raiseEvent.Record.Degraded, raiseEvent.Record.State));
|
||||
|
||||
// 2. Snapshot active alarms and confirm the raised alarm is present.
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot = consumer.SnapshotActiveAlarms();
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> snapshot = consumer.SnapshotActiveAlarms(out _);
|
||||
Log(string.Format("SnapshotActiveAlarms count={0}", snapshot.Count));
|
||||
foreach (MxAlarmSnapshotRecord s in snapshot)
|
||||
{
|
||||
|
||||
@@ -121,7 +121,7 @@ public sealed class AlarmsLiveSmokeTests
|
||||
Assert.Contains("Galaxy", raiseBody.AlarmFullReference);
|
||||
|
||||
// 2. Snapshot the active set + verify the captured alarm is there.
|
||||
var snapshot = dispatcher.SnapshotActiveAlarms();
|
||||
var snapshot = dispatcher.SnapshotActiveAlarms(out _);
|
||||
Log($"SnapshotActiveAlarms count={snapshot.Count}");
|
||||
foreach (var s in snapshot)
|
||||
{
|
||||
|
||||
@@ -325,11 +325,15 @@ public sealed class AlarmCommandHandler : IAlarmCommandHandler
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> QueryActive(string? alarmFilterPrefix)
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> QueryActive(
|
||||
string? alarmFilterPrefix,
|
||||
out bool snapshotTruncated)
|
||||
{
|
||||
threadAffinityCheck?.Invoke();
|
||||
AlarmDispatcher? d = GetDispatcherOrThrow();
|
||||
IReadOnlyList<ActiveAlarmSnapshot> all = d.SnapshotActiveAlarms();
|
||||
// The verdict rides out of the same call that produced the records, so
|
||||
// filtering below cannot separate it from the set it describes.
|
||||
IReadOnlyList<ActiveAlarmSnapshot> all = d.SnapshotActiveAlarms(out snapshotTruncated);
|
||||
if (string.IsNullOrEmpty(alarmFilterPrefix)) return all;
|
||||
List<ActiveAlarmSnapshot> filtered = new List<ActiveAlarmSnapshot>(all.Count);
|
||||
foreach (ActiveAlarmSnapshot snap in all)
|
||||
@@ -342,25 +346,6 @@ public sealed class AlarmCommandHandler : IAlarmCommandHandler
|
||||
return filtered;
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
/// <remarks>
|
||||
/// Deliberately does not go through <c>GetDispatcherOrThrow</c>: an
|
||||
/// unsubscribed handler has performed no fetch, and "no fetch" is not
|
||||
/// truncated. Throwing here would turn a status read into a command
|
||||
/// failure on a path the reply builder takes after the snapshot has
|
||||
/// already been produced.
|
||||
/// </remarks>
|
||||
public bool LastSnapshotTruncated
|
||||
{
|
||||
get
|
||||
{
|
||||
if (disposed) return false;
|
||||
AlarmDispatcher? d;
|
||||
lock (syncRoot) d = dispatcher;
|
||||
return d is not null && d.LastSnapshotTruncated;
|
||||
}
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public void PollOnce()
|
||||
{
|
||||
|
||||
@@ -154,15 +154,24 @@ public sealed class AlarmDispatcher : IDisposable
|
||||
/// <see cref="ActiveAlarmSnapshot"/> protos for the
|
||||
/// <c>QueryActiveAlarms</c> RPC's ConditionRefresh stream.
|
||||
/// </summary>
|
||||
/// <param name="truncated">
|
||||
/// Receives whether the fetch behind the snapshot hit the per-fetch cap,
|
||||
/// so the returned set may omit active alarms. Forwarded from the single
|
||||
/// atomic consumer read, and stamped onto every returned record as
|
||||
/// <c>ActiveAlarmSnapshot.FromTruncatedSnapshot</c>. Also returned
|
||||
/// separately because a snapshot of zero records still has to report it.
|
||||
/// </param>
|
||||
/// <returns>The currently active alarm snapshots.</returns>
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> SnapshotActiveAlarms()
|
||||
public IReadOnlyList<ActiveAlarmSnapshot> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
if (disposed) throw new ObjectDisposedException(nameof(AlarmDispatcher));
|
||||
// Read the truncation verdict before the snapshot, so a poll landing
|
||||
// between the two can only widen the warning (a stale "truncated" over a
|
||||
// complete snapshot), never narrow it into a false all-clear.
|
||||
bool truncated = consumer.LastSnapshotTruncated;
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> records = consumer.SnapshotActiveAlarms();
|
||||
// One consumer call yields the records and the verdict together, under a
|
||||
// single acquisition of the consumer's snapshot lock. Reading them
|
||||
// separately would let a poll interleave and pair a stale not-truncated
|
||||
// verdict with a capped snapshot — a set that reads complete while
|
||||
// missing actives. The atomicity is structural here, not a consequence of
|
||||
// the STA happening to serialize the two calls.
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> records = consumer.SnapshotActiveAlarms(out truncated);
|
||||
if (records.Count == 0) return Array.Empty<ActiveAlarmSnapshot>();
|
||||
List<ActiveAlarmSnapshot> snapshots = new List<ActiveAlarmSnapshot>(records.Count);
|
||||
foreach (MxAlarmSnapshotRecord record in records)
|
||||
@@ -172,14 +181,6 @@ public sealed class AlarmDispatcher : IDisposable
|
||||
return snapshots;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether the consumer's most recent fetch hit the per-fetch cap, so
|
||||
/// the set <see cref="SnapshotActiveAlarms"/> returns may omit actives.
|
||||
/// Stamped onto the QueryActiveAlarms reply payload, which is the only
|
||||
/// carrier when the snapshot filters down to zero records.
|
||||
/// </summary>
|
||||
public bool LastSnapshotTruncated => !disposed && consumer.LastSnapshotTruncated;
|
||||
|
||||
private void OnTransition(object? sender, MxAlarmTransitionEvent transition)
|
||||
{
|
||||
if (disposed) return;
|
||||
|
||||
@@ -260,23 +260,18 @@ public sealed class FailoverAlarmConsumer : IMxAccessAlarmConsumer
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms()
|
||||
/// <remarks>
|
||||
/// Both values come from ONE call to the active child, so the snapshot
|
||||
/// and its verdict cannot end up describing different children across a
|
||||
/// failover. A failover to the subtag standby therefore reports
|
||||
/// not-truncated — correctly, since that child performs no capped fetch.
|
||||
/// </remarks>
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
if (disposed) throw new ObjectDisposedException(nameof(FailoverAlarmConsumer));
|
||||
return ActiveChild.SnapshotActiveAlarms();
|
||||
return ActiveChild.SnapshotActiveAlarms(out truncated);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
/// <remarks>
|
||||
/// Delegated to the active child, matching
|
||||
/// <see cref="SnapshotActiveAlarms"/>: the flag describes the snapshot
|
||||
/// the same child produced, so reading it off the standby would pair a
|
||||
/// verdict with a snapshot it does not belong to. A failover to the
|
||||
/// subtag standby therefore reports not-truncated — correctly, since
|
||||
/// that child performs no capped fetch.
|
||||
/// </remarks>
|
||||
public bool LastSnapshotTruncated => !disposed && ActiveChild.LastSnapshotTruncated;
|
||||
|
||||
private IMxAccessAlarmConsumer ActiveChild => active == Active.Primary ? primary : standby;
|
||||
|
||||
/// <summary>
|
||||
@@ -351,7 +346,7 @@ public sealed class FailoverAlarmConsumer : IMxAccessAlarmConsumer
|
||||
{
|
||||
try
|
||||
{
|
||||
_ = standby.SnapshotActiveAlarms();
|
||||
_ = standby.SnapshotActiveAlarms(out _);
|
||||
}
|
||||
catch (Exception ex) when (ex is not OutOfMemoryException)
|
||||
{
|
||||
|
||||
@@ -71,18 +71,17 @@ public interface IAlarmCommandHandler : IDisposable
|
||||
/// prefix matched against <c>AlarmFullReference</c>.
|
||||
/// </summary>
|
||||
/// <param name="alarmFilterPrefix">Optional prefix to filter alarms by.</param>
|
||||
/// <param name="snapshotTruncated">
|
||||
/// Receives whether the fetch behind the snapshot hit the per-fetch cap,
|
||||
/// so the set may omit active alarms. Carried out alongside the records
|
||||
/// rather than read from a separate property, both so the pair comes from
|
||||
/// one atomic consumer read and because it is the only carrier left once
|
||||
/// <paramref name="alarmFilterPrefix"/> (or an empty galaxy) filters the
|
||||
/// records down to none. <see langword="false"/> when there is no active
|
||||
/// subscription: no fetch has happened, so nothing is capped.
|
||||
/// </param>
|
||||
/// <returns>The currently active alarms matching the filter.</returns>
|
||||
IReadOnlyList<ActiveAlarmSnapshot> QueryActive(string? alarmFilterPrefix);
|
||||
|
||||
/// <summary>
|
||||
/// Whether the consumer's most recent fetch hit the per-fetch cap, so
|
||||
/// the set <see cref="QueryActive"/> draws from may omit active alarms.
|
||||
/// Stamped on the QueryActiveAlarms reply payload — the only carrier
|
||||
/// once a prefix filter (or an empty galaxy) leaves zero records to
|
||||
/// carry the per-record flag. <see langword="false"/> when there is no
|
||||
/// active subscription: no fetch has happened, so nothing is capped.
|
||||
/// </summary>
|
||||
bool LastSnapshotTruncated { get; }
|
||||
IReadOnlyList<ActiveAlarmSnapshot> QueryActive(string? alarmFilterPrefix, out bool snapshotTruncated);
|
||||
|
||||
/// <summary>
|
||||
/// Drives a single poll of the underlying alarm consumer on the
|
||||
|
||||
@@ -36,20 +36,6 @@ public interface IMxAccessAlarmConsumer : IDisposable
|
||||
/// </summary>
|
||||
event EventHandler<MxAlarmTransitionEvent>? AlarmTransitionEmitted;
|
||||
|
||||
/// <summary>
|
||||
/// Whether the most recent fetch that reached the retained snapshot came
|
||||
/// back holding the per-fetch cap. While this is <see langword="true"/>
|
||||
/// the snapshot returned by <see cref="SnapshotActiveAlarms"/> is
|
||||
/// authoritative about presence only: the provider may hold actives it
|
||||
/// had no room to report, and the consumer has suspended the
|
||||
/// absence-implies-Clear inference. Not latched — the first sub-cap fetch
|
||||
/// after a run of capped ones clears it, because that fetch is complete
|
||||
/// and the snapshot it produced is again authoritative about absence.
|
||||
/// Consumers with no per-fetch cap (the subtag fallback, which is
|
||||
/// event-driven) always report <see langword="false"/>.
|
||||
/// </summary>
|
||||
bool LastSnapshotTruncated { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Initializes the AVEVA alarm-client connection, registers as a
|
||||
/// consumer, and subscribes to the supplied alarm-provider expression.
|
||||
@@ -111,12 +97,43 @@ public interface IMxAccessAlarmConsumer : IDisposable
|
||||
|
||||
/// <summary>
|
||||
/// Returns the consumer's most recently parsed snapshot of currently
|
||||
/// active alarms. Used by the gateway's QueryActiveAlarms (PR A.7)
|
||||
/// active alarms, together with whether the fetch that produced it hit
|
||||
/// the per-fetch cap. Used by the gateway's QueryActiveAlarms (PR A.7)
|
||||
/// ConditionRefresh path — operator clients call this after reconnect
|
||||
/// to seed local Part 9 state.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// The verdict is an <c>out</c> parameter rather than a separate
|
||||
/// property on purpose, and the reason is a correctness one.
|
||||
/// Implementations must produce both values from a single acquisition
|
||||
/// of whatever lock guards the retained snapshot, mirroring the write
|
||||
/// side (<c>WnWrapAlarmConsumer.FoldFetch</c> updates snapshot and
|
||||
/// verdict together). Two separate reads could straddle a poll that
|
||||
/// flips not-truncated → truncated and pair a stale
|
||||
/// <see langword="false"/> with a capped snapshot — a snapshot that
|
||||
/// reads as complete while missing actives, which is exactly the
|
||||
/// false all-clear this signal exists to prevent. Making the pair
|
||||
/// inseparable in the signature removes the possibility rather than
|
||||
/// relying on callers, or on the STA serializing them.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// While <paramref name="truncated"/> is <see langword="true"/> the
|
||||
/// returned snapshot is authoritative about presence only: the
|
||||
/// provider may hold actives it had no room to report, and the
|
||||
/// consumer has suspended the absence-implies-Clear inference. Not
|
||||
/// latched — the first sub-cap fetch clears it, because that fetch is
|
||||
/// complete and its snapshot is again authoritative about absence.
|
||||
/// Consumers with no per-fetch cap (the subtag fallback, which is
|
||||
/// advise-driven) always report <see langword="false"/>.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
/// <param name="truncated">
|
||||
/// Receives whether the fetch behind the returned snapshot hit the
|
||||
/// per-fetch cap.
|
||||
/// </param>
|
||||
/// <returns>The most recently parsed snapshot of currently active alarms.</returns>
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms();
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated);
|
||||
|
||||
/// <summary>
|
||||
/// Drives a single synchronous poll of the underlying alarm source.
|
||||
|
||||
@@ -974,13 +974,15 @@ public sealed class MxAccessCommandExecutor : IStaCommandExecutor
|
||||
try
|
||||
{
|
||||
IReadOnlyList<ActiveAlarmSnapshot> snapshots = alarmCommandHandler.QueryActive(
|
||||
command.Command.QueryActiveAlarmsCommand.AlarmFilterPrefix);
|
||||
command.Command.QueryActiveAlarmsCommand.AlarmFilterPrefix,
|
||||
out bool snapshotTruncated);
|
||||
QueryActiveAlarmsReplyPayload payload = new QueryActiveAlarmsReplyPayload();
|
||||
payload.Snapshots.AddRange(snapshots);
|
||||
// Set-level degraded status: the snapshot may omit actives because
|
||||
// the provider fetch hit its cap. The records carry the same flag,
|
||||
// but a prefix filter can leave none, so the payload states it too.
|
||||
payload.SnapshotTruncated = alarmCommandHandler.LastSnapshotTruncated;
|
||||
// Same value the records were stamped with — one read, not a second.
|
||||
payload.SnapshotTruncated = snapshotTruncated;
|
||||
MxCommandReply reply = CreateOkReply(command);
|
||||
reply.QueryActiveAlarms = payload;
|
||||
return reply;
|
||||
|
||||
@@ -45,16 +45,6 @@ public sealed class SubtagAlarmConsumer : IMxAccessAlarmConsumer
|
||||
/// <summary>Fires once per synthesized alarm-state transition.</summary>
|
||||
public event EventHandler<MxAlarmTransitionEvent>? AlarmTransitionEmitted;
|
||||
|
||||
/// <inheritdoc />
|
||||
/// <remarks>
|
||||
/// Always <see langword="false"/>. Subtag mode is advise-driven over a
|
||||
/// fixed watch list — there is no bulk fetch and therefore no per-fetch
|
||||
/// cap to hit. Subtag snapshots are lower-fidelity in other ways, which
|
||||
/// <c>MxAlarmSnapshotRecord.Degraded</c> already reports; truncation is
|
||||
/// not one of them.
|
||||
/// </remarks>
|
||||
public bool LastSnapshotTruncated => false;
|
||||
|
||||
/// <summary>
|
||||
/// Initializes the consumer over a subtag source and a watch list of
|
||||
/// alarm targets.
|
||||
@@ -162,8 +152,16 @@ public sealed class SubtagAlarmConsumer : IMxAccessAlarmConsumer
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms()
|
||||
/// <remarks>
|
||||
/// <paramref name="truncated"/> is always <see langword="false"/>: subtag
|
||||
/// mode is advise-driven over a fixed watch list, so there is no bulk
|
||||
/// fetch and no per-fetch cap to hit. Subtag snapshots are lower-fidelity
|
||||
/// in other ways, which <c>MxAlarmSnapshotRecord.Degraded</c> already
|
||||
/// reports; truncation is not one of them.
|
||||
/// </remarks>
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
truncated = false;
|
||||
IReadOnlyList<MxAlarmSnapshotRecord> records = stateMachine.SnapshotActive();
|
||||
foreach (MxAlarmSnapshotRecord record in records)
|
||||
{
|
||||
|
||||
@@ -128,8 +128,8 @@ public sealed class WnWrapAlarmConsumer : IMxAccessAlarmConsumer
|
||||
|
||||
/// <summary>
|
||||
/// COM-free construction, for exercising the retained-snapshot state
|
||||
/// machine (<see cref="FoldFetch"/> / <see cref="LastSnapshotTruncated"/>
|
||||
/// / <see cref="SnapshotActiveAlarms"/>) on a machine without AVEVA
|
||||
/// machine (<see cref="FoldFetch"/> / <see cref="SnapshotActiveAlarms"/>)
|
||||
/// on a machine without AVEVA
|
||||
/// installed. <see cref="Subscribe"/> throws and <see cref="PollOnce"/>
|
||||
/// no-ops on an instance built this way — both need the wnwrap coclass,
|
||||
/// which cannot be instantiated on the macOS/Linux test matrix. Internal
|
||||
@@ -372,8 +372,11 @@ public sealed class WnWrapAlarmConsumer : IMxAccessAlarmConsumer
|
||||
/// <see cref="PollOnce"/>. Erring toward "still active" keeps the feed
|
||||
/// at-least-once: a stale entry is repaired by the next sub-cap poll,
|
||||
/// whereas a dropped one is broadcast as a Clear that never happened.
|
||||
/// The snapshot and <paramref name="truncated"/> are produced under one
|
||||
/// <c>syncRoot</c> acquisition, the same one <see cref="FoldFetch"/>
|
||||
/// writes them both under, so no poll can interleave between them.
|
||||
/// </remarks>
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms()
|
||||
public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
|
||||
{
|
||||
if (disposed) throw new ObjectDisposedException(nameof(WnWrapAlarmConsumer));
|
||||
lock (syncRoot)
|
||||
@@ -387,22 +390,11 @@ public sealed class WnWrapAlarmConsumer : IMxAccessAlarmConsumer
|
||||
active.Add(record);
|
||||
}
|
||||
}
|
||||
truncated = lastSnapshotTruncated;
|
||||
return active;
|
||||
}
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
/// <remarks>
|
||||
/// Read without the disposed guard <see cref="SnapshotActiveAlarms"/>
|
||||
/// carries: this is degraded-status metadata a reply builder stamps
|
||||
/// alongside a snapshot, and throwing from it would fail a query whose
|
||||
/// snapshot half succeeded.
|
||||
/// </remarks>
|
||||
public bool LastSnapshotTruncated
|
||||
{
|
||||
get { lock (syncRoot) { return lastSnapshotTruncated; } }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Sink for the rate-limited truncated-fetch warning. Defaults to
|
||||
/// <see cref="Console.Error"/>, the stream
|
||||
@@ -463,10 +455,11 @@ public sealed class WnWrapAlarmConsumer : IMxAccessAlarmConsumer
|
||||
/// <summary>
|
||||
/// Folds one fetch into the retained state under a single lock: the
|
||||
/// transition diff, the snapshot merge/replace, and the truncation
|
||||
/// verdict move together. Splitting them would let a concurrent
|
||||
/// <see cref="SnapshotActiveAlarms"/> / <see cref="LastSnapshotTruncated"/>
|
||||
/// pair read a capped snapshot alongside the previous poll's "complete"
|
||||
/// verdict — precisely the false all-clear the signal exists to prevent.
|
||||
/// verdict move together. This is the write half of the pairing
|
||||
/// <see cref="SnapshotActiveAlarms"/> reads; splitting either half would
|
||||
/// let a reader see a capped snapshot alongside the previous poll's
|
||||
/// "complete" verdict — precisely the false all-clear the signal exists
|
||||
/// to prevent.
|
||||
/// The verdict is replaced, never latched: a sub-cap fetch is complete
|
||||
/// and restores absence authority, so leaving the flag set would strand
|
||||
/// the operator banner on after a single burst.
|
||||
|
||||
Reference in New Issue
Block a user