private TestServiceConnection MockServiceConnection(IConnectionFactory serviceConnectionFactory = null,
IClientConnectionFactory clientConnectionFactory = null,
ILoggerFactory loggerFactory = null,
GracefulShutdownMode mode = GracefulShutdownMode.Off)
{
clientConnectionFactory ??= new ClientConnectionFactory();
serviceConnectionFactory ??= new TestConnectionFactory(conn => Task.CompletedTask);
loggerFactory ??= NullLoggerFactory.Instance;
var services = new ServiceCollection();
var connectionHandler = new EndlessConnectionHandler();
services.AddSingleton(connectionHandler);
var builder = new ConnectionBuilder(services.BuildServiceProvider());
builder.UseConnectionHandler <EndlessConnectionHandler>();
ConnectionDelegate handler = builder.Build();
return(new TestServiceConnection(
serviceConnectionFactory,
clientConnectionFactory,
loggerFactory,
handler,
mode: mode
));
}
public override Task OfflineAsync(GracefulShutdownMode mode)
{
var task1 = base.OfflineAsync(mode);
var task2 = Task.WhenAll(_onDemandServiceConnections.Select(c => RemoveConnectionAsync(c, mode)));
return(Task.WhenAll(task1, task2));
}
public TestServiceConnection(TestConnectionContainer container,
IServiceProtocol serviceProtocol,
TestClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
string serverId,
string connectionId,
HubServiceEndpoint endpoint,
IServiceMessageHandler serviceMessageHandler,
IServiceEventHandler serviceEventHandler,
ServiceConnectionType connectionType = ServiceConnectionType.Default,
GracefulShutdownMode mode = GracefulShutdownMode.Off,
int closeTimeOutMilliseconds = 10000) : base(
serviceProtocol,
clientConnectionManager,
connectionFactory,
loggerFactory,
connectionDelegate,
clientConnectionFactory,
serverId,
connectionId,
endpoint,
serviceMessageHandler,
serviceEventHandler,
connectionType: connectionType,
mode: mode,
closeTimeOutMilliseconds: closeTimeOutMilliseconds)
{
_container = container;
ClientConnectionManager = clientConnectionManager;
}
public static ServicePingMessage GetFinPingMessage(GracefulShutdownMode mode = GracefulShutdownMode.Off)
{
return(mode switch
{
GracefulShutdownMode.WaitForClientsClose => ShutdownFinKeepAlive,
GracefulShutdownMode.MigrateClients => ShutdownFinMigratable,
_ => ShutdownFin,
});
private async Task OfflineAndWaitForCompletedAsync(GracefulShutdownMode mode)
{
_logger.LogInformation("[GracefulShutdown] Unloading server connections.");
await _serviceConnectionManager.OfflineAsync(mode);
_logger.LogInformation("[GracefulShutdown] Waiting client connections to complete.");
await _clientConnectionManager.WhenAllCompleted();
}
public TestServiceConnection(IConnectionFactory serviceConnectionFactory,
IClientConnectionFactory clientConnectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate handler,
GracefulShutdownMode mode = GracefulShutdownMode.Off) : base(
new ServiceProtocol(),
new TestClientConnectionManager(),
serviceConnectionFactory,
loggerFactory,
handler,
clientConnectionFactory,
"serverId",
Guid.NewGuid().ToString("N"),
null,
null,
mode: mode
)
{
}
public ServiceConnection(IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
string serverId,
string connectionId,
HubServiceEndpoint endpoint,
IServiceMessageHandler serviceMessageHandler,
ServiceConnectionType connectionType = ServiceConnectionType.Default,
GracefulShutdownMode mode = GracefulShutdownMode.Off,
int closeTimeOutMilliseconds = DefaultCloseTimeoutMilliseconds
) : base(serviceProtocol, serverId, connectionId, endpoint, serviceMessageHandler, connectionType, loggerFactory?.CreateLogger <ServiceConnection>(), mode)
{
_clientConnectionManager = clientConnectionManager;
_connectionFactory = connectionFactory;
_connectionDelegate = connectionDelegate;
_clientConnectionFactory = clientConnectionFactory;
_closeTimeOutMilliseconds = closeTimeOutMilliseconds;
}
internal async Task TestOffline(GracefulShutdownMode mode)
{
List <IServiceConnection> connections = new List <IServiceConnection>
{
new SimpleTestServiceConnection(),
new SimpleTestServiceConnection()
};
using TestServiceConnectionContainer container = new TestServiceConnectionContainer(connections, factory: new SimpleTestServiceConnectionFactory());
foreach (SimpleTestServiceConnection c in connections)
{
Assert.False(c.ConnectionOfflineTask.IsCompleted);
}
await container.OfflineAsync(mode);
foreach (SimpleTestServiceConnection c in connections)
{
Assert.True(c.ConnectionOfflineTask.IsCompleted);
}
}
public async Task OfflineAsync(GracefulShutdownMode mode)
{
await Task.Yield();
OfflineTime = DateTime.Now;
}
public async Task OfflineAsync(GracefulShutdownMode mode)
{
await Task.Yield();
OfflineIndex = Interlocked.Increment(ref _index.Value);
}
public async Task OfflineAsync(GracefulShutdownMode mode)
{
await _serviceConnection.OfflineAsync(mode);
}
public Task OfflineAsync(GracefulShutdownMode mode) => Task.CompletedTask;
public Task OfflineAsync(GracefulShutdownMode mode) => throw new NotSupportedException();
public override Task OfflineAsync(GracefulShutdownMode mode)
{
return(Task.CompletedTask);
}
public Task OfflineAsync(GracefulShutdownMode mode)
{
return(Task.WhenAll(GetConnections().Select(s => s.OfflineAsync(mode))));
}
private async Task OfflineAndWaitForCompletedAsync(GracefulShutdownMode mode)
{
await _serviceConnectionManager.OfflineAsync(mode);
await _clientConnectionManager.WhenAllCompleted();
}
