From 06ef1779bd72b06b25e1e78ae21392880219ec69 Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Tue, 16 Jun 2026 18:02:42 -0400 Subject: [PATCH] fix(dcl): deliver initial-read seed value after subscription registration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit DataConnectionActor seeded a tag's initial value by Tell-ing TagValueReceived from HandleSubscribe's background task, which runs BEFORE HandleSubscribeCompleted registers the instance's tags in _subscriptionsByInstance. HandleTagValueReceived's fan-out then found no subscriber and dropped the value. A tag that soon gets a data-change notification recovers, but a STATIC tag (e.g. an idle MES field that never changes) was left Uncertain forever — the dropped seed was its only value. Seeds now ride back on SubscribeCompleted and are delivered after registration, reusing HandleTagValueReceived's generation guard, fan-out and quality accounting. +1 regression test (DCL026). --- .../Actors/DataConnectionActor.cs | 41 ++++++++++++++++--- .../DataConnectionActorTests.cs | 37 +++++++++++++++++ 2 files changed, 72 insertions(+), 6 deletions(-) diff --git a/src/ZB.MOM.WW.ScadaBridge.DataConnectionLayer/Actors/DataConnectionActor.cs b/src/ZB.MOM.WW.ScadaBridge.DataConnectionLayer/Actors/DataConnectionActor.cs index fa6e8e34..b334d52f 100644 --- a/src/ZB.MOM.WW.ScadaBridge.DataConnectionLayer/Actors/DataConnectionActor.cs +++ b/src/ZB.MOM.WW.ScadaBridge.DataConnectionLayer/Actors/DataConnectionActor.cs @@ -713,9 +713,18 @@ public class DataConnectionActor : UntypedActor, IWithStash, IWithTimers } } - // Initial read — seed current values for resolved tags so the Instance Actor - // doesn't stay Uncertain until the next OPC UA data change notification. - // Tell is thread-safe, so seeded values are delivered directly as messages. + // Initial read — capture current values for resolved tags so the Instance + // Actor doesn't stay Uncertain until the next data-change notification. + // DataConnectionLayer-026: these are NOT delivered here. Emitting a + // TagValueReceived now (inside the background subscribe task) races ahead of + // the SubscribeCompleted that registers this instance's tags in + // _subscriptionsByInstance, so HandleTagValueReceived's fan-out finds no + // subscriber for the tag and drops the value. That's harmless for a tag that + // soon gets a real change notification, but for a STATIC tag (e.g. an idle + // MES field that never changes) the dropped seed is the only value it will + // ever produce — leaving the attribute Uncertain forever. So the seeds ride + // back on SubscribeCompleted and are delivered after registration. + var seedValues = new List(tagsToSeed.Count); foreach (var tagPath in tagsToSeed) { try @@ -723,7 +732,7 @@ public class DataConnectionActor : UntypedActor, IWithStash, IWithTimers var readResult = await _adapter.ReadAsync(tagPath); if (readResult.Success && readResult.Value != null) { - self.Tell(new TagValueReceived(tagPath, readResult.Value, generation)); + seedValues.Add(new SeededValue(tagPath, readResult.Value)); } } catch @@ -732,7 +741,7 @@ public class DataConnectionActor : UntypedActor, IWithStash, IWithTimers } } - return new SubscribeCompleted(request, sender, results); + return new SubscribeCompleted(request, sender, results, seedValues); }).PipeTo(self); } @@ -879,6 +888,21 @@ public class DataConnectionActor : UntypedActor, IWithStash, IWithTimers } } + // DataConnectionLayer-026: now that every tag is registered in + // _subscriptionsByInstance, deliver the values captured by the initial read. + // Re-entering via Self reuses HandleTagValueReceived's generation guard, fan-out + // and quality accounting — and crucially runs AFTER registration, so the value + // is no longer dropped. Only resolved tags (in _subscriptionIds) are seeded; an + // unresolved tag already got a Bad-quality update above and must not be masked. + if (!connectionLevelFailure) + { + foreach (var seed in msg.SeedValues) + { + if (_subscriptionIds.ContainsKey(seed.TagPath)) + Self.Tell(new TagValueReceived(seed.TagPath, seed.Value, _adapterGeneration)); + } + } + // Start the tag-resolution retry timer if any tags are unresolved. // DataConnectionLayer-022: StartPeriodicTimer with an existing key CANCELS // and replaces the prior timer, so a fan-out of SubscribeTagsRequests @@ -1641,7 +1665,12 @@ public class DataConnectionActor : UntypedActor, IWithStash, IWithTimers string TagPath, bool AlreadySubscribed, bool Success, string? SubscriptionId, string? Error, bool ConnectionLevelFailure = false); internal record SubscribeCompleted( - SubscribeTagsRequest Request, IActorRef ReplyTo, IReadOnlyList Results); + SubscribeTagsRequest Request, IActorRef ReplyTo, IReadOnlyList Results, + IReadOnlyList SeedValues); + + /// An initial-read value captured during subscribe, delivered after the + /// instance's tags are registered for fan-out (DataConnectionLayer-026). + internal record SeededValue(string TagPath, TagValue Value); internal record AlarmTransitionReceived(NativeAlarmTransition Transition, int AdapterGeneration); internal record AlarmSubscribeCompleted( string SourceReference, bool Success, string? SubscriptionId, string? Error, diff --git a/tests/ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Tests/DataConnectionActorTests.cs b/tests/ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Tests/DataConnectionActorTests.cs index f97b5e90..8468ea50 100644 --- a/tests/ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Tests/DataConnectionActorTests.cs +++ b/tests/ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Tests/DataConnectionActorTests.cs @@ -546,6 +546,43 @@ public class DataConnectionActorTests : TestKit Assert.True(ack.Success); } + [Fact] + public async Task DCL026_StaticTagSeedValue_IsDeliveredAfterRegistration() + { + // Regression test for DataConnectionLayer-026. The initial-read seed value used to + // be emitted (TagValueReceived) from HandleSubscribe's background task BEFORE + // HandleSubscribeCompleted registered the instance's tags in + // _subscriptionsByInstance. HandleTagValueReceived's fan-out then found no + // subscriber for the tag and silently dropped the value. A tag that soon gets a + // real data-change notification recovers, but a STATIC tag (subscribe succeeds, + // callback never fires again — e.g. an idle MES field) was left Uncertain forever. + // After the fix the seed rides on SubscribeCompleted and is delivered AFTER + // registration, so the subscriber receives it. + _mockAdapter.ConnectAsync(Arg.Any>(), Arg.Any()) + .Returns(Task.CompletedTask); + _mockAdapter.Status.Returns(ConnectionHealth.Connected); + // Subscribe succeeds; the adapter never invokes the value callback (a static tag). + _mockAdapter.SubscribeAsync(Arg.Any(), Arg.Any(), Arg.Any()) + .Returns(_ => Task.FromResult("sub-static")); + // The gateway returns a Good current value for the static tag. + _mockAdapter.ReadAsync(Arg.Any(), Arg.Any()) + .Returns(new ReadResult(true, + new TagValue("Left54321", QualityCode.Good, DateTimeOffset.UtcNow), null)); + + var actor = CreateConnectionActor("dcl026-static-seed"); + await Task.Delay(300); // reach Connected state + + actor.Tell(new SubscribeTagsRequest( + "c1", "inst1", "dcl026-static-seed", + ["MESReceiver_023.MoveInMesContainerNum"], DateTimeOffset.UtcNow)); + + // The seeded value must reach the subscriber (was dropped pre-fix). + var update = FishForMessage(_ => true, TimeSpan.FromSeconds(5)); + Assert.Equal("MESReceiver_023.MoveInMesContainerNum", update.TagPath); + Assert.Equal(QualityCode.Good, update.Quality); + Assert.Equal("Left54321", update.Value); + } + [Fact] public async Task DCL004_ConnectionLevelSubscribeFailure_TriggersReconnect_NotTagRetry() {