diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/BaselineRig.cs b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/BaselineRig.cs index 3f2974fa..7508152f 100644 --- a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/BaselineRig.cs +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/BaselineRig.cs @@ -18,6 +18,7 @@ internal sealed class BaselineRig : IAsyncDisposable ?? throw new InvalidOperationException("An ephemeral fixture credential is required"); private readonly OpcUaApplicationHostOptions _options; private OpcUaApplicationHost _host = null!; + private bool _disposed; internal OtOpcUaSdkServer Server { get; private set; } = null!; internal OtOpcUaNodeManager Nm => Server.NodeManager!; internal SdkAddressSpaceSink Sink { get; private set; } = null!; @@ -88,9 +89,13 @@ internal sealed class BaselineRig : IAsyncDisposable } public async ValueTask DisposeAsync() { - await _host.DisposeAsync(); - Canonical.Ledger.Record("host-stop"); - if (Directory.Exists(PkiRoot)) Directory.Delete(PkiRoot, true); + if (_disposed) return; + _disposed = true; + try + { + if (_host is not null) { await _host.DisposeAsync(); Canonical.Ledger.Record("host-stop"); } + } + finally { if (Directory.Exists(PkiRoot)) Directory.Delete(PkiRoot, true); } } private sealed class Auth : IOpcUaUserAuthenticator { diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/OWNERSHIP.md b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/OWNERSHIP.md new file mode 100644 index 00000000..d58c13c0 --- /dev/null +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/OWNERSHIP.md @@ -0,0 +1,167 @@ +# Original close semantics and bounded retention controls + +These are separately reviewed short controls against the unchanged 83ed880e +publication, SDK 1.5.378.182. They do not replace the historical `(1 browse, +6 history)` held-list port comparison, change an oracle, approve a memory +baseline, or claim an unbounded leak. The operation deadline is 120 seconds; +normal shutdown/private-directory cleanup has independent 20/20/5/5-second +bounds, and the semantic runner has a final 180-second process bound. + +## What was tested + +A fresh fixture creates the original production host, encrypted opc.tcp client, +one abandoned browse point and six event-history points. After normal client +CloseAsync, the control verifies removal from the same running SessionManager. +The old closed object still exposes `(1,6)` while explicitly held, as previously +recorded; that observation is not treated as live protocol ownership. + +A fresh valid session supplies the same open raw transport for all following +requests. `ITransportChannel.SendRequestAsync` receives explicit request headers; +no closed Session client guard or ClientBase header substitution can satisfy the +negative checks. Each response must carry the exact sent RequestHandle. + +| Request | Verified outcome | +|---|---| +| Fresh raw read before old-token request | Good service/item status | +| Read with old authentication token | Correlated ServiceFault, BadSessionIdInvalid (2149908480) | +| Fresh raw read after the fault, same transport | Good service/item status | +| Fresh browse point creation | Good, nonempty point | +| Old browse point from the fresh session | BadContinuationPointInvalid (2152333312) | +| Fresh own browse point resume and release | Good; resume returns references and another point | +| Fresh history page | Good; nonempty point; backend dispatched | +| Old history point from the fresh session | BadContinuationPointInvalid; backend counter remains 7 to 7 | +| Fresh own history point resume and release | Good; resume dispatches backend and returns another point | + +All 11 raw responses were correlated. Generic transport failures/timeouts are not +accepted as token denial. The exact .182 ClientBase independently preserves a +nonnull AuthenticationToken in UpdateRequestHeader; the raw path bypasses that +method entirely. The protected token getter is read through an exact-type-checked +diagnostic accessor before close; tokens and payloads are never logged. + +## Two distinct weak-reference boundaries + +A NoInlining synchronous helper completes the async closed-session scope from a +thread-pool context, returning only weak references and primitive/type metadata. +No Session, point, response, token array or backend is returned as a strong +reference. The first GC phase runs while the SAME original host/configuration +remain alive. Their weak targets are explicitly expected alive. A second +NoInlining fixture boundary completes normal host shutdown, private-directory +cleanup and the complete async fixture scope before the outer GC phase. + +Each phase records round 0 followed by exactly five forced blocking/compacting +collections with fixed 50/100/250/500/1000 ms delays. Each GC/finalizer worker is +bounded at five seconds. Observers use WeakReference.IsAlive rather than keeping +TryGetTarget values across collections. A deliberately retained positive object +must stay alive and an isolated collectible negative must disappear. No delay is +extended to obtain collection. + +In the ordinary run all **16 old client/server Session, browse point/Data, +history-slot wrapper and history-value targets** disappeared during the first +live-host forced collection. This separates the held-list implementation detail +from those objects' actual reclamation in this fixture. After normal stop and +all fixture boundaries, five server-graph targets remained across all five +observations: server, node manager, backend, server validator and server cached +store. Rig/client configuration/client application/client validator/client cached +store targets disappeared. Positive and negative controls behaved correctly. +PKI descriptors were zero in live-host and stopped-but-harness-held observations. +The ordinary run preserves **exit 1**, with unsupported SDK2 manager-disposal +observables still explicit. + +For this single fixture, live-host final managed bytes were 94,550,728 and timers +10; after-stop final managed bytes were 7,774,200 and timers 7. This drop does not +establish that the earlier multi-restart managed/timer growth disappears, nor is +it a usable performance denominator. Full process/framework parity remains open. + +## Exact point-resource ownership + +Runtime inspection identifies browse `ContinuationPoint.Data` as **Opc.Ua.NodeBrowser** +from the original Opc.Ua.Types binary. Its exact Dispose(bool) implementation is +empty. Its declared storage is managed IReference/List/HashSet/index state plus +managed context/view properties, with no owned IDisposable field. The containing +ContinuationPoint.Dispose delegates to Data, so omission of that call on this +exact browser does not skip a direct cleanup action. This is not a statement +about every INodeBrowser implementation or arbitrary driver browser resources. + +The six history values are the original event HistoryContinuationState records; +the original store saves each record directly in the SDK slot. They have scalar, +string/date and managed paging/set state, no IDisposable contract or backend/store +handle ownership. This event fixture has no pending raw end-bound resource. Both +the SDK slot wrapper and its Value are weak-tracked; all collected while the +original host remained running. + +## Stop is distinct from terminal Dispose + +Read-only inspection of the pinned original product/SDK establishes: + +1. Archived OtOpcUa OpcUaApplicationHost.DisposeAsync awaits only + ApplicationInstance.StopAsync. +2. Original ApplicationInstance.StopAsync delegates to Server.StopAsync. +3. ServerBase.StopAsync stops listeners/service hosts and invokes the standard + stopping hook. StandardServer's stopping hook DOES shut down subscriptions, + sessions and node managers and dispose internal server data. +4. Terminal ServerBase.Dispose separately disposes its RequestQueue. + RequestQueue owns a ServerBase reference and starts minimum worker tasks; + those workers await SemaphoreSlim with a 15,000 ms timeout and cancellation + token. At the minimum worker count they continue waiting. Queue.Dispose + cancels that token, releases/disposes its signal and terminates its ownership. +5. StandardServer.Dispose also unregisters its CertificateUpdate callback and + disposes remaining terminal resources. The SDK2 ApplicationInstance.DisposeAsync + explicitly performs StopAsync THEN Server.Dispose; the archived original host + never calls that terminal API. + +This is a source-backed original application lifecycle gap and a plausible +retention path consistent with the observed server graph. It is not a measured +heap dominator/root chain or attribution of any particular timer. No original +production code was patched, and no extra disposal was added to ordinary mode. + +A separate, gated `semantic-terminal-dispose` attribution mode first records the +ordinary result. Only afterward does a NoInlining helper briefly acquire the +known weak original server target, invoke its PUBLIC terminal Dispose once, +drop that strong reference, then repeat the same fixed GC schedule. No private +timer disposal, cache clearing, oracle adjustment or delay extension is used. +The original ordinary exit is returned even if terminal disposal clears all +observed targets. Its results are recorded separately in `semantic-evidence.json`. +It cannot turn the archived original behavior or failed RSS gates into a pass. + +That separately approved run reproduced the same normal-stop five survivors and +returned **exit 1**. After the single public Dispose, all five disappeared at the +first next forced collection and remained absent through round 5. At the final +observations, timers changed from 7 to 2 and managed bytes from 7,692,144 to +4,513,760. Positive/negative GC controls remained valid. This controlled intervention +supports missing terminal server disposal as the ownership distinction; it does +not identify which queue task, timer or event subscription was the actual GC root. +It does not establish an unbounded leak from one fixture, eliminate unrelated +native retention, or make the original process a performance denominator. + +Both immutable adapter builds completed with zero warnings/errors, using the +same 208 reference hashes. The ordinary run uses build 3 and the separate +counterfactual uses build 4; their exact source, binary, build-log and raw-result +hashes are retained in `semantic-evidence.json`. Raw evidence remains in private +external directories. No additional control was run to adjust these findings. + +The exact original test seams are public virtual +`ServerBase.StopAsync(CancellationToken)`, protected virtual `Dispose(bool)`, +`OnServerStarting(ApplicationConfiguration)`, +`StartApplicationAsync(ApplicationConfiguration, CancellationToken)`, and +`OnServerStoppingAsync(CancellationToken)`. Public `Dispose()` and `StartAsync` +are nonvirtual. StandardServer overrides those protected lifecycle hooks and +also exposes protected virtual `OnServerStarted(IServerInternal)`. A separate +reviewed application repair can test stop failure/partial startup using these +supported seams; this diagnostic does not repair or rebuild the archived product. + +## Smallest future matched-host path (proposal only) + +A standalone SDK2 driver mirroring this original standalone driver is the smallest +path: same .NET runtime, assertions, telemetry/logging configuration, PKI/security, +operation recipe/counts, raw request/correlation probes, NoInlining boundaries, +weak controls, sampling schedule and module provenance. Keep SDK-specific value +representations and read-only ownership observers explicit. Both xUnit hosts +would require creating/porting a larger original test-host graph and introduce +more loader/framework differences. Neither path has been implemented or approved +as an acceptance protocol. The current candidate xUnit control is semantic +corroboration, not process-memory comparability. + +Any correction of archived app ownership must be a separate reviewed change and +new provenance; these controls do not substitute a repaired baseline or use its +post-counterfactual memory as a denominator. Long original runs, reset baselines, +RSS caps and acceptance remain outside this work. diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/Program.cs b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/Program.cs index ee9f8af0..98d01bca 100644 --- a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/Program.cs +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/Program.cs @@ -11,7 +11,8 @@ using Shouldly; using ZB.MOM.WW.OtOpcUa.Commons.OpcUa; using ZB.MOM.WW.OtOpcUa.Core.Abstractions; using CoreHistoryReadResult = ZB.MOM.WW.OtOpcUa.Core.Abstractions.HistoryReadResult; -return await Canonical.RunAsync(args); +return args.Length == 3 && (args[2] == "--semantic-retention-control" || args[2] == "--semantic-terminal-dispose-control") + ? await Canonical.SemanticRetentionAsync(args) : await Canonical.RunAsync(args); internal static partial class Canonical { private const string Scalar = BaselineRig.RawDeviceFolder + "/SoakScalar"; @@ -103,12 +104,15 @@ internal static partial class Canonical {public Task WriteAsync(string id,object? value,AddressSpaceRealm realm,CancellationToken ct)=>Task.FromResult(new NodeWriteOutcome(true,null));} internal sealed class SqlLikeEventSource(List events) : IHistorianDataSource { + private int _eventReads; + internal int EventReads => Volatile.Read(ref _eventReads); private readonly List _all = events.OrderBy(e => e.EventTimeUtc).ThenBy(e => e.EventId, StringComparer.Ordinal).ToList(); public async Task ReadEventsAsync( string? sourceName, DateTime startUtc, DateTime endUtc, int maxEvents, CancellationToken ct) { + Interlocked.Increment(ref _eventReads); await Task.Delay(1, ct).ConfigureAwait(false); // complete on a pool thread, like a real backend var window = _all.Where(e => e.EventTimeUtc >= startUtc && e.EventTimeUtc < endUtc).ToList(); var cap = maxEvents <= 0 ? 1000 : maxEvents; diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/README.md b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/README.md index d7973b66..5cadcc2d 100644 --- a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/README.md +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/README.md @@ -82,13 +82,14 @@ as the candidate; those observations cannot invent the missing manager ownership proof. No manual Session.Dispose, store replacement or cache clearing was added to make an assertion pass. -Before any common lifecycle/acceptance protocol can be proposed, a separately -reviewed short control must establish original SessionManager removal, rejection -of the old authentication token, rejection of old CP tokens from a fresh session, -then drop every strong session/point/test reference at an isolated helper boundary -and perform bounded GC/weak-reference observation. Any retained IDisposable point -resource needs direct source/ownership inspection. Certificate-store/native -ownership gaps must remain explicit. This proposal has **not** been executed. +The historical partial proof above did not test token/continuation rejection or +collection after dropping its diagnostic references. Later, separately reviewed +short controls established those semantics and observed the remaining server +graph retention after normal shutdown. Their direct point-resource inspection, +two weak-reference phases and separate terminal-disposal attribution are recorded +in [OWNERSHIP.md](OWNERSHIP.md) and `semantic-evidence.json`. Both ordinary failure +results remain intact. Certificate-store/native ownership gaps remain explicit; +these findings do not approve a common lifecycle/acceptance protocol. The standalone adapter also lacks the candidate's xUnit/VSTest host; equal process memory overhead is not proven. Earlier original-subset managed/timer growth is an @@ -120,5 +121,10 @@ Add `--inventory` to build the read-only metadata inventory instead. The runner uses a fresh private directory and a temporary environment credential with the same prefix/byte length as the canonical fixture; it preserves the original child exit. Exit 1 is an observed control failure; exit 2 is operations completed with -unsupported ownership parity. Neither is a passing baseline. The smoke driver -has a hard 120-second bound and no long-run option. +unsupported ownership parity. Neither is a passing baseline. Normal/restart modes +have a hard 120-second bound and no long-run option. + +The later semantic modes are `--mode semantic-retention` and the separately gated +`--mode semantic-terminal-dispose` attribution control. They use the 120-second +operation deadline plus bounded independent cleanup and a 180-second outer runner +limit. Neither changes normal/active-restart results or authorizes a long run. diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/SemanticRetention.cs b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/SemanticRetention.cs new file mode 100644 index 00000000..23cafd0a --- /dev/null +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/SemanticRetention.cs @@ -0,0 +1,385 @@ +using System.Collections; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.ExceptionServices; +using System.Text.Json; +using Opc.Ua; +using Opc.Ua.Client; +using Opc.Ua.Configuration; +using Shouldly; +using ServerSession = Opc.Ua.Server.ISession; +using ClientSession = Opc.Ua.Client.ISession; + +internal static partial class Canonical +{ + internal static async Task SemanticRetentionAsync(string[] args) + { + if (args.Length != 3 || args[1] != "1") throw new InvalidOperationException("One bounded semantic control only"); + var root = Path.GetFullPath(args[0]); + var counterfactual = args[2] == "--semantic-terminal-dispose-control"; + if (Directory.Exists(root)) throw new InvalidOperationException("Use a fresh private directory"); + Directory.CreateDirectory(root); + if (!OperatingSystem.IsWindows()) File.SetUnixFileMode(root, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); + await using var output = new StreamWriter(new FileStream(Path.Combine(root, "resources.jsonl"), FileMode.CreateNew, FileAccess.Write, FileShare.Read)); + CurrentEvidence = output; + using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(120)); + var retainedPositive = new object(); + var positive = Witness("positive-retained", retainedPositive); + var negative = EphemeralNegative(); + try + { + await LogAsync(output, new { kind = "semantic-process", phase = "before-fixture", process = ProcessCounters() }); + // Task.Run has no captured synchronization context. Its closure contains only path/writer/token. + var result = await Task.Run(() => FixtureBoundary(root, output, positive, negative, deadline.Token), deadline.Token); + var phase2 = await ObserveAsync("after-stop", result.All, positive, negative, output, deadline.Token); + var liveOld = result.LiveHostSurvivors; + var stopped = phase2.Where(x => x.alive && x.label != "positive-retained").Select(x => x.label).ToArray(); + await LogAsync(output, new { kind = "semantic-retention-result", semanticsComplete = true, + liveHostOldSurvivors = liveOld, afterStopSurvivors = stopped, acceptance = false, ownershipParity = false, + unsupportedObservables = new[] { "SDK2 CertificateManager disposed flag", "SDK2 manager-owned cache-clear proof", "ApplicationInstance.DisposeAsync" } }); + var ordinaryExitCode = liveOld.Length == 0 && stopped.Length == 0 ? 2 : 1; + if (counterfactual) + { + // Separate attribution only, AFTER preserving the ordinary stop result above. + var server = result.All.Single(x => x.Label == "fixture-server"); + var invoked = await Task.Run(() => TerminalDisposeBoundary(server), deadline.Token).WaitAsync(TimeSpan.FromSeconds(20), deadline.Token); + await LogAsync(output, new { kind = "counterfactual-terminal-dispose", invoked, ordinaryExitCode, + publicMethod = "ServerBase.Dispose", acceptance = false }); + var terminal = await ObserveAsync("after-terminal-dispose", result.All, positive, negative, output, deadline.Token); + await LogAsync(output, new { kind = "counterfactual-attribution-result", ordinaryExitCode, + survivors = terminal.Where(x => x.alive && x.label != "positive-retained").Select(x => x.label).ToArray(), acceptance = false }); + } + GC.KeepAlive(retainedPositive); + // Even collection of every observed target does not invent the unsupported ownership proof. + return ordinaryExitCode; + } + catch (Exception error) + { + await LogAsync(output, new { kind = "semantic-control-failed", exceptionType = error.GetType().FullName, acceptance = false }); + Console.Error.WriteLine(error); + GC.KeepAlive(retainedPositive); + return 1; + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static FixtureWitness FixtureBoundary(string root, StreamWriter output, WeakWitness positive, WeakWitness negative, CancellationToken ct) => + FixtureScopeAsync(root, output, positive, negative, ct).GetAwaiter().GetResult(); + + private static async Task FixtureScopeAsync(string root, StreamWriter output, WeakWitness positive, WeakWitness negative, CancellationToken ct) + { + var sdk = typeof(NodeId).Assembly.GetCustomAttribute()?.InformationalVersion; + if (sdk is null || !sdk.StartsWith("1.5.378.182+", StringComparison.Ordinal)) throw new InvalidOperationException("Immutable .182 SDK required"); + var clientRoot = Path.Combine(root, "private-fixture", "client-pki"); + BaselineRig? rig = null; + ApplicationConfiguration? config = null; + ApplicationInstance? application = null; + ExceptionDispatchInfo? failure = null; + FixtureWitness? result = null; + var booted = false; + try + { + var telemetry = DefaultTelemetry.Create(_ => { }); + config = new ApplicationConfiguration(telemetry) + { + ApplicationName = "SDK2LifecycleSoak", ApplicationUri = $"urn:SDK2LifecycleSoak:{Guid.NewGuid():N}", ApplicationType = ApplicationType.Client, + SecurityConfiguration = new SecurityConfiguration + { + ApplicationCertificate = new CertificateIdentifier { StoreType = CertificateStoreType.Directory, StorePath = Path.Combine(clientRoot, "own"), SubjectName = "CN=SDK2LifecycleSoak" }, + TrustedIssuerCertificates = new CertificateTrustList { StoreType = CertificateStoreType.Directory, StorePath = Path.Combine(clientRoot, "issuer") }, + TrustedPeerCertificates = new CertificateTrustList { StoreType = CertificateStoreType.Directory, StorePath = Path.Combine(clientRoot, "trusted") }, + RejectedCertificateStore = new CertificateTrustList { StoreType = CertificateStoreType.Directory, StorePath = Path.Combine(clientRoot, "rejected") }, AutoAcceptUntrustedCertificates = true + }, + ClientConfiguration = new ClientConfiguration { DefaultSessionTimeout = 15000 }, TransportQuotas = new TransportQuotas { OperationTimeout = 5000 } + }; + application = new ApplicationInstance(telemetry) { ApplicationConfiguration = config }; + await config.ValidateAsync(ApplicationType.Client, ct); + await application.CheckApplicationInstanceCertificatesAsync(true, null, ct); + rig = new BaselineRig(Path.Combine(root, "private-fixture")); + await rig.BootAsync(ct); + Configure(rig); + booted = true; + await LogAsync(output, new { kind = "semantic-start", sdk, acceptance = false, productRebuilt = false, + maximumSeconds = 120, gcDelaysMilliseconds = new[] { 50, 100, 250, 500, 1000 }, gcRoundTimeoutSeconds = 5 }); + var fixture = new List + { + Witness("fixture-rig", rig), Witness("fixture-server", rig.Server), Witness("fixture-node-manager", rig.Nm), + Witness("fixture-backend", rig.Nm.HistorianDataSource), Witness("fixture-client-config", config), + Witness("fixture-client-application", application), Witness("fixture-server-validator", rig.Validator), + Witness("fixture-client-validator", config.CertificateValidator) + }; + // This synchronous NoInlining boundary drops the completed async state machine before phase1 GC. + var closed = ClosedBoundary(rig, config, output, ct); + PublicCounts(rig).ShouldBe((0, 0, 0)); + // Validation may populate stores on first connection; inspect after those operations. + CaptureStores(rig.Validator, "fixture-server-store", fixture); + CaptureStores(config.CertificateValidator, "fixture-client-store", fixture); + var all = closed.Concat(fixture).ToArray(); + await WriteShapes(all, output); + var phase1 = await ObserveAsync("live-host", all, positive, negative, output, ct); + var survivors = phase1.Where(x => x.alive && x.label.StartsWith("old-", StringComparison.Ordinal)).Select(x => x.label).ToArray(); + foreach (var live in phase1.Where(x => x.label.StartsWith("fixture-", StringComparison.Ordinal))) + live.alive.ShouldBeTrue("the host/configuration are intentionally still owned in phase1"); + var descriptors = await BaselineMetrics.DescriptorsAsync(ct, clientRoot, rig.PkiRoot); + descriptors.Pki.ShouldBe(0); + await LogAsync(output, new { kind = "semantic-owned-resources", phase = "live-host", pkiDescriptors = descriptors.Pki, + serverCachedStoreReferences = BaselineMetrics.CachedStoreReferences(rig.Validator), + clientCachedStoreReferences = BaselineMetrics.CachedStoreReferences(config.CertificateValidator), + cachedReferenceIsOpenHandle = false }); + result = new FixtureWitness(all, survivors); + } + catch (Exception error) { failure = ExceptionDispatchInfo.Capture(error); } + finally + { + // These bounds do not reuse the canceled 120-second operation token. + async Task Cleanup(string step, Func operation, int seconds) + { + try { await operation().WaitAsync(TimeSpan.FromSeconds(seconds), CancellationToken.None); } + catch (Exception error) + { + failure ??= ExceptionDispatchInfo.Capture(error); + await LogAsync(output, new { kind = "semantic-cleanup-failed", step, exceptionType = error.GetType().FullName }); + } + } + if (rig is not null) + await Cleanup("normal-host-stop", () => rig.DisposeAsync().AsTask(), 20); + if (booted && rig is not null && config is not null) + await Cleanup("post-stop-observations", async () => + { + using var probe = new CancellationTokenSource(TimeSpan.FromSeconds(15)); + var after = await BaselineMetrics.DescriptorsAsync(probe.Token, clientRoot, rig.PkiRoot); + after.Pki.ShouldBe(0); + await LogAsync(output, new { kind = "semantic-owned-resources", phase = "stopped-but-harness-held", pkiDescriptors = after.Pki, + serverCachedStoreReferences = BaselineMetrics.CachedStoreReferences(rig.Validator), + clientCachedStoreReferences = BaselineMetrics.CachedStoreReferences(config.CertificateValidator), disposalFlagObservable = false }); + }, 20); + await Cleanup("client-private-directory", () => Task.Run(() => { if (Directory.Exists(clientRoot)) Directory.Delete(clientRoot, true); }), 5); + if (rig is not null) + await Cleanup("server-private-directory", () => Task.Run(() => { if (Directory.Exists(rig.PkiRoot)) Directory.Delete(rig.PkiRoot, true); }), 5); + GC.KeepAlive(application); GC.KeepAlive(config); GC.KeepAlive(rig); + } + failure?.Throw(); + return result ?? throw new InvalidOperationException("The fixture did not produce diagnostic witnesses"); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static WeakWitness[] ClosedBoundary(BaselineRig rig, ApplicationConfiguration config, StreamWriter output, CancellationToken ct) => + ClosedScopeAsync(rig, config, output, ct).GetAwaiter().GetResult(); + + private static async Task ClosedScopeAsync(BaselineRig rig, ApplicationConfiguration config, StreamWriter output, CancellationToken ct) + { + var weak = new List(); + using var owner = await ConnectAsync(rig, config, null, ct); + weak.Add(Witness("old-client-session", owner)); + var oldServerSession = rig.Server.CurrentInstance.SessionManager.GetSessions().Single(x => x.Id == owner.SessionId); + weak.Add(Witness("old-server-session", oldServerSession)); + var oldAuthenticationToken = Token(owner); + var oldBrowse = (await BrowseAsync(owner, ct))!; + RequirePoint(oldBrowse); + byte[]? oldHistory = null; + for (var i = 0; i < 6; i++) + { + var page = await PageAsync(owner, null, false, ct); + RequirePoint(page.ContinuationPoint); + oldHistory ??= page.ContinuationPoint; + } + CapturePoints(oldServerSession, weak); + ContinuationCounts(oldServerSession).ShouldBe((1, 6)); + await owner.CloseAsync(ct); + rig.Server.CurrentInstance.SessionManager.GetSessions().Any(x => ReferenceEquals(x, oldServerSession)).ShouldBeFalse(); + rig.Server.CurrentInstance.SessionManager.GetSessions().Count.ShouldBe(0); + await LogAsync(output, new { kind = "semantic-closed-state", activeSessions = 0, rawClosedBrowse = ContinuationCounts(oldServerSession).Browse, + rawClosedHistory = ContinuationCounts(oldServerSession).History, diagnosticReferenceHeld = true }); + using var fresh = await ConnectAsync(rig, config, null, ct); + var channel = fresh.TransportChannel; + var freshToken = Token(fresh); + freshToken.ShouldNotBe(oldAuthenticationToken); + uint sequence = 10000; + RequestHeader Header(NodeId token) => new() { AuthenticationToken = token, RequestHandle = ++sequence, Timestamp = DateTime.UtcNow, TimeoutHint = 5000 }; + ReadRequest Read(NodeId token) => new() { RequestHeader = Header(token), TimestampsToReturn = TimestampsToReturn.Neither, + NodesToRead = [new ReadValueId { NodeId = Raw(fresh, Scalar), AttributeId = Attributes.Value }] }; + await RequireReadGood(channel, Read(freshToken), "fresh-read-before", output, ct); + var oldRequest = Read(oldAuthenticationToken); + var denied = await Send(channel, oldRequest, "old-authentication-token", output, ct); + var deniedCode = denied.ResponseHeader.ServiceResult; + (deniedCode == StatusCodes.BadSessionIdInvalid || deniedCode == StatusCodes.BadSessionClosed).ShouldBeTrue(); + await RequireReadGood(channel, Read(freshToken), "fresh-read-after", output, ct); + + var ownBrowseRequest = new BrowseRequest { RequestHeader = Header(freshToken), RequestedMaxReferencesPerNode = 1, + NodesToBrowse = [new BrowseDescription { NodeId = Raw(fresh, BaselineRig.RawDeviceFolder), BrowseDirection = BrowseDirection.Forward, + ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences, IncludeSubtypes = true, ResultMask = (uint)BrowseResultMask.All }] }; + var ownBrowse = (BrowseResponse)await Send(channel, ownBrowseRequest, "fresh-own-browse", output, ct); + ownBrowse.Results[0].StatusCode.ShouldBe(StatusCodes.Good); RequirePoint(ownBrowse.Results[0].ContinuationPoint); + var oldBrowseResponse = (BrowseNextResponse)await Send(channel, new BrowseNextRequest { RequestHeader = Header(freshToken), + ContinuationPoints = [oldBrowse], ReleaseContinuationPoints = false }, "old-browse-point", output, ct); + oldBrowseResponse.Results[0].StatusCode.ShouldBe(StatusCodes.BadContinuationPointInvalid); + await LogAsync(output, new { kind = "semantic-item-status", name = "old-browse-point", statusCode = (uint)oldBrowseResponse.Results[0].StatusCode }); + var ownBrowseNext = (BrowseNextResponse)await Send(channel, new BrowseNextRequest { RequestHeader = Header(freshToken), + ContinuationPoints = [ownBrowse.Results[0].ContinuationPoint], ReleaseContinuationPoints = false }, "fresh-own-browse-resume", output, ct); + ownBrowseNext.Results[0].StatusCode.ShouldBe(StatusCodes.Good); + ownBrowseNext.Results[0].References.Count.ShouldBeGreaterThan(0); RequirePoint(ownBrowseNext.Results[0].ContinuationPoint); + var ownBrowseRelease = (BrowseNextResponse)await Send(channel, new BrowseNextRequest { RequestHeader = Header(freshToken), + ContinuationPoints = [ownBrowseNext.Results[0].ContinuationPoint], ReleaseContinuationPoints = true }, "fresh-own-browse-release", output, ct); + ownBrowseRelease.Results[0].StatusCode.ShouldBe(StatusCodes.Good); + + HistoryReadRequest History(byte[]? point, bool release) => new() + { + RequestHeader = Header(freshToken), TimestampsToReturn = TimestampsToReturn.Both, ReleaseContinuationPoints = release, + HistoryReadDetails = new ExtensionObject(new ReadEventDetails { StartTime = Epoch.AddDays(-1), EndTime = Epoch.AddDays(1), NumValuesPerNode = 4, + Filter = new EventFilter { SelectClauses = [new SimpleAttributeOperand(ObjectTypeIds.BaseEventType, new QualifiedName(BrowseNames.EventId))] } }), + NodesToRead = [new HistoryReadValueId { NodeId = Raw(fresh, BaselineRig.RawDeviceFolder), ContinuationPoint = point }] + }; + var backend = (SqlLikeEventSource)rig.Nm.HistorianDataSource; + var beforeOwn = backend.EventReads; + var ownHistory = (HistoryReadResponse)await Send(channel, History(null, false), "fresh-own-history", output, ct); + ownHistory.Results[0].StatusCode.ShouldBe(StatusCodes.Good); RequirePoint(ownHistory.Results[0].ContinuationPoint); + backend.EventReads.ShouldBeGreaterThan(beforeOwn); + var beforeOld = backend.EventReads; + var oldHistoryResponse = (HistoryReadResponse)await Send(channel, History(oldHistory, false), "old-history-point", output, ct); + oldHistoryResponse.Results[0].StatusCode.ShouldBe(StatusCodes.BadContinuationPointInvalid); + backend.EventReads.ShouldBe(beforeOld); + await LogAsync(output, new { kind = "semantic-backend", operation = "old-history-point", before = beforeOld, after = backend.EventReads, + statusCode = (uint)oldHistoryResponse.Results[0].StatusCode }); + var ownHistoryNext = (HistoryReadResponse)await Send(channel, History(ownHistory.Results[0].ContinuationPoint, false), "fresh-own-history-resume", output, ct); + ownHistoryNext.Results[0].StatusCode.ShouldBe(StatusCodes.Good); RequirePoint(ownHistoryNext.Results[0].ContinuationPoint); + backend.EventReads.ShouldBeGreaterThan(beforeOld); + var releaseHistory = (HistoryReadResponse)await Send(channel, History(ownHistoryNext.Results[0].ContinuationPoint, true), "fresh-own-history-release", output, ct); + releaseHistory.Results[0].StatusCode.ShouldBe(StatusCodes.Good); + await fresh.CloseAsync(ct); + rig.Server.CurrentInstance.SessionManager.GetSessions().Count.ShouldBe(0); + return weak.ToArray(); + } + + private static NodeId Token(ClientSession session) + { + var property = typeof(ClientBase).GetProperty("AuthenticationToken", BindingFlags.Instance | BindingFlags.NonPublic) + ?? throw new InvalidOperationException("Exact .182 token getter is missing"); + return property.PropertyType == typeof(NodeId) && property.GetValue(session) is NodeId value && !NodeId.IsNull(value) + ? NodeId.Parse(value.ToString()) : throw new InvalidOperationException("Exact .182 token getter changed"); + } + private static async Task Send(ITransportChannel channel, IServiceRequest request, string name, StreamWriter output, CancellationToken ct) + { + // No Session closed guard or ClientBase header update runs on this public raw transport path. + var response = await channel.SendRequestAsync(request, ct); + response.ResponseHeader.RequestHandle.ShouldBe(request.RequestHeader.RequestHandle); + await LogAsync(output, new { kind = "semantic-wire", name, requestHandle = request.RequestHeader.RequestHandle, + responseHandle = response.ResponseHeader.RequestHandle, responseType = response.GetType().Name, + serviceStatusCode = (uint)response.ResponseHeader.ServiceResult }); + return response; + } + private static async Task RequireReadGood(ITransportChannel channel, ReadRequest request, string name, StreamWriter output, CancellationToken ct) + { + var response = (ReadResponse)await Send(channel, request, name, output, ct); + response.ResponseHeader.ServiceResult.ShouldBe(StatusCodes.Good); + response.Results[0].StatusCode.ShouldBe(StatusCodes.Good); + } + + private static FieldInfo ExactField(object owner, string name) + { + for (var type = owner.GetType(); type is not null; type = type.BaseType) + if (type.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly) is { } field) return field; + throw new InvalidOperationException("Missing exact .182 diagnostic field: " + name); + } + private static void CapturePoints(ServerSession session, List target) + { + var gate = ExactField(session, "m_lock").GetValue(session) as System.Threading.Lock ?? throw new InvalidOperationException("Unexpected session lock"); + using (gate.EnterScope()) + { + var browse = ExactField(session, "m_browseContinuationPoints").GetValue(session) as IList ?? throw new InvalidOperationException("Missing populated browse list"); + foreach (var value in browse) + { + var point = value as Opc.Ua.Server.ContinuationPoint ?? throw new InvalidOperationException("Unexpected browse point type"); + target.Add(Witness("old-browse-point", point)); + if (point.Data is { } data) target.Add(Witness("old-browse-data", data)); + } + var history = ExactField(session, "m_historyContinuationPoints").GetValue(session) as IList ?? throw new InvalidOperationException("Missing populated history list"); + var index = 0; + foreach (var value in history) + { + var slot = value ?? throw new InvalidOperationException("Null history slot"); + target.Add(Witness("old-history-slot-" + index, slot)); + var state = ExactField(slot, "Value").GetValue(slot) ?? throw new InvalidOperationException("Null history state"); + target.Add(Witness("old-history-value-" + index++, state)); + } + } + } + private static void CaptureStores(CertificateValidator validator, string label, List target) + { + var gate = ExactField(validator, "m_semaphore").GetValue(validator) as SemaphoreSlim ?? throw new InvalidOperationException("Unexpected validator lock"); + if (!gate.Wait(TimeSpan.FromSeconds(5))) throw new TimeoutException("Validator witness lock timed out"); + try + { + var index = 0; + foreach (var name in new[] { "m_trustedCertificateStore", "m_issuerCertificateStore", "m_rejectedCertificateStore" }) + if (ExactField(validator, name).GetValue(validator) is CertificateStoreIdentifier identifier + && ExactField(identifier, "m_store").GetValue(identifier) is ICertificateStore store) + target.Add(Witness(label + "-" + index++, store)); + } + finally { gate.Release(); } + } + private static WeakWitness Witness(string label, object target) => new(label, target); + [MethodImpl(MethodImplOptions.NoInlining)] + private static WeakWitness EphemeralNegative() => Witness("negative-collectible", new object()); + [MethodImpl(MethodImplOptions.NoInlining)] + private static bool TerminalDisposeBoundary(WeakWitness server) => server.DisposeOriginalServerForAttribution(); + private static async Task WriteShapes(IEnumerable witnesses, StreamWriter output) + { foreach (var witness in witnesses) await LogAsync(output, witness.Shape); } + private static async Task ObserveAsync(string phase, WeakWitness[] witnesses, WeakWitness positive, WeakWitness negative, StreamWriter output, CancellationToken ct) + { + var delays = new[] { 0, 50, 100, 250, 500, 1000 }; + WeakObservation[] last = []; + for (var round = 0; round < delays.Length; round++) + { + if (round > 0) + { + await Task.Delay(delays[round], ct); + await Task.Run(ForcedCollection, ct).WaitAsync(TimeSpan.FromSeconds(5), ct); + } + last = witnesses.Concat([positive, negative]).Select(x => x.Observe(phase == "live-host" && x.Label.StartsWith("fixture-", StringComparison.Ordinal) + || x.Label == "positive-retained")).ToArray(); + await LogAsync(output, new { kind = "weak-observation", phase, round, groups = last, process = ProcessCounters() }); + positive.IsAlive().ShouldBeTrue("the retained positive must remain observable"); + if (round > 0) negative.IsAlive().ShouldBeFalse("the isolated collectible negative proves GC observation is effective"); + } + return last; + } + private static void ForcedCollection() { GC.Collect(2, GCCollectionMode.Forced, true, true); GC.WaitForPendingFinalizers(); GC.Collect(2, GCCollectionMode.Forced, true, true); } + private static object ProcessCounters() + { + using var process = Process.GetCurrentProcess(); process.Refresh(); + return new { managedBytes = GC.GetTotalMemory(false), rssBytes = process.WorkingSet64, + activeTimers = Timer.ActiveCount, gcCommittedBytes = GC.GetGCMemoryInfo().TotalCommittedBytes, + jitMethods = System.Runtime.JitInfo.GetCompiledMethodCount() }; + } + private sealed class WeakWitness + { + private readonly WeakReference _reference; + internal string Label { get; } + internal object Shape { get; } + private readonly string _type; + internal WeakWitness(string label, object target) + { + Label = label; _type = target.GetType().FullName ?? target.GetType().Name; _reference = new WeakReference(target); + var fields = new List(); + for (var type = target.GetType(); type is not null; type = type.BaseType) + foreach (var field in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)) + if (typeof(IDisposable).IsAssignableFrom(field.FieldType)) fields.Add(new { name = field.Name, type = field.FieldType.FullName }); + Shape = new { kind = "weak-resource-shape", label, type = _type, isDisposable = target is IDisposable, resourceFields = fields }; + } + [MethodImpl(MethodImplOptions.NoInlining)] internal bool IsAlive() => _reference.IsAlive; + [MethodImpl(MethodImplOptions.NoInlining)] + internal bool DisposeOriginalServerForAttribution() + { + var value = _reference.Target; + if (value is null) return false; + if (Label != "fixture-server" || value is not ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaSdkServer server) + throw new InvalidOperationException("Only the known original server may receive terminal attribution disposal"); + server.Dispose(); // Public terminal lifecycle API, once; no private timer/cache manipulation. + return true; + } + internal WeakObservation Observe(bool expectedAlive) => new(Label, _type, IsAlive(), expectedAlive); + } + private sealed record WeakObservation(string label, string type, bool alive, bool expectedAlive); + private sealed record FixtureWitness(WeakWitness[] All, string[] LiveHostSurvivors); +} diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/build.py b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/build.py index 49955d23..ba6c83e8 100644 --- a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/build.py +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/build.py @@ -32,7 +32,7 @@ items = ET.SubElement(project,'ItemGroup') ET.SubElement(items,'FrameworkReference',Include='Microsoft.AspNetCore.App') for name,path in references.items(): reference=ET.SubElement(items,'Reference',Include=path.stem); ET.SubElement(reference,'HintPath').text=str(path) -files = ['Inventory.cs'] if args.inventory else ['Program.cs','BaselineRig.cs','BaselineMetrics.cs','CanonicalOperations.cs'] +files = ['Inventory.cs'] if args.inventory else ['Program.cs','BaselineRig.cs','BaselineMetrics.cs','CanonicalOperations.cs','SemanticRetention.cs'] for name in files: ET.SubElement(items,'Compile',Include=str(source/name)) path=root/'adapter.csproj'; ET.indent(project); ET.ElementTree(project).write(path,encoding='unicode') manifest={'diagnosticOnly':True,'productRebuilt':False,'references':{name:hashlib.sha256(p.read_bytes()).hexdigest() for name,p in references.items()}, diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/run_smoke.py b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/run_smoke.py index c86c9f73..04b493da 100644 --- a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/run_smoke.py +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/run_smoke.py @@ -10,7 +10,7 @@ import subprocess parser=argparse.ArgumentParser(description=__doc__) parser.add_argument('--adapter',type=Path,required=True) parser.add_argument('--output',type=Path,required=True) -parser.add_argument('--mode',choices=['normal','active-restart'],required=True) +parser.add_argument('--mode',choices=['normal','active-restart','semantic-retention','semantic-terminal-dispose'],required=True) args=parser.parse_args() output=args.output.resolve() if output.exists():raise RuntimeError('Use a fresh private output directory') @@ -19,11 +19,14 @@ environment=os.environ.copy() environment['OTOPCUA_BASELINE_CANONICAL_KEY']='otua_k-server-events_'+secrets.token_hex(3) command=['dotnet',str(args.adapter.resolve(strict=True)),str(output),'1'] if args.mode=='active-restart':command+=['--active-restart-control'] +if args.mode=='semantic-retention':command+=['--semantic-retention-control'] +if args.mode=='semantic-terminal-dispose':command+=['--semantic-terminal-dispose-control'] +outer_timeout=180 if args.mode.startswith('semantic-') else 120 with os.fdopen(os.open(log,os.O_WRONLY|os.O_CREAT|os.O_EXCL,0o600),'w') as stream: - try:result=subprocess.run(command,env=environment,stdout=stream,stderr=subprocess.STDOUT,timeout=120);exit_code=result.returncode + try:result=subprocess.run(command,env=environment,stdout=stream,stderr=subprocess.STDOUT,timeout=outer_timeout);exit_code=result.returncode except subprocess.TimeoutExpired:exit_code=124 if output.exists(): (output/'runner-receipt.json').write_text(json.dumps({'mode':args.mode,'exitCode':exit_code,'acceptance':False, - 'productRebuilt':False,'timeoutSeconds':120,'credentialBytes':len(environment['OTOPCUA_BASELINE_CANONICAL_KEY'].encode())},indent=2)+'\n') + 'productRebuilt':False,'timeoutSeconds':outer_timeout,'credentialBytes':len(environment['OTOPCUA_BASELINE_CANONICAL_KEY'].encode())},indent=2)+'\n') print(json.dumps({'mode':args.mode,'exitCode':exit_code,'acceptance':False})) raise SystemExit(exit_code) diff --git a/scripts/validation/opcua-lifecycle-memory/baseline-canonical/semantic-evidence.json b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/semantic-evidence.json new file mode 100644 index 00000000..2b20212e --- /dev/null +++ b/scripts/validation/opcua-lifecycle-memory/baseline-canonical/semantic-evidence.json @@ -0,0 +1,2081 @@ +{ + "diagnosticOnly": true, + "acceptance": false, + "ownershipParity": false, + "performanceDenominatorApproved": false, + "longRunPerformed": false, + "productRebuilt": false, + "originalPublication": "83ed880e", + "sourceParent": "ed60970fc294ab171a80cda1b57942a7130b4c39", + "sdk": "1.5.378.182+6cca32dd6d79c8b57d2e00e4d2071b991d2cf71b", + "runtimeScope": "Mac arm64 standalone net10.0; runtimeconfig requests 10.0.0 with default patch roll-forward; only Microsoft.NETCore.App/Microsoft.AspNetCore.App 10.0.14 installed in recorded environment; not xUnit/VSTest memory parity", + "historicalEvidenceSha256": "94105384ab6627655e395cf727b56dfb1dbd79b7c6ce68436efb0afa915d9b1e", + "bounds": { + "operationSeconds": 120, + "normalStopSeconds": 20, + "postStopObservationSeconds": 20, + "eachPrivateDirectoryCleanupSeconds": 5, + "outerProcessSeconds": 180, + "gcRoundSeconds": 5, + "gcDelaysMilliseconds": [ + 50, + 100, + 250, + 500, + 1000 + ], + "counterfactualPublicDisposeSeconds": 20 + }, + "sources": { + "build.py": "062e4933a27510517387b8cc66e1c06f0a4088321a5d5a1f505f083662581f9c", + "run_smoke.py": "5ec79cd74b433e1799f9ecd4670e7deaba0d89e51f1dd8c921b3725d637ea132" + }, + "referenceCount": 208, + "references": { + "Akka.Cluster.Hosting.dll": "d9b44216b34fc9655c86c3e9d30422e47683969577e205a17096a9a706db768e", + "Akka.Cluster.Sharding.dll": "9f5b418e908a4d579858889af823f780a5e7ff6be2f27c24aa38309759d09423", + "Akka.Cluster.Tools.dll": "a819b0c3e73e08ea474936ad429763ec11681f43c090e2b92dbc1d37d7c94e35", + "Akka.Cluster.dll": "e64aee4dbd305f533c9eea995c9676c0ce7bc8e55a77437afd14b0cf8fe3c0a9", + "Akka.Coordination.dll": "2472a627de9cf9185b3a98860266b7751c173f859d3bd185b272d5f4078be26b", + "Akka.DependencyInjection.dll": "ebea19a2f75f2e275531fbd62be5499a5132563958ebccfc25a450979cfa0039", + "Akka.Discovery.dll": "8c1733537b6cedfb4e7234b86ae63a45cd204ad3c6bc8843f52a85643c507a89", + "Akka.DistributedData.LightningDB.dll": "56100ac684f6acef390b2e546d198899366f035aaa51bb64bc494ebaf2d85007", + "Akka.DistributedData.dll": "9ba2724f0cd49676338241b6249e3b9b95a5c50ddadea5e28adedf31b3ef9fc6", + "Akka.Hosting.dll": "937444c766e641d7c1f86e718e97a148587136a249f91c2986e1f77e2f8d9f92", + "Akka.Logger.Serilog.dll": "49068dc58456684f3c2804bb541223c3aa2dade07f4b1e9877b2e7e058d2056a", + "Akka.Persistence.Hosting.dll": "a9e840a8bc6d7c404e0c83ec5576fcaac3a848880c0ab2b0ed9f1bae33ec2076", + "Akka.Persistence.dll": "c11fc9b044bb927d764f85c0ca8a02c16e8084c05c5ecffd050869ed7810c390", + "Akka.Remote.Hosting.dll": "f0d2ca67e9affd0c68ef32dc859974fe415c00ec5a4710a8e06467542799ad6b", + "Akka.Remote.dll": "b1d27508442727938c4076561f6b4ee81cdd3caa0ef76a481cb45dbfc4c5a0fb", + "Akka.Streams.dll": "e3d9024ece608d6f8b2a15d15f211d50919ed983834fa85d9cc3c9be3c56eb73", + "Akka.dll": "b2d2b8422ba6759d315cbd07622e705fb69daf64e9425cda45f5605132303e34", + "Azure.Core.dll": "224d09cb39eae4d8c30272a0c49beb19d873c87347eae9487f0ddd859d752b56", + "Azure.Identity.dll": "af18f20be25b2895c912f3ba0a9f2901a82dda823edcad76e6a19eac9886a40f", + "BitFaster.Caching.dll": "7af73841cafd0c8b05ad166c45ad0886bcf80926d4c4a65e0fa7578ea1e04d03", + "DotNetty.Buffers.dll": "65f066d108192cefc6e44f18e2d92cf338be30056f4fad02d6b8ea692f81bd37", + "DotNetty.Codecs.dll": "809d9e582ce909356b34ef8d4f212adea5d5ca25e1492a31ccb81a6f9be23070", + "DotNetty.Common.dll": "7a375647446f11a5d5f5eddf72f0327b4b69956a91917100d0f4d8f120fa7962", + "DotNetty.Handlers.dll": "08ce96ee9108adda52adb87119c54fdb819806817867943987d77983c3f1a9c5", + "DotNetty.Transport.dll": "f393993cc027ec61f758b8832029b21f2efd8583807e0aa06af4df90d239eb09", + "FASTER.core.dll": "318092fdd4eccb8e30ab04493a5ce3e827714df2721770af62ef81aea8bd21d8", + "Google.Protobuf.dll": "c2769d0bc587db846b99fefcd778a8ffbb7fbcb4a03d2fcd8ce9573c7ef7042a", + "Grpc.AspNetCore.Server.ClientFactory.dll": "7340bd5dccbe5298825df443d4971a90afd87388e381c008a90556e42c2c04d1", + "Grpc.AspNetCore.Server.dll": "f200b4cae34c51f4f607c684dd72107ad2487808673ae20960edacdf437ec9dd", + "Grpc.Core.Api.dll": "3535e79c38523d239303a33d420c8a856babdcc4d08a167d532decdcc5453951", + "Grpc.Net.Client.dll": "ad2dae77484dabaa9dade62035d761a0d1ec26394e8b600e80dff7b792c088e7", + "Grpc.Net.ClientFactory.dll": "9bf1e593838013238a56d5b4e4e2dd2e8c93589063eaf2a3b2f71e3d3219fd3d", + "Grpc.Net.Common.dll": "d91c6969c65943f22f8a6f67f832e763def7fcb2af0ce16862b3748fa06e0521", + "LightningDB.dll": "b0ebedf36fd19f1dedd7547e49c5a7b6e4a6b53015dde70699e4e69ae8f50406", + "MQTTnet.dll": "1bb34492a9018fec3f627458364dc6e46fef076a647df181403246da65f5bce2", + "Microsoft.AspNetCore.Authentication.JwtBearer.dll": "2a2f99ce877c62a8c600c390ce1f15bb0cc2a92a973a9da60ddcf4bd60bdcb64", + "Microsoft.AspNetCore.DataProtection.EntityFrameworkCore.dll": "a768ee07664430adbbdf9a761ed0b691dbf52d67d2f1af833de606b851516394", + "Microsoft.AspNetCore.Http.Connections.Client.dll": "1ce2e273eab3c4ca003e65bfdf78318b3195f08385c814a02f10890bdd34d05f", + "Microsoft.AspNetCore.SignalR.Client.Core.dll": "5833a8070a9c50faa38331fead1c106c4c4bf4e6eca773b00a1d44e16c6911f8", + "Microsoft.AspNetCore.SignalR.Client.dll": "f5201eaf736cab8651013a49b6bd8bbd2d80fb2f46ffdef0e40ce21bfcb161f3", + "Microsoft.Bcl.AsyncInterfaces.dll": "136d5965cf4768e8420b547a8bddea882921f426c371833d558a858a2f0c235a", + "Microsoft.Bcl.Cryptography.dll": "009a27b8e3093fdd2960bba63e4acd48eab05c4f8f8a6d9fe8c24b4657f44c4f", + "Microsoft.CodeAnalysis.CSharp.Scripting.dll": "d0f4798de9cb78c13463a0f3df747814c177ec15e03e1c03aee17136798a2cfe", + "Microsoft.CodeAnalysis.CSharp.dll": "36f5ac8da30a6107f53a2ca6509b61e284c08eb59aa1b22956d4e200e4514aa5", + "Microsoft.CodeAnalysis.Scripting.dll": "7c3973a0997a1901c4f5978ef901e3ae96ddb780dead70a42f65f2e3f6f23e8f", + "Microsoft.CodeAnalysis.dll": "10f489db67b8ac7489e58d392166c928302ba5698506dd652311da5d89f0a0f8", + "Microsoft.Data.SqlClient.dll": "5a34e2fa3479b1508dbc20fbeb2c9172f18c3868bdb147a185213a446645b400", + "Microsoft.Data.Sqlite.dll": "9f1fe804321767b6cc8db751ecedd56ab308e5f15492a7f40d7093bb61ab7638", + "Microsoft.EntityFrameworkCore.Abstractions.dll": "34aaa94035fdb18400c9c40df82a731d935153e71c99932a92830e5807cf41d6", + "Microsoft.EntityFrameworkCore.Relational.dll": "ae537828754942c45e884795bf666205f5cff414c9238641bbe8687ea455cb79", + "Microsoft.EntityFrameworkCore.SqlServer.dll": "9261df9184d4aa3914e9f20cbe9a8abc478702de3ebdddcb622143f798698464", + "Microsoft.EntityFrameworkCore.dll": "1783882ff577f09cd2b220f322e0b3eea0f77bb86f80611089274482ae1dbf75", + "Microsoft.Extensions.DependencyModel.dll": "3a39ec75b47ea48175fe0586dc7513bb4f56423d2946662b8dac24afde925d8f", + "Microsoft.Extensions.Hosting.WindowsServices.dll": "39de9399e095736aeae2a29568207ea349d889bc3b72affa68f92d6581bf6f1a", + "Microsoft.Identity.Client.Extensions.Msal.dll": "9c1f736b16cacd318afe07d3b9d707a4b4b56def5e403b0aff471c1af413aaf0", + "Microsoft.Identity.Client.dll": "10d59df4170053ea9597e3c20adc9607ad17318ad5d8747eda3d930a5a4b463a", + "Microsoft.IdentityModel.Abstractions.dll": "b438fd27bdd5ba7dc4a482c1f135d6305301b1685f624bb36ac0ed24f499fc2d", + "Microsoft.IdentityModel.JsonWebTokens.dll": "cf889db7a04e956d03726954f9389a23a952666a66137021c712ee977630bd37", + "Microsoft.IdentityModel.Logging.dll": "da14a0467587838b7fedc6670315452ff9c7a9fe54fb7f0742fe7a34274753b7", + "Microsoft.IdentityModel.Protocols.OpenIdConnect.dll": "3fdcb7b20fe91de47857aa3fee0d13affaecfd0544cae5a3ad3f7f105a3d8cd6", + "Microsoft.IdentityModel.Protocols.dll": "1126552d469948ed6d7887e8c24cbd65fddad103193eeea869930e27da2bc010", + "Microsoft.IdentityModel.Tokens.dll": "b3d4bcb1d9f9c469825e7aa041bc35c33d85651a88ee24b5ef9ea29d7502d214", + "Microsoft.SqlServer.Server.dll": "a9dca1b42bc875f966b78b2c0880e62b838f0ed6567166d7f1f07ae4b76ec4bf", + "MySqlConnector.dll": "e7734ef5db26f5e5626f8ef354831c60adff9a8e88447cc5e865cfe1f9e466bc", + "Newtonsoft.Json.dll": "a28c251dfe36d881e9e2462e171441b8b0ec156fe3f452602c9149b1b9efe05b", + "Novell.Directory.Ldap.NETStandard.dll": "85918b6f9e91acffac9bd081b70404b0456c7a6f0c9c5666ccda8951bd8120d4", + "Npgsql.dll": "e2bcafe1660fe4543fe9dfcabed972ec8d32259e5ea8009462ce1de23c7034c2", + "Opc.Ua.Client.dll": "fd000b186f4bc5dbd9947e876f96c178e8c4259ee3e8717d672a4ac2f4c3a058", + "Opc.Ua.Configuration.dll": "30fb5142f13a3b3083c0484bcdedaec2efe2f50e57f10ec6a61257ca5359aa7e", + "Opc.Ua.Core.dll": "602e85316943ad7ebae33a23d60a69a6ea50d91250ad0556906b816435daa37c", + "Opc.Ua.Security.Certificates.dll": "a2a05c64348f6f8aa60de0fe27d8e5e22d12e09b1ba6172ca34b3773620e394c", + "Opc.Ua.Server.dll": "d8d9706dea577858325730cd89896826ed82f7bfcf9503ccd0260311663a69f4", + "Opc.Ua.Types.dll": "c5c5e36cf6381444b408fe1b51726b17deca74173764cd62ccee954b3c8c2718", + "OpenTelemetry.Api.ProviderBuilderExtensions.dll": "5c5727de149a0232825774a8ee75b60581ce19ce8b944d422bd545e2e3d7f915", + "OpenTelemetry.Api.dll": "ca5ddb7a51bcbb1ab8bcc6484603c70a4077142a8745d521c4bd2363f9e7c217", + "OpenTelemetry.Exporter.OpenTelemetryProtocol.dll": "20bf20b94e2e92a73d20d97b81d9cd3b26ef0967ff29f80d84b421c4317ac77e", + "OpenTelemetry.Exporter.Prometheus.AspNetCore.dll": "60dcd62f532a61821328e52e511bd47db620c301c7105c4aaf70619c0f217d65", + "OpenTelemetry.Extensions.Hosting.dll": "a627ebf2a7d14e0f0b3c2568e6ee37773397de25c90ee89d4560422c42d8b945", + "OpenTelemetry.Instrumentation.AspNetCore.dll": "247771e79186a704722510e03aefb2f09c10286ff3fc658dcd4bb81ba347f6c3", + "OpenTelemetry.Instrumentation.GrpcNetClient.dll": "8edab07d2cc02b81cc53bd9ccc0f6160e483a4b42ced3cf339de530fecfe88ee", + "OpenTelemetry.Instrumentation.Http.dll": "154c41bc484085a74a0b1886478ffb4aeaf850686d173d0c93a11ad0283aea2e", + "OpenTelemetry.Instrumentation.Process.dll": "a789454f78efbf4d2f04605b98d3f143f6396bec208f4b5765e8e8d2d0f35143", + "OpenTelemetry.Instrumentation.Runtime.dll": "08b62837d801db4afe0ac77d27fe66fff99493cbb6b9c49a5876627c2aabd7a8", + "OpenTelemetry.dll": "edc9799efd614cb083193d90eafcd99abf70496738c3065933093cf99d162cae", + "Oracle.ManagedDataAccess.dll": "a76f5f278e9db505d76ce21bc57163c0079ec03ef1dda7d9a524d9bec3a3bbbf", + "OtOpcUa.Host.dll": "e88fc71f59e69e15c3191a782c29ce44127e320c7560ddd26ce1759787806f98", + "Polly.Core.dll": "802ffe5c74c26cf6bdd0f0ecacc36965807a267765f61b63eea8605da15fe0e3", + "Reactive.Streams.dll": "dfb748806727fe261f48e15ed6c1e3ab952f7021208fec4df0184615ba5ec6f0", + "S7.Net.dll": "e293fe25f6e774069a5c38f0778e47f2c8a0d7327741a6df1c62fb0f98d497cf", + "SQLitePCLRaw.batteries_v2.dll": "bc69777001eb4db81c580f62835396f67e74aaa381eef446193a904499d5310b", + "SQLitePCLRaw.core.dll": "50c999a1ab2afeacc93bce5ac2948d3bb630d99d23efc3cfcbd8bc11d3426eb7", + "SQLitePCLRaw.provider.e_sqlite3.dll": "02ad639f45a26de1919ffbb6696bdb399ad01afc149970a163c3867162f310b3", + "Serilog.AspNetCore.dll": "a550c57df7a04edbed00da036fc14be12acd0d425b7401855975fb628e3dbada", + "Serilog.Extensions.Hosting.dll": "3e6d0284179ee0e1c197568fd79b58f869d15298fff8ecb8447322fe87d44f47", + "Serilog.Extensions.Logging.dll": "80d3edbe3e3ac0b4c5bc764474220e7da11df8d285e0098f3dc1b65a734c8507", + "Serilog.Formatting.Compact.dll": "319fbcefc2161dd50ccdd8d60b30edee48a09f794aedb28421a23f35ddd670d9", + "Serilog.Settings.Configuration.dll": "ec8cfd1f8970a44e2aa3f7bcc71116ca2691b196564bff83e3e3ead0c1143b67", + "Serilog.Sinks.Console.dll": "dc88002ddd9f5fd0ffec9a6568ef89954671f60f2c9161593ee78932538c1e3e", + "Serilog.Sinks.Debug.dll": "df543d3df8bd00d72e5eb2b9b2a15e67a6e4d10c13834de4cedbf500b8793e01", + "Serilog.Sinks.File.dll": "4f4282671c2ac68284b4dc99f7a76eac9cbd4e659978cef642cff9e6c01b676d", + "Serilog.Sinks.OpenTelemetry.dll": "e17a2dd847560cd22bdb6df8302f8fd202c3f073888cdd9ad8b1df9e80da4351", + "Serilog.dll": "e6b551a75ff7fff20dd0024670d5c42dfb74afa16d54aa0201106dea400a9505", + "System.ClientModel.dll": "ce44a4fae4c4787c12475700e19a365fc2f388ae5d0f6182557ce5ea175be7f6", + "System.ComponentModel.Composition.dll": "434522d676f626589e21aedea883f6acfbe276f9c3a935dfb4d8af7a19feb75a", + "System.Configuration.ConfigurationManager.dll": "08b618461d62fe65451bdac4dbc25f8ac8ab16a914a687f2dbe3923bf0e8b3e7", + "System.Data.Odbc.dll": "703fa599513e6ef21193933f061f2b6cdd57f268d593344faa5980b823e8226c", + "System.Diagnostics.PerformanceCounter.dll": "c596c35317c7bd5ae3938854996d62c24c7f67f61d3710a379bf1f3ab1a9e3b4", + "System.DirectoryServices.Protocols.dll": "096102bad94746479987ffc4fc6c9faafb9e1ae6ed1c74c9a7dccae0e4f3ea9f", + "System.IdentityModel.Tokens.Jwt.dll": "56cf18b0b16ea80738e0768cdcbc9368f13bdbedaca86025756009e30f969fe6", + "System.Interactive.Async.dll": "75a516771f2e10fdb76c1ea603f8d11e702af7ec97b383f1036cee114ef3f491", + "System.Linq.Async.dll": "149757a4113ae6102c425f1469a7cc14deb28635e94cbc9e0404f5e4dc518001", + "System.Memory.Data.dll": "bae79a4ff6e8fcfb65a3d88eb53d281898e699e5471ebd780843e5616753f0c3", + "System.Reactive.dll": "c1cae1a8b97d5e0ed64f7a9947f6ae44498398b6e9ee71473c2bef24646e91f8", + "System.Security.Cryptography.ProtectedData.dll": "02321322ec85e0a68f28ad33e549213b1dbf3de0e66c3f7803f9ae32c0d00ffd", + "System.ServiceProcess.ServiceController.dll": "62ca0ff8bccaf622bd75f03b6a5ab46b8ad7b28c5eb6ba6a0a9e4ecc49cca640", + "TwinCAT.Ads.Abstractions.dll": "f9892e164816e0b1cc9aa47c2efe3f48814ea8fbe4f04a125460555eaac9d9ab", + "TwinCAT.Ads.ConfigurationProviders.dll": "016eb9f6687832b0a7a819609ffb3227204f75732919ef19fb3366c038a11c5e", + "TwinCAT.Ads.Server.dll": "7da06f37c0572d5a8af8e0a5d6a81bea18c3ce1c08ee7501668570fc70a7d033", + "TwinCAT.Ads.dll": "2a9c2ca91889e24f088123ce313fc96060897b9e34232022b0566dfd2ea32a0d", + "ZB.MOM.WW.Audit.dll": "8dfda63f20ac0a34c43716f593bcad60755daf71ae4aefbf7ab1f34a0951de11", + "ZB.MOM.WW.Auth.Abstractions.dll": "24099d4d38811a364569cba4924af2430fe1e8ad8d3e735bd840dbfaa548cef8", + "ZB.MOM.WW.Auth.AspNetCore.dll": "ac062c1f634055ad9b80bd13344481318d6f45ac45f40dbaeed861ee20a75984", + "ZB.MOM.WW.Auth.Ldap.dll": "8625dea672beff26bd8f4f2aa54307cf652e50ad66a2c6625bb27d282199c32d", + "ZB.MOM.WW.Configuration.dll": "ad89f1d2abcad33be99b03bca37b26a9b92f90c354e98a99928d6176b12d58a7", + "ZB.MOM.WW.Health.Akka.dll": "a1345d712159544954955b41e7d04bc35180e1b9b36fdddcaedff5821a09d9c1", + "ZB.MOM.WW.Health.EntityFrameworkCore.dll": "d4fa98ca71512d1927037db22477facf49472249854898fca55c49c726307693", + "ZB.MOM.WW.Health.dll": "3c95dff17440b9df9195092812949b6e16e0c02456953650a839963af66df633", + "ZB.MOM.WW.HistorianGateway.Client.dll": "a4567376dba7d63f566aab1eea7509832c82ec8bb66c89575d85041ef370d46f", + "ZB.MOM.WW.HistorianGateway.Contracts.dll": "d5cd87ee5279b1bc532c6508dcd227af4bf883819b2f3a54dfec7d799c944547", + "ZB.MOM.WW.LocalDb.Contracts.dll": "d4da2a5bdfd3ebcb56f7ec948cda12bf378dc34079cd20e864509902a93bed38", + "ZB.MOM.WW.LocalDb.Replication.dll": "234e31795fd0641f8f873f9ce9641d7d4b028be724463abdafb0f119dc18d800", + "ZB.MOM.WW.LocalDb.dll": "ac243f94af069faa0b171556a6e24bd5140237f275f3548c37789993c221ee6c", + "ZB.MOM.WW.MxGateway.Client.dll": "0c058c2827829d54a8556308e4ed552f1cb0011b863c26dafd40cef7bff5c42d", + "ZB.MOM.WW.MxGateway.Contracts.dll": "af97aa90aa944afd6e7613d5bbdbe85cd43c6f33f2bcdcf74b1ef5d854369775", + "ZB.MOM.WW.OtOpcUa.AdminUI.dll": "1ae11959c22bc53a648b91c6c1ae41e4a5d717e396bd645eae4fb08dc1633597", + "ZB.MOM.WW.OtOpcUa.Cluster.dll": "d6bc21641172d832004b62b8bb76aeb40622a943be2172f394e5c6333c04ef57", + "ZB.MOM.WW.OtOpcUa.Commons.dll": "be97a0b975afde7ec4ebf0b10de53c26f212ceca1f6a3ae090e40ebfde304413", + "ZB.MOM.WW.OtOpcUa.Configuration.dll": "195dab9f7a9f80c45902e653ff361116a307d8110a3f87baad814bea57689b84", + "ZB.MOM.WW.OtOpcUa.ControlPlane.dll": "36954f51b09930df414675e5a0c038933ad2b27cd6560bf797d99801c02b30a1", + "ZB.MOM.WW.OtOpcUa.Core.Abstractions.dll": "b0f4e332ced57eae3ab1dcc282c073f51ea0c545a381aef50479ee58f0c23efc", + "ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian.dll": "a61a6ea68236dd4ed86ab4e74e4d632c5e260103aa5ebd92f4f995eb9f170b22", + "ZB.MOM.WW.OtOpcUa.Core.ScriptedAlarms.dll": "f1e429c0b8fcab8216b9107440008b92eea1236ff1225e79580ad70f51d56431", + "ZB.MOM.WW.OtOpcUa.Core.Scripting.Abstractions.dll": "ea24898698c8351bc9cf20fcce725dccc93ccf05ef3af7783f73854cc2033c31", + "ZB.MOM.WW.OtOpcUa.Core.Scripting.OutOfProcess.dll": "cf44009a720a00bf9192374d371c7c76e75afbe62cc216b5c1be913b92679127", + "ZB.MOM.WW.OtOpcUa.Core.Scripting.Protocol.dll": "07800332d0842b93c3987fca1dc10a1390bcb16f44567610d867513ad9fe17e0", + "ZB.MOM.WW.OtOpcUa.Core.Scripting.dll": "9637b7ffb4984f54bc54363ff2d81b6a3401f0cb7eeed8694db626ef41d54d5b", + "ZB.MOM.WW.OtOpcUa.Core.VirtualTags.dll": "107aaf2ef2d7704e320dabc1072bc50217faabb2d1488e66c91b1f756b440c45", + "ZB.MOM.WW.OtOpcUa.Core.dll": "34a4d7c0dddf4efa5fae91a3798c2f1c08b992faf4a827a9e05ed1338c6e4720", + "ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport.dll": "315dcc540d304c9f1d5b48caa25e5f081569f1a41aa8784cf371c1d6cef7322d", + "ZB.MOM.WW.OtOpcUa.Driver.AbCip.Contracts.dll": "d7b34798587d0939cc78eb69d9df1d617c1c75a61b8dd11a5308958a43a8c4f1", + "ZB.MOM.WW.OtOpcUa.Driver.AbCip.dll": "73073627fcdc8079df645478d6717576975117c3b21cfa7e9422f1e3bc5f4e44", + "ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Contracts.dll": "5c66d76dd455c42f0c5b0aed11240fa31e1bdbd2f0a8368d8f41976977e93502", + "ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.dll": "cbf92a935d86596a9d4dbeeaa625e304c2045851a0367c3a6b0de03bf78bd6fa", + "ZB.MOM.WW.OtOpcUa.Driver.Calculation.Contracts.dll": "29c079414497b30debe8d3ecd7e77bdc4eb16c4fc076e675680a2e880e54b6c2", + "ZB.MOM.WW.OtOpcUa.Driver.Calculation.dll": "132e36042a4691cc8e252ab9e9d8c90592fcd897959f533aa37e33f193cf00c8", + "ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Contracts.dll": "2bdbf743194193d5a7bc323912e2c7f740cc21633154a4a3cc8e034fd15bb7e8", + "ZB.MOM.WW.OtOpcUa.Driver.FOCAS.dll": "17c28f27fdecd09a46b971b19655bdb933f84990e91bb80c7092c344a0ca974f", + "ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Browser.dll": "f2796d323c222708c28cd0a4289c46db31ec3b6537da7f5cd260fc76f8abdc76", + "ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Contracts.dll": "780a11f69194713e2f87e74277e99882ee3518b2824551b45cd04e3b9bdf6648", + "ZB.MOM.WW.OtOpcUa.Driver.Galaxy.dll": "a8e19baa5a736544d914f942d526a5cc038f6b982451bfa82a77365a159434e4", + "ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway.dll": "400b1896e55d08781231efeba302596299df2b00b2f48afd43d46c22d59b515c", + "ZB.MOM.WW.OtOpcUa.Driver.Historian.QuestDb.dll": "8e91a8cce804023639a4bdb2dc60f9fc950992882e50786d45ceeb0f38ed1f68", + "ZB.MOM.WW.OtOpcUa.Driver.Historian.Sql.Common.dll": "2746b8e9c03b5b8c330152803eee91cf2069f0e6c074d70d03017b1f1f1a2398", + "ZB.MOM.WW.OtOpcUa.Driver.Historian.SqlServer.dll": "94b9bcd4506427a44158e0b299a5ae7bcee14fd40b85cc9f63420e4631aa1a6f", + "ZB.MOM.WW.OtOpcUa.Driver.MTConnect.Contracts.dll": "6582151085ddea7d319b990c2c58057b6ba5a49860593229b3642dff527ae204", + "ZB.MOM.WW.OtOpcUa.Driver.MTConnect.dll": "c9670c5d169056563294673839ca63321a72a438c519263be708b55f3fc818f9", + "ZB.MOM.WW.OtOpcUa.Driver.Modbus.Addressing.dll": "ed07d04709372ef804f465995431b15acdef791f66c8130ab7282372728f7cda", + "ZB.MOM.WW.OtOpcUa.Driver.Modbus.Contracts.dll": "724873ac2f6c08f307a150c5575cc3c022d7e367124ed924c0c7899b0e9575a5", + "ZB.MOM.WW.OtOpcUa.Driver.Modbus.dll": "db1e3e7c79dc1a46e1d4ffaa5ea1aac9ed73814d7f06cbfa855ebb3b27a8810d", + "ZB.MOM.WW.OtOpcUa.Driver.Mqtt.Browser.dll": "ace18db746c30307e67efa3acd68e915cc2b62b0a85bdba833df4ea7c85b5f6c", + "ZB.MOM.WW.OtOpcUa.Driver.Mqtt.Contracts.dll": "24e795bd8027d7b3ca3d95630b73be6d7cef774243357b01850f145b6066dcb9", + "ZB.MOM.WW.OtOpcUa.Driver.Mqtt.Transport.dll": "bec0cecc0bbb06b4715d7b909ccf4d357420e120b2bff3c10ee9f59f71044927", + "ZB.MOM.WW.OtOpcUa.Driver.Mqtt.dll": "da64eacb80ddca9cd0a40295bba2c8ff81ee9c68ccaf32cbd329ae854375deb7", + "ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Browser.dll": "7e2ac501136d24a3d0ad6bdae2e4a47460439ad8ab78af538bbccca2e38e5695", + "ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Contracts.dll": "c15e6db37681cbbef8684d5301e1bba54186ae503aaf55d1c2d06a0567ab28fe", + "ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Session.dll": "910604abd4daa6196c8fdcd2db085873ee5a4c27b5a67c359590071117c6e4dd", + "ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.dll": "cd689b0ec777820d91f914abfd9e4a921143a46df84ee43d0214c66f74225ac0", + "ZB.MOM.WW.OtOpcUa.Driver.S7.Contracts.dll": "6fe895674318dc42c0c3cc74266831862d3fe2f13098c26e7d826baf79d7fc47", + "ZB.MOM.WW.OtOpcUa.Driver.S7.dll": "d23a7ac62d781f0c14dd7c9d4f51b712c13599ee78b9b6d302d30dfd5e77da37", + "ZB.MOM.WW.OtOpcUa.Driver.Sql.Browser.dll": "c341d49bf100e0617d9c4e7d24f63d8affd1bc0fe2edce15e51cc14366fa2207", + "ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts.dll": "f0a0cc852116f739247422a0427550e52c938b27d1a8b4e685f45a19a23635ab", + "ZB.MOM.WW.OtOpcUa.Driver.Sql.Dialect.dll": "7d78655da50c07ac049cd687c59f2a7b6eb2c491543bd4089ffbe60fb805205f", + "ZB.MOM.WW.OtOpcUa.Driver.Sql.dll": "6ec1a9bc7443c1d7b8084ee2fc5e67cbfd2a8d61add303a980cef78a46cb5c67", + "ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Contracts.dll": "96db9e5d162b19914cf0ba55c1408c1c9271c80c1a1a12604e684f5785de4b96", + "ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.dll": "c24cfc897bde6c0eb65b9958bad952814ed02a27fe25a55c416c1ba61be2c261", + "ZB.MOM.WW.OtOpcUa.OpcUaServer.dll": "ee1f704fa1574b77bf56cef415c47c33a4428c6852db52bb1443d6765d092cb1", + "ZB.MOM.WW.OtOpcUa.Runtime.dll": "50e752383ae81ef6bb23e360fafe9162be0d1dcb7dd2d8731f16bce762834dd4", + "ZB.MOM.WW.OtOpcUa.Security.dll": "a88b1577d1e4dd580e012e7673e31d5363c3d9a79fb415bef4c3d63849678a4d", + "ZB.MOM.WW.Secrets.Abstractions.dll": "3a39c92e9a96a305bd229e99d2f59f2c273f8d08c03e431d47e24bd8b8b0ef49", + "ZB.MOM.WW.Secrets.Replicator.AkkaDotNet.dll": "d6a3780f3487f5c8432fe12c057defb709d1dc7678c59307acd19b4cb0d6bdb7", + "ZB.MOM.WW.Secrets.Ui.dll": "782f903b42bce46fb3de827e24d1edcbe41187976b6918c740383de158e35064", + "ZB.MOM.WW.Secrets.dll": "0565fd86abead89be7b4520dddf92cabd5d0994f3620069aa496b8dfa41c9f39", + "ZB.MOM.WW.Telemetry.Serilog.dll": "bd33ce7657de5d2966a7768a014f8282ca434a208b05defa2d27bf24c6f124c5", + "ZB.MOM.WW.Telemetry.dll": "834772ecc662ea7c49a5b512a26f2447db55a072ef1fad16ca768fbee0cfe853", + "ZB.MOM.WW.Theme.dll": "12bf7d7ec7a618acdf9f5bff9a7c67091ce715698d3befb9aa610cc5c8b1b221", + "libplctag.NativeImport.dll": "dec38f56006ae9e2119e9f61f9ff0e1aa9c08503ba4f42943c2d7632f60cbad5", + "libplctag.dll": "1545b5813148d7ade7662282683e15d2761e0e34cb853bafa3b11a4d47795aa4", + "CliFx.dll": "af06268aba8215c17b300fe8ec81bbef8d9982b5958a3291563f504537ce844d", + "Microsoft.Extensions.DependencyInjection.Abstractions.dll": "ca708422782fb25819941a16a057ea96d6d18b037e7e5cbfdf340b7a04362b57", + "Microsoft.Extensions.DependencyInjection.dll": "47f8175d34e9087d3858644803c558cb9cf52b29bffda796f65c1c527d1b6a22", + "Microsoft.Extensions.Logging.Abstractions.dll": "ec244a2db19dffe90cd299fa4b0691456ced342a078b4a93cf3726a9b431e9ac", + "Microsoft.Extensions.Logging.dll": "74d8fd2d7997fc638474e2bd79916458a30481e6a6925b50e7e96b4b852031c3", + "Microsoft.Extensions.Options.dll": "644350f8c2404d4479b97a250edb29585e5fafec1b6ce8486ae600c5015fd7fb", + "Microsoft.Extensions.Primitives.dll": "a0794c3bab2d7e0c848f0dffb3b9aa4b43ce07dc0abd122ebb7bf6dc79452ec4", + "ZB.MOM.WW.OtOpcUa.Client.CLI.dll": "38ff27df4c1389d2cf97a7ec1fe206733f02c3664b29c4fe18586ede225a53ca", + "ZB.MOM.WW.OtOpcUa.Client.Shared.dll": "326e14df7bf2a7602637fbff36988c3dd4be38de936da24a1b4287c0ab685be6", + "Shouldly.dll": "498dad657f324ab068e800d5711ae36feb4af4ba9a572eb941197e2fb677549d", + "DiffEngine.dll": "0c6b99a47c609a4263b80feaed95a357e30be3ad5a1cda79355663e407682aa7" + }, + "builds": { + "ordinary": { + "directory": "/tmp/opcua2-baseline-semantic-build3", + "warnings": 0, + "errors": 0, + "sources": { + "Program.cs": "c5bcbea742f587e9f7c5dd6ef19bb70d8740c8d9079e9b94aa8a3708eb45281b", + "BaselineRig.cs": "8e8c9226d875f71303c8ac3b5a20ed9cf8b241f4e30e9ba140f8fe9aeb7350d9", + "BaselineMetrics.cs": "9c94bd5b04d8d1835a7f718fbbff8b191c7d366bbd52af6bc894fcbfeccdde9e", + "CanonicalOperations.cs": "a2236295480ad81ace27ea7311991a12a7827eed62729fb1aae6f56752a7da6c", + "SemanticRetention.cs": "6b0ef8f9814179f3d6343fcf2fd5c197be741215b53a738ff5c03b5ab6806fc7" + }, + "provenanceSha256": "3a94ef256dad04914c4af1b92db9d3b9b4f40ecf381e51af3e4dececf41d5744", + "buildLogSha256": "9aecf98dc5bf41ebe889067a87b8cd352390c80f3ba4c11d7a99a1427406ff40", + "adapterSha256": "1062361a8765fa802b4a151f12bb2dbe06ffd5b74d54f99ff99a40ad8ea038e2", + "runtimeConfigSha256": "f8bd1713a3691d58eb332a71675f129385b91e852b66e7b6761cae1f34d4efd2" + }, + "counterfactual": { + "directory": "/tmp/opcua2-baseline-semantic-build4", + "warnings": 0, + "errors": 0, + "sources": { + "Program.cs": "10d5d0b17ea3af371728bea1f5843f67e1708a454cb89f6547446287ef05242d", + "BaselineRig.cs": "8e8c9226d875f71303c8ac3b5a20ed9cf8b241f4e30e9ba140f8fe9aeb7350d9", + "BaselineMetrics.cs": "9c94bd5b04d8d1835a7f718fbbff8b191c7d366bbd52af6bc894fcbfeccdde9e", + "CanonicalOperations.cs": "a2236295480ad81ace27ea7311991a12a7827eed62729fb1aae6f56752a7da6c", + "SemanticRetention.cs": "b68fbb55bbf5e95dc57bcdf5649f9b9d33c789ca8dd65deb4f2fe251c1629196" + }, + "provenanceSha256": "ad93747ffd870f818e4d5b42b14845b51a872ec3b790a2ae468bd974aec2e78f", + "buildLogSha256": "397eb7eceda6f03ee5d0b491ee5942631cb22cc56e11324bd501b947972b57f6", + "adapterSha256": "43f2c8e2ffb105494c5775b25ba64d78be3789ef4d76ace55f0fa6fbe31cd6f6", + "runtimeConfigSha256": "f8bd1713a3691d58eb332a71675f129385b91e852b66e7b6761cae1f34d4efd2" + } + }, + "runs": [ + { + "directory": "/tmp/opcua2-baseline-semantic-retention1", + "build": "ordinary", + "receipt": { + "mode": "semantic-retention", + "exitCode": 1, + "acceptance": false, + "productRebuilt": false, + "timeoutSeconds": 180, + "credentialBytes": 27 + }, + "artifactsSha256": { + "resources.jsonl": "227b11e0249a1d48fbe3034848abe6e987a980759027148dec3e86d19faab1e8", + "runner-receipt.json": "fdf448df2d5f8999d085e12b73211fafa4fb84ee08207e1eb92b14627318160a", + "opcua2-baseline-semantic-retention1.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "retainedClosedListAndManagerObservation": { + "kind": "semantic-closed-state", + "activeSessions": 0, + "rawClosedBrowse": 1, + "rawClosedHistory": 6, + "diagnosticReferenceHeld": true + }, + "correlatedWireResponses": [ + { + "kind": "semantic-wire", + "name": "fresh-read-before", + "requestHandle": 10001, + "responseHandle": 10001, + "responseType": "ReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "old-authentication-token", + "requestHandle": 10002, + "responseHandle": 10002, + "responseType": "ServiceFault", + "serviceStatusCode": 2149908480 + }, + { + "kind": "semantic-wire", + "name": "fresh-read-after", + "requestHandle": 10003, + "responseHandle": 10003, + "responseType": "ReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-browse", + "requestHandle": 10004, + "responseHandle": 10004, + "responseType": "BrowseResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "old-browse-point", + "requestHandle": 10005, + "responseHandle": 10005, + "responseType": "BrowseNextResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-browse-resume", + "requestHandle": 10006, + "responseHandle": 10006, + "responseType": "BrowseNextResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-browse-release", + "requestHandle": 10007, + "responseHandle": 10007, + "responseType": "BrowseNextResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-history", + "requestHandle": 10008, + "responseHandle": 10008, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "old-history-point", + "requestHandle": 10009, + "responseHandle": 10009, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-history-resume", + "requestHandle": 10010, + "responseHandle": 10010, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-history-release", + "requestHandle": 10011, + "responseHandle": 10011, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + } + ], + "oldBrowseItemResult": { + "kind": "semantic-item-status", + "name": "old-browse-point", + "statusCode": 2152333312 + }, + "oldHistoryBackendResult": { + "kind": "semantic-backend", + "operation": "old-history-point", + "before": 7, + "after": 7, + "statusCode": 2152333312 + }, + "resourceObservations": [ + { + "kind": "semantic-owned-resources", + "phase": "live-host", + "pkiDescriptors": 0, + "serverCachedStoreReferences": 1, + "clientCachedStoreReferences": 1, + "cachedReferenceIsOpenHandle": false + }, + { + "kind": "semantic-owned-resources", + "phase": "stopped-but-harness-held", + "pkiDescriptors": 0, + "serverCachedStoreReferences": 1, + "clientCachedStoreReferences": 1, + "disposalFlagObservable": false + } + ], + "weakTargets": [ + { + "kind": "weak-resource-shape", + "label": "old-client-session", + "type": "Opc.Ua.Client.Session", + "isDisposable": true, + "resourceFields": [ + { + "name": "m_instanceCertificate", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_nodeCache", + "type": "Opc.Ua.Client.NodeCache" + }, + { + "name": "m_serverCertificate", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_keepAliveTimer", + "type": "System.Threading.Timer" + }, + { + "name": "m_keepAliveWorker", + "type": "System.Threading.Tasks.Task" + }, + { + "name": "m_keepAliveCancellation", + "type": "System.Threading.CancellationTokenSource" + }, + { + "name": "m_reconnectLock", + "type": "System.Threading.SemaphoreSlim" + }, + { + "name": "m_eccServerEphemeralKey", + "type": "Opc.Ua.Nonce" + }, + { + "name": "m_defaultSubscription", + "type": "Opc.Ua.Client.Subscription" + }, + { + "name": "k__BackingField", + "type": "System.Diagnostics.Metrics.Meter" + }, + { + "name": "m_channel", + "type": "Opc.Ua.ITransportChannel" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "old-server-session", + "type": "Opc.Ua.Server.Session", + "isDisposable": true, + "resourceFields": [ + { + "name": "k__BackingField", + "type": "Opc.Ua.UserIdentityToken" + }, + { + "name": "k__BackingField", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_server", + "type": "Opc.Ua.Server.IServerInternal" + }, + { + "name": "m_serverCertificate", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_serverNonce", + "type": "Opc.Ua.Nonce" + }, + { + "name": "m_eccUserTokenNonce", + "type": "Opc.Ua.Nonce" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "old-browse-point", + "type": "Opc.Ua.Server.ContinuationPoint", + "isDisposable": true, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-browse-data", + "type": "Opc.Ua.NodeBrowser", + "isDisposable": true, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-0", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-0", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-1", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-1", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-2", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-2", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-3", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-3", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-4", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-4", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-5", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-5", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-rig", + "type": "BaselineRig", + "isDisposable": false, + "resourceFields": [ + { + "name": "k__BackingField", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaSdkServer" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-server", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaSdkServer", + "isDisposable": true, + "resourceFields": [ + { + "name": "_otOpcUaNodeManager", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaNodeManager" + }, + { + "name": "m_semaphoreSlim", + "type": "System.Threading.SemaphoreSlim" + }, + { + "name": "m_reassemblySessionManager", + "type": "Opc.Ua.Server.ISessionManager" + }, + { + "name": "m_serverInternal", + "type": "Opc.Ua.Server.IServerInternal" + }, + { + "name": "m_configurationWatcher", + "type": "Opc.Ua.ConfigurationWatcher" + }, + { + "name": "m_registrationTimer", + "type": "System.Threading.Timer" + }, + { + "name": "m_conformanceUnitsManager", + "type": "Opc.Ua.Server.ConformanceUnitsManager" + }, + { + "name": "m_requestQueue", + "type": "Opc.Ua.ServerBase+RequestQueue" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-node-manager", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaNodeManager", + "isDisposable": true, + "resourceFields": [ + { + "name": "_root", + "type": "Opc.Ua.FolderState" + }, + { + "name": "_historianDataSource", + "type": "ZB.MOM.WW.OtOpcUa.Core.Abstractions.IHistorianDataSource" + }, + { + "name": "_historyReadBatchLimiter", + "type": "System.Threading.SemaphoreSlim" + }, + { + "name": "k__BackingField", + "type": "Opc.Ua.Server.IServerInternal" + }, + { + "name": "m_monitoredItemManager", + "type": "Opc.Ua.Server.IMonitoredItemManager" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-backend", + "type": "Canonical+SqlLikeEventSource", + "isDisposable": true, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-config", + "type": "Opc.Ua.ApplicationConfiguration", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-application", + "type": "Opc.Ua.Configuration.ApplicationInstance", + "isDisposable": false, + "resourceFields": [ + { + "name": "k__BackingField", + "type": "Opc.Ua.ServerBase" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-server-validator", + "type": "Opc.Ua.CertificateValidator", + "isDisposable": false, + "resourceFields": [ + { + "name": "m_semaphore", + "type": "System.Threading.SemaphoreSlim" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-validator", + "type": "Opc.Ua.CertificateValidator", + "isDisposable": false, + "resourceFields": [ + { + "name": "m_semaphore", + "type": "System.Threading.SemaphoreSlim" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-server-store-0", + "type": "Opc.Ua.DirectoryCertificateStore", + "isDisposable": true, + "resourceFields": [ + { + "name": "m_lock", + "type": "System.Threading.SemaphoreSlim" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-store-0", + "type": "Opc.Ua.DirectoryCertificateStore", + "isDisposable": true, + "resourceFields": [ + { + "name": "m_lock", + "type": "System.Threading.SemaphoreSlim" + } + ] + } + ], + "boundedWeakObservations": [ + { + "phase": "live-host", + "round": 0, + "oldAlive": [ + "old-client-session", + "old-server-session", + "old-browse-point", + "old-browse-data", + "old-history-slot-0", + "old-history-value-0", + "old-history-slot-1", + "old-history-value-1", + "old-history-slot-2", + "old-history-value-2", + "old-history-slot-3", + "old-history-value-3", + "old-history-slot-4", + "old-history-value-4", + "old-history-slot-5", + "old-history-value-5" + ], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 124009224, + "rssBytes": 231129088, + "activeTimers": 10, + "gcCommittedBytes": 87769088, + "jitMethods": 9732 + } + }, + { + "phase": "live-host", + "round": 1, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94533480, + "rssBytes": 207060992, + "activeTimers": 11, + "gcCommittedBytes": 63635456, + "jitMethods": 9770 + } + }, + { + "phase": "live-host", + "round": 2, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94541224, + "rssBytes": 207060992, + "activeTimers": 11, + "gcCommittedBytes": 63635456, + "jitMethods": 9770 + } + }, + { + "phase": "live-host", + "round": 3, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94533000, + "rssBytes": 209059840, + "activeTimers": 10, + "gcCommittedBytes": 63635456, + "jitMethods": 9781 + } + }, + { + "phase": "live-host", + "round": 4, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94550728, + "rssBytes": 203997184, + "activeTimers": 10, + "gcCommittedBytes": 57606144, + "jitMethods": 10338 + } + }, + { + "phase": "live-host", + "round": 5, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94550728, + "rssBytes": 204111872, + "activeTimers": 10, + "gcCommittedBytes": 57606144, + "jitMethods": 10465 + } + }, + { + "phase": "after-stop", + "round": 0, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 96551432, + "rssBytes": 204832768, + "activeTimers": 7, + "gcCommittedBytes": 57606144, + "jitMethods": 10725 + } + }, + { + "phase": "after-stop", + "round": 1, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7774632, + "rssBytes": 178487296, + "activeTimers": 7, + "gcCommittedBytes": 31260672, + "jitMethods": 10726 + } + }, + { + "phase": "after-stop", + "round": 2, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7774200, + "rssBytes": 162217984, + "activeTimers": 7, + "gcCommittedBytes": 14991360, + "jitMethods": 10726 + } + }, + { + "phase": "after-stop", + "round": 3, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7774200, + "rssBytes": 162807808, + "activeTimers": 7, + "gcCommittedBytes": 14991360, + "jitMethods": 11109 + } + }, + { + "phase": "after-stop", + "round": 4, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7774200, + "rssBytes": 162824192, + "activeTimers": 7, + "gcCommittedBytes": 14991360, + "jitMethods": 11122 + } + }, + { + "phase": "after-stop", + "round": 5, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7774200, + "rssBytes": 162824192, + "activeTimers": 7, + "gcCommittedBytes": 14991360, + "jitMethods": 11124 + } + } + ], + "results": [ + { + "kind": "semantic-retention-result", + "semanticsComplete": true, + "liveHostOldSurvivors": [], + "afterStopSurvivors": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "acceptance": false, + "ownershipParity": false, + "unsupportedObservables": [ + "SDK2 CertificateManager disposed flag", + "SDK2 manager-owned cache-clear proof", + "ApplicationInstance.DisposeAsync" + ] + } + ] + }, + { + "directory": "/tmp/opcua2-baseline-semantic-terminal1", + "build": "counterfactual", + "receipt": { + "mode": "semantic-terminal-dispose", + "exitCode": 1, + "acceptance": false, + "productRebuilt": false, + "timeoutSeconds": 180, + "credentialBytes": 27 + }, + "artifactsSha256": { + "resources.jsonl": "b09a4ffde730cd252e23043cfbd1ad19015bbe5c1f7b56fbdc642c915d4599cf", + "runner-receipt.json": "830119567a0f7874e4076d07c8dd12e0676c649315f05910ab6df7262bcdbbc5", + "opcua2-baseline-semantic-terminal1.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "retainedClosedListAndManagerObservation": { + "kind": "semantic-closed-state", + "activeSessions": 0, + "rawClosedBrowse": 1, + "rawClosedHistory": 6, + "diagnosticReferenceHeld": true + }, + "correlatedWireResponses": [ + { + "kind": "semantic-wire", + "name": "fresh-read-before", + "requestHandle": 10001, + "responseHandle": 10001, + "responseType": "ReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "old-authentication-token", + "requestHandle": 10002, + "responseHandle": 10002, + "responseType": "ServiceFault", + "serviceStatusCode": 2149908480 + }, + { + "kind": "semantic-wire", + "name": "fresh-read-after", + "requestHandle": 10003, + "responseHandle": 10003, + "responseType": "ReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-browse", + "requestHandle": 10004, + "responseHandle": 10004, + "responseType": "BrowseResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "old-browse-point", + "requestHandle": 10005, + "responseHandle": 10005, + "responseType": "BrowseNextResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-browse-resume", + "requestHandle": 10006, + "responseHandle": 10006, + "responseType": "BrowseNextResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-browse-release", + "requestHandle": 10007, + "responseHandle": 10007, + "responseType": "BrowseNextResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-history", + "requestHandle": 10008, + "responseHandle": 10008, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "old-history-point", + "requestHandle": 10009, + "responseHandle": 10009, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-history-resume", + "requestHandle": 10010, + "responseHandle": 10010, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + }, + { + "kind": "semantic-wire", + "name": "fresh-own-history-release", + "requestHandle": 10011, + "responseHandle": 10011, + "responseType": "HistoryReadResponse", + "serviceStatusCode": 0 + } + ], + "oldBrowseItemResult": { + "kind": "semantic-item-status", + "name": "old-browse-point", + "statusCode": 2152333312 + }, + "oldHistoryBackendResult": { + "kind": "semantic-backend", + "operation": "old-history-point", + "before": 7, + "after": 7, + "statusCode": 2152333312 + }, + "resourceObservations": [ + { + "kind": "semantic-owned-resources", + "phase": "live-host", + "pkiDescriptors": 0, + "serverCachedStoreReferences": 1, + "clientCachedStoreReferences": 1, + "cachedReferenceIsOpenHandle": false + }, + { + "kind": "semantic-owned-resources", + "phase": "stopped-but-harness-held", + "pkiDescriptors": 0, + "serverCachedStoreReferences": 1, + "clientCachedStoreReferences": 1, + "disposalFlagObservable": false + } + ], + "weakTargets": [ + { + "kind": "weak-resource-shape", + "label": "old-client-session", + "type": "Opc.Ua.Client.Session", + "isDisposable": true, + "resourceFields": [ + { + "name": "m_instanceCertificate", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_nodeCache", + "type": "Opc.Ua.Client.NodeCache" + }, + { + "name": "m_serverCertificate", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_keepAliveTimer", + "type": "System.Threading.Timer" + }, + { + "name": "m_keepAliveWorker", + "type": "System.Threading.Tasks.Task" + }, + { + "name": "m_keepAliveCancellation", + "type": "System.Threading.CancellationTokenSource" + }, + { + "name": "m_reconnectLock", + "type": "System.Threading.SemaphoreSlim" + }, + { + "name": "m_eccServerEphemeralKey", + "type": "Opc.Ua.Nonce" + }, + { + "name": "m_defaultSubscription", + "type": "Opc.Ua.Client.Subscription" + }, + { + "name": "k__BackingField", + "type": "System.Diagnostics.Metrics.Meter" + }, + { + "name": "m_channel", + "type": "Opc.Ua.ITransportChannel" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "old-server-session", + "type": "Opc.Ua.Server.Session", + "isDisposable": true, + "resourceFields": [ + { + "name": "k__BackingField", + "type": "Opc.Ua.UserIdentityToken" + }, + { + "name": "k__BackingField", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_server", + "type": "Opc.Ua.Server.IServerInternal" + }, + { + "name": "m_serverCertificate", + "type": "System.Security.Cryptography.X509Certificates.X509Certificate2" + }, + { + "name": "m_serverNonce", + "type": "Opc.Ua.Nonce" + }, + { + "name": "m_eccUserTokenNonce", + "type": "Opc.Ua.Nonce" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "old-browse-point", + "type": "Opc.Ua.Server.ContinuationPoint", + "isDisposable": true, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-browse-data", + "type": "Opc.Ua.NodeBrowser", + "isDisposable": true, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-0", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-0", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-1", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-1", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-2", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-2", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-3", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-3", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-4", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-4", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-slot-5", + "type": "Opc.Ua.Server.Session+HistoryContinuationPoint", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "old-history-value-5", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.HistoryContinuationState", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-rig", + "type": "BaselineRig", + "isDisposable": false, + "resourceFields": [ + { + "name": "k__BackingField", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaSdkServer" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-server", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaSdkServer", + "isDisposable": true, + "resourceFields": [ + { + "name": "_otOpcUaNodeManager", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaNodeManager" + }, + { + "name": "m_semaphoreSlim", + "type": "System.Threading.SemaphoreSlim" + }, + { + "name": "m_reassemblySessionManager", + "type": "Opc.Ua.Server.ISessionManager" + }, + { + "name": "m_serverInternal", + "type": "Opc.Ua.Server.IServerInternal" + }, + { + "name": "m_configurationWatcher", + "type": "Opc.Ua.ConfigurationWatcher" + }, + { + "name": "m_registrationTimer", + "type": "System.Threading.Timer" + }, + { + "name": "m_conformanceUnitsManager", + "type": "Opc.Ua.Server.ConformanceUnitsManager" + }, + { + "name": "m_requestQueue", + "type": "Opc.Ua.ServerBase+RequestQueue" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-node-manager", + "type": "ZB.MOM.WW.OtOpcUa.OpcUaServer.OtOpcUaNodeManager", + "isDisposable": true, + "resourceFields": [ + { + "name": "_root", + "type": "Opc.Ua.FolderState" + }, + { + "name": "_historianDataSource", + "type": "ZB.MOM.WW.OtOpcUa.Core.Abstractions.IHistorianDataSource" + }, + { + "name": "_historyReadBatchLimiter", + "type": "System.Threading.SemaphoreSlim" + }, + { + "name": "k__BackingField", + "type": "Opc.Ua.Server.IServerInternal" + }, + { + "name": "m_monitoredItemManager", + "type": "Opc.Ua.Server.IMonitoredItemManager" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-backend", + "type": "Canonical+SqlLikeEventSource", + "isDisposable": true, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-config", + "type": "Opc.Ua.ApplicationConfiguration", + "isDisposable": false, + "resourceFields": [] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-application", + "type": "Opc.Ua.Configuration.ApplicationInstance", + "isDisposable": false, + "resourceFields": [ + { + "name": "k__BackingField", + "type": "Opc.Ua.ServerBase" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-server-validator", + "type": "Opc.Ua.CertificateValidator", + "isDisposable": false, + "resourceFields": [ + { + "name": "m_semaphore", + "type": "System.Threading.SemaphoreSlim" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-validator", + "type": "Opc.Ua.CertificateValidator", + "isDisposable": false, + "resourceFields": [ + { + "name": "m_semaphore", + "type": "System.Threading.SemaphoreSlim" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-server-store-0", + "type": "Opc.Ua.DirectoryCertificateStore", + "isDisposable": true, + "resourceFields": [ + { + "name": "m_lock", + "type": "System.Threading.SemaphoreSlim" + } + ] + }, + { + "kind": "weak-resource-shape", + "label": "fixture-client-store-0", + "type": "Opc.Ua.DirectoryCertificateStore", + "isDisposable": true, + "resourceFields": [ + { + "name": "m_lock", + "type": "System.Threading.SemaphoreSlim" + } + ] + } + ], + "boundedWeakObservations": [ + { + "phase": "live-host", + "round": 0, + "oldAlive": [ + "old-client-session", + "old-server-session", + "old-browse-point", + "old-browse-data", + "old-history-slot-0", + "old-history-value-0", + "old-history-slot-1", + "old-history-value-1", + "old-history-slot-2", + "old-history-value-2", + "old-history-slot-3", + "old-history-value-3", + "old-history-slot-4", + "old-history-value-4", + "old-history-slot-5", + "old-history-value-5" + ], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 135007448, + "rssBytes": 230785024, + "activeTimers": 10, + "gcCommittedBytes": 85491712, + "jitMethods": 9834 + } + }, + { + "phase": "live-host", + "round": 1, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94685384, + "rssBytes": 209371136, + "activeTimers": 11, + "gcCommittedBytes": 63815680, + "jitMethods": 9872 + } + }, + { + "phase": "live-host", + "round": 2, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94684904, + "rssBytes": 209371136, + "activeTimers": 11, + "gcCommittedBytes": 63815680, + "jitMethods": 9872 + } + }, + { + "phase": "live-host", + "round": 3, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94684952, + "rssBytes": 210812928, + "activeTimers": 10, + "gcCommittedBytes": 63815680, + "jitMethods": 10914 + } + }, + { + "phase": "live-host", + "round": 4, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94702424, + "rssBytes": 206733312, + "activeTimers": 10, + "gcCommittedBytes": 57786368, + "jitMethods": 12368 + } + }, + { + "phase": "live-host", + "round": 5, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 94702400, + "rssBytes": 207437824, + "activeTimers": 10, + "gcCommittedBytes": 57786368, + "jitMethods": 13006 + } + }, + { + "phase": "after-stop", + "round": 0, + "oldAlive": [], + "fixtureAlive": [ + "fixture-rig", + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-client-config", + "fixture-client-application", + "fixture-server-validator", + "fixture-client-validator", + "fixture-server-store-0", + "fixture-client-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 96717568, + "rssBytes": 208158720, + "activeTimers": 7, + "gcCommittedBytes": 57786368, + "jitMethods": 13276 + } + }, + { + "phase": "after-stop", + "round": 1, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7692448, + "rssBytes": 179224576, + "activeTimers": 7, + "gcCommittedBytes": 28819456, + "jitMethods": 13277 + } + }, + { + "phase": "after-stop", + "round": 2, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7692144, + "rssBytes": 163905536, + "activeTimers": 7, + "gcCommittedBytes": 13500416, + "jitMethods": 13277 + } + }, + { + "phase": "after-stop", + "round": 3, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7692144, + "rssBytes": 164282368, + "activeTimers": 7, + "gcCommittedBytes": 13500416, + "jitMethods": 13544 + } + }, + { + "phase": "after-stop", + "round": 4, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7692144, + "rssBytes": 164282368, + "activeTimers": 7, + "gcCommittedBytes": 13500416, + "jitMethods": 13554 + } + }, + { + "phase": "after-stop", + "round": 5, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7692144, + "rssBytes": 164298752, + "activeTimers": 7, + "gcCommittedBytes": 13500416, + "jitMethods": 13562 + } + }, + { + "phase": "after-terminal-dispose", + "round": 0, + "oldAlive": [], + "fixtureAlive": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 7815480, + "rssBytes": 164347904, + "activeTimers": 1, + "gcCommittedBytes": 13500416, + "jitMethods": 13602 + } + }, + { + "phase": "after-terminal-dispose", + "round": 1, + "oldAlive": [], + "fixtureAlive": [], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 4514624, + "rssBytes": 162758656, + "activeTimers": 2, + "gcCommittedBytes": 11911168, + "jitMethods": 13602 + } + }, + { + "phase": "after-terminal-dispose", + "round": 2, + "oldAlive": [], + "fixtureAlive": [], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 4513760, + "rssBytes": 162758656, + "activeTimers": 2, + "gcCommittedBytes": 11911168, + "jitMethods": 13602 + } + }, + { + "phase": "after-terminal-dispose", + "round": 3, + "oldAlive": [], + "fixtureAlive": [], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 4513760, + "rssBytes": 162938880, + "activeTimers": 2, + "gcCommittedBytes": 11911168, + "jitMethods": 13739 + } + }, + { + "phase": "after-terminal-dispose", + "round": 4, + "oldAlive": [], + "fixtureAlive": [], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 4513760, + "rssBytes": 162938880, + "activeTimers": 2, + "gcCommittedBytes": 11911168, + "jitMethods": 13743 + } + }, + { + "phase": "after-terminal-dispose", + "round": 5, + "oldAlive": [], + "fixtureAlive": [], + "positiveAlive": true, + "negativeAlive": false, + "process": { + "managedBytes": 4513760, + "rssBytes": 162922496, + "activeTimers": 2, + "gcCommittedBytes": 11911168, + "jitMethods": 13746 + } + } + ], + "results": [ + { + "kind": "semantic-retention-result", + "semanticsComplete": true, + "liveHostOldSurvivors": [], + "afterStopSurvivors": [ + "fixture-server", + "fixture-node-manager", + "fixture-backend", + "fixture-server-validator", + "fixture-server-store-0" + ], + "acceptance": false, + "ownershipParity": false, + "unsupportedObservables": [ + "SDK2 CertificateManager disposed flag", + "SDK2 manager-owned cache-clear proof", + "ApplicationInstance.DisposeAsync" + ] + }, + { + "kind": "counterfactual-terminal-dispose", + "invoked": true, + "ordinaryExitCode": 1, + "publicMethod": "ServerBase.Dispose", + "acceptance": false + }, + { + "kind": "counterfactual-attribution-result", + "ordinaryExitCode": 1, + "survivors": [], + "acceptance": false + } + ] + } + ], + "sourceInspection": { + "Session": { + "decompileArtifact": "/tmp/opcua2-baseline-session182.cs", + "decompileSha256": "863c2758362016e0b0a49371d50a563b00d21f477cc01befadee50eb842f57db", + "assembly": "Opc.Ua.Server.dll", + "assemblySha256": "d8d9706dea577858325730cd89896826ed82f7bfcf9503ccd0260311663a69f4" + }, + "SessionManager": { + "decompileArtifact": "/tmp/opcua2-baseline-session-manager182.cs", + "decompileSha256": "ad96ce49637c0f7776b0297c7ab016dc3e846fede92104beb853a40e2addb364", + "assembly": "Opc.Ua.Server.dll", + "assemblySha256": "d8d9706dea577858325730cd89896826ed82f7bfcf9503ccd0260311663a69f4" + }, + "ClientBase": { + "decompileArtifact": "/tmp/opcua2-baseline-clientbase182.cs", + "decompileSha256": "63b6dbf064aaeb41a974270aa9f0f3a673dfd356e76c3b001a291ad1b229732f", + "assembly": "Opc.Ua.Client.dll", + "assemblySha256": "fd000b186f4bc5dbd9947e876f96c178e8c4259ee3e8717d672a4ac2f4c3a058" + }, + "ContinuationPoint": { + "decompileArtifact": "/tmp/opcua2-baseline-browsepoint182.cs", + "decompileSha256": "465601b490be92cb5d38472e9dd5bd2533b3c25e99fe273c468e2f3432112482", + "assembly": "Opc.Ua.Server.dll", + "assemblySha256": "d8d9706dea577858325730cd89896826ed82f7bfcf9503ccd0260311663a69f4" + }, + "NodeBrowser": { + "decompileArtifact": "/tmp/opcua2-baseline-nodebrowser182.cs", + "decompileSha256": "3d1a83e89b32e362fed5effb6e1f11718f24e41d9c91a538db9fb694126d49cf", + "assembly": "Opc.Ua.Types.dll", + "assemblySha256": "c5c5e36cf6381444b408fe1b51726b17deca74173764cd62ccee954b3c8c2718" + }, + "ServerBase": { + "decompileArtifact": "/tmp/opcua2-baseline-serverbase182.cs", + "decompileSha256": "34dfc0dcba27eee714bf147e0d0937e7d721570b363585a3e642af2113c28221", + "assembly": "Opc.Ua.Core.dll", + "assemblySha256": "602e85316943ad7ebae33a23d60a69a6ea50d91250ad0556906b816435daa37c" + }, + "StandardServer": { + "decompileArtifact": "/tmp/opcua2-baseline-standardserver182.cs", + "decompileSha256": "ec4fd4eefb856bd7b8cefe4c270383c72414e7901a1706c8bf33e63d52e3b15a", + "assembly": "Opc.Ua.Server.dll", + "assemblySha256": "d8d9706dea577858325730cd89896826ed82f7bfcf9503ccd0260311663a69f4" + }, + "ApplicationInstance": { + "decompileArtifact": "/tmp/opcua2-rss-investigation/baseline-ApplicationInstance.cs", + "decompileSha256": "0fac69b8765bd9d3e74ebe65da8072644edde52ddf17ce98a02fff6fc8d42a9a", + "assembly": "Opc.Ua.Configuration.dll", + "assemblySha256": "30fb5142f13a3b3083c0484bcdedaec2efe2f50e57f10ec6a61257ca5359aa7e" + }, + "OpcUaApplicationHost": { + "gitRevision": "83ed880e", + "repositoryPath": "src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/OpcUaApplicationHost.cs", + "sourceSha256": "346362c8c18b5bcdb90757f654c02c68bad44fc5875abc8b4672f4c7ac49b381" + }, + "HistoryContinuationStore": { + "gitRevision": "83ed880e", + "repositoryPath": "src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/HistoryContinuationStore.cs", + "sourceSha256": "a044e212b7c715e53f2dd2a085816b1ff74dc5ff06ca53b6eaee83e11f079b28" + }, + "HistoryPaging": { + "gitRevision": "83ed880e", + "repositoryPath": "src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/HistoryPaging.cs", + "sourceSha256": "59feb77a9824cfea089c588dbb025db2385a721e04c1a65f58a8c7f2ef005dc6" + } + }, + "limits": [ + "Both ordinary outcomes remain exit 1; public terminal Dispose is a separately gated attribution intervention after recording ordinary failure.", + "All old objects collected with the same host alive, distinguishing held closed-list contents from live retention.", + "One fixture demonstrates bounded server-graph survival and terminal-disposal attribution, not unbounded growth or a measured particular task/timer GC root.", + "The exact NodeBrowser Dispose(bool) is empty; event HistoryContinuationState values have no IDisposable or backend/store ownership. This is fixture-specific.", + "Original CertificateManager disposed/cache-clear observables and ApplicationInstance.DisposeAsync are unavailable; never reported as zero.", + "No archived production source/binary, expected semantic result, resource cap or memory baseline changed.", + "Matched standalone SDK2 host/operation/runtime/observer parity remains a proposal, not implemented or acceptance-approved." + ] +}