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(); }