f966efcfad
C1 (critical): B6 computes the plan off the pinned thread while B1 made writes non-creating, so a value/status/alarm write for a node the in-flight plan adds was skipped, and change-driven drivers never republish it (BadWaitingForInitialData indefinitely; on a full rebuild every re-subscribe value landed on discarded nodes). OpcUaPublishActor now applies writes immediately AND remembers the latest per (realm, id) while a plan is in flight or queued (value+status compose; alarm state/quality coalesce to the latest, which the node's delta gate makes inert on an existing condition), replays it after each apply before answering, and drops it once the pipeline is idle. Bounded (250k keys by default; beyond it new keys are not held, logged once). I2: the data-plane-authority parse runs in its own try inside the plan task; a throw is logged and never degrades the address-space apply. I3: the SDK's DeleteMonitoredItems releases an item's component-cache reference on a Good delete; a tombstoned item's reference was already released, so the delete took one from the re-created node's entry. Released items are remembered and the orphan delete takes one back first. Event items never held a reference (EventManager + SubscribeToEvents), so the three event-item releases are gone. I4: direct tests for the HistoryUpdate override's per-request updater check and the HistoryReadEvents override's source guard (both reached by restoring the bit after a reset - the B7 race window); fixed the false remark. Minors: the MaterialiseAlarmCondition kind-swap tombstones the dropped instance; a bytes-less rebuild arriving mid-plan queues behind it (replies in order); a PlanReady/PlanFailed from a previous actor incarnation is ignored and its requester answered degraded; the tie-cluster end bound of an uncapped read fits against the backend ceiling (defence in depth - guarded by a sweep test); the lock-time benchmark stays in the default run, headroom noted. Refs #732 Claude-Session: https://claude.ai/code/session_01Ub9hGmYLQvn9XETzw7CMsT
439 lines
22 KiB
C#
439 lines
22 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();
|
|
}
|
|
|
|
// ───────────────────────────── 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() =>
|
|
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" },
|
|
},
|
|
DriverInstances = Array.Empty<object>(),
|
|
Tags = Array.Empty<object>(),
|
|
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();
|
|
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; }
|
|
_alarmStates[alarmNodeId] = state;
|
|
}
|
|
}
|
|
|
|
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); }
|
|
}
|
|
|
|
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; _variables.Add(variableNodeId); }
|
|
}
|
|
|
|
public void RebuildAddressSpace()
|
|
{
|
|
lock (_gate)
|
|
{
|
|
_applyClosed = false;
|
|
_variables.Clear();
|
|
_conditions.Clear();
|
|
_values.Clear();
|
|
_alarmStates.Clear();
|
|
_alarmQualities.Clear();
|
|
}
|
|
}
|
|
|
|
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") { }
|
|
public bool UpdateTagAttributes(string variableNodeId, bool writable, string? historianTagname, string dataType, bool isArray, uint? arrayLength, AddressSpaceRealm realm) => 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;
|
|
}
|
|
}
|