Joseph Doherty
314 lines
16 KiB
C#
314 lines
16 KiB
C#
using Akka.Actor;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
|
|
using ZB.MOM.WW.OtOpcUa.Commons.Types;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
|
using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
|
|
using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Drivers;
|
|
|
|
/// <summary>
|
|
/// Covers WS-4b: <see cref="DriverInstanceActor"/> subscribes a driver's native
|
|
/// <see cref="IAlarmSource.OnAlarmEvent"/> (when the driver is an <see cref="IAlarmSource"/>)
|
|
/// and forwards every transition to its parent as
|
|
/// <see cref="DriverInstanceActor.AttributeAlarmPublished"/> — mirroring the OnDataChange →
|
|
/// <see cref="DriverInstanceActor.AttributeValuePublished"/> forward. The driver fires
|
|
/// <c>OnAlarmEvent</c> on its OWN thread; the actor marshals it onto the actor thread via Self.
|
|
/// </summary>
|
|
public sealed class DriverInstanceActorNativeAlarmTests : RuntimeActorTestBase
|
|
{
|
|
/// <summary>
|
|
/// Driving an <see cref="IAlarmSource"/> driver to Connected then raising a native alarm forwards
|
|
/// it to the parent as <see cref="DriverInstanceActor.AttributeAlarmPublished"/> carrying the
|
|
/// driver-instance id + the original <see cref="AlarmEventArgs"/> (SourceNodeId preserved).
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task Native_alarm_is_forwarded_to_parent_as_AttributeAlarmPublished()
|
|
{
|
|
var driver = new AlarmSourceStubDriver();
|
|
var parent = CreateTestProbe();
|
|
var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver));
|
|
|
|
actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
|
|
AwaitCondition(() => driver.InitializeCount > 0, TimeSpan.FromSeconds(2));
|
|
// The alarm handler is attached after Become(Connected); wait for it to be wired before raising.
|
|
AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(2));
|
|
// Also establish a data-change subscription so the OnDataChange path is wired (the alarm attach is
|
|
// independent of Subscribe — this proves both event paths coexist on one driver).
|
|
await actor.Ask<DriverInstanceActor.SubscriptionEstablished>(
|
|
new DriverInstanceActor.Subscribe(new[] { "tag-z" }, TimeSpan.FromMilliseconds(100)),
|
|
TimeSpan.FromSeconds(3));
|
|
|
|
driver.RaiseAlarm(new AlarmEventArgs(
|
|
new StubAlarmHandle(),
|
|
SourceNodeId: "src-node-7",
|
|
ConditionId: "cond-1",
|
|
AlarmType: "AnalogLimitAlarm.HiHi",
|
|
Message: "level too high",
|
|
Severity: AlarmSeverity.High,
|
|
SourceTimestampUtc: DateTime.UtcNow,
|
|
Kind: AlarmTransitionKind.Raise));
|
|
|
|
var published = parent.ExpectMsg<DriverInstanceActor.AttributeAlarmPublished>(TimeSpan.FromSeconds(2));
|
|
published.DriverInstanceId.ShouldBe(driver.DriverInstanceId);
|
|
published.Args.SourceNodeId.ShouldBe("src-node-7");
|
|
published.Args.ConditionId.ShouldBe("cond-1");
|
|
published.Args.Kind.ShouldBe(AlarmTransitionKind.Raise);
|
|
|
|
// The same driver's OnDataChange still flows independently — alarm + value events coexist.
|
|
driver.FireDataChange("tag-z", value: 9.0, statusCode: 0u);
|
|
parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(2))
|
|
.FullReference.ShouldBe("tag-z");
|
|
}
|
|
|
|
/// <summary>
|
|
/// A driver that is NOT an <see cref="IAlarmSource"/> (only <see cref="ISubscribable"/>) connects
|
|
/// and serves data changes normally — <c>AttachAlarmSource</c> is a safe no-op (no crash) and no
|
|
/// <see cref="DriverInstanceActor.AttributeAlarmPublished"/> is ever produced.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task Non_alarm_source_driver_serves_data_changes_and_never_publishes_alarms()
|
|
{
|
|
var driver = new SubscribableOnlyStubDriver();
|
|
var parent = CreateTestProbe();
|
|
var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver));
|
|
|
|
actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
|
|
AwaitCondition(() => driver.InitializeCount > 0, TimeSpan.FromSeconds(2));
|
|
|
|
await actor.Ask<DriverInstanceActor.SubscriptionEstablished>(
|
|
new DriverInstanceActor.Subscribe(new[] { "tag-a" }, TimeSpan.FromMilliseconds(100)),
|
|
TimeSpan.FromSeconds(3));
|
|
|
|
driver.FireDataChange("tag-a", value: 1.5, statusCode: 0u);
|
|
|
|
// Data-change forwarding still works (no crash on AttachAlarmSource for a non-IAlarmSource driver).
|
|
var dc = parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(2));
|
|
dc.FullReference.ShouldBe("tag-a");
|
|
// An AttributeAlarmPublished can never be produced for a non-IAlarmSource driver.
|
|
parent.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
|
|
}
|
|
|
|
/// <summary>
|
|
/// A native alarm transition that races in while the actor is in <c>Reconnecting</c> is silently
|
|
/// dropped (debug log only) — it NEVER reaches the parent as
|
|
/// <see cref="DriverInstanceActor.AttributeAlarmPublished"/> and does NOT dead-letter. The feed
|
|
/// re-delivers active alarms once the actor re-enters <c>Connected</c>, so dropping here is safe.
|
|
/// (<see cref="DriverInstanceActor"/> line ~345: the <c>Reconnecting</c> state's
|
|
/// <c>Receive<NativeAlarmRaised></c> logs a debug message and discards.)
|
|
///
|
|
/// <para>
|
|
/// To reproduce the race deterministically: a <c>ForceReconnect</c> is enqueued first, then
|
|
/// the driver fires an alarm while its <c>OnAlarmEvent</c> handler is still attached (the actor
|
|
/// hasn't yet processed <c>ForceReconnect</c>). The handler's <c>self.Tell(NativeAlarmRaised)</c>
|
|
/// lands second in the mailbox. The actor then processes <c>ForceReconnect</c> → Reconnecting
|
|
/// (detaches handler), then processes the queued <c>NativeAlarmRaised</c> in Reconnecting
|
|
/// → drops it. The default 10 s reconnect interval ensures no retry fires during the check.
|
|
/// </para>
|
|
/// </summary>
|
|
[Fact]
|
|
public void Native_alarm_during_reconnect_is_dropped_not_forwarded()
|
|
{
|
|
// Long reconnect interval (default 10 s) so the retry doesn't fire during the assertion window.
|
|
var driver = new AlarmSourceStubDriver();
|
|
var parent = CreateTestProbe();
|
|
var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver));
|
|
|
|
// Drive to Connected; confirm the alarm handler is attached.
|
|
actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
|
|
AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(2));
|
|
|
|
// Enqueue ForceReconnect FIRST — the actor hasn't processed it yet, so the handler is
|
|
// still wired. The test thread then immediately fires the alarm on the driver; the handler's
|
|
// self.Tell(NativeAlarmRaised) lands SECOND in the mailbox.
|
|
actor.Tell(new DriverInstanceActor.ForceReconnect());
|
|
driver.RaiseAlarm(new AlarmEventArgs(
|
|
new StubAlarmHandle(),
|
|
SourceNodeId: "src-node-reconnect",
|
|
ConditionId: "cond-reconnect",
|
|
AlarmType: "T",
|
|
Message: "during-reconnect raise",
|
|
Severity: AlarmSeverity.High,
|
|
SourceTimestampUtc: DateTime.UtcNow,
|
|
Kind: AlarmTransitionKind.Raise));
|
|
|
|
// The actor processes: (1) ForceReconnect → Reconnecting (handler detached);
|
|
// (2) NativeAlarmRaised → dropped (debug log, no forward).
|
|
// The parent must NOT receive AttributeAlarmPublished from that alarm.
|
|
// Wait generously — the default reconnect interval of 10 s means no retry fires here.
|
|
parent.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
|
|
// The actor must still be alive — Watch + no Terminated (not crashed or dead-lettered).
|
|
Watch(actor);
|
|
parent.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
|
|
}
|
|
|
|
/// <summary>
|
|
/// After a full reconnect cycle (Connected → Reconnecting → Connected), a single raised alarm still
|
|
/// yields EXACTLY ONE <see cref="DriverInstanceActor.AttributeAlarmPublished"/> — the
|
|
/// <c>_alarmEventHandler is not null</c> guard in <c>AttachAlarmSource</c> plus the detach on the
|
|
/// Connected → Reconnecting transition prevent a double-attach (which would publish twice).
|
|
/// </summary>
|
|
[Fact]
|
|
public void Reconnect_does_not_double_attach_alarm_handler()
|
|
{
|
|
var driver = new AlarmSourceStubDriver();
|
|
var parent = CreateTestProbe();
|
|
var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver, reconnectInterval: TimeSpan.FromMilliseconds(50)));
|
|
|
|
actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
|
|
AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(2));
|
|
|
|
// Force Connected → Reconnecting (detaches) → Connected (re-attaches). InitializeCount climbs on
|
|
// the retry; the alarm handler count must settle back to exactly one (no leaked extra handler).
|
|
var initBefore = driver.InitializeCount;
|
|
actor.Tell(new DriverInstanceActor.DisconnectObserved("backend blip"));
|
|
AwaitCondition(() => driver.InitializeCount > initBefore, TimeSpan.FromSeconds(3));
|
|
AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(3));
|
|
|
|
driver.RaiseAlarm(new AlarmEventArgs(
|
|
new StubAlarmHandle(),
|
|
SourceNodeId: "src-node-1",
|
|
ConditionId: "cond-x",
|
|
AlarmType: "T",
|
|
Message: "m",
|
|
Severity: AlarmSeverity.Low,
|
|
SourceTimestampUtc: DateTime.UtcNow,
|
|
Kind: AlarmTransitionKind.Raise));
|
|
|
|
// Exactly one forward — a double-attach would surface as a second AttributeAlarmPublished.
|
|
parent.ExpectMsg<DriverInstanceActor.AttributeAlarmPublished>(TimeSpan.FromSeconds(2))
|
|
.Args.SourceNodeId.ShouldBe("src-node-1");
|
|
parent.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
|
|
}
|
|
|
|
// --- stub drivers ----------------------------------------------------------------------------
|
|
|
|
private class StubDriver : IDriver
|
|
{
|
|
/// <summary>Gets the number of times initialization was called.</summary>
|
|
public int InitializeCount;
|
|
|
|
/// <summary>Gets the driver instance ID.</summary>
|
|
public string DriverInstanceId => "alarm-stub-driver-1";
|
|
/// <summary>Gets the driver type.</summary>
|
|
public string DriverType => "Stub";
|
|
|
|
/// <summary>Initializes the driver.</summary>
|
|
public Task InitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
|
|
{
|
|
Interlocked.Increment(ref InitializeCount);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
/// <summary>Reinitializes the driver.</summary>
|
|
public Task ReinitializeAsync(string driverConfigJson, CancellationToken cancellationToken) =>
|
|
Task.CompletedTask;
|
|
|
|
/// <summary>Shuts down the driver.</summary>
|
|
public Task ShutdownAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
|
/// <summary>Gets the health status of the driver.</summary>
|
|
public DriverHealth GetHealth() => new(DriverState.Healthy, DateTime.UtcNow, null);
|
|
/// <summary>Gets the memory footprint of the driver.</summary>
|
|
public long GetMemoryFootprint() => 0;
|
|
/// <summary>Flushes optional caches in the driver.</summary>
|
|
public Task FlushOptionalCachesAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
|
}
|
|
|
|
/// <summary>A driver that implements <see cref="ISubscribable"/> + <see cref="IAlarmSource"/> and lets the
|
|
/// test raise <see cref="IAlarmSource.OnAlarmEvent"/> on demand (the driver fires it on its own thread in
|
|
/// production; here the test thread stands in for that).</summary>
|
|
private sealed class AlarmSourceStubDriver : StubDriver, ISubscribable, IAlarmSource
|
|
{
|
|
private readonly StubHandle _subHandle = new();
|
|
|
|
/// <summary>Occurs when data changes.</summary>
|
|
public event EventHandler<DataChangeEventArgs>? OnDataChange;
|
|
/// <summary>Server-pushed alarm transition.</summary>
|
|
public event EventHandler<AlarmEventArgs>? OnAlarmEvent;
|
|
|
|
/// <summary>Number of live subscribers on <see cref="OnAlarmEvent"/> — proves attach/detach.</summary>
|
|
public int AlarmSubscriberCount => OnAlarmEvent?.GetInvocationList().Length ?? 0;
|
|
|
|
/// <summary>Subscribes to the specified full references.</summary>
|
|
public Task<ISubscriptionHandle> SubscribeAsync(
|
|
IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken) =>
|
|
Task.FromResult<ISubscriptionHandle>(_subHandle);
|
|
|
|
/// <summary>Unsubscribes from the specified subscription handle.</summary>
|
|
public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken) =>
|
|
Task.CompletedTask;
|
|
|
|
/// <summary>Subscribes to alarm events for the specified node set.</summary>
|
|
public Task<IAlarmSubscriptionHandle> SubscribeAlarmsAsync(
|
|
IReadOnlyList<string> sourceNodeIds, CancellationToken cancellationToken) =>
|
|
Task.FromResult<IAlarmSubscriptionHandle>(new StubAlarmHandle());
|
|
|
|
/// <summary>Cancels an alarm subscription.</summary>
|
|
public Task UnsubscribeAlarmsAsync(IAlarmSubscriptionHandle handle, CancellationToken cancellationToken) =>
|
|
Task.CompletedTask;
|
|
|
|
/// <summary>Acknowledges a batch of alarms.</summary>
|
|
public Task AcknowledgeAsync(
|
|
IReadOnlyList<AlarmAcknowledgeRequest> acknowledgements, CancellationToken cancellationToken) =>
|
|
Task.CompletedTask;
|
|
|
|
/// <summary>Fires <see cref="OnAlarmEvent"/> — stands in for the driver's native feed.</summary>
|
|
public void RaiseAlarm(AlarmEventArgs args) => OnAlarmEvent?.Invoke(this, args);
|
|
|
|
/// <summary>Fires a data change event (keeps OnDataChange exercised; the actor wires both events).</summary>
|
|
public void FireDataChange(string fullRef, object? value, uint statusCode)
|
|
{
|
|
var snapshot = new DataValueSnapshot(value, statusCode, DateTime.UtcNow, DateTime.UtcNow);
|
|
OnDataChange?.Invoke(this, new DataChangeEventArgs(_subHandle, fullRef, snapshot));
|
|
}
|
|
|
|
private sealed class StubHandle : ISubscriptionHandle
|
|
{
|
|
/// <summary>Gets the diagnostic ID of the subscription.</summary>
|
|
public string DiagnosticId => "stub-sub";
|
|
}
|
|
}
|
|
|
|
/// <summary>A driver that is <see cref="ISubscribable"/> but NOT <see cref="IAlarmSource"/> — proves
|
|
/// <c>AttachAlarmSource</c> is a no-op (no crash) and no alarm forward ever happens.</summary>
|
|
private sealed class SubscribableOnlyStubDriver : StubDriver, ISubscribable
|
|
{
|
|
private readonly StubHandle _subHandle = new();
|
|
|
|
/// <summary>Occurs when data changes.</summary>
|
|
public event EventHandler<DataChangeEventArgs>? OnDataChange;
|
|
|
|
/// <summary>Subscribes to the specified full references.</summary>
|
|
public Task<ISubscriptionHandle> SubscribeAsync(
|
|
IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken) =>
|
|
Task.FromResult<ISubscriptionHandle>(_subHandle);
|
|
|
|
/// <summary>Unsubscribes from the specified subscription handle.</summary>
|
|
public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken) =>
|
|
Task.CompletedTask;
|
|
|
|
/// <summary>Fires a data change event with the specified parameters.</summary>
|
|
public void FireDataChange(string fullRef, object? value, uint statusCode)
|
|
{
|
|
var snapshot = new DataValueSnapshot(value, statusCode, DateTime.UtcNow, DateTime.UtcNow);
|
|
OnDataChange?.Invoke(this, new DataChangeEventArgs(_subHandle, fullRef, snapshot));
|
|
}
|
|
|
|
private sealed class StubHandle : ISubscriptionHandle
|
|
{
|
|
/// <summary>Gets the diagnostic ID of the subscription.</summary>
|
|
public string DiagnosticId => "stub-sub";
|
|
}
|
|
}
|
|
|
|
/// <summary>Minimal <see cref="IAlarmSubscriptionHandle"/> for building <see cref="AlarmEventArgs"/>.</summary>
|
|
private sealed class StubAlarmHandle : IAlarmSubscriptionHandle
|
|
{
|
|
/// <summary>Gets the diagnostic ID of the alarm subscription.</summary>
|
|
public string DiagnosticId => "stub-alarm-sub";
|
|
}
|
|
}
|