Joseph Doherty
ff4e210a27
N3 (critical): the node manager carries only NATIVE conditions' state over a full rebuild; scripted conditions come back fresh and rely on the engine's re-assert, which since the off-thread plan is handled in the window and lands on the discarded instance. On a rebuild the condition replay scope is now AddedConditions plus every enabled scripted condition in the new composition (native kept conditions stay carried-over, not replayed). The test sink again models the real rebuild: it clears non-native condition state only. N4: a surgical in-place shape edit (DataType / IsArray / ArrayLength) resets the raw node and its UNS mirror to BadWaitingForInitialData without ensuring them, so the window's value was not replayed and the two NodeIds disagreed. The applier records re-shaped nodes (MaterialisationRecording.Reshaped); their deferred value replays only once fitted to the new shape (VariableShape.TryFit: as is, or converted invariantly; never an old-typed value - WriteValues assigns the value verbatim with no type check), otherwise it is dropped at Debug and the node keeps waiting. Status-only entries are not replayed onto a re-shaped node. Minors: m1/m2 documented on _replayScope (degraded-path only); m3 corrected the false carry-over premise in the scope doc (the ScriptedAlarmHostActor ordering remark is outside this lane - F8); m4 the replay Debug log reports alarm-state and alarm-quality counts again. Refs #732 Claude-Session: https://claude.ai/code/session_01Ub9hGmYLQvn9XETzw7CMsT
845 lines
44 KiB
C#
845 lines
44 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Text.Json;
|
|
using Akka.Actor;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
|
|
using ZB.MOM.WW.OtOpcUa.Commons.Types;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Authorization;
|
|
using ZB.MOM.WW.OtOpcUa.OpcUaServer;
|
|
using ZB.MOM.WW.OtOpcUa.Runtime.OpcUa;
|
|
using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.OpcUa;
|
|
|
|
/// <summary>
|
|
/// Lane B review fix round 1. C1: the plan runs off the pinned thread (R02:P5) while writes are non-creating
|
|
/// (R01:L1), so a value, status or alarm write for a node the IN-FLIGHT plan adds used to be skipped — and a
|
|
/// change-driven driver never republishes it. The actor now remembers the latest write per node while a plan
|
|
/// is in flight and replays it after the apply. Every test holds the plan open with a gate, so "during the
|
|
/// plan" is deterministic, and runs against a sink that — like the real node manager — drops writes for nodes
|
|
/// that do not exist.
|
|
/// Also here: I2 (an authority parse throw never fails the apply), the bytes-less request queued behind an
|
|
/// in-flight plan, and a plan piped back to a restarted actor.
|
|
/// </summary>
|
|
public sealed class OpcUaPublishActorDeferredWriteTests : RuntimeActorTestBase
|
|
{
|
|
private const string NewTag = "Plant/Modbus/dev1/T1";
|
|
private static readonly TimeSpan PlanBudget = TimeSpan.FromSeconds(30);
|
|
|
|
[Fact]
|
|
public void A_value_for_a_node_the_in_flight_plan_adds_lands_on_that_node_after_the_apply()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
|
|
actor.Tell(Rebuild(RawTagArtifact(3)));
|
|
var at = DateTime.UtcNow;
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate(
|
|
[new ValueWrite(NewTag, 7, OpcUaStatus.Good, at, AddressSpaceRealm.Raw)]));
|
|
AwaitAssert(() => sink.SkippedWrites.ShouldContain(NewTag), PlanBudget); // non-vacuity: it really missed
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
|
|
sink.Exists(NewTag).ShouldBeTrue("the plan materialised the node");
|
|
sink.ValueOf(NewTag).ShouldBe((7, OpcUaStatus.Good, at), "the value sent while the plan was in flight must end up on the node");
|
|
}
|
|
|
|
[Fact]
|
|
public void A_status_after_a_value_composes_onto_the_new_node_in_order()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
|
|
actor.Tell(Rebuild(RawTagArtifact(3)));
|
|
var t1 = DateTime.UtcNow;
|
|
var t2 = t1.AddSeconds(1);
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate([new ValueWrite(NewTag, 7, OpcUaStatus.Good, t1, AddressSpaceRealm.Raw)]));
|
|
actor.Tell(new OpcUaPublishActor.AttributeStatusBatchUpdate([new StatusWrite(NewTag, OpcUaStatus.BadNoCommunication, t2, AddressSpaceRealm.Raw)]));
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
sink.ValueOf(NewTag).ShouldBe((7, OpcUaStatus.BadNoCommunication, t2), "last known value under the later status");
|
|
}
|
|
|
|
[Fact]
|
|
public void Existing_nodes_keep_updating_while_the_plan_computes()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(RawTagArtifact(1)));
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
var existing = "Plant/Modbus/dev1/T0";
|
|
sink.Exists(existing).ShouldBeTrue();
|
|
|
|
gate.Reset();
|
|
actor.Tell(Rebuild(RawTagArtifact(3)));
|
|
var at = DateTime.UtcNow;
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate([new ValueWrite(existing, 5, OpcUaStatus.Good, at, AddressSpaceRealm.Raw)]));
|
|
|
|
// Applied immediately, while the plan is still held open.
|
|
AwaitAssert(() => sink.ValueOf(existing).ShouldBe((5, OpcUaStatus.Good, at)), PlanBudget);
|
|
sink.Exists(NewTag).ShouldBeFalse("the plan is still in flight");
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
sink.ValueOf(existing).ShouldBe((5, OpcUaStatus.Good, at));
|
|
}
|
|
|
|
[Fact]
|
|
public void An_alarm_state_sent_during_the_plan_lands_on_the_condition_it_materialises()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
|
|
actor.Tell(Rebuild(AlarmArtifact()));
|
|
var state = new AlarmConditionSnapshot(Active: true, Acknowledged: false, Confirmed: true, Enabled: true, AlarmShelvingKind.Unshelved, 500, "high");
|
|
actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("al-1", state, DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
actor.Tell(new OpcUaPublishActor.AlarmQualityUpdate("al-1", OpcUaStatus.BadNoCommunication, DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
AwaitAssert(() => sink.SkippedAlarms.ShouldContain("al-1"), PlanBudget);
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
|
|
sink.ConditionExists("al-1").ShouldBeTrue("the plan materialised the condition");
|
|
sink.AlarmStateOf("al-1").ShouldBeSameAs(state);
|
|
sink.AlarmQualityOf("al-1").ShouldBe(OpcUaStatus.BadNoCommunication);
|
|
}
|
|
|
|
[Fact]
|
|
public void The_deferred_buffer_is_bounded_under_a_flood_and_keeps_the_earliest_keys()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Sys.ActorOf(OpcUaPublishActor.PropsForTests(
|
|
sink, new AddressSpaceApplier(sink, NullLogger<AddressSpaceApplier>.Instance),
|
|
new OpcUaPublishActor.TestHooks { BeforePlan = () => gate.Wait() }, deferredWriteCapacity: 2));
|
|
|
|
actor.Tell(Rebuild(RawTagArtifact(5)));
|
|
var at = DateTime.UtcNow;
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate(Enumerable.Range(0, 5)
|
|
.Select(i => new ValueWrite($"Plant/Modbus/dev1/T{i}", i, OpcUaStatus.Good, at, AddressSpaceRealm.Raw)).ToList()));
|
|
// An existing key still updates when the buffer is full.
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate([new ValueWrite("Plant/Modbus/dev1/T0", 100, OpcUaStatus.Good, at, AddressSpaceRealm.Raw)]));
|
|
AwaitAssert(() => sink.SkippedWrites.Count.ShouldBe(6), PlanBudget);
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
sink.ValueOf("Plant/Modbus/dev1/T0")!.Value.Value.ShouldBe(100);
|
|
sink.ValueOf("Plant/Modbus/dev1/T1")!.Value.Value.ShouldBe(1);
|
|
for (var i = 2; i < 5; i++)
|
|
sink.ValueOf($"Plant/Modbus/dev1/T{i}").ShouldBeNull("beyond the bound a new key is not held");
|
|
sink.ReplayedItems.ShouldBe(2);
|
|
}
|
|
|
|
[Fact]
|
|
public void Writes_after_the_pipeline_drains_are_not_replayed_again()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(RawTagArtifact(3)));
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate([new ValueWrite(NewTag, 7, OpcUaStatus.Good, DateTime.UtcNow, AddressSpaceRealm.Raw)]));
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
var replayed = sink.ReplayedItems;
|
|
replayed.ShouldBe(1);
|
|
|
|
// A later plan replays only what arrived during IT.
|
|
actor.Tell(Rebuild(RawTagArtifact(3)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
sink.ReplayedItems.ShouldBe(replayed);
|
|
}
|
|
|
|
[Fact]
|
|
public void A_throwing_authority_parse_does_not_fail_the_apply()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
var authority = new RecordingAuthoritySink();
|
|
var actor = Sys.ActorOf(OpcUaPublishActor.PropsForTests(
|
|
sink, new AddressSpaceApplier(sink, NullLogger<AddressSpaceApplier>.Instance),
|
|
new OpcUaPublishActor.TestHooks { ParseAuthority = (_, _) => throw new InvalidOperationException("bad grants") },
|
|
dataPlaneAuthority: authority));
|
|
|
|
actor.Tell(Rebuild(RawTagArtifact(2)));
|
|
|
|
var completed = ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
completed.Degraded.ShouldBeFalse(completed.DegradedReason);
|
|
sink.Exists("Plant/Modbus/dev1/T1").ShouldBeTrue("the address space is applied");
|
|
authority.Applies.ShouldBe(0, "nothing is installed from an authority that could not be read");
|
|
|
|
// Positive control: the same actor installs an authority that CAN be read.
|
|
var healthy = Sys.ActorOf(OpcUaPublishActor.PropsForTests(
|
|
new ExistenceSink(), new AddressSpaceApplier(new ExistenceSink(), NullLogger<AddressSpaceApplier>.Instance),
|
|
hooks: null, dataPlaneAuthority: authority));
|
|
healthy.Tell(Rebuild(RawTagArtifact(2)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
authority.Applies.ShouldBe(1);
|
|
}
|
|
|
|
[Fact]
|
|
public void A_bytes_less_rebuild_arriving_mid_plan_answers_after_the_plan_ahead_of_it()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
|
|
var first = Rebuild(RawTagArtifact(2));
|
|
var second = new OpcUaPublishActor.RebuildAddressSpace(CorrelationId.NewId(), DeploymentId.NewId(), Artifact: null, ReportOutcome: true);
|
|
actor.Tell(first);
|
|
actor.Tell(second);
|
|
ExpectNoMsg(TimeSpan.FromMilliseconds(300)); // the bytes-less one must not overtake the held plan
|
|
|
|
gate.Set();
|
|
var a = ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
var b = ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
a.Correlation.ShouldBe(first.Correlation);
|
|
a.Degraded.ShouldBeFalse();
|
|
b.Correlation.ShouldBe(second.Correlation);
|
|
b.Degraded.ShouldBeTrue();
|
|
}
|
|
|
|
[Fact]
|
|
public void A_plan_piped_back_to_a_restarted_actor_is_not_applied()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var applier = new AddressSpaceApplier(sink, NullLogger<AddressSpaceApplier>.Instance);
|
|
var childProps = OpcUaPublishActor.PropsForTests(sink, applier, new OpcUaPublishActor.TestHooks { BeforePlan = () => gate.Wait() });
|
|
var parent = Sys.ActorOf(Props.Create(() => new RestartingParent(childProps)));
|
|
parent.Tell(RestartingParent.GetChild.Instance);
|
|
var child = ExpectMsg<IActorRef>();
|
|
|
|
var stale = Rebuild(RawTagArtifact(3));
|
|
child.Tell(stale);
|
|
child.Tell(Kill.Instance); // the parent's strategy RESTARTS on any failure, ActorKilledException included
|
|
ExpectNoMsg(TimeSpan.FromMilliseconds(300));
|
|
|
|
gate.Set();
|
|
var answer = ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
answer.Correlation.ShouldBe(stale.Correlation);
|
|
answer.Degraded.ShouldBeTrue("the requester is still answered");
|
|
sink.Exists(NewTag).ShouldBeFalse("a plan from the previous incarnation must not be applied");
|
|
|
|
// Positive control: the restarted instance applies a fresh rebuild.
|
|
child.Tell(Rebuild(RawTagArtifact(3)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
sink.Exists(NewTag).ShouldBeTrue();
|
|
}
|
|
|
|
// ───────────────────── fix round 2: N1 / N2 / M1 / M4 / M5 ─────────────────────
|
|
|
|
/// <summary>N1 — a full state snapshot carries quality, so it supersedes an EARLIER quality-only write for the
|
|
/// same condition (the engine sends a transition with the recovered worst quality and no QualityChanged).</summary>
|
|
[Fact]
|
|
public void A_state_after_a_quality_only_write_supersedes_it_on_replay()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
|
|
actor.Tell(Rebuild(AlarmArtifact()));
|
|
actor.Tell(new OpcUaPublishActor.AlarmQualityUpdate("al-1", OpcUaStatus.BadNoCommunication, DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("al-1", ActiveUnacked(OpcUaStatus.Good), DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
AwaitAssert(() => sink.SkippedAlarms.Count.ShouldBe(2), PlanBudget);
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
sink.AlarmQualityOf("al-1").ShouldBe(OpcUaStatus.Good, "the later snapshot's quality is what live would leave");
|
|
sink.AlarmStateOf("al-1")!.Active.ShouldBeTrue();
|
|
}
|
|
|
|
/// <summary>N1 positive control — the reverse order: a quality-only write AFTER the state still lands last.</summary>
|
|
[Fact]
|
|
public void A_quality_only_write_after_a_state_still_lands_after_it_on_replay()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var actor = Spawn(sink, gate);
|
|
|
|
actor.Tell(Rebuild(AlarmArtifact()));
|
|
actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("al-1", ActiveUnacked(OpcUaStatus.Good), DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
actor.Tell(new OpcUaPublishActor.AlarmQualityUpdate("al-1", OpcUaStatus.BadNoCommunication, DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
AwaitAssert(() => sink.SkippedAlarms.Count.ShouldBe(2), PlanBudget);
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
sink.AlarmQualityOf("al-1").ShouldBe(OpcUaStatus.BadNoCommunication);
|
|
}
|
|
|
|
/// <summary>
|
|
/// N2 — a condition the plan KEEPS took the live write already; replaying it would roll back an operator's
|
|
/// Acknowledge applied in the window (the SDK mutates the node directly) and fire spurious events. The surgical
|
|
/// apply shape; the rebuild shapes are the two tests below (scripted: replayed; native: carried over).
|
|
/// </summary>
|
|
[Fact]
|
|
public void An_out_of_band_ack_on_a_kept_condition_is_not_reverted_by_the_replay()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(AlarmArtifact()));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
sink.ConditionExists("al-1").ShouldBeTrue();
|
|
|
|
gate.Reset();
|
|
// A surgical pure-add (new raw tags) that keeps al-1.
|
|
actor.Tell(Rebuild(AlarmArtifact(rawTags: 2)));
|
|
actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("al-1", ActiveUnacked(OpcUaStatus.Good), DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
AwaitAssert(() => sink.AlarmWritesTo("al-1").ShouldBe(1), PlanBudget); // the live write landed
|
|
sink.AcknowledgeOutOfBand("al-1"); // an operator acks in the window
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
|
|
sink.SawRebuild.ShouldBeFalse("non-vacuity: a surgical apply");
|
|
sink.AlarmStateOf("al-1")!.Acknowledged.ShouldBeTrue("the operator's ack must survive the apply");
|
|
sink.AlarmWritesTo("al-1").ShouldBe(1, "no replayed write (and so no extra Part 9 event) on a kept condition");
|
|
}
|
|
|
|
/// <summary>M1 — a variable the surgical plan keeps took the live write; replaying it would revert a client
|
|
/// Write applied in the window. Positive control in the same apply: the node the plan ADDS gets its value.</summary>
|
|
[Fact]
|
|
public void A_surgical_apply_replays_values_only_onto_the_variables_it_added()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(RawTagArtifact(1)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
const string kept = "Plant/Modbus/dev1/T0";
|
|
|
|
gate.Reset();
|
|
actor.Tell(Rebuild(RawTagArtifact(3)));
|
|
var at = DateTime.UtcNow;
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate(
|
|
[
|
|
new ValueWrite(kept, 5, OpcUaStatus.Good, at, AddressSpaceRealm.Raw),
|
|
new ValueWrite(NewTag, 7, OpcUaStatus.Good, at, AddressSpaceRealm.Raw),
|
|
]));
|
|
AwaitAssert(() => sink.ValueOf(kept)!.Value.Value.ShouldBe(5), PlanBudget);
|
|
sink.SetValueOutOfBand(kept, 9); // a client Write in the window
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
sink.SawRebuild.ShouldBeFalse("non-vacuity: a surgical apply");
|
|
sink.ValueOf(kept)!.Value.Value.ShouldBe(9, "the kept node's client write is not reverted");
|
|
sink.ValueOf(NewTag)!.Value.Value.ShouldBe(7, "positive control: the added node gets its deferred value");
|
|
}
|
|
|
|
/// <summary>M1 — a FULL rebuild recreates every variable, so every deferred value replays (the live write landed
|
|
/// on a node the rebuild discarded).</summary>
|
|
[Fact]
|
|
public void A_rebuild_replays_every_deferred_value()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(AlarmArtifact(rawTags: 1)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
const string kept = "Plant/Modbus/dev1/T0";
|
|
sink.Exists(kept).ShouldBeTrue();
|
|
|
|
gate.Reset();
|
|
// An equipment rename is a ChangedEquipment delta ⇒ full rebuild; the raw tag keeps its path.
|
|
actor.Tell(Rebuild(AlarmArtifact(equipmentName: "Eq-renamed", rawTags: 1)));
|
|
var at = DateTime.UtcNow;
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate([new ValueWrite(kept, 5, OpcUaStatus.Good, at, AddressSpaceRealm.Raw)]));
|
|
AwaitAssert(() => sink.ValueOf(kept)!.Value.Value.ShouldBe(5), PlanBudget);
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
sink.SawRebuild.ShouldBeTrue("non-vacuity: a full rebuild ran");
|
|
sink.ValueOf(kept)!.Value.Value.ShouldBe(5, "the recreated node gets the value its predecessor took");
|
|
}
|
|
|
|
/// <summary>M4 — a FAILED plan applies nothing, so nothing is replayed, and the buffer is dropped once the
|
|
/// pipeline is idle: a later plan that adds the node does not receive a write from the failed window.</summary>
|
|
[Fact]
|
|
public void A_failed_plan_replays_nothing_and_drops_the_buffer()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(RawTagArtifact(2)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
gate.Reset();
|
|
actor.Tell(Rebuild("not json"u8.ToArray()));
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate(
|
|
[new ValueWrite("Plant/Modbus/dev1/T2", 42, OpcUaStatus.Good, DateTime.UtcNow, AddressSpaceRealm.Raw)]));
|
|
AwaitAssert(() => sink.SkippedWrites.ShouldContain("Plant/Modbus/dev1/T2"), PlanBudget);
|
|
// Snapshot AFTER the live write (the sink's counter cannot tell a live write after an apply from a replay).
|
|
var replayedBefore = sink.ReplayedItems;
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeTrue();
|
|
sink.ReplayedItems.ShouldBe(replayedBefore, "nothing was applied, so nothing is replayed");
|
|
|
|
actor.Tell(Rebuild(RawTagArtifact(3)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
sink.Exists("Plant/Modbus/dev1/T2").ShouldBeTrue("positive control: the later plan adds it");
|
|
sink.ValueOf("Plant/Modbus/dev1/T2").ShouldBeNull("the failed window's buffer was dropped");
|
|
}
|
|
|
|
/// <summary>M5 — a restart answers every QUEUED requester (degraded) instead of leaving it to the deploy timeout;
|
|
/// the in-flight one is answered by the incarnation check.</summary>
|
|
[Fact]
|
|
public void A_restart_answers_queued_rebuild_requesters()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(false);
|
|
var applier = new AddressSpaceApplier(sink, NullLogger<AddressSpaceApplier>.Instance);
|
|
var childProps = OpcUaPublishActor.PropsForTests(sink, applier, new OpcUaPublishActor.TestHooks { BeforePlan = () => gate.Wait() });
|
|
var parent = Sys.ActorOf(Props.Create(() => new RestartingParent(childProps)));
|
|
parent.Tell(RestartingParent.GetChild.Instance);
|
|
var child = ExpectMsg<IActorRef>();
|
|
|
|
var inFlight = Rebuild(RawTagArtifact(2));
|
|
var queued = Rebuild(RawTagArtifact(3));
|
|
child.Tell(inFlight);
|
|
child.Tell(queued);
|
|
child.Tell(Kill.Instance);
|
|
|
|
var first = ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
first.Correlation.ShouldBe(queued.Correlation, "the queued requester is answered at the restart");
|
|
first.Degraded.ShouldBeTrue();
|
|
|
|
gate.Set();
|
|
var second = ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
second.Correlation.ShouldBe(inFlight.Correlation);
|
|
second.Degraded.ShouldBeTrue();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// N3 (i) — a full rebuild recreates every KEPT SCRIPTED condition fresh (only native conditions are carried
|
|
/// over), so the engine's re-assert handled in the window — landing on the discarded instance — must be
|
|
/// replayed onto the new one, or the active alarm reads Normal until its next transition (#487).
|
|
/// </summary>
|
|
[Fact]
|
|
public void A_rebuild_replays_the_window_state_onto_every_kept_scripted_condition()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(AlarmArtifact()));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
|
|
gate.Reset();
|
|
actor.Tell(Rebuild(AlarmArtifact(equipmentName: "Eq-renamed"))); // ChangedEquipment ⇒ full rebuild, al-1 kept
|
|
actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("al-1", ActiveUnacked(OpcUaStatus.Good), DateTime.UtcNow, AddressSpaceRealm.Uns));
|
|
AwaitAssert(() => sink.AlarmWritesTo("al-1").ShouldBe(1), PlanBudget); // landed live on the old instance
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
|
|
sink.SawRebuild.ShouldBeTrue("non-vacuity: a full rebuild ran");
|
|
sink.AlarmStateOf("al-1").ShouldNotBeNull("the re-assert must reach the recreated condition")
|
|
.Active.ShouldBeTrue();
|
|
}
|
|
|
|
/// <summary>
|
|
/// N3 (ii) — the native counterpart: a kept NATIVE condition is restored from the node manager's carry-over
|
|
/// (which already holds the live write and the operator's ack), so it is not replayed — the ack survives and no
|
|
/// extra write lands.
|
|
/// </summary>
|
|
[Fact]
|
|
public void A_rebuild_does_not_replay_onto_a_kept_native_condition()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(AlarmArtifact(nativeAlarm: true)));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
sink.ConditionExists(NativeAlarm).ShouldBeTrue();
|
|
|
|
gate.Reset();
|
|
actor.Tell(Rebuild(AlarmArtifact(equipmentName: "Eq-renamed", nativeAlarm: true)));
|
|
actor.Tell(new OpcUaPublishActor.AlarmStateUpdate(NativeAlarm, ActiveUnacked(OpcUaStatus.Good), DateTime.UtcNow, AddressSpaceRealm.Raw));
|
|
AwaitAssert(() => sink.AlarmWritesTo(NativeAlarm).ShouldBe(1), PlanBudget);
|
|
sink.AcknowledgeOutOfBand(NativeAlarm);
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
|
|
sink.SawRebuild.ShouldBeTrue("non-vacuity: a full rebuild ran");
|
|
sink.AlarmStateOf(NativeAlarm)!.Acknowledged.ShouldBeTrue("the carried-over ack survives");
|
|
sink.AlarmWritesTo(NativeAlarm).ShouldBe(1, "no replayed write on a carried-over native condition");
|
|
}
|
|
|
|
/// <summary>
|
|
/// N4 — a surgical in-place DataType edit resets the raw node AND its UNS mirror (the node manager drops an
|
|
/// old-typed value), and neither is ensured by the apply. The window's value is replayed onto both, fitted to
|
|
/// the new type, so the two NodeIds of one value agree.
|
|
/// </summary>
|
|
[Fact]
|
|
public void A_surgical_shape_edit_replays_the_window_value_fitted_onto_the_raw_node_and_its_mirror()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(ShapeArtifact("Float")));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
sink.Exists(RawSpeed).ShouldBeTrue();
|
|
sink.Exists(UnsSpeed).ShouldBeTrue("non-vacuity: the mirror exists");
|
|
|
|
gate.Reset();
|
|
actor.Tell(Rebuild(ShapeArtifact("Int32")));
|
|
var at = DateTime.UtcNow;
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate(
|
|
[
|
|
new ValueWrite(RawSpeed, 5.0f, OpcUaStatus.Good, at, AddressSpaceRealm.Raw),
|
|
new ValueWrite(UnsSpeed, 5.0f, OpcUaStatus.Good, at, AddressSpaceRealm.Uns),
|
|
]));
|
|
AwaitAssert(() => sink.ValueOf(RawSpeed)!.Value.Value.ShouldBe(5.0f), PlanBudget);
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget).Degraded.ShouldBeFalse();
|
|
|
|
sink.SawRebuild.ShouldBeFalse("non-vacuity: a surgical in-place edit");
|
|
sink.ReshapedNodes.ShouldContain(RawSpeed, "non-vacuity: the raw node was reset");
|
|
sink.ReshapedNodes.ShouldContain(UnsSpeed, "non-vacuity: the mirror was reset");
|
|
var raw = sink.ValueOf(RawSpeed).ShouldNotBeNull();
|
|
raw.Value.ShouldBeOfType<int>().ShouldBe(5);
|
|
sink.ValueOf(UnsSpeed).ShouldBe(raw, "the raw node and its UNS mirror agree");
|
|
}
|
|
|
|
/// <summary>N4 — a window value that cannot be fitted to the new shape is never written: both NodeIds stay
|
|
/// value-less (BadWaitingForInitialData) until the driver's next value.</summary>
|
|
[Fact]
|
|
public void A_surgical_shape_edit_never_replays_a_value_that_does_not_fit_the_new_shape()
|
|
{
|
|
var sink = new ExistenceSink();
|
|
using var gate = new ManualResetEventSlim(true);
|
|
var actor = Spawn(sink, gate);
|
|
actor.Tell(Rebuild(ShapeArtifact("String")));
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
gate.Reset();
|
|
actor.Tell(Rebuild(ShapeArtifact("Int32")));
|
|
var at = DateTime.UtcNow;
|
|
actor.Tell(new OpcUaPublishActor.AttributeValueBatchUpdate(
|
|
[
|
|
new ValueWrite(RawSpeed, "fast", OpcUaStatus.Good, at, AddressSpaceRealm.Raw),
|
|
new ValueWrite(UnsSpeed, "fast", OpcUaStatus.Good, at, AddressSpaceRealm.Uns),
|
|
]));
|
|
AwaitAssert(() => sink.ValueOf(RawSpeed)!.Value.Value.ShouldBe("fast"), PlanBudget);
|
|
|
|
gate.Set();
|
|
ExpectMsg<OpcUaPublishActor.RebuildCompleted>(PlanBudget);
|
|
|
|
sink.ReshapedNodes.ShouldContain(RawSpeed, "non-vacuity: the raw node was reset");
|
|
sink.ValueOf(RawSpeed).ShouldBeNull("\"fast\" is not an Int32 — the node keeps waiting");
|
|
sink.ValueOf(UnsSpeed).ShouldBeNull();
|
|
}
|
|
|
|
private const string NativeAlarm = "Plant/Modbus/dev1/Hi";
|
|
private const string RawSpeed = "Plant/Modbus/dev1/Speed";
|
|
private const string UnsSpeed = "Area/Line/Eq/Speed";
|
|
|
|
/// <summary>One raw tag (Speed) of <paramref name="dataType"/> and one UNS reference to it under Area/Line/Eq.</summary>
|
|
private static byte[] ShapeArtifact(string dataType) =>
|
|
JsonSerializer.SerializeToUtf8Bytes(new
|
|
{
|
|
UnsAreas = new[] { new { UnsAreaId = "area-1", ClusterId = "c1", Name = "Area" } },
|
|
UnsLines = new[] { new { UnsLineId = "line-1", UnsAreaId = "area-1", Name = "Line" } },
|
|
Equipment = new[] { new { EquipmentId = "eq-1", DriverInstanceId = (string?)null, UnsLineId = "line-1", Name = "Eq", MachineCode = "EQ-1" } },
|
|
RawFolders = new[] { new { RawFolderId = "rf-1", ParentRawFolderId = (string?)null, Name = "Plant", ClusterId = "c1" } },
|
|
DriverInstances = new[] { new { DriverInstanceId = "drv-1", DriverType = "Modbus", DriverConfig = "{}", Name = "Modbus", RawFolderId = "rf-1", ClusterId = "c1" } },
|
|
Devices = new[] { new { DeviceId = "dev-1", DriverInstanceId = "drv-1", Name = "dev1", DeviceConfig = "{}" } },
|
|
TagGroups = Array.Empty<object>(),
|
|
Tags = new[] { new { TagId = "t-speed", DeviceId = "dev-1", TagGroupId = (string?)null, Name = "Speed", DataType = dataType, AccessLevel = 0, TagConfig = "{}" } },
|
|
UnsTagReferences = new[] { new { UnsTagReferenceId = "ref-1", EquipmentId = "eq-1", TagId = "t-speed", DisplayNameOverride = (string?)null } },
|
|
ScriptedAlarms = Array.Empty<object>(),
|
|
});
|
|
|
|
private static AlarmConditionSnapshot ActiveUnacked(uint quality) =>
|
|
new(Active: true, Acknowledged: false, Confirmed: true, Enabled: true, AlarmShelvingKind.Unshelved, 500, "high", quality);
|
|
|
|
// ───────────────────────────── helpers ─────────────────────────────
|
|
|
|
private IActorRef Spawn(ExistenceSink sink, ManualResetEventSlim gate) =>
|
|
Sys.ActorOf(OpcUaPublishActor.PropsForTests(
|
|
sink, new AddressSpaceApplier(sink, NullLogger<AddressSpaceApplier>.Instance),
|
|
new OpcUaPublishActor.TestHooks { BeforePlan = () => gate.Wait() }));
|
|
|
|
private static OpcUaPublishActor.RebuildAddressSpace Rebuild(byte[] artifact) =>
|
|
new(CorrelationId.NewId(), DeploymentId.NewId(), artifact, ReportOutcome: true);
|
|
|
|
private static byte[] RawTagArtifact(int tagCount) =>
|
|
JsonSerializer.SerializeToUtf8Bytes(new
|
|
{
|
|
UnsAreas = Array.Empty<object>(),
|
|
UnsLines = Array.Empty<object>(),
|
|
Equipment = Array.Empty<object>(),
|
|
RawFolders = new[] { new { RawFolderId = "rf-1", ParentRawFolderId = (string?)null, Name = "Plant", ClusterId = "c1" } },
|
|
DriverInstances = new[] { new { DriverInstanceId = "drv-1", DriverType = "Modbus", DriverConfig = "{}", Name = "Modbus", RawFolderId = "rf-1", ClusterId = "c1" } },
|
|
Devices = new[] { new { DeviceId = "dev-1", DriverInstanceId = "drv-1", Name = "dev1", DeviceConfig = "{}" } },
|
|
TagGroups = Array.Empty<object>(),
|
|
Tags = Enumerable.Range(0, tagCount).Select(i => new
|
|
{
|
|
TagId = $"t-{i}", DeviceId = "dev-1", TagGroupId = (string?)null, Name = $"T{i}",
|
|
DataType = "Float", AccessLevel = 0, TagConfig = "{}",
|
|
}).ToArray(),
|
|
UnsTagReferences = Array.Empty<object>(),
|
|
ScriptedAlarms = Array.Empty<object>(),
|
|
});
|
|
|
|
private static byte[] AlarmArtifact(string equipmentName = "Eq", int rawTags = 0, bool nativeAlarm = false) =>
|
|
JsonSerializer.SerializeToUtf8Bytes(new
|
|
{
|
|
UnsAreas = new[] { new { UnsAreaId = "area-1", ClusterId = "c1", Name = "Area" } },
|
|
UnsLines = new[] { new { UnsLineId = "line-1", UnsAreaId = "area-1", Name = "Line" } },
|
|
Equipment = new[]
|
|
{
|
|
new { EquipmentId = "eq-1", DriverInstanceId = (string?)null, UnsLineId = "line-1", Name = equipmentName, MachineCode = "EQ-1" },
|
|
},
|
|
RawFolders = rawTags == 0 && !nativeAlarm
|
|
? Array.Empty<object>()
|
|
: new object[] { new { RawFolderId = "rf-1", ParentRawFolderId = (string?)null, Name = "Plant", ClusterId = "c1" } },
|
|
DriverInstances = rawTags == 0 && !nativeAlarm
|
|
? Array.Empty<object>()
|
|
: new object[] { new { DriverInstanceId = "drv-1", DriverType = "Modbus", DriverConfig = "{}", Name = "Modbus", RawFolderId = "rf-1", ClusterId = "c1" } },
|
|
Devices = rawTags == 0 && !nativeAlarm
|
|
? Array.Empty<object>()
|
|
: new object[] { new { DeviceId = "dev-1", DriverInstanceId = "drv-1", Name = "dev1", DeviceConfig = "{}" } },
|
|
TagGroups = Array.Empty<object>(),
|
|
Tags = Enumerable.Range(0, rawTags).Select(i => (object)new
|
|
{
|
|
TagId = $"t-{i}", DeviceId = "dev-1", TagGroupId = (string?)null, Name = $"T{i}",
|
|
DataType = "Float", AccessLevel = 0, TagConfig = "{}",
|
|
}).Concat(nativeAlarm
|
|
? new object[]
|
|
{
|
|
new
|
|
{
|
|
TagId = "t-hi", DeviceId = "dev-1", TagGroupId = (string?)null, Name = "Hi", DataType = "Boolean",
|
|
AccessLevel = 0, TagConfig = "{\"alarm\":{\"alarmType\":\"OffNormalAlarm\",\"severity\":700}}",
|
|
},
|
|
}
|
|
: Array.Empty<object>()).ToArray(),
|
|
ScriptedAlarms = new[]
|
|
{
|
|
new
|
|
{
|
|
ScriptedAlarmId = "al-1", EquipmentId = "eq-1", Name = "High", AlarmType = "AlarmCondition",
|
|
Severity = 500, MessageTemplate = "high", PredicateScriptId = "s-1", HistorizeToAveva = false,
|
|
Retain = true, Enabled = true,
|
|
},
|
|
},
|
|
Scripts = new[] { new { ScriptId = "s-1", SourceCode = "return false;" } },
|
|
});
|
|
|
|
/// <summary>Restarts its one child on any failure, and lets the test reach the child.</summary>
|
|
private sealed class RestartingParent : ReceiveActor
|
|
{
|
|
public sealed class GetChild { public static readonly GetChild Instance = new(); }
|
|
|
|
public RestartingParent(Props childProps)
|
|
{
|
|
var child = Context.ActorOf(childProps, "publish");
|
|
Receive<GetChild>(_ => Sender.Tell(child));
|
|
}
|
|
|
|
protected override SupervisorStrategy SupervisorStrategy() =>
|
|
new OneForOneStrategy(_ => Directive.Restart);
|
|
}
|
|
|
|
/// <summary>An authority sink that counts installs.</summary>
|
|
private sealed class RecordingAuthoritySink : IDataPlaneAuthoritySink
|
|
{
|
|
private int _applies;
|
|
public int Applies => Volatile.Read(ref _applies);
|
|
|
|
public DataPlaneAuthoritySnapshot Apply(
|
|
string? clusterId, string revision, IReadOnlyList<ZB.MOM.WW.OtOpcUa.Configuration.Entities.ApiKey> keys,
|
|
IReadOnlyList<ZB.MOM.WW.OtOpcUa.Configuration.Entities.NodeAcl> grants,
|
|
IReadOnlyDictionary<AclScopeRef, IReadOnlyList<NodeAclPath>> scopePaths)
|
|
{
|
|
Interlocked.Increment(ref _applies);
|
|
return new DataPlaneAuthorityState().Apply(clusterId, revision, keys, grants, scopePaths);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Models the node manager's non-creating writes: a write to a node that was never ensured (or was removed)
|
|
/// is skipped and recorded; a full sink rebuild forgets every node. <see cref="ReplayedItems"/> counts the
|
|
/// items written after an apply closed and before the next apply starts — the actor's replay, since the
|
|
/// tests send nothing between releasing a plan and its answer.
|
|
/// </summary>
|
|
private sealed class ExistenceSink : IOpcUaAddressSpaceSink, ISurgicalAddressSpaceSink
|
|
{
|
|
private readonly object _gate = new();
|
|
private readonly HashSet<string> _variables = new();
|
|
private readonly HashSet<string> _conditions = new();
|
|
private readonly Dictionary<string, (object? Value, uint Status, DateTime At)> _values = new();
|
|
private readonly Dictionary<string, AlarmConditionSnapshot> _alarmStates = new();
|
|
private readonly Dictionary<string, uint> _alarmQualities = new();
|
|
|
|
public ConcurrentQueue<string> SkippedWrites { get; } = new();
|
|
private readonly Dictionary<string, int> _alarmWrites = new();
|
|
private volatile bool _sawRebuild;
|
|
|
|
/// <summary>Whether any apply called <see cref="RebuildAddressSpace"/> (the full-rebuild shape).</summary>
|
|
public bool SawRebuild => _sawRebuild;
|
|
public int AlarmWritesTo(string id) { lock (_gate) return _alarmWrites.GetValueOrDefault(id); }
|
|
public void SetValueOutOfBand(string id, object? value)
|
|
{
|
|
lock (_gate) { var c = _values.GetValueOrDefault(id); _values[id] = (value, c.Status, c.At); }
|
|
}
|
|
|
|
/// <summary>What an SDK-applied Part 9 Acknowledge does: mutates the condition directly, no sink write.</summary>
|
|
public void AcknowledgeOutOfBand(string id)
|
|
{
|
|
lock (_gate) _alarmStates[id] = _alarmStates[id] with { Acknowledged = true };
|
|
}
|
|
public ConcurrentQueue<string> SkippedAlarms { get; } = new();
|
|
public int ReplayedItems;
|
|
|
|
public bool Exists(string id) { lock (_gate) return _variables.Contains(id); }
|
|
public bool ConditionExists(string id) { lock (_gate) return _conditions.Contains(id); }
|
|
public (object? Value, uint Status, DateTime At)? ValueOf(string id) { lock (_gate) return _values.TryGetValue(id, out var v) ? v : null; }
|
|
public AlarmConditionSnapshot? AlarmStateOf(string id) { lock (_gate) return _alarmStates.GetValueOrDefault(id); }
|
|
public uint? AlarmQualityOf(string id) { lock (_gate) return _alarmQualities.TryGetValue(id, out var q) ? q : null; }
|
|
|
|
public void WriteValue(string nodeId, object? value, uint statusCode, DateTime ts, AddressSpaceRealm realm) =>
|
|
WriteValues([new ValueWrite(nodeId, value, statusCode, ts, realm)]);
|
|
|
|
public void WriteValues(IReadOnlyList<ValueWrite> values)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (_applyClosed) ReplayedItems += values.Count;
|
|
foreach (var v in values)
|
|
{
|
|
if (!_variables.Contains(v.NodeId)) { SkippedWrites.Enqueue(v.NodeId); continue; }
|
|
_values[v.NodeId] = (v.Value, v.StatusCode, v.SourceTimestampUtc);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void WriteStatuses(IReadOnlyList<StatusWrite> statuses)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (_applyClosed) ReplayedItems += statuses.Count;
|
|
foreach (var s in statuses)
|
|
{
|
|
if (!_variables.Contains(s.NodeId)) { SkippedWrites.Enqueue(s.NodeId); continue; }
|
|
var current = _values.GetValueOrDefault(s.NodeId);
|
|
_values[s.NodeId] = (current.Value, s.StatusCode, s.SourceTimestampUtc);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime ts, AddressSpaceRealm realm)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (!_conditions.Contains(alarmNodeId)) { SkippedAlarms.Enqueue(alarmNodeId); return; }
|
|
_alarmWrites[alarmNodeId] = _alarmWrites.GetValueOrDefault(alarmNodeId) + 1;
|
|
// The node manager projects the snapshot's StatusCode onto the condition's Quality.
|
|
_alarmStates[alarmNodeId] = state;
|
|
_alarmQualities[alarmNodeId] = state.StatusCode;
|
|
}
|
|
}
|
|
|
|
public void WriteAlarmQuality(string alarmNodeId, uint statusCode, DateTime ts, AddressSpaceRealm realm)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (!_conditions.Contains(alarmNodeId)) { SkippedAlarms.Enqueue(alarmNodeId); return; }
|
|
_alarmQualities[alarmNodeId] = statusCode;
|
|
}
|
|
}
|
|
|
|
public void MaterialiseAlarmCondition(string alarmNodeId, string equipmentNodeId, string displayName, string alarmType, int severity, AddressSpaceRealm realm, bool isNative = false)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
_applyClosed = false;
|
|
_conditions.Add(alarmNodeId);
|
|
if (isNative) _nativeConditions.Add(alarmNodeId); else _nativeConditions.Remove(alarmNodeId);
|
|
}
|
|
}
|
|
|
|
private readonly HashSet<string> _nativeConditions = new();
|
|
private readonly Dictionary<string, (string DataType, bool IsArray, uint? ArrayLength)> _shapes = new();
|
|
public ConcurrentQueue<string> ReshapedNodes { get; } = new();
|
|
|
|
public void EnsureFolder(string folderNodeId, string? parentNodeId, string displayName, AddressSpaceRealm realm)
|
|
{
|
|
lock (_gate) _applyClosed = false;
|
|
}
|
|
|
|
public void EnsureVariable(string variableNodeId, string? parentFolderNodeId, string displayName, string dataType, bool writable, AddressSpaceRealm realm, string? historianTagname = null, bool isArray = false, uint? arrayLength = null, bool refuseArrayOnScalar = false)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
_applyClosed = false;
|
|
if (_variables.Add(variableNodeId)) _shapes[variableNodeId] = (dataType, isArray, arrayLength);
|
|
}
|
|
}
|
|
|
|
public void RebuildAddressSpace()
|
|
{
|
|
lock (_gate)
|
|
{
|
|
// OtOpcUaNodeManager.RebuildAddressSpace: variables are recreated empty; only NATIVE conditions'
|
|
// state is captured and carried over to the re-materialised instance — a scripted condition comes
|
|
// back fresh (its engine re-asserts it).
|
|
_applyClosed = false;
|
|
_sawRebuild = true;
|
|
_variables.Clear();
|
|
_shapes.Clear();
|
|
_conditions.Clear();
|
|
_values.Clear();
|
|
foreach (var id in _alarmStates.Keys.Where(k => !_nativeConditions.Contains(k)).ToList()) _alarmStates.Remove(id);
|
|
foreach (var id in _alarmQualities.Keys.Where(k => !_nativeConditions.Contains(k)).ToList()) _alarmQualities.Remove(id);
|
|
}
|
|
}
|
|
|
|
private bool _applyClosed;
|
|
|
|
public void CompleteAddressSpaceApply()
|
|
{
|
|
lock (_gate) _applyClosed = true;
|
|
}
|
|
|
|
public void RaiseNodesAddedModelChange(string affectedNodeId, AddressSpaceRealm realm) { }
|
|
public void WireAlarmNotifiers(string alarmNodeId, AddressSpaceRealm alarmRealm, IReadOnlyList<string> notifierFolderNodeIds, AddressSpaceRealm notifierFolderRealm) { }
|
|
public void AddReference(string sourceNodeId, AddressSpaceRealm sourceRealm, string targetNodeId, AddressSpaceRealm targetRealm, string referenceType = "Organizes") { }
|
|
/// <summary>OtOpcUaNodeManager.UpdateTagAttributes: a SHAPE change (DataType / array-ness / length) drops the
|
|
/// node's value (BadWaitingForInitialData); any other attribute edit leaves it.</summary>
|
|
public bool UpdateTagAttributes(string variableNodeId, bool writable, string? historianTagname, string dataType, bool isArray, uint? arrayLength, AddressSpaceRealm realm)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (!_variables.Contains(variableNodeId)) return false;
|
|
if (_shapes.GetValueOrDefault(variableNodeId) != (dataType, isArray, arrayLength))
|
|
{
|
|
_shapes[variableNodeId] = (dataType, isArray, arrayLength);
|
|
_values.Remove(variableNodeId);
|
|
ReshapedNodes.Enqueue(variableNodeId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
public bool UpdateFolderDisplayName(string folderNodeId, string displayName, AddressSpaceRealm realm) => true;
|
|
public bool RemoveVariableNode(string variableNodeId, AddressSpaceRealm realm) { lock (_gate) return _variables.Remove(variableNodeId); }
|
|
public bool RemoveAlarmConditionNode(string alarmNodeId, AddressSpaceRealm realm) { lock (_gate) return _conditions.Remove(alarmNodeId); }
|
|
public bool RemoveEquipmentSubtree(string equipmentNodeId, AddressSpaceRealm realm) => true;
|
|
}
|
|
}
|