Joseph Doherty
f40409a688
Tracking IDs are review bookkeeping that rots in shipped source; the rationale they tagged is kept. Comment-only change (CommentChecker 458 -> 16 false positives).
1116 lines
46 KiB
C#
1116 lines
46 KiB
C#
using System.Diagnostics.CodeAnalysis;
|
|
using System.Diagnostics.Metrics;
|
|
using System.Threading.Channels;
|
|
using Google.Protobuf.WellKnownTypes;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Microsoft.Extensions.Options;
|
|
using ZB.MOM.WW.MxGateway.Contracts.Proto;
|
|
using ZB.MOM.WW.MxGateway.Server.Alarms;
|
|
using ZB.MOM.WW.MxGateway.Server.Configuration;
|
|
using ZB.MOM.WW.MxGateway.Server.Metrics;
|
|
using ZB.MOM.WW.MxGateway.Server.Sessions;
|
|
using ZB.MOM.WW.MxGateway.Tests.TestSupport;
|
|
|
|
namespace ZB.MOM.WW.MxGateway.Tests.Alarms;
|
|
|
|
/// <summary>
|
|
/// Drives <see cref="GatewayAlarmMonitor"/> with a fake session manager to
|
|
/// verify it reflects the worker's <c>OnAlarmProviderModeChanged</c> event into
|
|
/// the alarm feed and the switch metric, and that a new subscriber receives the
|
|
/// provider status as its first message. Also covers the watch-list / forced-mode
|
|
/// wiring of the <c>SubscribeAlarms</c> command and the Mode→enum mapping.
|
|
/// </summary>
|
|
public sealed class GatewayAlarmMonitorProviderModeTests
|
|
{
|
|
private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(15);
|
|
|
|
/// <summary>A worker-reported provider-mode change to subtag broadcasts a degraded status message and increments the provider-switch metric.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ProviderModeChange_BroadcastsDegradedStatus_AndIncrementsSwitchMetric()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
long switchCount = 0;
|
|
using MeterListener listener = new();
|
|
listener.InstrumentPublished = (instrument, meterListener) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_switches")
|
|
{
|
|
meterListener.EnableMeasurementEvents(instrument);
|
|
}
|
|
};
|
|
listener.SetMeasurementEventCallback<long>(
|
|
(instrument, measurement, _, _) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_switches")
|
|
{
|
|
Interlocked.Add(ref switchCount, measurement);
|
|
}
|
|
});
|
|
listener.Start();
|
|
|
|
FakeSessionManager sessions = new();
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
// Subscribe a live feed reader. Gate emitting the mode-change event until the
|
|
// reader has consumed its baseline ProviderStatus message, avoiding a race where
|
|
// the event arrives before the subscriber is registered and draining its snapshot.
|
|
List<AlarmFeedMessage> received = [];
|
|
TaskCompletionSource baselineReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
using CancellationTokenSource streamCts = new();
|
|
Task reader = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
lock (received)
|
|
{
|
|
received.Add(message);
|
|
// Signal once the first message (baseline ProviderStatus) has arrived.
|
|
if (received.Count == 1)
|
|
{
|
|
baselineReceived.TrySetResult();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// Expected when the test cancels the stream.
|
|
}
|
|
});
|
|
|
|
// Wait for the baseline ProviderStatus to arrive before emitting the mode change,
|
|
// so the subscriber is registered and the event is not dropped.
|
|
await baselineReceived.Task.WaitAsync(WaitTimeout);
|
|
|
|
// Emit the worker event that flips the provider into subtag mode.
|
|
sessions.EmitEvent(new MxEvent
|
|
{
|
|
OnAlarmProviderModeChanged = new OnAlarmProviderModeChangedEvent
|
|
{
|
|
Mode = AlarmProviderMode.Subtag,
|
|
Reason = "alarmmgr failed",
|
|
Hresult = unchecked((int)0x80004005),
|
|
At = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
|
|
},
|
|
});
|
|
|
|
AlarmFeedMessage degraded = await WaitForAsync(
|
|
received,
|
|
m => m.PayloadCase == AlarmFeedMessage.PayloadOneofCase.ProviderStatus
|
|
&& m.ProviderStatus.Mode == AlarmProviderMode.Subtag,
|
|
WaitTimeout);
|
|
|
|
Assert.Equal(AlarmProviderMode.Subtag, degraded.ProviderStatus.Mode);
|
|
Assert.True(degraded.ProviderStatus.Degraded);
|
|
Assert.Equal("alarmmgr failed", degraded.ProviderStatus.Reason);
|
|
|
|
await WaitUntilAsync(() => Interlocked.Read(ref switchCount) >= 1, WaitTimeout);
|
|
Assert.Equal(1, Interlocked.Read(ref switchCount));
|
|
|
|
await streamCts.CancelAsync();
|
|
await reader;
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A redundant <c>OnAlarmProviderModeChanged</c> event whose target
|
|
/// mode equals the current mode still records a provider switch. The worker is the
|
|
/// authority on when a mode change occurred; the gateway does not second-guess it,
|
|
/// so each event the worker emits increments <c>provider_switches</c> (no from==to
|
|
/// suppression). This test pins that semantics so it cannot drift silently.
|
|
/// </summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ProviderModeChange_RepeatedSameMode_RecordsASwitchForEachEvent()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
long switchCount = 0;
|
|
using MeterListener listener = new();
|
|
listener.InstrumentPublished = (instrument, meterListener) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_switches")
|
|
{
|
|
meterListener.EnableMeasurementEvents(instrument);
|
|
}
|
|
};
|
|
listener.SetMeasurementEventCallback<long>(
|
|
(instrument, measurement, _, _) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_switches")
|
|
{
|
|
Interlocked.Add(ref switchCount, measurement);
|
|
}
|
|
});
|
|
listener.Start();
|
|
|
|
FakeSessionManager sessions = new();
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
List<AlarmFeedMessage> received = [];
|
|
TaskCompletionSource baselineReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
using CancellationTokenSource streamCts = new();
|
|
Task reader = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
lock (received)
|
|
{
|
|
received.Add(message);
|
|
if (received.Count == 1)
|
|
{
|
|
baselineReceived.TrySetResult();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// Expected when the test cancels the stream.
|
|
}
|
|
});
|
|
|
|
await baselineReceived.Task.WaitAsync(WaitTimeout);
|
|
|
|
// First subtag-mode event.
|
|
sessions.EmitEvent(new MxEvent
|
|
{
|
|
OnAlarmProviderModeChanged = new OnAlarmProviderModeChangedEvent
|
|
{
|
|
Mode = AlarmProviderMode.Subtag,
|
|
Reason = "alarmmgr failed",
|
|
At = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
|
|
},
|
|
});
|
|
await WaitUntilAsync(() => Interlocked.Read(ref switchCount) >= 1, WaitTimeout);
|
|
|
|
// Second subtag-mode event — same mode, but still a worker-reported switch.
|
|
sessions.EmitEvent(new MxEvent
|
|
{
|
|
OnAlarmProviderModeChanged = new OnAlarmProviderModeChangedEvent
|
|
{
|
|
Mode = AlarmProviderMode.Subtag,
|
|
Reason = "still degraded",
|
|
At = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
|
|
},
|
|
});
|
|
await WaitUntilAsync(() => Interlocked.Read(ref switchCount) >= 2, WaitTimeout);
|
|
|
|
Assert.Equal(2, Interlocked.Read(ref switchCount));
|
|
|
|
await streamCts.CancelAsync();
|
|
await reader;
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pins the monitor's <c>toMode → AlarmProviderSwitchReason</c>
|
|
/// derivation (<c>GatewayAlarmMonitor.ApplyProviderModeChangeAsync</c>): an
|
|
/// alarmmgr→subtag change must emit <c>reason=failover</c> and a subtag→alarmmgr
|
|
/// change must emit <c>reason=failback</c>. Captures the <c>reason</c> tag off the
|
|
/// <c>mxgateway.alarms.provider_switches</c> counter — a regression that swapped
|
|
/// the Failover/Failback arms or collapsed them to Unknown would be caught here,
|
|
/// whereas the count-only tests above would still pass.
|
|
/// </summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ProviderModeChange_FailoverThenFailback_RecordsCorrectReasonTags()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
List<string> capturedReasons = [];
|
|
using MeterListener listener = new();
|
|
listener.InstrumentPublished = (instrument, meterListener) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_switches")
|
|
{
|
|
meterListener.EnableMeasurementEvents(instrument);
|
|
}
|
|
};
|
|
listener.SetMeasurementEventCallback<long>(
|
|
(instrument, _, tags, _) =>
|
|
{
|
|
if (!ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
|| instrument.Name != "mxgateway.alarms.provider_switches")
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (KeyValuePair<string, object?> tag in tags)
|
|
{
|
|
if (tag.Key == "reason" && tag.Value is string reasonTag)
|
|
{
|
|
lock (capturedReasons)
|
|
{
|
|
capturedReasons.Add(reasonTag);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
listener.Start();
|
|
|
|
FakeSessionManager sessions = new();
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
// Register a live subscriber and gate the mode-change events until the baseline
|
|
// ProviderStatus message has been drained, so neither event is dropped.
|
|
List<AlarmFeedMessage> received = [];
|
|
TaskCompletionSource baselineReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
using CancellationTokenSource streamCts = new();
|
|
Task reader = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
lock (received)
|
|
{
|
|
received.Add(message);
|
|
if (received.Count == 1)
|
|
{
|
|
baselineReceived.TrySetResult();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// Expected when the test cancels the stream.
|
|
}
|
|
});
|
|
|
|
await baselineReceived.Task.WaitAsync(WaitTimeout);
|
|
|
|
// alarmmgr (baseline) → subtag: must classify as a failover.
|
|
sessions.EmitEvent(new MxEvent
|
|
{
|
|
OnAlarmProviderModeChanged = new OnAlarmProviderModeChangedEvent
|
|
{
|
|
Mode = AlarmProviderMode.Subtag,
|
|
Reason = "alarmmgr failed",
|
|
At = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
|
|
},
|
|
});
|
|
await WaitUntilAsync(
|
|
() => { lock (capturedReasons) { return capturedReasons.Count >= 1; } },
|
|
WaitTimeout);
|
|
|
|
// subtag → alarmmgr: must classify as a failback.
|
|
sessions.EmitEvent(new MxEvent
|
|
{
|
|
OnAlarmProviderModeChanged = new OnAlarmProviderModeChangedEvent
|
|
{
|
|
Mode = AlarmProviderMode.Alarmmgr,
|
|
Reason = "alarmmgr recovered",
|
|
At = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
|
|
},
|
|
});
|
|
await WaitUntilAsync(
|
|
() => { lock (capturedReasons) { return capturedReasons.Count >= 2; } },
|
|
WaitTimeout);
|
|
|
|
lock (capturedReasons)
|
|
{
|
|
Assert.Equal(new[] { "failover", "failback" }, capturedReasons);
|
|
}
|
|
|
|
await streamCts.CancelAsync();
|
|
await reader;
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>A subscriber that joins the alarm feed receives the current provider status as its first message.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task NewSubscriber_ReceivesProviderStatusAsFirstMessage()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
FakeSessionManager sessions = new();
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
using CancellationTokenSource streamCts = new();
|
|
AlarmFeedMessage? first = null;
|
|
Task reader = Task.Run(async () =>
|
|
{
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
first = message;
|
|
break;
|
|
}
|
|
});
|
|
|
|
await WaitUntilAsync(() => first is not null, WaitTimeout);
|
|
|
|
Assert.NotNull(first);
|
|
Assert.Equal(AlarmFeedMessage.PayloadOneofCase.ProviderStatus, first!.PayloadCase);
|
|
// Baseline before any provider-mode event: alarm-manager, not degraded.
|
|
Assert.Equal(AlarmProviderMode.Alarmmgr, first.ProviderStatus.Mode);
|
|
Assert.False(first.ProviderStatus.Degraded);
|
|
|
|
await streamCts.CancelAsync();
|
|
await reader;
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>With the fallback mode forced to subtag, the initial provider status baselines to degraded subtag without recording a provider switch.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ForceSubtagConfig_BaselinesProviderStatusToSubtagDegraded_WithoutSwitch()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
long switchCount = 0;
|
|
int gaugeValue = -1;
|
|
using MeterListener listener = new();
|
|
listener.InstrumentPublished = (instrument, meterListener) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& (instrument.Name == "mxgateway.alarms.provider_switches"
|
|
|| instrument.Name == "mxgateway.alarms.provider_mode"))
|
|
{
|
|
meterListener.EnableMeasurementEvents(instrument);
|
|
}
|
|
};
|
|
listener.SetMeasurementEventCallback<long>(
|
|
(instrument, measurement, _, _) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_switches")
|
|
{
|
|
Interlocked.Add(ref switchCount, measurement);
|
|
}
|
|
});
|
|
listener.SetMeasurementEventCallback<int>(
|
|
(instrument, measurement, _, _) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_mode")
|
|
{
|
|
Interlocked.Exchange(ref gaugeValue, measurement);
|
|
}
|
|
});
|
|
listener.Start();
|
|
|
|
FakeSessionManager sessions = new();
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics, "ForceSubtag");
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
using CancellationTokenSource streamCts = new();
|
|
AlarmFeedMessage? first = null;
|
|
Task reader = Task.Run(async () =>
|
|
{
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
first = message;
|
|
break;
|
|
}
|
|
});
|
|
|
|
await WaitUntilAsync(() => first is not null, WaitTimeout);
|
|
|
|
Assert.NotNull(first);
|
|
Assert.Equal(AlarmFeedMessage.PayloadOneofCase.ProviderStatus, first!.PayloadCase);
|
|
Assert.Equal(AlarmProviderMode.Subtag, first.ProviderStatus.Mode);
|
|
Assert.True(first.ProviderStatus.Degraded);
|
|
|
|
// The observable gauge must read subtag (2) after start.
|
|
listener.RecordObservableInstruments();
|
|
Assert.Equal(2, Volatile.Read(ref gaugeValue));
|
|
|
|
// The initial set must not record a provider switch.
|
|
Assert.Equal(0, Interlocked.Read(ref switchCount));
|
|
|
|
await streamCts.CancelAsync();
|
|
await reader;
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>With the fallback mode forced to alarm manager, the initial provider status baselines to non-degraded alarmmgr without recording a provider switch.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ForceAlarmManagerConfig_BaselinesProviderStatusToAlarmmgr_WithoutSwitch()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
long switchCount = 0;
|
|
int gaugeValue = -1;
|
|
using MeterListener listener = new();
|
|
listener.InstrumentPublished = (instrument, meterListener) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& (instrument.Name == "mxgateway.alarms.provider_switches"
|
|
|| instrument.Name == "mxgateway.alarms.provider_mode"))
|
|
{
|
|
meterListener.EnableMeasurementEvents(instrument);
|
|
}
|
|
};
|
|
listener.SetMeasurementEventCallback<long>(
|
|
(instrument, measurement, _, _) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_switches")
|
|
{
|
|
Interlocked.Add(ref switchCount, measurement);
|
|
}
|
|
});
|
|
listener.SetMeasurementEventCallback<int>(
|
|
(instrument, measurement, _, _) =>
|
|
{
|
|
if (ReferenceEquals(instrument.Meter, metrics.Meter)
|
|
&& instrument.Name == "mxgateway.alarms.provider_mode")
|
|
{
|
|
Interlocked.Exchange(ref gaugeValue, measurement);
|
|
}
|
|
});
|
|
listener.Start();
|
|
|
|
FakeSessionManager sessions = new();
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics, "ForceAlarmManager");
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
using CancellationTokenSource streamCts = new();
|
|
AlarmFeedMessage? first = null;
|
|
Task reader = Task.Run(async () =>
|
|
{
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
first = message;
|
|
break;
|
|
}
|
|
});
|
|
|
|
await WaitUntilAsync(() => first is not null, WaitTimeout);
|
|
|
|
Assert.NotNull(first);
|
|
Assert.Equal(AlarmFeedMessage.PayloadOneofCase.ProviderStatus, first!.PayloadCase);
|
|
Assert.Equal(AlarmProviderMode.Alarmmgr, first.ProviderStatus.Mode);
|
|
Assert.False(first.ProviderStatus.Degraded);
|
|
|
|
listener.RecordObservableInstruments();
|
|
Assert.Equal(1, Volatile.Read(ref gaugeValue));
|
|
Assert.Equal(0, Interlocked.Read(ref switchCount));
|
|
|
|
await streamCts.CancelAsync();
|
|
await reader;
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>The monitor's SubscribeAlarms command carries the forced provider mode, failover settings, and watch list resolved from configuration.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SubscribeAlarms_SendsForcedModeAndWatchList_FromConfiguration()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
FakeSessionManager sessions = new();
|
|
StubWatchListResolver resolver = new(
|
|
[
|
|
new AlarmSubtagTarget { AlarmFullReference = "Galaxy!Area.Tank01.Hi", ActiveSubtag = "Tank01.Hi.active" },
|
|
]);
|
|
|
|
AlarmsOptions options = new()
|
|
{
|
|
Enabled = true,
|
|
SubscriptionExpression = @"\\NODE\Galaxy!Area",
|
|
Fallback = new AlarmFallbackOptions
|
|
{
|
|
Mode = "ForceSubtag",
|
|
ConsecutiveFailureThreshold = 7,
|
|
FailbackProbeIntervalSeconds = 11,
|
|
FailbackStableProbes = 4,
|
|
},
|
|
};
|
|
|
|
using GatewayAlarmMonitor monitor = new(
|
|
sessions,
|
|
resolver,
|
|
metrics,
|
|
Microsoft.Extensions.Options.Options.Create(new GatewayOptions { Alarms = options }),
|
|
NullLogger<GatewayAlarmMonitor>.Instance);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
SubscribeAlarmsCommand sent = Assert.IsType<SubscribeAlarmsCommand>(sessions.LastSubscribeCommand);
|
|
Assert.Equal(AlarmProviderMode.Subtag, sent.ForcedMode);
|
|
Assert.Equal(7, sent.Failover.ConsecutiveFailureThreshold);
|
|
Assert.Equal(11, sent.Failover.FailbackProbeIntervalSeconds);
|
|
Assert.Equal(4, sent.Failover.FailbackStableProbes);
|
|
AlarmSubtagTarget target = Assert.Single(sent.WatchList);
|
|
Assert.Equal("Galaxy!Area.Tank01.Hi", target.AlarmFullReference);
|
|
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>The configured fallback mode string maps to the expected <see cref="AlarmProviderMode"/> sent in the SubscribeAlarms command.</summary>
|
|
/// <param name="mode">The configured fallback mode string.</param>
|
|
/// <param name="expected">The expected forced <see cref="AlarmProviderMode"/>.</param>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Theory]
|
|
[InlineData("ForceAlarmManager", AlarmProviderMode.Alarmmgr)]
|
|
[InlineData("forcealarmmanager", AlarmProviderMode.Alarmmgr)]
|
|
[InlineData("ForceSubtag", AlarmProviderMode.Subtag)]
|
|
[InlineData("forcesubtag", AlarmProviderMode.Subtag)]
|
|
[InlineData("Auto", AlarmProviderMode.Unspecified)]
|
|
[InlineData("", AlarmProviderMode.Unspecified)]
|
|
[InlineData("nonsense", AlarmProviderMode.Unspecified)]
|
|
public async Task ModeString_MapsToForcedProviderMode(string mode, AlarmProviderMode expected)
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
FakeSessionManager sessions = new();
|
|
|
|
AlarmsOptions options = new()
|
|
{
|
|
Enabled = true,
|
|
SubscriptionExpression = @"\\NODE\Galaxy!Area",
|
|
Fallback = new AlarmFallbackOptions { Mode = mode },
|
|
};
|
|
|
|
using GatewayAlarmMonitor monitor = new(
|
|
sessions,
|
|
new StubWatchListResolver([]),
|
|
metrics,
|
|
Microsoft.Extensions.Options.Options.Create(new GatewayOptions { Alarms = options }),
|
|
NullLogger<GatewayAlarmMonitor>.Instance);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
Assert.Equal(expected, sessions.LastSubscribeCommand!.ForcedMode);
|
|
// Auto + empty watch-list preserves historical alarmmgr-only behaviour.
|
|
if (expected == AlarmProviderMode.Unspecified)
|
|
{
|
|
Assert.Empty(sessions.LastSubscribeCommand!.WatchList);
|
|
}
|
|
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A Galaxy Repository outage at startup used to leave one <c>LogWarning</c> and an
|
|
/// empty subtag watch-list that stayed empty for the monitor's whole life — invisible until
|
|
/// a failover found the standby covering nothing. The condition is now a standing verdict
|
|
/// on the provider status, so it reaches the alarm feed, the dashboard badge and every
|
|
/// late-joining subscriber. The mode stays <c>ALARMMGR</c>: the live provider is healthy,
|
|
/// it is the standby behind it that is unsound.
|
|
/// </summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SubtagCoverage_WhenDiscoveryFailsAtSubscribe_ProviderStatusIsDegradedWithReason()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
FakeSessionManager sessions = new();
|
|
ScriptedWatchListResolver resolver = new(DiscoveryFailedResolution());
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics, resolver);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
// The empty list still went to the worker — the verdict is a report, not a behaviour change.
|
|
Assert.Empty(sessions.LastSubscribeCommand!.WatchList);
|
|
Assert.True(sessions.LastSubscribeCommand.FallbackEnabled);
|
|
|
|
AlarmProviderStatus status = await ReadFirstProviderStatusAsync(monitor);
|
|
|
|
Assert.Equal(AlarmProviderMode.Alarmmgr, status.Mode);
|
|
Assert.True(status.Degraded);
|
|
Assert.Contains(AlarmProviderReasons.SubtagWatchListEmpty, status.Reason, StringComparison.Ordinal);
|
|
Assert.Contains(AlarmProviderReasons.SubtagDiscoveryFailed, status.Reason, StringComparison.Ordinal);
|
|
Assert.Contains("gr offline", status.Reason, StringComparison.Ordinal);
|
|
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The failover edge is the moment the watch-list stops being theoretical, so the
|
|
/// monitor re-resolves it there, hot-swaps the recovered list through
|
|
/// <c>UpdateAlarmWatchList</c>, and publishes the acknowledged verdict on the same status
|
|
/// frame the failover produces. The update must precede the status frame so the frame never
|
|
/// claims recovered coverage before the worker has accepted it.
|
|
/// </summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SubtagCoverage_WhenDiscoveryRecoversByFailover_UpdatesWorkerBeforePublishingStatus()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
FakeSessionManager sessions = new();
|
|
ScriptedWatchListResolver resolver = new(
|
|
DiscoveryFailedResolution(),
|
|
new AlarmWatchListResolution(
|
|
[Target("Galaxy!Area.Tank01.Level.HiHi"), Target("Galaxy!Area.Tank02.Level.HiHi")],
|
|
DiscoveryAttempted: true,
|
|
DiscoveryFailed: false,
|
|
DiscoveryFailureMessage: null));
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics, resolver);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
Assert.Equal(1, resolver.Calls);
|
|
|
|
List<AlarmFeedMessage> received = [];
|
|
TaskCompletionSource baselineReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
using CancellationTokenSource streamCts = new();
|
|
Task reader = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
lock (received)
|
|
{
|
|
received.Add(message);
|
|
if (received.Count == 1)
|
|
{
|
|
baselineReceived.TrySetResult();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// Expected when the test cancels the stream.
|
|
}
|
|
});
|
|
|
|
await baselineReceived.Task.WaitAsync(WaitTimeout);
|
|
|
|
sessions.EmitEvent(new MxEvent
|
|
{
|
|
OnAlarmProviderModeChanged = new OnAlarmProviderModeChangedEvent
|
|
{
|
|
Mode = AlarmProviderMode.Subtag,
|
|
Reason = "alarmmgr failed",
|
|
At = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
|
|
},
|
|
});
|
|
|
|
AlarmFeedMessage degraded = await WaitForAsync(
|
|
received,
|
|
m => m.PayloadCase == AlarmFeedMessage.PayloadOneofCase.ProviderStatus
|
|
&& m.ProviderStatus.Mode == AlarmProviderMode.Subtag,
|
|
WaitTimeout);
|
|
|
|
// The re-resolve happened on the failover edge, before the status was published.
|
|
Assert.Equal(2, resolver.Calls);
|
|
|
|
Assert.Single(sessions.UpdateCommands);
|
|
Assert.Equal(2, sessions.UpdateCommands[0].WatchList.Count);
|
|
string reason = degraded.ProviderStatus.Reason;
|
|
Assert.Contains("alarmmgr failed", reason, StringComparison.Ordinal);
|
|
Assert.DoesNotContain(AlarmProviderReasons.SubtagWatchListStale, reason, StringComparison.Ordinal);
|
|
Assert.DoesNotContain(AlarmProviderReasons.SubtagWatchListEmpty, reason, StringComparison.Ordinal);
|
|
Assert.DoesNotContain(AlarmProviderReasons.SubtagDiscoveryFailed, reason, StringComparison.Ordinal);
|
|
|
|
await streamCts.CancelAsync();
|
|
await reader;
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>Periodic reconciliation applies a recovered watch list once and suppresses an unchanged resolution on the next cadence.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task WatchListRefresh_PeriodicRecovery_SendsExactlyOneMaterialUpdate()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
FakeSessionManager sessions = new();
|
|
AlarmWatchListResolution recovered = new(
|
|
[Target("Galaxy!Area.Tank01.Level.HiHi")],
|
|
DiscoveryAttempted: true,
|
|
DiscoveryFailed: false,
|
|
DiscoveryFailureMessage: null);
|
|
ScriptedWatchListResolver resolver = new(DiscoveryFailedResolution(), recovered, recovered);
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics, resolver, reconcileIntervalSeconds: 5);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForUpdateCountAsync(1, WaitTimeout);
|
|
await WaitUntilAsync(() => resolver.Calls >= 3, WaitTimeout);
|
|
|
|
Assert.Single(sessions.UpdateCommands);
|
|
Assert.Single(sessions.UpdateCommands[0].WatchList);
|
|
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>A rejected refresh keeps the old fingerprint and degraded verdict so the same material change is retried.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task WatchListRefresh_WorkerRejects_RetainsFingerprintAndRetriesSameTargets()
|
|
{
|
|
using GatewayMetrics metrics = new();
|
|
FakeSessionManager sessions = new();
|
|
sessions.UpdateReplyCodes.Enqueue(ProtocolStatusCode.MxaccessFailure);
|
|
sessions.UpdateReplyCodes.Enqueue(ProtocolStatusCode.Ok);
|
|
AlarmWatchListResolution recovered = new(
|
|
[Target("Galaxy!Area.Tank01.Level.HiHi")],
|
|
DiscoveryAttempted: true,
|
|
DiscoveryFailed: false,
|
|
DiscoveryFailureMessage: null);
|
|
ScriptedWatchListResolver resolver = new(DiscoveryFailedResolution(), recovered, recovered);
|
|
using GatewayAlarmMonitor monitor = CreateMonitor(sessions, metrics, resolver);
|
|
|
|
using CancellationTokenSource cts = new();
|
|
await monitor.StartAsync(cts.Token);
|
|
await sessions.WaitForSubscribeAsync(WaitTimeout);
|
|
|
|
sessions.EmitModeChange(AlarmProviderMode.Subtag, "alarmmgr failed");
|
|
await sessions.WaitForUpdateCountAsync(1, WaitTimeout);
|
|
AlarmProviderStatus rejected = await ReadFirstProviderStatusAsync(monitor);
|
|
Assert.True(rejected.Degraded);
|
|
Assert.Contains(AlarmProviderReasons.SubtagWatchListStale, rejected.Reason, StringComparison.Ordinal);
|
|
|
|
sessions.EmitModeChange(AlarmProviderMode.Subtag, "alarmmgr still failed");
|
|
await sessions.WaitForUpdateCountAsync(2, WaitTimeout);
|
|
|
|
Assert.Equal(
|
|
sessions.UpdateCommands[0].WatchList[0].AlarmFullReference,
|
|
sessions.UpdateCommands[1].WatchList[0].AlarmFullReference);
|
|
|
|
await cts.CancelAsync();
|
|
await monitor.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
/// <summary>Reads the provider-status frame every stream opens with, then closes the stream.</summary>
|
|
/// <param name="monitor">The monitor to read from.</param>
|
|
/// <returns>The provider status carried by the first frame.</returns>
|
|
private static async Task<AlarmProviderStatus> ReadFirstProviderStatusAsync(GatewayAlarmMonitor monitor)
|
|
{
|
|
using CancellationTokenSource streamCts = new(WaitTimeout);
|
|
await foreach (AlarmFeedMessage message in monitor.StreamAsync(null, streamCts.Token))
|
|
{
|
|
if (message.PayloadCase == AlarmFeedMessage.PayloadOneofCase.ProviderStatus)
|
|
{
|
|
return message.ProviderStatus;
|
|
}
|
|
}
|
|
|
|
throw new TimeoutException("No provider-status message was received in time.");
|
|
}
|
|
|
|
/// <summary>A resolution standing for "Galaxy Repository discovery was on and it failed".</summary>
|
|
/// <returns>The resolution.</returns>
|
|
private static AlarmWatchListResolution DiscoveryFailedResolution() => new(
|
|
[],
|
|
DiscoveryAttempted: true,
|
|
DiscoveryFailed: true,
|
|
DiscoveryFailureMessage: "gr offline");
|
|
|
|
private static AlarmSubtagTarget Target(string fullReference) => new()
|
|
{
|
|
AlarmFullReference = fullReference,
|
|
SourceObjectReference = fullReference,
|
|
ActiveSubtag = $"{fullReference}.InAlarm",
|
|
AckedSubtag = $"{fullReference}.Acked",
|
|
};
|
|
|
|
private static GatewayAlarmMonitor CreateMonitor(
|
|
FakeSessionManager sessions,
|
|
GatewayMetrics metrics,
|
|
IAlarmWatchListResolver resolver,
|
|
int reconcileIntervalSeconds = 30)
|
|
{
|
|
AlarmsOptions options = new()
|
|
{
|
|
Enabled = true,
|
|
SubscriptionExpression = @"\\NODE\Galaxy!Area",
|
|
ReconcileIntervalSeconds = reconcileIntervalSeconds,
|
|
};
|
|
return new GatewayAlarmMonitor(
|
|
sessions,
|
|
resolver,
|
|
metrics,
|
|
Microsoft.Extensions.Options.Options.Create(new GatewayOptions { Alarms = options }),
|
|
NullLogger<GatewayAlarmMonitor>.Instance);
|
|
}
|
|
|
|
private static GatewayAlarmMonitor CreateMonitor(FakeSessionManager sessions, GatewayMetrics metrics)
|
|
{
|
|
AlarmsOptions options = new()
|
|
{
|
|
Enabled = true,
|
|
SubscriptionExpression = @"\\NODE\Galaxy!Area",
|
|
};
|
|
return new GatewayAlarmMonitor(
|
|
sessions,
|
|
new StubWatchListResolver([]),
|
|
metrics,
|
|
Microsoft.Extensions.Options.Options.Create(new GatewayOptions { Alarms = options }),
|
|
NullLogger<GatewayAlarmMonitor>.Instance);
|
|
}
|
|
|
|
private static GatewayAlarmMonitor CreateMonitor(FakeSessionManager sessions, GatewayMetrics metrics, string mode)
|
|
{
|
|
AlarmsOptions options = new()
|
|
{
|
|
Enabled = true,
|
|
SubscriptionExpression = @"\\NODE\Galaxy!Area",
|
|
Fallback = new AlarmFallbackOptions { Mode = mode },
|
|
};
|
|
return new GatewayAlarmMonitor(
|
|
sessions,
|
|
new StubWatchListResolver([]),
|
|
metrics,
|
|
Microsoft.Extensions.Options.Options.Create(new GatewayOptions { Alarms = options }),
|
|
NullLogger<GatewayAlarmMonitor>.Instance);
|
|
}
|
|
|
|
private static async Task<AlarmFeedMessage> WaitForAsync(
|
|
List<AlarmFeedMessage> received,
|
|
Func<AlarmFeedMessage, bool> predicate,
|
|
TimeSpan timeout)
|
|
{
|
|
DateTime deadline = DateTime.UtcNow + timeout;
|
|
while (DateTime.UtcNow < deadline)
|
|
{
|
|
lock (received)
|
|
{
|
|
AlarmFeedMessage? match = received.FirstOrDefault(predicate);
|
|
if (match is not null)
|
|
{
|
|
return match;
|
|
}
|
|
}
|
|
|
|
await Task.Delay(25);
|
|
}
|
|
|
|
throw new TimeoutException("No matching AlarmFeedMessage was received in time.");
|
|
}
|
|
|
|
private static async Task WaitUntilAsync(Func<bool> condition, TimeSpan timeout)
|
|
{
|
|
DateTime deadline = DateTime.UtcNow + timeout;
|
|
while (DateTime.UtcNow < deadline)
|
|
{
|
|
if (condition())
|
|
{
|
|
return;
|
|
}
|
|
|
|
await Task.Delay(25);
|
|
}
|
|
|
|
throw new TimeoutException("Condition was not met in time.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// <see cref="IAlarmWatchListResolver"/> that hands out a scripted sequence of
|
|
/// resolutions — one per call, the last repeating — and counts the calls, so a test can
|
|
/// drive "discovery was down at subscribe and back up by the failover" and assert that the
|
|
/// second resolution happened at all.
|
|
/// </summary>
|
|
/// <param name="script">Resolutions to return, in call order.</param>
|
|
private sealed class ScriptedWatchListResolver(params AlarmWatchListResolution[] script) : IAlarmWatchListResolver
|
|
{
|
|
private int _calls;
|
|
|
|
/// <summary>Gets the number of times <see cref="ResolveAsync"/> has been called.</summary>
|
|
public int Calls => Volatile.Read(ref _calls);
|
|
|
|
/// <inheritdoc />
|
|
public Task<AlarmWatchListResolution> ResolveAsync(
|
|
AlarmsOptions options,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
int index = Interlocked.Increment(ref _calls) - 1;
|
|
return Task.FromResult(script[Math.Min(index, script.Length - 1)]);
|
|
}
|
|
}
|
|
|
|
/// <summary><see cref="IAlarmWatchListResolver"/> that returns a fixed watch-list.</summary>
|
|
private sealed class StubWatchListResolver(IReadOnlyList<AlarmSubtagTarget> targets) : IAlarmWatchListResolver
|
|
{
|
|
/// <inheritdoc />
|
|
public Task<AlarmWatchListResolution> ResolveAsync(
|
|
AlarmsOptions options,
|
|
CancellationToken cancellationToken = default) =>
|
|
Task.FromResult(new AlarmWatchListResolution(
|
|
targets,
|
|
DiscoveryAttempted: false,
|
|
DiscoveryFailed: false,
|
|
DiscoveryFailureMessage: null));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Minimal <see cref="ISessionManager"/> for driving the monitor: opens a
|
|
/// constructed session, records the SubscribeAlarms command, replies OK to
|
|
/// every command, and exposes a channel for pushing worker events.
|
|
/// </summary>
|
|
private sealed class FakeSessionManager : ISessionManager
|
|
{
|
|
private readonly Channel<WorkerEvent> _events = Channel.CreateUnbounded<WorkerEvent>();
|
|
private readonly TaskCompletionSource _subscribed =
|
|
new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
/// <summary>The most recent SubscribeAlarms command the monitor sent.</summary>
|
|
public SubscribeAlarmsCommand? LastSubscribeCommand { get; private set; }
|
|
|
|
/// <summary>Gets each live replacement command in invocation order.</summary>
|
|
public List<UpdateAlarmWatchListCommand> UpdateCommands { get; } = [];
|
|
|
|
/// <summary>Scripted protocol statuses for replacement commands.</summary>
|
|
public Queue<ProtocolStatusCode> UpdateReplyCodes { get; } = new();
|
|
|
|
/// <summary>Pushes a worker event onto the monitor's event stream.</summary>
|
|
/// <param name="mxEvent">The worker event to push.</param>
|
|
public void EmitEvent(MxEvent mxEvent) =>
|
|
_events.Writer.TryWrite(new WorkerEvent { Event = mxEvent });
|
|
|
|
/// <summary>Pushes a provider-mode change onto the worker event stream.</summary>
|
|
/// <param name="mode">The provider mode being reported.</param>
|
|
/// <param name="reason">The reason for the mode change.</param>
|
|
public void EmitModeChange(AlarmProviderMode mode, string reason) => EmitEvent(new MxEvent
|
|
{
|
|
OnAlarmProviderModeChanged = new OnAlarmProviderModeChangedEvent
|
|
{
|
|
Mode = mode,
|
|
Reason = reason,
|
|
At = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
|
|
},
|
|
});
|
|
|
|
/// <summary>Waits until at least the requested number of update commands have arrived.</summary>
|
|
/// <param name="count">The minimum number of update commands to wait for.</param>
|
|
/// <param name="timeout">The maximum time to wait.</param>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
public async Task WaitForUpdateCountAsync(int count, TimeSpan timeout)
|
|
{
|
|
await WaitUntilAsync(() => UpdateCommands.Count >= count, timeout);
|
|
}
|
|
|
|
/// <summary>Completes once the monitor has issued its SubscribeAlarms command.</summary>
|
|
/// <param name="timeout">The maximum time to wait.</param>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
public Task WaitForSubscribeAsync(TimeSpan timeout) => _subscribed.Task.WaitAsync(timeout);
|
|
|
|
/// <inheritdoc />
|
|
public Task<GatewaySession> OpenSessionAsync(
|
|
SessionOpenRequest request,
|
|
string? clientIdentity,
|
|
string? ownerKeyId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
// The monitor attaches its internal subscriber directly on this session, so the
|
|
// session has to be a genuinely Ready one with a worker client feeding the
|
|
// distributor pump — EmitEvent writes into that worker's event stream.
|
|
GatewaySession session = new(
|
|
Guid.NewGuid().ToString("N"),
|
|
"Galaxy",
|
|
"pipe-test",
|
|
"nonce-test",
|
|
clientIdentity,
|
|
null,
|
|
null,
|
|
TimeSpan.FromSeconds(30),
|
|
TimeSpan.FromSeconds(30),
|
|
TimeSpan.FromSeconds(30),
|
|
DateTimeOffset.UtcNow);
|
|
session.AttachWorkerClient(new ChannelWorkerClient(session.SessionId, _events.Reader));
|
|
session.MarkReady();
|
|
return Task.FromResult(session);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task<WorkerCommandReply> InvokeAsync(
|
|
string sessionId,
|
|
WorkerCommand command,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (command.Command?.Kind == MxCommandKind.SubscribeAlarms)
|
|
{
|
|
LastSubscribeCommand = command.Command.SubscribeAlarms;
|
|
_subscribed.TrySetResult();
|
|
}
|
|
|
|
if (command.Command?.Kind == MxCommandKind.UpdateAlarmWatchList)
|
|
{
|
|
UpdateCommands.Add(command.Command.UpdateAlarmWatchList.Clone());
|
|
}
|
|
|
|
MxCommandReply reply = new()
|
|
{
|
|
ProtocolStatus = new ProtocolStatus
|
|
{
|
|
Code = command.Command?.Kind == MxCommandKind.UpdateAlarmWatchList
|
|
&& UpdateReplyCodes.TryDequeue(out ProtocolStatusCode updateCode)
|
|
? updateCode
|
|
: ProtocolStatusCode.Ok,
|
|
},
|
|
};
|
|
if (command.Command?.Kind == MxCommandKind.QueryActiveAlarms)
|
|
{
|
|
reply.QueryActiveAlarms = new QueryActiveAlarmsReplyPayload();
|
|
}
|
|
|
|
return Task.FromResult(new WorkerCommandReply { Reply = reply });
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool TryGetSession(string sessionId, [MaybeNullWhen(false)] out GatewaySession session)
|
|
{
|
|
session = null;
|
|
return false;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task<SessionCloseResult> CloseSessionAsync(string sessionId, CancellationToken cancellationToken)
|
|
{
|
|
_events.Writer.TryComplete();
|
|
return Task.FromResult(new SessionCloseResult(sessionId, SessionState.Closed, AlreadyClosed: false));
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task<SessionCloseResult> KillWorkerAsync(string sessionId, string reason, CancellationToken cancellationToken) =>
|
|
Task.FromResult(new SessionCloseResult(sessionId, SessionState.Closed, AlreadyClosed: false));
|
|
|
|
/// <inheritdoc />
|
|
public Task<int> CloseExpiredLeasesAsync(DateTimeOffset now, CancellationToken cancellationToken) =>
|
|
Task.FromResult(0);
|
|
|
|
/// <inheritdoc />
|
|
public Task ShutdownAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
|
}
|
|
}
|