Joseph Doherty
278 lines
13 KiB
C#
278 lines
13 KiB
C#
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Security.Certificates;
|
|
using Opc.Ua.Server;
|
|
using Shouldly;
|
|
using Xunit;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;
|
|
|
|
/// <summary>Verifies host ownership using the real sealed SDK2 server and public manager factories.</summary>
|
|
public sealed class OpcUaApplicationHostDisposalTests : IDisposable
|
|
{
|
|
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
|
private readonly string _pki = Path.Combine(Path.GetTempPath(), $"otopcua-sdk2-disposal-{Guid.NewGuid():N}");
|
|
|
|
/// <summary>Normal and repeated disposal complete one manager shutdown and terminal server cleanup.</summary>
|
|
[Fact]
|
|
public async Task Host_terminally_disposes_its_booted_server_once()
|
|
{
|
|
var factory = new RecordingSessionManagerFactory();
|
|
var (host, server) = await BootAsync(factory);
|
|
var manager = factory.Created.ShouldNotBeNull();
|
|
try
|
|
{
|
|
await host.DisposeAsync();
|
|
manager.ShutdownCalls.ShouldBe(1);
|
|
manager.DisposalCalls.ShouldBe(1);
|
|
await RequireTerminalServerAsync(server);
|
|
|
|
await host.DisposeAsync();
|
|
manager.ShutdownCalls.ShouldBe(1);
|
|
manager.DisposalCalls.ShouldBe(1);
|
|
await RequireTerminalServerAsync(server);
|
|
}
|
|
finally { await CleanupAsync(host, server); }
|
|
}
|
|
|
|
/// <summary>Manager disposal during Stop alone does not satisfy the terminal server assertion.</summary>
|
|
[Fact]
|
|
public async Task Stop_only_is_distinct_from_terminal_server_disposal()
|
|
{
|
|
var factory = new RecordingSessionManagerFactory();
|
|
var (host, server) = await BootAsync(factory);
|
|
var manager = factory.Created.ShouldNotBeNull();
|
|
try
|
|
{
|
|
await server.StopAsync(Ct);
|
|
manager.ShutdownCalls.ShouldBe(1);
|
|
manager.DisposalCalls.ShouldBe(1);
|
|
var probe = new NonCreatingNodeManagerFactory();
|
|
var stopped = await Should.ThrowAsync<InvalidOperationException>(() =>
|
|
server.NodeManagerLifecycle.AddAsync(probe, callerContext: null, Ct).AsTask());
|
|
stopped.GetType().ShouldBe(typeof(InvalidOperationException));
|
|
probe.CreateCalls.ShouldBe(0);
|
|
|
|
await host.DisposeAsync();
|
|
await RequireTerminalServerAsync(server);
|
|
manager.ShutdownCalls.ShouldBe(1);
|
|
manager.DisposalCalls.ShouldBe(1);
|
|
}
|
|
finally { await CleanupAsync(host, server); }
|
|
}
|
|
|
|
/// <summary>A manager shutdown failure is recorded by the SDK while terminal cleanup still completes.</summary>
|
|
[Fact]
|
|
public async Task Shutdown_stage_failure_still_terminally_disposes_the_server()
|
|
{
|
|
var factory = new RecordingSessionManagerFactory { ThrowAfterShutdown = true };
|
|
var (host, server) = await BootAsync(factory);
|
|
var manager = factory.Created.ShouldNotBeNull();
|
|
try
|
|
{
|
|
await host.DisposeAsync();
|
|
manager.ShutdownCalls.ShouldBe(1);
|
|
manager.DisposalCalls.ShouldBe(1);
|
|
ServiceResult.IsBad(server.ServerError).ShouldBeTrue();
|
|
server.ServerError.ToString().ShouldContain(RecordingSessionManager.ShutdownFailure);
|
|
await RequireTerminalServerAsync(server);
|
|
}
|
|
finally { await CleanupAsync(host, server); }
|
|
}
|
|
|
|
/// <summary>A factory failure after address-space initialization leaves the real server owned for cleanup.</summary>
|
|
[Fact]
|
|
public async Task Partial_startup_failure_does_not_strand_the_server()
|
|
{
|
|
var factory = new RecordingSessionManagerFactory { ThrowDuringCreate = true };
|
|
var host = NewHost(OpcUaHostStart.AllocateFreePort());
|
|
var server = new OtOpcUaSdkServer { SessionManagerFactory = factory };
|
|
try
|
|
{
|
|
var failure = await Should.ThrowAsync<ServiceResultException>(() => host.StartAsync(server, Ct));
|
|
failure.StatusCode.ShouldBe(StatusCodes.BadInternalError);
|
|
failure.InnerResult.ShouldNotBeNull().LocalizedText.Text.ShouldNotBeNull()
|
|
.ShouldContain(RecordingSessionManagerFactory.StartupFailure);
|
|
factory.CreateCalls.ShouldBe(1);
|
|
factory.Created.ShouldBeNull("the sentinel fails before constructing an unowned manager");
|
|
host.ApplicationInstance.ShouldBeNull();
|
|
host.Server.ShouldBeNull();
|
|
await RequireTerminalServerAsync(server);
|
|
await host.DisposeAsync();
|
|
await RequireTerminalServerAsync(server);
|
|
}
|
|
finally { await CleanupAsync(host, server); }
|
|
}
|
|
|
|
/// <summary>Configuration cancellation before ApplicationInstance adopts the server still releases its host owner.</summary>
|
|
[Fact]
|
|
public async Task Canceled_start_before_application_adoption_terminally_disposes_the_server()
|
|
{
|
|
var factory = new RecordingSessionManagerFactory();
|
|
var host = NewHost(OpcUaHostStart.AllocateFreePort());
|
|
var server = new OtOpcUaSdkServer { SessionManagerFactory = factory };
|
|
using var cancellation = new CancellationTokenSource();
|
|
cancellation.Cancel();
|
|
try
|
|
{
|
|
await Should.ThrowAsync<OperationCanceledException>(() => host.StartAsync(server, cancellation.Token));
|
|
factory.CreateCalls.ShouldBe(0);
|
|
factory.Created.ShouldBeNull();
|
|
host.ApplicationInstance.ShouldBeNull();
|
|
host.Server.ShouldBeNull();
|
|
await host.DisposeAsync();
|
|
await RequireTerminalServerAsync(server);
|
|
}
|
|
finally { await CleanupAsync(host, server); }
|
|
}
|
|
|
|
/// <summary>Every concurrent host disposer waits until the one actual manager shutdown is released.</summary>
|
|
[Fact]
|
|
public async Task Concurrent_disposers_share_completion_and_one_cleanup_owner()
|
|
{
|
|
var factory = new RecordingSessionManagerFactory();
|
|
var (host, server) = await BootAsync(factory);
|
|
var manager = factory.Created.ShouldNotBeNull();
|
|
manager.BlockShutdown = true;
|
|
var calls = new List<Task>();
|
|
try
|
|
{
|
|
calls.Add(Task.Run(async () => await host.DisposeAsync(), Ct));
|
|
await manager.ShutdownEntered.Task.WaitAsync(TimeSpan.FromSeconds(10), Ct);
|
|
for (var i = 0; i < 3; i++) calls.Add(host.DisposeAsync().AsTask());
|
|
calls.ShouldAllBe(task => !task.IsCompleted);
|
|
manager.ShutdownCalls.ShouldBe(1);
|
|
manager.DisposalCalls.ShouldBe(0);
|
|
manager.ReleaseShutdown.TrySetResult();
|
|
await Task.WhenAll(calls).WaitAsync(TimeSpan.FromSeconds(20), Ct);
|
|
manager.ShutdownCalls.ShouldBe(1);
|
|
manager.DisposalCalls.ShouldBe(1);
|
|
await RequireTerminalServerAsync(server);
|
|
}
|
|
finally
|
|
{
|
|
manager.ReleaseShutdown.TrySetResult();
|
|
try { await Task.WhenAll(calls).WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None); }
|
|
finally { await CleanupAsync(host, server); }
|
|
}
|
|
}
|
|
|
|
/// <summary>A terminal host rejects a new real server before invoking its manager factory.</summary>
|
|
[Fact]
|
|
public async Task Disposed_host_rejects_start_without_taking_server_ownership()
|
|
{
|
|
var factory = new RecordingSessionManagerFactory();
|
|
var host = NewHost(OpcUaHostStart.AllocateFreePort());
|
|
var server = new OtOpcUaSdkServer { SessionManagerFactory = factory };
|
|
try
|
|
{
|
|
await host.DisposeAsync();
|
|
await Should.ThrowAsync<ObjectDisposedException>(() => host.StartAsync(server, Ct));
|
|
factory.CreateCalls.ShouldBe(0, "the rejected server still belongs to its caller");
|
|
host.ApplicationInstance.ShouldBeNull();
|
|
host.Server.ShouldBeNull();
|
|
}
|
|
finally { await CleanupAsync(host, server); }
|
|
}
|
|
|
|
private Task<(OpcUaApplicationHost Host, OtOpcUaSdkServer Server)> BootAsync(RecordingSessionManagerFactory factory) =>
|
|
OpcUaHostStart.StartAsync(NewHost, () => new OtOpcUaSdkServer { SessionManagerFactory = factory }, Ct);
|
|
|
|
private OpcUaApplicationHost NewHost(int port) => new(new OpcUaApplicationHostOptions
|
|
{
|
|
ApplicationName = "OtOpcUa.SDK2.Disposal", ApplicationUri = "urn:OtOpcUa.SDK2.Disposal",
|
|
PublicHostname = "localhost", OpcUaPort = port, PkiStoreRoot = _pki, AllowAnonymous = false,
|
|
}, NullLogger<OpcUaApplicationHost>.Instance);
|
|
|
|
private static async Task RequireTerminalServerAsync(OtOpcUaSdkServer server)
|
|
{
|
|
// The public lifecycle checks terminal disposal before considering or invoking this factory.
|
|
var probe = new NonCreatingNodeManagerFactory();
|
|
var disposed = await Should.ThrowAsync<ObjectDisposedException>(() =>
|
|
server.NodeManagerLifecycle.AddAsync(probe, callerContext: null, CancellationToken.None).AsTask());
|
|
disposed.GetType().ShouldBe(typeof(ObjectDisposedException));
|
|
probe.CreateCalls.ShouldBe(0);
|
|
}
|
|
|
|
private static async Task CleanupAsync(OpcUaApplicationHost host, OtOpcUaSdkServer server)
|
|
{
|
|
try { await host.DisposeAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None); }
|
|
finally
|
|
{
|
|
// RED assertions still release the actual test-owned server; never dispose a manager manually.
|
|
await server.DisposeAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None);
|
|
}
|
|
}
|
|
|
|
private sealed class RecordingSessionManagerFactory : ISessionManagerFactory
|
|
{
|
|
internal const string StartupFailure = "controlled SDK2 partial startup";
|
|
private int _createCalls;
|
|
internal int CreateCalls => Volatile.Read(ref _createCalls);
|
|
internal RecordingSessionManager? Created { get; private set; }
|
|
internal bool ThrowDuringCreate { get; init; }
|
|
internal bool ThrowAfterShutdown { get; init; }
|
|
|
|
public ISessionManager Create(IServerInternal server, ApplicationConfiguration configuration,
|
|
TimeProvider timeProvider, Func<string, Certificate?> serverCertificateProvider)
|
|
{
|
|
Interlocked.Increment(ref _createCalls);
|
|
if (ThrowDuringCreate) throw new InvalidOperationException(StartupFailure);
|
|
return Created = new RecordingSessionManager(server, configuration, timeProvider)
|
|
{
|
|
ThrowAfterShutdown = ThrowAfterShutdown,
|
|
};
|
|
}
|
|
}
|
|
|
|
private sealed class RecordingSessionManager(IServerInternal server, ApplicationConfiguration configuration, TimeProvider timeProvider)
|
|
: SessionManager(server, configuration, timeProvider)
|
|
{
|
|
internal const string ShutdownFailure = "controlled SDK2 manager shutdown failure";
|
|
private int _shutdownCalls;
|
|
private int _disposalCalls;
|
|
internal int ShutdownCalls => Volatile.Read(ref _shutdownCalls);
|
|
internal int DisposalCalls => Volatile.Read(ref _disposalCalls);
|
|
internal bool ThrowAfterShutdown { get; init; }
|
|
internal bool BlockShutdown { get; set; }
|
|
internal TaskCompletionSource ShutdownEntered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
internal TaskCompletionSource ReleaseShutdown { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
public override async ValueTask ShutdownAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
Interlocked.Increment(ref _shutdownCalls);
|
|
if (BlockShutdown)
|
|
{
|
|
ShutdownEntered.TrySetResult();
|
|
await ReleaseShutdown.Task.WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None);
|
|
}
|
|
await base.ShutdownAsync(cancellationToken);
|
|
if (ThrowAfterShutdown) throw new InvalidOperationException(ShutdownFailure);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing) Interlocked.Increment(ref _disposalCalls);
|
|
base.Dispose(disposing);
|
|
}
|
|
}
|
|
|
|
private sealed class NonCreatingNodeManagerFactory : INodeManagerFactory
|
|
{
|
|
private int _createCalls;
|
|
internal int CreateCalls => Volatile.Read(ref _createCalls);
|
|
public ArrayOf<string> NamespacesUris => [];
|
|
public INodeManager Create(IServerInternal server, ApplicationConfiguration configuration)
|
|
{
|
|
Interlocked.Increment(ref _createCalls);
|
|
throw new InvalidOperationException("The terminal lifecycle probe must not create a node manager.");
|
|
}
|
|
}
|
|
|
|
/// <summary>Removes only this test's private fixture after bounded server cleanup.</summary>
|
|
public void Dispose()
|
|
{
|
|
if (Directory.Exists(_pki)) Directory.Delete(_pki, true);
|
|
}
|
|
}
|