public async Task FarmDisconnectRaisesUncleanDisconnects()
{
// Each node shares the same bus but are independent servers
const int nodeCount = 3;
var counters = new Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
configurationManager.DisconnectTimeout = TimeSpan.FromSeconds(6);
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var loadBalancer = new LoadBalancer(nodeCount))
{
var broadcasters = new List <IConnection>();
var disconnectCounter = new DisconnectCounter();
loadBalancer.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
resolver.Register(typeof(IConfigurationManager), () => configurationManager);
resolver.Register(typeof(FarmConnection), () => new FarmConnection(disconnectCounter));
var connectionManager = resolver.Resolve <IConnectionManager>();
broadcasters.Add(connectionManager.GetConnectionContext <FarmConnection>().Connection);
app.MapSignalR <FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
});
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
await connection.Start(transport);
for (int i = 0; i < nodeCount; i++)
{
broadcasters[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1)).Wait();
await Task.Delay(TimeSpan.FromSeconds(1));
}
((Client.IConnection)connection).Disconnect();
await Task.Delay(TimeSpan.FromTicks(TimeSpan.FromSeconds(5).Ticks *nodeCount));
Assert.Equal(0, disconnectCounter.CleanDisconnectCount);
Assert.Equal(3, disconnectCounter.UncleanDisconnectCount);
}
}
public async Task ContextGroupAddCompletesSuccessfully()
{
// https://github.com/SignalR/SignalR/issues/3337
// Each node shares the same bus but are independent servers
var counters = new Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var memoryHost = new MemoryHost())
{
memoryHost.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
app.MapSignalR(new HubConfiguration {
Resolver = resolver
});
});
using (var connection = new HubConnection("http://goo/"))
{
var proxy = connection.CreateHubProxy("FarmGroupHub");
const string group = "group";
const string message = "message";
var mre = new AsyncManualResetEvent();
proxy.On <string>("message", m =>
{
if (m == message)
{
mre.Set();
}
});
await connection.Start(memoryHost);
// Add the connection to a group via an IHubContext on a "second" server.
var secondResolver = new DefaultDependencyResolver();
secondResolver.Register(typeof(IMessageBus), () => bus);
var secondConnectionManager = secondResolver.Resolve <IConnectionManager>();
var secondHubContext = secondConnectionManager.GetHubContext <FarmGroupHub>();
await secondHubContext.Groups.Add(connection.ConnectionId, group);
await proxy.Invoke("SendToGroup", group, message);
Assert.True(await mre.WaitAsync(TimeSpan.FromSeconds(5)));
}
}
}
public async Task FarmDisconnectRaisesUncleanDisconnects()
{
// Each node shares the same bus but are independent servers
const int nodeCount = 3;
var counters = new Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
configurationManager.DisconnectTimeout = TimeSpan.FromSeconds(6);
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var loadBalancer = new LoadBalancer(nodeCount))
{
var broadcasters = new List<IConnection>();
var disconnectCounter = new DisconnectCounter();
loadBalancer.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
resolver.Register(typeof(IConfigurationManager), () => configurationManager);
resolver.Register(typeof(FarmConnection), () => new FarmConnection(disconnectCounter));
var connectionManager = resolver.Resolve<IConnectionManager>();
broadcasters.Add(connectionManager.GetConnectionContext<FarmConnection>().Connection);
app.MapSignalR<FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
});
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
await connection.Start(transport);
for (int i = 0; i < nodeCount; i++)
{
broadcasters[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1)).Wait();
await Task.Delay(TimeSpan.FromSeconds(1));
}
((Client.IConnection)connection).Disconnect();
await Task.Delay(TimeSpan.FromTicks(TimeSpan.FromSeconds(5).Ticks * nodeCount));
Assert.Equal(0, disconnectCounter.CleanDisconnectCount);
Assert.Equal(3, disconnectCounter.UncleanDisconnectCount);
}
}
public async Task FarmGroupAddCompletesSuccessfully(TransportType transportType)
{
// https://github.com/SignalR/SignalR/issues/3337
// Each node shares the same bus but are independent servers
const int nodeCount = 2;
var counters = new Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
// Ensure /send and /connect requests get handled by different servers
Func<string, int> scheduler = url => url.Contains("/send") ? 0 : 1;
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var loadBalancer = new LoadBalancer(nodeCount, scheduler))
{
loadBalancer.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
app.MapSignalR(new HubConfiguration { Resolver = resolver });
});
using (var connection = new HubConnection("http://goo/"))
{
var proxy = connection.CreateHubProxy("FarmGroupHub");
const string group = "group";
const string message = "message";
var mre = new AsyncManualResetEvent();
proxy.On<string>("message", m =>
{
if (m == message)
{
mre.Set();
}
});
Client.Transports.IClientTransport transport;
switch (transportType)
{
case TransportType.LongPolling:
transport = new Client.Transports.LongPollingTransport(loadBalancer);
break;
case TransportType.ServerSentEvents:
transport = new Client.Transports.ServerSentEventsTransport(loadBalancer);
break;
default:
throw new ArgumentException("transportType");
}
await connection.Start(transport);
await proxy.Invoke("JoinGroup", group);
await proxy.Invoke("SendToGroup", group, message);
Assert.True(await mre.WaitAsync(TimeSpan.FromSeconds(5)));
}
}
}
public async Task ContextGroupAddCompletesSuccessfully()
{
// https://github.com/SignalR/SignalR/issues/3337
// Each node shares the same bus but are independent servers
var counters = new Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var memoryHost = new MemoryHost())
{
memoryHost.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
app.MapSignalR(new HubConfiguration { Resolver = resolver });
});
using (var connection = new HubConnection("http://goo/"))
{
var proxy = connection.CreateHubProxy("FarmGroupHub");
const string group = "group";
const string message = "message";
var mre = new AsyncManualResetEvent();
proxy.On<string>("message", m =>
{
if (m == message)
{
mre.Set();
}
});
await connection.Start(memoryHost);
// Add the connection to a group via an IHubContext on a "second" server.
var secondResolver = new DefaultDependencyResolver();
secondResolver.Register(typeof(IMessageBus), () => bus);
var secondConnectionManager = secondResolver.Resolve<IConnectionManager>();
var secondHubContext = secondConnectionManager.GetHubContext<FarmGroupHub>();
await secondHubContext.Groups.Add(connection.ConnectionId, group);
await proxy.Invoke("SendToGroup", group, message);
Assert.True(await mre.WaitAsync(TimeSpan.FromSeconds(5)));
}
}
}
public async Task FarmGroupAddCompletesSuccessfully(TransportType transportType)
{
// https://github.com/SignalR/SignalR/issues/3337
// Each node shares the same bus but are independent servers
const int nodeCount = 2;
var counters = new Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
// Ensure /send and /connect requests get handled by different servers
Func <string, int> scheduler = url => url.Contains("/send") ? 0 : 1;
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var loadBalancer = new LoadBalancer(nodeCount, scheduler))
{
loadBalancer.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
app.MapSignalR(new HubConfiguration {
Resolver = resolver
});
});
using (var connection = new HubConnection("http://goo/"))
{
var proxy = connection.CreateHubProxy("FarmGroupHub");
const string group = "group";
const string message = "message";
var mre = new AsyncManualResetEvent();
proxy.On <string>("message", m =>
{
if (m == message)
{
mre.Set();
}
});
Client.Transports.IClientTransport transport;
switch (transportType)
{
case TransportType.LongPolling:
transport = new Client.Transports.LongPollingTransport(loadBalancer);
break;
case TransportType.ServerSentEvents:
transport = new Client.Transports.ServerSentEventsTransport(loadBalancer);
break;
default:
throw new ArgumentException("transportType");
}
await connection.Start(transport);
await proxy.Invoke("JoinGroup", group);
await proxy.Invoke("SendToGroup", group, message);
Assert.True(await mre.WaitAsync(TimeSpan.FromSeconds(5)));
}
}
}
