fix(redundancy): advertise ServiceLevel 0 until the node has a redundancy level (#885)
v2-ci / unit-tests (push) Has been cancelled

The SDK starts Server.ServiceLevel at 255 (full service), and OpcUaPublishActor publishes nothing
until the node's first redundancy snapshot arrives, so a restarting pair node advertised 255 for the
~10-13 s it took to join, out-ranking the real Primary (250) for any client that picks the highest
ServiceLevel.

OtOpcUaSdkServer now writes StartupServiceLevel = 0 in OnNodeManagerStartedAsync: after the SDK's
CreateServerObjectAsync wrote 255 and before the server goes Running, so no session can ever read
255. 0 is the design's existing Down / Detached tier (ServiceLevelCalculator returns 0 for a member
that is not Up/Joining, and a node with no snapshot has no role yet). It is below the SDK 2
session-headroom floor (200), so it stands through session churn before the #884 claim, and the
claim's bind replays any level already requested. Single-node deployments are unaffected beyond
the window: the first snapshot publishes 250 as before.

New Node_with_no_requested_level_advertises_the_startup_level_until_one_is_published: reads 0
before the bind, 0 after a bind with nothing to replay, then 250 once published. Without the
startup write it reads 255 on the first session (mutation-checked). docs/Redundancy.md updated for
#884 and #885.

Claude-Session: https://claude.ai/code/session_01GT67ACmpMR7b9LGRPLijMi
This commit is contained in:
Joseph Doherty
2026-11-12 11:11:11 -05:00
parent 5e3fb4229d
commit 3fff439b11
3 changed files with 93 additions and 4 deletions
@@ -11,6 +11,8 @@ namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.IntegrationTests;
/// <summary>Local loopback evidence that late binding replaces the SDK default on the wire.</summary>
public sealed class ServiceLevelBindingReplayTests
{
// Since #885 the server starts at 0, so the 0 case no longer distinguishes "replayed" from "not replayed" — it pins
// that a requested 0 still reads 0. The 100 case is the replay evidence.
[Theory]
[InlineData((byte)100)]
[InlineData((byte)0)]
@@ -135,6 +137,66 @@ public sealed class ServiceLevelBindingReplayTests
}
}
/// <summary>
/// lmxopcua#885: a node that has not yet received its first redundancy snapshot has requested no level. The SDK starts
/// <c>Server.ServiceLevel</c> at 255, so a restarting pair node advertised full service, out-ranking the real Primary
/// (250), for the ~10 s it took to join. It must read <see cref="OtOpcUaSdkServer.StartupServiceLevel"/> (0) from its
/// first session, through the bind with nothing to replay and across session churn, and still settle to the level
/// the redundancy layer publishes once it has one (a single-node deployment's 250).
/// </summary>
[Fact]
public async Task Node_with_no_requested_level_advertises_the_startup_level_until_one_is_published()
{
using var deadline = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
deadline.CancelAfter(TimeSpan.FromSeconds(30));
var ct = deadline.Token;
var pki = Path.Combine(Path.GetTempPath(), $"otopcua-startup-{Guid.NewGuid():N}");
var clientPki = TestClientSecurity.AllocatePkiRoot();
var port = 0;
try
{
var started = await OpcUaHostStart.StartAsync(p =>
{
port = p;
return new OpcUaApplicationHost(new OpcUaApplicationHostOptions
{
ApplicationName = "OtOpcUa.Startup",
ApplicationUri = $"urn:OtOpcUa.Startup:{Path.GetFileName(pki)}",
OpcUaPort = p, PublicHostname = "localhost", PkiStoreRoot = pki,
}, NullLogger<OpcUaApplicationHost>.Instance);
}, () => new OtOpcUaSdkServer(), ct);
await using var host = started.Host;
var url = $"opc.tcp://localhost:{port}/OtOpcUa";
// Before the host binds a publisher: the SDK-start window.
using (var early = await OpenAsync(url, clientPki, ct))
{
(await ReadServiceLevelAsync(early, ct)).ShouldBe(OtOpcUaSdkServer.StartupServiceLevel,
"an endpoint that has not been told its redundancy level must not advertise the SDK's 255");
await early.CloseAsync(5_000, true, ct);
}
// The bind with nothing to replay (no snapshot yet), then session churn under the claim.
var deferred = new DeferredServiceLevelPublisher();
deferred.SetInner(new SdkServiceLevelPublisher(started.Server.CurrentInstance,
NullLogger<SdkServiceLevelPublisher>.Instance));
using var session = await OpenAsync(url, clientPki, ct);
(await ReadServiceLevelAsync(session, ct)).ShouldBe(OtOpcUaSdkServer.StartupServiceLevel,
"binding with no requested level must leave the startup level standing");
// The first snapshot arrives: a single-node deployment settles to its steady Primary value.
deferred.Publish(250);
using (var later = await OpenAsync(url, clientPki, ct))
await later.CloseAsync(5_000, true, ct);
(await ReadServiceLevelAsync(session, ct)).ShouldBe((byte)250, "the published level must replace the startup level");
}
finally
{
if (Directory.Exists(pki)) Directory.Delete(pki, recursive: true);
if (Directory.Exists(clientPki)) Directory.Delete(clientPki, recursive: true);
}
}
private static async Task<Opc.Ua.Client.ISession> OpenAsync(string url, string clientPki, CancellationToken ct)
{
var config = new ApplicationConfiguration(DefaultTelemetry.Create(_ => { }))