public async Task TestContainerWithTwoEndpointWithAllOfflineAndConnectionStartedThrows()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter(false);
var container = new MultiEndpointServiceConnectionContainer(
e => new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
}, e), sem, router, null);
_ = container.StartAsync();
// Instead of NotActiveException, throws NotConnectedException
await Assert.ThrowsAsync <AzureSignalRNotConnectedException>(
() => container.WriteAsync(DefaultGroupMessage)
);
await Assert.ThrowsAsync <AzureSignalRNotConnectedException>(
() => container.WriteAsync("1", DefaultGroupMessage)
);
}
public async Task TestContainerWithTwoEndpointWithAllConnectedFailsWithBadRouter()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter(true);
var container = new MultiEndpointServiceConnectionContainer(
e => new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, null);
await Assert.ThrowsAsync <InvalidOperationException>(
() => container.WriteAsync(DefaultGroupMessage)
);
await Assert.ThrowsAsync <InvalidOperationException>(
() => container.WriteAsync("1", DefaultGroupMessage)
);
}
public void TestEndpointManagerWithDuplicateEndpoints()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "1"),
new ServiceEndpoint(ConnectionString1, EndpointType.Secondary, "2"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "11"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "12")
);
var endpoints = sem.GetAvailableEndpoints().ToArray();
Assert.Equal(2, endpoints.Length);
Assert.Equal("1", endpoints[0].Name);
Assert.Equal("11", endpoints[1].Name);
var primaryEndpoints = sem.GetPrimaryEndpoints().ToArray();
Assert.Single(primaryEndpoints);
Assert.Equal("1", primaryEndpoints[0].Name);
var router = new TestEndpointRouter(false);
var container = new MultiEndpointServiceConnectionContainer(
e => new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, null);
Assert.Equal(2, container.Connections.Count);
}
public async Task TestEndpointManagerWithDuplicateEndpoints()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "1"),
new ServiceEndpoint(ConnectionString1, EndpointType.Secondary, "2"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "11"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "12")
);
var endpoints = sem.Endpoints.Keys.OrderBy(x => x.Name).ToArray();
Assert.Equal(2, endpoints.Length);
Assert.Equal("1", endpoints[0].Name);
Assert.Equal("11", endpoints[1].Name);
var router = new TestEndpointRouter(false);
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, NullLoggerFactory.Instance);
_ = container.StartAsync();
await container.ConnectionInitializedTask.OrTimeout();
endpoints = container.GetOnlineEndpoints().ToArray();
Assert.Equal(2, endpoints.Length);
}
public async Task TestContainerWithTwoEndpointWithAllConnectedSucceedsWithGoodRouter()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter();
var writeTcs = new TaskCompletionSource <object>();
var containers = new Dictionary <ServiceEndpoint, TestServiceConnectionContainer>();
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => containers[e] = new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e), sem, router, NullLoggerFactory.Instance);
// All the connections started
_ = container.StartAsync();
await container.ConnectionInitializedTask;
var task = container.WriteAckableMessageAsync(DefaultGroupMessage);
await writeTcs.Task.OrTimeout();
containers.First().Value.HandleAck(new AckMessage(1, (int)AckStatus.Ok));
await task.OrTimeout();
}
public async Task TestContainerWithTwoEndpointWithAllOfflineSucceedsWithWarning()
{
using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning, logChecker: logs =>
{
var warns = logs.Where(s => s.Write.LogLevel == LogLevel.Warning).ToList();
Assert.Equal(2, warns.Count);
Assert.Contains(warns, s => s.Write.Message.Contains(string.Format(MultiEndpointMessageWriter.Log.FailedWritingMessageToEndpointTemplate, "JoinGroupWithAckMessage", "(null)", "(Primary)http://url1")));
return(true);
}))
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter(false);
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
}, e), sem, router, loggerFactory);
_ = container.StartAsync();
await container.ConnectionInitializedTask.OrTimeout();
await container.WriteAsync(DefaultGroupMessage);
}
}
public void TestGetRoutedEndpointsReturnDistinctResultForMultiMessages()
{
var endpoints = new[]
{
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "1"),
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "2"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "11"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "12")
};
var sem = new TestServiceEndpointManager(endpoints);
var router = new TestEndpointRouter();
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
}, e), sem, router, NullLoggerFactory.Instance);
var result = container.GetRoutedEndpoints(new MultiGroupBroadcastDataMessage(new[] { "group1", "group2" }, null)).ToList();
Assert.Equal(2, result.Count);
result = container.GetRoutedEndpoints(new MultiUserDataMessage(new[] { "user1", "user2" }, null)).ToList();
Assert.Equal(2, result.Count);
}
public void TestContainerWithNoEndpointDontThrowFromBaseClass()
{
var manager = new TestServiceEndpointManager();
var endpoints = manager.GetAvailableEndpoints();
Assert.Empty(endpoints);
}
public async Task TestContainerWithTwoEndpointWithAllConnectedFailsWithBadRouter()
{
using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug, logChecker: logs => true))
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var logger = loggerFactory.CreateLogger <TestServiceConnection>();
var router = new TestEndpointRouter(true);
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(logger: logger),
new TestServiceConnection(logger: logger),
new TestServiceConnection(logger: logger),
new TestServiceConnection(logger: logger),
new TestServiceConnection(logger: logger),
new TestServiceConnection(logger: logger),
new TestServiceConnection(logger: logger),
}, e, logger), sem, router, loggerFactory);
_ = Task.Run(container.StartAsync);
await container.ConnectionInitializedTask.OrTimeout();
await Assert.ThrowsAsync <InvalidOperationException>(
() => container.WriteAsync(DefaultGroupMessage)
);
}
}
public async Task TestContainerWithTwoEndpointWithAllConnectedFailsWithBadRouter()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter(true);
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, NullLoggerFactory.Instance);
_ = container.StartAsync();
await container.ConnectionInitializedTask.OrTimeout();
await Assert.ThrowsAsync <InvalidOperationException>(
() => container.WriteAsync(DefaultGroupMessage)
);
}
public async Task TestContainerWithTwoOfflineEndpointWriteAckableMessageSucceedsWithWarning()
{
using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning, logChecker: logs =>
{
var warns = logs.Where(s => s.Write.LogLevel == LogLevel.Warning).ToList();
Assert.Equal(2, warns.Count);
Assert.Contains(warns, s => s.Write.Message.Contains("Message JoinGroupWithAckMessage is not sent to endpoint (Primary)http://url1 because all connections to this endpoint are offline."));
return(true);
}))
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter();
var container = new TestMultiEndpointServiceConnectionContainer("hub", e =>
{
return(new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected),
}, e));
}, sem, router, loggerFactory);
_ = container.StartAsync();
await container.ConnectionInitializedTask;
await container.WriteAckableMessageAsync(DefaultGroupMessage);
}
}
public async Task TestContainerWithOneEndpointWithAllConnectedSucceeeds()
{
var sem = new TestServiceEndpointManager(new ServiceEndpoint(ConnectionString1));
var throws = new ServiceConnectionNotActiveException();
var router = new TestEndpointRouter(throws);
var writeTcs = new TaskCompletionSource <object>();
TestServiceConnectionContainer innerContainer = null;
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => innerContainer = new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e), sem, router, NullLoggerFactory.Instance);
// All the connections started
_ = container.StartAsync();
await container.ConnectionInitializedTask;
var task = container.WriteAckableMessageAsync(DefaultGroupMessage);
await writeTcs.Task.OrTimeout();
innerContainer.HandleAck(new AckMessage(1, (int)AckStatus.Ok));
await task.OrTimeout();
}
public async Task TestContainerWithTwoConnectedEndpointAndBadRouterThrows()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter(new ServiceConnectionNotActiveException());
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
}, e), sem, router, NullLoggerFactory.Instance);
// All the connections started
_ = container.StartAsync();
await container.ConnectionInitializedTask;
await Assert.ThrowsAsync <ServiceConnectionNotActiveException>(
() => container.WriteAsync(DefaultGroupMessage)
);
}
public async Task TestGetRoutedEndpointsReturnDistinctResultForMultiMessages()
{
var endpoints = new[]
{
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "1"),
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "2"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "11"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "12")
};
var sem = new TestServiceEndpointManager(endpoints);
var router = new TestEndpointRouter(false);
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, NullLoggerFactory.Instance);
// Start the container for it to disconnect
_ = container.StartAsync();
await container.ConnectionInitializedTask.OrTimeout();
var result = container.GetRoutedEndpoints(new MultiGroupBroadcastDataMessage(new[] { "group1", "group2" }, null)).ToList();
Assert.Equal(2, result.Count);
result = container.GetRoutedEndpoints(new MultiUserDataMessage(new[] { "user1", "user2" }, null)).ToList();
Assert.Equal(2, result.Count);
}
public async Task TestEndpointManagerWithDuplicateEndpointsAndConnectionStarted()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "1"),
new ServiceEndpoint(ConnectionString1, EndpointType.Secondary, "2"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "11"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "12")
);
var endpoints = sem.Endpoints;
Assert.Equal(2, endpoints.Length);
Assert.Equal("1", endpoints[0].Name);
Assert.Equal("11", endpoints[1].Name);
var router = new TestEndpointRouter();
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(),
new TestSimpleServiceConnection(),
}, e), sem, router, NullLoggerFactory.Instance);
// All the connections started
_ = container.StartAsync();
await container.ConnectionInitializedTask;
endpoints = container.GetOnlineEndpoints().ToArray();
Assert.Equal(2, endpoints.Length);
Assert.Equal("1", endpoints[0].Name);
Assert.Equal("11", endpoints[1].Name);
Assert.Equal(2, container.ConnectionContainers.Count);
}
public async Task TestContainerWithTwoEndpointWithAllConnectedSucceedsWithGoodRouter()
{
using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning, logChecker: logs => true))
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2));
var router = new TestEndpointRouter(false);
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, loggerFactory);
_ = container.StartAsync();
await container.ConnectionInitializedTask.OrTimeout();
await container.WriteAsync(DefaultGroupMessage);
}
}
public async Task TestSingleEndpointOffline(bool migratable)
{
var manager = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1)
);
await TestEndpointOfflineInner(manager, null, migratable);
}
public async Task TestMultiEndpointOffline(bool migratable)
{
var manager = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2)
);
await TestEndpointOfflineInner(manager, new TestEndpointRouter(), migratable);
}
public async Task TestTwoEndpointsWithAllNotFoundAck()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, name: "online"));
var router = new TestEndpointRouter();
var writeTcs = new TaskCompletionSource <object>();
TestBaseServiceConnectionContainer innerContainer = null;
var containers = new Dictionary <ServiceEndpoint, TestBaseServiceConnectionContainer>();
var container = new MultiEndpointServiceConnectionContainer("hub", e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e));
}
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e));
}, sem, router, null);
// All the connections started
_ = container.StartAsync();
await container.ConnectionInitializedTask;
var task = container.WriteAckableMessageAsync(DefaultGroupMessage);
await writeTcs.Task.OrTimeout();
foreach (var c in containers)
{
c.Value.HandleAck(new AckMessage(1, (int)AckStatus.NotFound));
}
var result = await task.OrTimeout();
Assert.False(result);
}
public async Task TestTwoEndpointsWithCancellationToken()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, name: "online"));
var router = new TestEndpointRouter();
var writeTcs = new TaskCompletionSource <object>();
TestBaseServiceConnectionContainer innerContainer = null;
var containers = new Dictionary <ServiceEndpoint, TestBaseServiceConnectionContainer>();
var container = new MultiEndpointServiceConnectionContainer("hub", e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e, new AckHandler(100, 200)));
}
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e, new AckHandler(100, 200)));
}, sem, router, null);
// All the connections started
_ = container.StartAsync();
await container.ConnectionInitializedTask;
var task = container.WriteAckableMessageAsync(DefaultGroupMessage, new CancellationToken(true));
await writeTcs.Task.OrTimeout();
foreach (var c in containers)
{
c.Value.HandleAck(new AckMessage(1, (int)AckStatus.Timeout));
}
await Assert.ThrowsAnyAsync <OperationCanceledException>(async() => await task).OrTimeout();
}
public async Task TestContainerWithTwoEndpointWithPrimaryOfflineAndConnectionStartedSucceeds()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "online"));
var router = new TestEndpointRouter();
var writeTcs = new TaskCompletionSource <object>();
var containers = new Dictionary <ServiceEndpoint, TestBaseServiceConnectionContainer>();
var container = new MultiEndpointServiceConnectionContainer("hub", e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
}, e));
}
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e));
}, sem, router, null);
_ = container.StartAsync();
var task = container.WriteAckableMessageAsync(DefaultGroupMessage);
await writeTcs.Task.OrTimeout();
containers.First(p => !string.IsNullOrEmpty(p.Key.Name)).Value.HandleAck(new AckMessage(1, (int)AckStatus.Ok));
await task.OrTimeout();
var endpoints = container.GetOnlineEndpoints().ToArray();
Assert.Single(endpoints);
Assert.Equal("online", endpoints.First().Name);
}
public async Task TestContainerWithTwoEndpointWithPrimaryOfflineAndConnectionStartedSucceeds()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "online"));
var router = new TestEndpointRouter(false);
var container = new MultiEndpointServiceConnectionContainer(e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
}, e));
}
return(new TestServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e));
}, sem, router, null);
_ = container.StartAsync();
await container.WriteAsync(DefaultGroupMessage);
await container.WriteAsync("1", DefaultGroupMessage);
var endpoints = sem.GetAvailableEndpoints();
Assert.Single(endpoints);
endpoints = sem.GetPrimaryEndpoints();
Assert.Single(endpoints);
Assert.Equal("online", endpoints.First().Name);
}
public async Task TestTwoEndpointsWithOneSucceededAndOtherNotAcked()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, name: "online"));
var router = new TestEndpointRouter();
var writeTcs = new TaskCompletionSource <object>();
var containers = new Dictionary <ServiceEndpoint, TestBaseServiceConnectionContainer>();
var container = new MultiEndpointServiceConnectionContainer("hub", e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e, new AckHandler(100, 500)));
}
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e, new AckHandler(100, 500)));
}, sem, router, null);
// All the connections started
_ = container.StartAsync();
await container.ConnectionInitializedTask;
var task = container.WriteAckableMessageAsync(DefaultGroupMessage);
await writeTcs.Task.OrTimeout();
containers.First().Value.HandleAck(new AckMessage(1, (int)AckStatus.Ok));
var result = await task.OrTimeout();
Assert.True(result);
}
public async Task TestContainerWithTwoEndpointWithOneOfflineSucceedsWithWarning()
{
using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning, logChecker: logs =>
{
var warns = logs.Where(s => s.Write.LogLevel == LogLevel.Warning).ToList();
Assert.Single(warns);
Assert.Contains(warns, s => s.Write.Message.Contains("Message JoinGroupWithAckMessage is not sent to endpoint (Primary)http://url1 because all connections to this endpoint are offline."));
return(true);
}))
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, name: "online"));
var router = new TestEndpointRouter(false);
var container = new TestMultiEndpointServiceConnectionContainer("hub", e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
}, e));
}
return(new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e));
}, sem, router, loggerFactory);
_ = container.StartAsync();
await container.ConnectionInitializedTask.OrTimeout();
await container.WriteAsync(DefaultGroupMessage);
}
}
public async Task TestContainerWithOneEndpointWithAllConnectedSucceeeds()
{
var sem = new TestServiceEndpointManager(new ServiceEndpoint(ConnectionString1));
var router = new TestEndpointRouter(true);
var container = new MultiEndpointServiceConnectionContainer(
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, null);
await container.WriteAsync(DefaultGroupMessage);
await container.WriteAsync("1", DefaultGroupMessage);
}
public async Task TestContainerWithTwoEndpointWithOneOfflineSucceeds()
{
using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning))
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, name: "online"));
var router = new TestEndpointRouter();
var writeTcs = new TaskCompletionSource <object>();
var containers = new Dictionary <ServiceEndpoint, TestBaseServiceConnectionContainer>();
var container = new MultiEndpointServiceConnectionContainer("hub", e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(ServiceConnectionStatus.Disconnected, writeAsyncTcs: writeTcs),
}, e));
}
return(containers[e] = new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
new TestSimpleServiceConnection(writeAsyncTcs: writeTcs),
}, e));
}, sem, router, loggerFactory);
_ = container.StartAsync();
var task = container.WriteAckableMessageAsync(DefaultGroupMessage);
await writeTcs.Task.OrTimeout();
containers.First(p => !string.IsNullOrEmpty(p.Key.Name)).Value.HandleAck(new AckMessage(1, (int)AckStatus.Ok));
await task.OrTimeout();
}
}
public async Task TestContainerWithTwoEndpointWithPrimaryOfflineAndConnectionStartedSucceeds()
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "online"));
var router = new TestEndpointRouter(false);
var container = new TestMultiEndpointServiceConnectionContainer("hub", e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
}, e));
}
return(new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e));
}, sem, router, NullLoggerFactory.Instance);
_ = container.StartAsync();
await container.ConnectionInitializedTask;
await container.WriteAsync(DefaultGroupMessage);
var endpoints = container.GetOnlineEndpoints().ToArray();
Assert.Single(endpoints);
Assert.Equal("online", endpoints.First().Name);
}
public async Task TestEndpointsForDifferentContainersHaveDifferentStatus()
{
var endpoints = new[]
{
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "1"),
new ServiceEndpoint(ConnectionString1, EndpointType.Primary, "2"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "11"),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "12")
};
var sem = new TestServiceEndpointManager(endpoints);
var router = new TestEndpointRouter(false);
var container1 = new MultiEndpointServiceConnectionContainer(
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
}, e), sem, router, null);
var container2 = new MultiEndpointServiceConnectionContainer(
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, null);
// Start the container for it to disconnect
await container1.StartAsync();
var result = container1.GetRoutedEndpoints(new MultiGroupBroadcastDataMessage(new[] { "group1", "group2" }, null)).ToList();
Assert.Empty(result);
result = container1.GetRoutedEndpoints(new MultiUserDataMessage(new[] { "user1", "user2" }, null)).ToList();
Assert.Empty(result);
result = container2.GetRoutedEndpoints(new MultiGroupBroadcastDataMessage(new[] { "group1", "group2" }, null)).ToList();
Assert.Equal(2, result.Count);
result = container2.GetRoutedEndpoints(new MultiUserDataMessage(new[] { "user1", "user2" }, null)).ToList();
Assert.Equal(2, result.Count);
}
public async Task TestContainerWithOneEndpointCustomizeRouterWithAllConnectedSucceeeds()
{
var sem = new TestServiceEndpointManager(new ServiceEndpoint(ConnectionString1));
var router = new TestEndpointRouter(false);
var container = new TestMultiEndpointServiceConnectionContainer("hub",
e => new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e), sem, router, NullLoggerFactory.Instance);
_ = container.StartAsync();
await container.ConnectionInitializedTask.OrTimeout();
await container.WriteAsync(DefaultGroupMessage);
}
public async Task TestMultiEndpointConnectionWithNotExistEndpointRouter()
{
using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning))
{
var sem = new TestServiceEndpointManager(
new ServiceEndpoint(ConnectionString1),
new ServiceEndpoint(ConnectionString2, EndpointType.Secondary, "online"));
var router = new NotExistEndpointRouter();
var container = new MultiEndpointServiceConnectionContainer(e =>
{
if (string.IsNullOrEmpty(e.Name))
{
return(new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
new TestServiceConnection(ServiceConnectionStatus.Disconnected),
}, e));
}
return(new TestBaseServiceConnectionContainer(new List <IServiceConnection> {
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
new TestServiceConnection(),
}, e));
}, sem, router, loggerFactory);
_ = container.StartAsync();
await container.WriteAsync(DefaultGroupMessage);
await container.WriteAsync("1", DefaultGroupMessage);
}
}
