public void SendAfterOpenAndAfterErrorThrows() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; var firstSend = stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); stream.Open(); // Wait on the first send to drain firstSend.Wait(); stream.SetError(new Exception("Failed")); Assert.Throws <Exception>(() => { stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null).Wait(); }); Assert.Equal(1, x); }
public void CloseWhileQueueRunsWithFailedTask() { int x = 0; var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Close(); Assert.Equal(1, x); }
public void InitialToClosed() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Close(); }
public void SendAfterOpenAndAfterErrorThrows() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; var firstSend = stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); stream.Open(); // Wait on the first send to drain firstSend.Wait(); stream.SetError(new Exception("Failed")); Assert.Throws<Exception>(() => { stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null).Wait(); }); Assert.Equal(1, x); }
public void CloseWhileQueueRunsWithFailedTask() { int x = 0; var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Close(); Assert.Equal(1, x); }
public void SendsBeforeOpenedRunOnceOpenedWhenQueuingBehaviorInitialOnly() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); Task task = stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); stream.Open(); task.Wait(); Assert.Equal(2, x); }
public void OpenAfterErrorRunsQueue() { int x = 0; var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(_ => { throw new InvalidOperationException(); }, null); stream.Open(); stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); var task = stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); task.Wait(); Assert.Equal(2, x); }
public void EnqueueWithoutOpenRaisesOnError() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); Assert.Throws<InvalidOperationException>(() => stream.Send(_ => { throw new InvalidOperationException(); }, null)); }
public void SendAfterOpenAndAfterErrorThrows() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; var firstSend = stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); stream.Open(); // Wait on the first send to drain firstSend.Wait(); stream.SetError(new Exception("Failed")); Assert.Throws <Exception>(() => { stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null).Wait(); }); Assert.Equal(1, x); }
public void CloseWhileQueueRunsWithFailedTask() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Close(); Assert.Equal(1, x); }
public void SendsBeforeOpenedRunOnceOpenedWhenQueuingBehaviorInitialOnly() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); Task task = stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); stream.Open(); task.Wait(); Assert.Equal(2, x); }
public void CloseWhileQueueRuns() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Close(); Assert.Equal(3, x); }
public void CloseWhileQueueRuns() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Close(); Assert.Equal(3, x); }
public void OpenAfterErrorRunsQueue() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); stream.Open(); stream.Send(_ => { throw new InvalidOperationException(); }, null); stream.Open(); stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); var task = stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); task.Wait(); Assert.Equal(2, x); }
public void OpenAfterErrorRunsQueue() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(_ => { throw new InvalidOperationException(); }, null); stream.Open(); stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); var task = stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); Assert.True(task.Wait(10000)); Assert.Equal(2, x); }
public void EnqueueWithoutOpenRaisesOnError() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); Assert.Throws <InvalidOperationException>(() => stream.Send(_ => { throw new InvalidOperationException(); }, null)); }
public void SendsBeforeOpenedRunOnceOpenedWhenQueuingBehaviorInitialOnly() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); Task task = stream.Send(_ => { x++; return(TaskAsyncHelper.Empty); }, null); stream.Open(); task.Wait(); Assert.Equal(2, x); }
public void BufferAfterClosedEnqueueThrows() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); stream.Close(); stream.SetError(new Exception()); Assert.Throws<Exception>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void InitialToClosed() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Close(); }
public async Task BufferAfterClosedEnqueueThrows() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Close(); stream.SetError(new Exception()); await Assert.ThrowsAsync <Exception>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void OpenAfterClosedEnqueueThrows() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); stream.Close(); stream.Open(); Assert.Throws <InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void BufferAfterClosedEnqueueThrows() { var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Close(); stream.SetError(new Exception()); Assert.ThrowsAsync<Exception>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void GroupThrowsNullExceptionWhenGroupNameIsNull() { var serializer = JsonUtility.CreateDefaultSerializer(); var counters = new PerformanceCounterManager(); var connection = new Mock<IConnection>(); var invoker = new Mock<IHubPipelineInvoker>(); var hubContext = new HubContext(connection.Object, invoker.Object, "test"); Assert.Throws<ArgumentException>(() => hubContext.Clients.Group(null)); }
public async Task SendBeforeOpenDoesNotThrowWhenQueuingBehaviorInitialOnly() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.InitialOnly, 1000, perfCounters); var sendTask = stream.Send(_ => { return(TaskAsyncHelper.Empty); }, null); stream.Open(); await sendTask.OrTimeout(); }
public void BufferAfterClosedEnqueueThrows() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Close(); stream.SetError(new Exception()); Assert.ThrowsAsync <Exception>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void SendBeforeOpenDoesNotThrowWhenQueuingBehaviorInitialOnly() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.InitialOnly, 1000, perfCounters); var sendTask = stream.Send(_ => { return TaskAsyncHelper.Empty; }, null); stream.Open(); Assert.DoesNotThrow(() => sendTask.Wait()); }
public void SendAfterCloseThenOpenRemainsClosed() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(_ => Task.Delay(50), null); stream.Close(); stream.Open(); Assert.Throws <InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void SendBeforeOpenDoesNotThrowWhenQueuingBehaviorInitialOnly() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.InitialOnly, 1000, perfCounters); var sendTask = stream.Send(_ => { return(TaskAsyncHelper.Empty); }, null); stream.Open(); Assert.DoesNotThrow(() => sendTask.Wait()); }
public void SendAfterCloseThenOpenRemainsClosed() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(_ => Task.Delay(50), null); stream.Close(); stream.Open(); Assert.ThrowsAsync <InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public async Task FarmDisconnectRaisesUncleanDisconnects() { // Each node shares the same bus but are independent servers const int nodeCount = 3; var counters = new 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 PerformanceCounterManager(); var configurationManager = new DefaultConfigurationManager(); using (EnableTracing()) 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 ErrorOnSendThrowsNextTime() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); stream.Open(); Task task = stream.Send(_ => { throw new InvalidOperationException(); }, null); Assert.Throws<AggregateException>(() => task.Wait()); Assert.Throws<InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void SanitizesInstanceNames(string instanceName, string expectedSanitizedName) { // Details on how to sanitize instance names are at http://msdn.microsoft.com/en-us/library/vstudio/system.diagnostics.performancecounter.instancename // Arrange var traceManager = new Mock<ITraceManager>(); traceManager.Setup(tm => tm[It.IsAny<string>()]).Returns<string>(name => new TraceSource(name)); // Act var perfCountersMgr = new PerformanceCounterManager(traceManager.Object); perfCountersMgr.Initialize(instanceName, CancellationToken.None); // Assert Assert.Equal(expectedSanitizedName, perfCountersMgr.InstanceName); }
public void ErrorOnSendThrowsNextTime() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", 1000, perfCounters); stream.Open(); Task task = stream.Send(_ => { throw new InvalidOperationException(); }, null); Assert.Throws <AggregateException>(() => task.Wait()); Assert.Throws <InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void InitialToBufferingToOpenToSend() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.SetError(new Exception()); stream.Open(); stream.Send(async _ => { await Task.Delay(20); x++; }, null).Wait(); Assert.Equal(1, x); }
public async Task ErrorOnSendThrowsNextTime() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); Task task = stream.Send(_ => { throw new InvalidOperationException(); }, null); await Assert.ThrowsAsync <InvalidOperationException>(() => task); await Assert.ThrowsAsync <InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void ErrorOnSendThrowsNextTime() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); Task task = stream.Send(_ => { throw new InvalidOperationException(); }, null); Assert.Throws <AggregateException>(() => task.Wait()); Assert.ThrowsAsync <InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void InitialToBufferingToOpenToSend() { int x = 0; var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.SetError(new Exception()); stream.Open(); stream.Send(async _ => { await Task.Delay(20); x++; }, null).Wait(); Assert.Equal(1, x); }
public void SendThrowsNullExceptionWhenConnectionIdIsNull() { var serializer = new JsonNetSerializer(); var counters = new PerformanceCounterManager(); var connection = new Connection(new Mock<IMessageBus>().Object, serializer, "signal", "connectonid", new[] { "test" }, new string[] { }, new Mock<ITraceManager>().Object, new AckHandler(completeAcksOnTimeout: false, ackThreshold: TimeSpan.Zero, ackInterval: TimeSpan.Zero), counters, new Mock<IProtectedData>().Object); Assert.Throws<ArgumentException>(() => connection.Send(null, new object())); }
async public void SendThrowsNullExceptionWhenConnectionIdsAreNull() { var serializer = JsonUtility.CreateDefaultSerializer(); var counters = new PerformanceCounterManager(new Mock<ILoggerFactory>().Object); var connection = new Connection(new Mock<IMessageBus>().Object, serializer, "signal", "connectonid", new[] { "test" }, new string[] { }, new Mock<ILoggerFactory>().Object, new AckHandler(completeAcksOnTimeout: false, ackThreshold: TimeSpan.Zero, ackInterval: TimeSpan.Zero), counters, new Mock<IProtectedData>().Object, new MemoryPool()); await Assert.ThrowsAsync<ArgumentNullException>(() => connection.Send((IList<string>)null, new object())); }
public void SendingCommandObjectSetsCommandOnBus() { var messageBus = new Mock<IMessageBus>(); var counters = new PerformanceCounterManager(); Message message = null; messageBus.Setup(m => m.Publish(It.IsAny<Message>())).Returns<Message>(m => { message = m; return TaskAsyncHelper.Empty; }); var serializer = JsonUtility.CreateDefaultSerializer(); var traceManager = new Mock<ITraceManager>(); var connection = new Connection(messageBus.Object, serializer, "signal", "connectonid", new[] { "a", "signal", "connectionid" }, new string[] { }, traceManager.Object, new AckHandler(completeAcksOnTimeout: false, ackThreshold: TimeSpan.Zero, ackInterval: TimeSpan.Zero), counters, new Mock<IProtectedData>().Object, new MemoryPool()); connection.Send("a", new Command { CommandType = CommandType.AddToGroup, Value = "foo" }); Assert.NotNull(message); Assert.True(message.IsCommand); var command = serializer.Parse<Command>(message.Value, message.Encoding); Assert.Equal(CommandType.AddToGroup, command.CommandType); Assert.Equal("foo", command.Value); }
/// <summary> /// Installs SignalR performance counters. /// </summary> public IList <string> InstallCounters() { // Delete any existing counters UninstallCounters(); var counterCreationData = SignalRPerfCounterManager.GetCounterPropertyInfo() .Select(p => { var attribute = SignalRPerfCounterManager.GetPerformanceCounterAttribute(p); return(new CounterCreationData(attribute.Name, attribute.Description, attribute.CounterType)); }) .ToArray(); var createDataCollection = new CounterCreationDataCollection(counterCreationData); PerformanceCounterCategory.Create(SignalRPerfCounterManager.CategoryName, "SignalR application performance counters", PerformanceCounterCategoryType.MultiInstance, createDataCollection); return(counterCreationData.Select(c => c.CounterName).ToList()); }
public void OpenQueueErrorOpenQueue() { int x = 0; var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock <ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); Task t1 = stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); Assert.Throws <AggregateException>(() => t1.Wait()); stream.Open(); Task t2 = stream.Send(async _ => { await Task.Delay(50); x++; }, null); t2.Wait(); Assert.Equal(2, x); }
public void GroupThrowsNullExceptionWhenGroupNameIsNull() { Func<string, ClientHubInvocation, IList<string>, Task> send = (signal, value, exclude) => Task.Factory.StartNew(() => { }); var serializer = new JsonNetSerializer(); var counters = new PerformanceCounterManager(); var connection = new Connection(new Mock<IMessageBus>().Object, serializer, "signal", "connectonid", new[] { "test" }, new string[] { }, new Mock<ITraceManager>().Object, new AckHandler(completeAcksOnTimeout: false, ackThreshold: TimeSpan.Zero, ackInterval: TimeSpan.Zero), counters, new Mock<IProtectedData>().Object); var hubContext = new HubContext(send, "test", connection); Assert.Throws<ArgumentException>(() => hubContext.Clients.Group(null)); }
public void OpenQueueErrorOpenQueue() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); Task t1 = stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); Assert.Throws <AggregateException>(() => t1.Wait()); stream.Open(); Task t2 = stream.Send(async _ => { await Task.Delay(50); x++; }, null); t2.Wait(); Assert.Equal(2, x); }
public void OpenQueueErrorOpenQueue() { int x = 0; var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); Task t1 = stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); Assert.Throws<AggregateException>(() => t1.Wait()); stream.Open(); Task t2 = stream.Send(async _ => { await Task.Delay(50); x++; }, null); t2.Wait(); Assert.Equal(2, x); }
public void SendAfterCloseThenOpenRemainsClosed() { var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(_ => Task.Delay(50), null); stream.Close(); stream.Open(); Assert.ThrowsAsync<InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void SendAfterOpenAndAfterErrorThrows() { var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; var firstSend = stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); stream.Open(); // Wait on the first send to drain firstSend.Wait(); stream.SetError(new Exception("Failed")); Assert.Throws<Exception>(() => { stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null).Wait(); }); Assert.Equal(1, x); }
public void SendBeforeOpenDoesNotThrowWhenQueuingBehaviorInitialOnly() { var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.InitialOnly, 1000, perfCounters); var sendTask = stream.Send(_ => { return TaskAsyncHelper.Empty; }, null); stream.Open(); // (Does not throw) sendTask.Wait(); }
public void SendsBeforeOpenedRunOnceOpenedWhenQueuingBehaviorInitialOnly() { var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.InitialOnly, 1000, perfCounters); int x = 0; stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); Task task = stream.Send(_ => { x++; return TaskAsyncHelper.Empty; }, null); stream.Open(); task.Wait(); Assert.Equal(2, x); }
public void RequestCompletesAfterFaultedInitializeResponse() { // Arrange var response = new Mock<IResponse>(); response.Setup(m => m.CancellationToken).Returns(CancellationToken.None); var request = new Mock<IRequest>(); var qs = new NameValueCollection(); qs["connectionId"] = "1"; request.Setup(m => m.QueryString).Returns(new NameValueCollectionWrapper(qs)); request.Setup(m => m.LocalPath).Returns("/test/echo/connect"); var counters = new PerformanceCounterManager(); var heartBeat = new Mock<ITransportHeartbeat>(); var json = new JsonSerializer(); var hostContext = new HostContext(request.Object, response.Object); var transportConnection = new Mock<ITransportConnection>(); var traceManager = new Mock<ITraceManager>(); traceManager.Setup(m => m[It.IsAny<string>()]).Returns(new System.Diagnostics.TraceSource("foo")); transportConnection.Setup(m => m.Receive(It.IsAny<string>(), It.IsAny<Func<PersistentResponse, object, Task<bool>>>(), It.IsAny<int>(), It.IsAny<object>())) .Returns<string, Func<PersistentResponse, object, Task<bool>>, int, object>( (messageId, callback, maxMessages, state) => new DisposableAction(() => callback(new PersistentResponse(), state)) ); var transport = new Mock<ForeverTransport>(hostContext, json, heartBeat.Object, counters, traceManager.Object) { CallBase = true }; var queue = new TaskQueue(); transport.Setup(t => t.EnqueueOperation(It.IsAny<Func<object, Task>>(), It.IsAny<object>())) .Returns<Func<object, Task>, object>( (writeAsync, state) => queue.Enqueue(writeAsync, state)); transport.Setup(t => t.InitializeResponse(It.IsAny<ITransportConnection>())) .Returns<ITransportConnection>( pr => TaskAsyncHelper.FromError(new Exception())); transport.Setup(t => t.Send(It.IsAny<PersistentResponse>())) .Returns<PersistentResponse>( pr => transport.Object.EnqueueOperation(() => TaskAsyncHelper.Empty)); var tcs = new TaskCompletionSource<bool>(); transport.Object.AfterRequestEnd = (ex) => { // Trip the cancellation token tcs.TrySetResult(transport.Object.WriteQueue.IsDrained); }; // Act transport.Object.ProcessRequest(transportConnection.Object); // Assert Assert.True(tcs.Task.Wait(TimeSpan.FromSeconds(2))); Assert.True(tcs.Task.Result); }
public void ErrorOnSendThrowsNextTime() { var loggerFactory = new Mock<ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var logger = new Mock<ILogger>(); var stream = new ScaleoutStream(logger.Object, "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); Task task = stream.Send(_ => { throw new InvalidOperationException(); }, null); Assert.Throws<AggregateException>(() => task.Wait()); Assert.ThrowsAsync<InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public void InitialToBufferingToOpenToSend() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.SetError(new Exception()); stream.Open(); stream.Send(async _ => { await Task.Delay(20); x++; }, null).Wait(); Assert.Equal(1, x); }
public void OpenQueueErrorOpenQueue() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); Task t1 = stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); Assert.Throws<AggregateException>(() => t1.Wait()); stream.Open(); Task t2 = stream.Send(async _ => { await Task.Delay(50); x++; }, null); t2.Wait(); Assert.Equal(2, x); }
public void CloseWhileQueueRunsWithFailedTask() { int x = 0; var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Open(); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Send(async _ => { await Task.Delay(50); await TaskAsyncHelper.FromError(new Exception()); }, null); stream.Send(async _ => { await Task.Delay(50); x++; }, null); stream.Close(); Assert.Equal(1, x); }
public void OpenAfterClosedEnqueueThrows() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Close(); stream.Open(); Assert.Throws<InvalidOperationException>(() => stream.Send(_ => TaskAsyncHelper.Empty, null)); }
public async Task FarmDisconnectRaisesUncleanDisconnects() { // Each node shares the same bus but are independent servers const int nodeCount = 3; var counters = new PerformanceCounterManager(); var configurationManager = new DefaultConfigurationManager(); configurationManager.DisconnectTimeout = TimeSpan.FromSeconds(6); using (EnableTracing()) 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 = Channel.CreateUnbounded <DisconnectData>(); loadBalancer.Configure(app => { var resolver = new DefaultDependencyResolver(); resolver.Register(typeof(IMessageBus), () => bus); resolver.Register(typeof(IConfigurationManager), () => configurationManager); resolver.Register(typeof(FarmConnection), () => new FarmConnection(disconnectCounter.Writer)); 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(); // Give up after 30 seconds var cts = new CancellationTokenSource(); cts.CancelAfter(TimeSpan.FromSeconds(30)); // We can get duplicate OnDisconnected calls, and that's a known by-design issue. var instancesDisconnected = new HashSet <string>(); while (await disconnectCounter.Reader.WaitToReadAsync(cts.Token)) { while (!cts.IsCancellationRequested && disconnectCounter.Reader.TryRead(out var disconnect)) { Assert.False(disconnect.StopCalled, "Disconnect should not have been due to stop being called."); instancesDisconnected.Add(disconnect.InstanceName); if (instancesDisconnected.Count == 3) { // We're done, all three instances disconneted return; } } } // If we get here it means the cts was cancelled which means we timed out cts.Token.ThrowIfCancellationRequested(); } }
public void RequestCompletesAfterFaultedInitializeResponse() { // Arrange var testContext = new TestContext("/test/echo/connect"); var counters = new PerformanceCounterManager(new Mock<ILoggerFactory>().Object); var heartBeat = new Mock<ITransportHeartbeat>(); var json = new JsonSerializer(); var transportConnection = new Mock<ITransportConnection>(); var loggerFactory = new Mock<ILoggerFactory>(); var memoryPool = new Mock<IMemoryPool>(); var applicationLifetime = new Mock<IApplicationLifetime>(); applicationLifetime.SetupGet(m => m.ApplicationStopping).Returns(CancellationToken.None); var logger = new Mock<ILogger>(); loggerFactory.Setup(m => m.CreateLogger(It.IsAny<string>())).Returns(logger.Object); transportConnection.Setup(m => m.Receive(It.IsAny<string>(), It.IsAny<Func<PersistentResponse, object, Task<bool>>>(), It.IsAny<int>(), It.IsAny<object>())) .Returns<string, Func<PersistentResponse, object, Task<bool>>, int, object>( (messageId, callback, maxMessages, state) => new DisposableAction(() => callback(new PersistentResponse(), state)) ); var transport = new Mock<ForeverTransport>(testContext.MockHttpContext.Object, json, heartBeat.Object, counters, applicationLifetime.Object, loggerFactory.Object, memoryPool.Object) { CallBase = true }; var queue = new TaskQueue(); transport.Setup(t => t.EnqueueOperation(It.IsAny<Func<object, Task>>(), It.IsAny<object>())) .Returns<Func<object, Task>, object>( (writeAsync, state) => queue.Enqueue(writeAsync, state)); transport.Setup(t => t.InitializeResponse(It.IsAny<ITransportConnection>())) .Returns<ITransportConnection>( pr => TaskAsyncHelper.FromError(new Exception())); transport.Setup(t => t.Send(It.IsAny<PersistentResponse>())) .Returns<PersistentResponse>( pr => transport.Object.EnqueueOperation(() => TaskAsyncHelper.Empty)); var tcs = new TaskCompletionSource<bool>(); transport.Object.AfterRequestEnd = (ex) => { // Trip the cancellation token tcs.TrySetResult(transport.Object.WriteQueue.IsDrained); }; // Act transport.Object.ProcessRequest(transportConnection.Object); // Assert Assert.True(tcs.Task.Wait(TimeSpan.FromSeconds(2))); Assert.True(tcs.Task.Result); }
public void InitialToClosed() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var stream = new ScaleoutStream(new TraceSource("Queue"), "0", QueuingBehavior.Always, 1000, perfCounters); stream.Close(); }
public void AcksAreSentToAckSubscriber() { // Arrange var waitCommand = new Command { WaitForAck = true }; var ackerId = "acker"; var waiterId = "waiter"; var messageId = "messageId"; var maxMessages = 1; var ackHandler = new Mock<IAckHandler>(); ackHandler.Setup(m => m.TriggerAck(waitCommand.Id)).Returns(false); var messageBus = new Mock<IMessageBus>(); Message waitMessage = null; Message ackMessage = null; messageBus.Setup(m => m.Publish(It.IsAny<Message>())).Returns<Message>(m => { if (m.WaitForAck) { waitMessage = m; } else if (m.IsAck) { ackMessage = m; } return TaskAsyncHelper.Empty; }); var loggerFactory = new Mock<ILoggerFactory>(); var counters = new PerformanceCounterManager(loggerFactory.Object); var serializer = JsonUtility.CreateDefaultSerializer(); var waiterConnection = new Connection(messageBus.Object, serializer, "signal", waiterId, new string[] { }, new string[] { }, loggerFactory.Object, ackHandler.Object, counters, new Mock<IProtectedData>().Object, new MemoryPool()); // Act waiterConnection.Send(ackerId, waitCommand); // Assert Assert.NotNull(waitMessage); Assert.Equal(waiterId, waitMessage.Source); Assert.Equal(PrefixHelper.GetConnectionId(ackerId), waitMessage.Key); // Arrange some more now that we have a waitMessage var messages = new List<ArraySegment<Message>>() { new ArraySegment<Message>(new[] { waitMessage }) }; var messageResult = new MessageResult(messages, 1); var ackerConnection = new Connection(messageBus.Object, serializer, "signal", ackerId, new string[] { }, new string[] { }, loggerFactory.Object, ackHandler.Object, counters, new Mock<IProtectedData>().Object, new Mock<IMemoryPool>().Object); ackerConnection.WriteCursor = _ => { }; messageBus.Setup(m => m.Subscribe(ackerConnection, messageId, It.IsAny<Func<MessageResult, object, Task<bool>>>(), maxMessages, It.IsAny<object>())) .Callback<ISubscriber, string, Func<MessageResult, object, Task<bool>>, int, object>((subsciber, cursor, callback, max, state) => { callback(messageResult, state); }); // Act ackerConnection.Receive(messageId, (_, __) => TaskAsyncHelper.False, maxMessages, null); // Assert Assert.NotNull(ackMessage); Assert.Equal(ackerId, ackMessage.Source); Assert.Equal(AckSubscriber.Signal, ackMessage.Key); }