public async Task FirstClientCanOverrideDefaultTimeout() { var cts = new CancellationTokenSource(); var listener = new TestableDiagnosticListener(); TimeSpan?newTimeSpan = null; var connectionSource = new TaskCompletionSource <int>(); var diagnosticListener = new Mock <IDiagnosticListener>(); diagnosticListener .Setup(x => x.UpdateKeepAlive(It.IsAny <TimeSpan>())) .Callback <TimeSpan>(ts => { newTimeSpan = ts; }); diagnosticListener .Setup(x => x.ConnectionProcessed(It.IsAny <int>())) .Callback <int>(count => connectionSource.SetResult(count)); var pipeName = Guid.NewGuid().ToString(); var dispatcherTask = Task.Run(() => { var dispatcher = new ServerDispatcher(CreateNopRequestHandler().Object, diagnosticListener.Object); dispatcher.ListenAndDispatchConnections(pipeName, TimeSpan.FromSeconds(1), cancellationToken: cts.Token); }); var seconds = 10; var response = await RunCSharpCompile(pipeName, HelloWorldSourceText, TimeSpan.FromSeconds(seconds)).ConfigureAwait(false); Assert.Equal(BuildResponse.ResponseType.Completed, response.Type); Assert.Equal(1, await connectionSource.Task.ConfigureAwait(false)); Assert.True(newTimeSpan.HasValue); Assert.Equal(seconds, newTimeSpan.Value.TotalSeconds); cts.Cancel(); await dispatcherTask.ConfigureAwait(false); }
public async Task KeepAliveAfterSimultaneousConnection() { var keepAlive = TimeSpan.FromSeconds(1); var listener = new TestableDiagnosticListener(); var pipeName = Guid.NewGuid().ToString(); var dispatcherTask = Task.Run(() => { var dispatcher = new ServerDispatcher(new CompilerRequestHandler(Temp.CreateDirectory().Path), listener); dispatcher.ListenAndDispatchConnections(pipeName, keepAlive); }); var list = new List <Task>(); for (int i = 0; i < 5; i++) { var task = Task.Run(() => RunCSharpCompile(pipeName, HelloWorldSourceText)); list.Add(task); } foreach (var current in list) { await current.ConfigureAwait(false); } await dispatcherTask.ConfigureAwait(false); Assert.Equal(5, listener.ProcessedCount); Assert.True(listener.LastProcessedTime.HasValue); Assert.True((DateTime.Now - listener.LastProcessedTime.Value) > keepAlive); }
public void KeepAliveNoConnections() { var keepAlive = TimeSpan.FromSeconds(3); var pipeName = Guid.NewGuid().ToString(); var requestHandler = new Mock <IRequestHandler>(MockBehavior.Strict); var dispatcher = new ServerDispatcher(requestHandler.Object, new EmptyDiagnosticListener()); var startTime = DateTime.Now; dispatcher.ListenAndDispatchConnections(pipeName, keepAlive); Assert.True((DateTime.Now - startTime) > keepAlive); }
public void KeepAliveAfterSingleConnection() { var connection = CreateClientConnection(CompletionReason.CompilationCompleted); var host = CreateClientConnectionHost( Task.FromResult(connection), new TaskCompletionSource <IClientConnection>().Task); var listener = new TestableDiagnosticListener(); var keepAlive = TimeSpan.FromSeconds(1); var dispatcher = new ServerDispatcher(host, listener); dispatcher.ListenAndDispatchConnections(keepAlive); Assert.Equal(1, listener.CompletedCount); Assert.True(listener.LastProcessedTime.HasValue); Assert.True(listener.HitKeepAliveTimeout); }
public void KeepAliveNoConnections() { var keepAlive = TimeSpan.FromSeconds(3); var connectionHost = new Mock <IClientConnectionHost>(); connectionHost .Setup(x => x.CreateListenTask(It.IsAny <CancellationToken>())) .Returns(new TaskCompletionSource <IClientConnection>().Task); var listener = new TestableDiagnosticListener(); var dispatcher = new ServerDispatcher(connectionHost.Object, listener); var startTime = DateTime.Now; dispatcher.ListenAndDispatchConnections(keepAlive); Assert.True(listener.HitKeepAliveTimeout); }
public async Task KeepAliveAfterSimultaneousConnection() { var totalCount = 2; var readySource = new TaskCompletionSource <bool>(); var list = new List <TaskCompletionSource <ConnectionData> >(); var host = new Mock <IClientConnectionHost>(); host .Setup(x => x.CreateListenTask(It.IsAny <CancellationToken>())) .Returns((CancellationToken ct) => { if (list.Count < totalCount) { var source = new TaskCompletionSource <ConnectionData>(); var client = CreateClientConnection(source.Task); list.Add(source); return(Task.FromResult(client)); } readySource.SetResult(true); return(new TaskCompletionSource <IClientConnection>().Task); }); var keepAlive = TimeSpan.FromSeconds(1); var listener = new TestableDiagnosticListener(); var dispatcherTask = Task.Run(() => { var dispatcher = new ServerDispatcher(host.Object, listener); dispatcher.ListenAndDispatchConnections(keepAlive); }); await readySource.Task.ConfigureAwait(true); foreach (var source in list) { source.SetResult(new ConnectionData(CompletionReason.Completed)); } await dispatcherTask.ConfigureAwait(true); Assert.Equal(totalCount, listener.ProcessedCount); Assert.True(listener.LastProcessedTime.HasValue); Assert.True(listener.HitKeepAliveTimeout); }
public async Task KeepAliveAfterSingleConnection() { var keepAlive = TimeSpan.FromSeconds(1); var listener = new TestableDiagnosticListener(); var pipeName = Guid.NewGuid().ToString(); var dispatcherTask = Task.Run(() => { var dispatcher = new ServerDispatcher(CreateNopRequestHandler().Object, listener); dispatcher.ListenAndDispatchConnections(pipeName, keepAlive); }); await RunCSharpCompile(pipeName, HelloWorldSourceText).ConfigureAwait(false); await dispatcherTask.ConfigureAwait(false); Assert.Equal(1, listener.ProcessedCount); Assert.True(listener.LastProcessedTime.HasValue); Assert.True((DateTime.Now - listener.LastProcessedTime.Value) > keepAlive); }
public void KeepAliveAfterMultipleConnection() { var count = 5; var list = new List <Task <IClientConnection> >(); for (var i = 0; i < count; i++) { var connection = CreateClientConnection(CompletionReason.CompilationCompleted); list.Add(Task.FromResult(connection)); } list.Add(new TaskCompletionSource <IClientConnection>().Task); var host = CreateClientConnectionHost(list.ToArray()); var listener = new TestableDiagnosticListener(); var keepAlive = TimeSpan.FromSeconds(1); var dispatcher = new ServerDispatcher(host, listener); dispatcher.ListenAndDispatchConnections(keepAlive); Assert.Equal(count, listener.CompletedCount); Assert.True(listener.LastProcessedTime.HasValue); Assert.True(listener.HitKeepAliveTimeout); }
public void ClientExceptionShouldBeginShutdown() { var client = new Mock <IClientConnection>(); client .Setup(x => x.HandleConnection(It.IsAny <bool>(), It.IsAny <CancellationToken>())) .Throws(new Exception()); var listenCancellationToken = default(CancellationToken); var first = true; var host = new Mock <IClientConnectionHost>(); host .Setup(x => x.CreateListenTask(It.IsAny <CancellationToken>())) .Returns((CancellationToken cancellationToken) => { if (first) { first = false; return(Task.FromResult(client.Object)); } else { listenCancellationToken = cancellationToken; return(Task.Delay(-1, cancellationToken).ContinueWith <IClientConnection>(_ => null, TaskScheduler.Default)); } }); var listener = new TestableDiagnosticListener(); var dispatcher = new ServerDispatcher(host.Object, listener); dispatcher.ListenAndDispatchConnections(TimeSpan.FromSeconds(10)); Assert.True(listener.HasDetectedBadConnection); Assert.True(listenCancellationToken.IsCancellationRequested); }