public void SubscriptionWithCancelledTaskCanBeDisposed()
{
var dr = new DefaultDependencyResolver();
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "key" });
var wh = new ManualResetEventSlim();
IDisposable subscription = bus.Subscribe(subscriber, null, async (result, state) =>
{
if (result.Terminal)
{
return false;
}
await Task.Delay(50);
var tcs = new TaskCompletionSource<bool>();
tcs.SetCanceled();
wh.Set();
return await tcs.Task;
}, 10, null);
bus.Publish("me", "key", "hello");
wh.Wait();
subscription.Dispose();
}
}
protected override void Dispose(bool disposing)
{
if (_bus != null && disposing)
{
_bus.Dispose();
_bus = null;
}
base.Dispose(disposing);
}
public static IDisposable Run(int connections, int senders, string payload, int messageBufferSize = 10)
{
var resolver = new DefaultDependencyResolver();
var bus = new MessageBus(resolver);
var countDown = new CountdownEvent(senders);
var subscriptions = new List<IDisposable>();
var cancellationTokenSource = new CancellationTokenSource();
// Initialize performance counters for this run
Utility.InitializePerformanceCounters(resolver, cancellationTokenSource.Token);
for (int i = 0; i < connections; i++)
{
string identity = i.ToString();
var subscriber = new Subscriber(identity, new[] { "a", "b", "c" });
IDisposable subscription = bus.Subscribe(subscriber,
cursor: null,
callback: _ => TaskAsyncHelper.True,
maxMessages: messageBufferSize);
subscriptions.Add(subscription);
}
for (var i = 0; i < senders; i++)
{
ThreadPool.QueueUserWorkItem(_ =>
{
while (!cancellationTokenSource.IsCancellationRequested)
{
string source = i.ToString();
bus.Publish(source, "a", payload);
}
countDown.Signal();
});
}
return new DisposableAction(() =>
{
cancellationTokenSource.Cancel();
// Wait for all senders to stop
countDown.Wait(TimeSpan.FromMilliseconds(1000 * senders));
// Shut the bus down and wait for workers to stop
bus.Dispose();
// Dispose of all the subscriptions
subscriptions.ForEach(s => s.Dispose());
});
}
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 void DisposingBusShutsWorkersDown()
{
var dr = new DefaultDependencyResolver();
var bus = new MessageBus(dr);
var subscriber = new TestSubscriber(new[] { "key" });
var wh = new ManualResetEventSlim(initialState: false);
IDisposable subscription = null;
try
{
subscription = bus.Subscribe(subscriber, null, result =>
{
if (!result.Terminal)
{
var m = result.GetMessages().Single();
Assert.Equal("key", m.Key);
Assert.Equal("value", m.Value);
wh.Set();
return TaskAsyncHelper.True;
}
return TaskAsyncHelper.False;
}, 10);
bus.Publish("test", "key", "value").Wait();
Assert.True(wh.Wait(TimeSpan.FromSeconds(5)));
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
Assert.Equal(bus.AllocatedWorkers, 1);
bus.Dispose();
Assert.Equal(bus.AllocatedWorkers, 0);
}
}
public void NewSubscriptionGetsAllMessages()
{
var dr = new DefaultDependencyResolver();
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "key" });
var wh = new ManualResetEventSlim(initialState: false);
IDisposable subscription = null;
try
{
bus.Publish("test", "key", "1").Wait();
subscription = bus.Subscribe(subscriber, null, (result, state) =>
{
if (!result.Terminal)
{
var m = result.GetMessages().Single();
Assert.Equal("key", m.Key);
Assert.Equal("value", m.GetString());
wh.Set();
return TaskAsyncHelper.True;
}
return TaskAsyncHelper.False;
}, 10, null);
bus.Publish("test", "key", "value").Wait();
Assert.True(wh.Wait(TimeSpan.FromSeconds(5)));
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
}
}
}
public void AddingEventAndSendingMessages()
{
var dr = new DefaultDependencyResolver();
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "a" });
int max = 100;
var cd = new CountDownRange<int>(Enumerable.Range(0, max));
int prev = -1;
IDisposable subscription = null;
try
{
subscription = bus.Subscribe(subscriber, null, result =>
{
foreach (var m in result.GetMessages())
{
int n = Int32.Parse(m.Value);
Assert.True(prev < n, "out of order");
prev = n;
Assert.True(cd.Mark(n));
}
return TaskAsyncHelper.True;
}, 10);
for (int i = 0; i < max; i++)
{
subscriber.AddEvent("b");
bus.Publish("test", "b", i.ToString()).Wait();
}
Assert.True(cd.Wait(TimeSpan.FromSeconds(10)));
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
}
}
}
public void GarbageCollectingTopicsBeforeSubscribingTopicSetsStateToHasSubscription()
{
var dr = new DefaultDependencyResolver();
var configuration = dr.Resolve<IConfigurationManager>();
configuration.DisconnectTimeout = TimeSpan.FromSeconds(6);
configuration.KeepAlive = null;
using (var bus = new MessageBus(dr))
{
bus.BeforeTopicMarked = (key, t) =>
{
bus.GarbageCollectTopics();
};
Topic topic = bus.SubscribeTopic("key");
Assert.Equal(1, bus.Topics.Count);
Assert.True(bus.Topics.TryGetValue("key", out topic));
Assert.Equal(TopicState.HasSubscriptions, topic.State);
}
}
public void GetTopicDoesNotChangeStateWhenNotDying()
{
var dr = new DefaultDependencyResolver();
var configuration = dr.Resolve<IConfigurationManager>();
configuration.DisconnectTimeout = TimeSpan.FromSeconds(6);
configuration.KeepAlive = null;
using (var bus = new MessageBus(dr))
{
bus.Subscribe(new TestSubscriber(new[] { "key" }), null, (result, state) => TaskAsyncHelper.True, 10, null);
Topic topic;
Assert.True(bus.Topics.TryGetValue("key", out topic));
Assert.Equal(TopicState.HasSubscriptions, topic.State);
topic = bus.GetTopic("key");
Assert.Equal(TopicState.HasSubscriptions, topic.State);
topic.RemoveSubscription(topic.Subscriptions.First());
Assert.Equal(TopicState.NoSubscriptions, topic.State);
topic = bus.GetTopic("key");
Assert.Equal(TopicState.NoSubscriptions, topic.State);
topic.State = TopicState.Dying;
topic = bus.GetTopic("key");
Assert.Equal(TopicState.NoSubscriptions, topic.State);
}
}
public void SubscribingTopicAfterNoSubscriptionsStateSetsStateToHasSubscription()
{
var dr = new DefaultDependencyResolver();
var configuration = dr.Resolve<IConfigurationManager>();
configuration.DisconnectTimeout = TimeSpan.FromSeconds(6);
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "key" });
// Make sure the topic is in the no subs state
bus.Subscribe(subscriber, null, (result, state) => TaskAsyncHelper.True, 10, null)
.Dispose();
Topic topic = bus.SubscribeTopic("key");
Assert.Equal(1, bus.Topics.Count);
Assert.True(bus.Topics.TryGetValue("key", out topic));
Assert.Equal(TopicState.HasSubscriptions, topic.State);
}
}
public void GarbageCollectingTopicsAfterGettingTopicsNoops()
{
var dr = new DefaultDependencyResolver();
var configuration = dr.Resolve<IConfigurationManager>();
configuration.KeepAlive = null;
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "key" });
IDisposable subscription = null;
bus.AfterTopicMarkedSuccessfully = (key, topic) =>
{
bus.GarbageCollectTopics();
};
try
{
subscription = bus.Subscribe(subscriber, null, (result, state) => TaskAsyncHelper.True, 10, null);
Assert.Equal(1, bus.Topics.Count);
Topic topic;
Assert.True(bus.Topics.TryGetValue("key", out topic));
Assert.Equal(TopicState.HasSubscriptions, topic.State);
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
}
}
}
public void FarmDisconnectOnlyRaisesEventOnce()
{
// Each node shares the same bus but are indepenent servers
var counters = new SignalR.Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
{
var nodeCount = 3;
var nodes = new List<ServerNode>();
for (int i = 0; i < nodeCount; i++)
{
nodes.Add(new ServerNode(bus));
}
var timeout = TimeSpan.FromSeconds(5);
foreach (var node in nodes)
{
var config = node.Resolver.Resolve<IConfigurationManager>();
config.DisconnectTimeout = TimeSpan.FromSeconds(6);
IDependencyResolver resolver = node.Resolver;
node.Server.Configure(app =>
{
app.MapConnection<FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
});
}
var loadBalancer = new LoadBalancer(nodes.Select(f => f.Server).ToArray());
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
connection.Start(transport).Wait();
for (int i = 0; i < nodes.Count; i++)
{
nodes[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1));
Thread.Sleep(TimeSpan.FromSeconds(1));
}
connection.Disconnect();
Thread.Sleep(TimeSpan.FromTicks(timeout.Ticks * nodes.Count));
Assert.Equal(1, nodes.Sum(n => n.Connection.DisconnectCount));
}
}
public async Task FarmDisconnectOnlyRaisesUncleanDisconnects()
{
EnableTracing();
// Each node shares the same bus but are indepenent servers
var counters = new SignalR.Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
var protectedData = new DefaultProtectedData();
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
{
var nodeCount = 3;
var nodes = new List<ServerNode>();
for (int i = 0; i < nodeCount; i++)
{
nodes.Add(new ServerNode(bus));
}
var timeout = TimeSpan.FromSeconds(5);
foreach (var node in nodes)
{
var config = node.Resolver.Resolve<IConfigurationManager>();
config.DisconnectTimeout = TimeSpan.FromSeconds(6);
IDependencyResolver resolver = node.Resolver;
node.Server.Configure(app =>
{
app.MapSignalR<FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
resolver.Register(typeof(IProtectedData), () => protectedData);
});
}
var loadBalancer = new LoadBalancer(nodes.Select(f => f.Server).ToArray());
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
await connection.Start(transport);
for (int i = 0; i < nodes.Count; i++)
{
nodes[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1));
await Task.Delay(TimeSpan.FromSeconds(1));
}
((Client.IConnection)connection).Disconnect();
await Task.Delay(TimeSpan.FromTicks(timeout.Ticks * nodes.Count));
Assert.Equal(0, FarmConnection.OldOnDisconnectedCalls);
Assert.Equal(0, FarmConnection.CleanDisconnectCount);
Assert.Equal(3, FarmConnection.UncleanDisconnectCount);
}
}
public void SubscriptionWithScaleoutCursorGetsOnlyNewMessages()
{
var dr = new DefaultDependencyResolver();
var passThroughMinfier = new PassThroughStringMinifier();
dr.Register(typeof(IStringMinifier), () => passThroughMinfier);
using (var bus = new MessageBus(dr))
{
Func<ISubscriber> subscriberFactory = () => new TestSubscriber(new[] { "key" });
var tcs = new TaskCompletionSource<Message[]>();
IDisposable subscription = null;
try
{
// Set-up dummy subscription so the first Publish doesn't noop
bus.Subscribe(subscriberFactory(), null, (result, state) => TaskAsyncHelper.True, 10, null).Dispose();
bus.Publish("test", "key", "badvalue").Wait();
subscription = bus.Subscribe(subscriberFactory(), "s-key,00000000", (result, state) =>
{
tcs.TrySetResult(result.GetMessages().ToArray());
return TaskAsyncHelper.True;
}, 10, null);
bus.Publish("test", "key", "value");
Assert.True(tcs.Task.Wait(TimeSpan.FromSeconds(5)));
foreach (var m in tcs.Task.Result)
{
Assert.Equal("key", m.Key);
Assert.Equal("value", m.GetString());
}
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
}
}
}
public void SubscriptionWithMultipleExistingCursors()
{
var dr = new DefaultDependencyResolver();
var passThroughMinfier = new PassThroughStringMinifier();
dr.Register(typeof(IStringMinifier), () => passThroughMinfier);
using (var bus = new MessageBus(dr))
{
Func<ISubscriber> subscriberFactory = () => new TestSubscriber(new[] { "key", "key2" });
var cdKey = new CountDownRange<int>(Enumerable.Range(2, 4));
var cdKey2 = new CountDownRange<int>(new[] { 1, 2, 10 });
IDisposable subscription = null;
string prefix = DefaultSubscription._defaultCursorPrefix;
// Pretend like we had an initial subscription
bus.Subscribe(subscriberFactory(), null, (result, state) => TaskAsyncHelper.True, 10, null)
.Dispose();
// This simulates a reconnect
bus.Publish("test", "key", "1").Wait();
bus.Publish("test", "key", "2").Wait();
bus.Publish("test", "key", "3").Wait();
bus.Publish("test", "key", "4").Wait();
bus.Publish("test", "key2", "1").Wait();
bus.Publish("test", "key2", "2").Wait();
try
{
subscription = bus.Subscribe(subscriberFactory(), prefix + "key,00000001|key2,00000000", (result, state) =>
{
foreach (var m in result.GetMessages())
{
int n = Int32.Parse(m.GetString());
if (m.Key == "key")
{
Assert.True(cdKey.Mark(n));
}
else
{
Assert.True(cdKey2.Mark(n));
}
}
return TaskAsyncHelper.True;
}, 10, null);
bus.Publish("test", "key", "5");
bus.Publish("test", "key2", "10");
Assert.True(cdKey.Wait(TimeSpan.FromSeconds(5)));
Assert.True(cdKey2.Wait(TimeSpan.FromSeconds(5)));
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
}
}
}
public override void Initialize()
{
_bus = CreateMessageBus();
base.Initialize();
}
public void SubscriptionWithExistingCursor()
{
var dr = new DefaultDependencyResolver();
var passThroughMinfier = new PassThroughStringMinifier();
dr.Register(typeof(IStringMinifier), () => passThroughMinfier);
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "key" });
var cd = new CountDownRange<int>(Enumerable.Range(2, 4));
IDisposable subscription = null;
// Pretend like we had an initial subscription
bus.Subscribe(subscriber, null, _ => TaskAsyncHelper.True, 10)
.Dispose();
bus.Publish("test", "key", "1").Wait();
bus.Publish("test", "key", "2").Wait();
bus.Publish("test", "key", "3").Wait();
bus.Publish("test", "key", "4").Wait();
try
{
subscription = bus.Subscribe(subscriber, "key,00000001", result =>
{
foreach (var m in result.GetMessages())
{
int n = Int32.Parse(m.Value);
Assert.True(cd.Mark(n));
}
return TaskAsyncHelper.True;
}, 10);
bus.Publish("test", "key", "5");
Assert.True(cd.Wait(TimeSpan.FromSeconds(5)));
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
}
}
}
public void SubscriptionWithExistingCursorGetsAllMessagesAfterMessageBusRestart()
{
var dr = new DefaultDependencyResolver();
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "key" });
var wh = new ManualResetEvent(false);
IDisposable subscription = null;
try
{
subscription = bus.Subscribe(subscriber, "d-key,00000001", (result, state) =>
{
foreach (var m in result.GetMessages())
{
Assert.Equal("key", m.Key);
Assert.Equal("value", m.GetString());
wh.Set();
}
return TaskAsyncHelper.True;
}, 10, null);
bus.Publish("test", "key", "value");
Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5)));
}
finally
{
if (subscription != null)
{
subscription.Dispose();
}
}
}
}
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 void MessageBusCanBeDisposedTwiceWithoutHanging()
{
var bus = new MessageBus(new DefaultDependencyResolver());
bus.Dispose();
Assert.True(Task.Run(() => bus.Dispose()).Wait(TimeSpan.FromSeconds(10)));
}
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 void PublishingDoesNotCreateTopic()
{
var dr = new DefaultDependencyResolver();
var configuration = dr.Resolve<IConfigurationManager>();
configuration.KeepAlive = null;
using (var bus = new MessageBus(dr))
{
bus.Publish("test", "key", "1").Wait();
Assert.Equal(0, bus.Topics.Count);
Assert.False(bus.Topics.ContainsKey("key"));
}
}
public MessageBusRun(RunData runData)
: base(runData)
{
_bus = CreateMessageBus();
}
