public async Task FaultedTaskShouldPropagateAsync() { Func <MessageResult, object, Task <bool> > callback = async(result, state) => { await Task.Delay(500); await TaskAsyncHelper.FromError(new Exception()); return(false); }; var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 1); using (subscription) { Task task = subscription.Work(); await Assert.ThrowsAsync <Exception>(() => task.OrTimeout()); Assert.True(task.IsFaulted); } }
private Task InvokeHubPipeline(IHub hub, IJsonValue[] parameterValues, MethodDescriptor methodDescriptor, HubRequest hubRequest, StateChangeTracker tracker) { Task <object> piplineInvocation; try { var args = _binder.ResolveMethodParameters(methodDescriptor, parameterValues); var context = new HubInvokerContext(hub, tracker, methodDescriptor, args); // Invoke the pipeline and save the task piplineInvocation = _pipelineInvoker.Invoke(context); } catch (Exception ex) { piplineInvocation = TaskAsyncHelper.FromError <object>(ex); } // Determine if we have a faulted task or not and handle it appropriately. return(piplineInvocation.ContinueWith(task => { if (task.IsFaulted) { return ProcessResponse(tracker, result: null, request: hubRequest, error: task.Exception); } else if (task.IsCanceled) { return ProcessResponse(tracker, result: null, request: hubRequest, error: new OperationCanceledException()); } else { return ProcessResponse(tracker, task.Result, hubRequest, error: null); } }) .FastUnwrap()); }
public void FailedStartShouldNotBeActive() { var connection = new Connection("http://test"); var transport = new Mock <IClientTransport>(); transport.Setup(m => m.Negotiate(connection)) .Returns(TaskAsyncHelper.FromResult(new NegotiationResponse { ProtocolVersion = "1.0", ConnectionId = "Something" })); transport.Setup(m => m.Start(connection, null)) .Returns(TaskAsyncHelper.FromError(new InvalidOperationException("Something failed."))); var aggEx = Assert.Throws <AggregateException>(() => connection.Start(transport.Object).Wait()); var ex = aggEx.Unwrap(); Assert.IsType(typeof(InvalidOperationException), ex); Assert.Equal("Something failed.", ex.Message); Assert.Equal(ConnectionState.Disconnected, connection.State); }
private Task WriteAsync(ArraySegment <byte> data, bool disableBuffering) { if (disableBuffering) { DisableResponseBuffering(); } if (!IsClientConnected) { return(TaskAsyncHelper.Empty); } try { _context.Response.OutputStream.Write(data.Array, data.Offset, data.Count); return(_context.Response.FlushAsync()); } catch (Exception ex) { return(TaskAsyncHelper.FromError(ex)); } }
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 Test_unsubscribe_handles_aggregate_exception() { //Arrange _mockMessageBus.Setup((b) => b.Unsubscribe(It.IsAny <string>(), It.IsAny <string>())) .Returns(TaskAsyncHelper.FromError <AggregateException>(new ArgumentException())); _mockMessageBus.Setup(b => b.Subscribe(It.IsAny <string>(), null, It.IsAny <MessageBusCallbackDelegate>())) .Returns(TaskAsyncHelper.Empty); _mockGroupManager.Setup(g => g.Add(It.IsAny <string>(), It.IsAny <string>())).Returns(TaskAsyncHelper.Empty); _mockGroupManager.Setup(g => g.Remove(It.IsAny <string>(), It.IsAny <string>())).Returns(TaskAsyncHelper.Empty); //Act _messageHub.Subscribe("123", "foo").Wait(); Assert.That(() => _messageHub.Unsubscribe("123", "foo").Wait(), Throws.TypeOf <AggregateException>()); //Assert _mockTraceListener.Verify(t => t.TraceEvent( It.IsAny <TraceEventCache>(), It.IsAny <string>(), TraceEventType.Error, It.IsAny <int>(), It.IsAny <string>(), It.IsAny <object[]>())); }
public void FaultedTaskShouldPropagateSync() { Func <MessageResult, object, Task <bool> > callback = async(result, state) => { await TaskAsyncHelper.FromError(new Exception()); return(false); }; var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 1); using (subscription) { Task task = null; TestUtilities.AssertUnwrappedException <Exception>(() => { task = subscription.Work(); task.Wait(); }); Assert.True(task.IsFaulted); } }
public void FailedStartShouldBeDisconnected() { var connection = new Client.Connection("http://test"); var transport = new Mock <IClientTransport>(); transport.Setup(m => m.Negotiate(connection, It.IsAny <string>())) .Returns(TaskAsyncHelper.FromResult(new NegotiationResponse { ProtocolVersion = connection.Protocol.ToString(), ConnectionId = "Something", DisconnectTimeout = 120 })); transport.Setup(m => m.Start(connection, null, It.IsAny <CancellationToken>())) .Returns(TaskAsyncHelper.FromError(new InvalidOperationException("Something failed."))); var aggEx = Assert.Throws <AggregateException>(() => connection.Start(transport.Object).Wait()); var ex = aggEx.Unwrap(); Assert.IsType(typeof(InvalidOperationException), ex); Assert.Equal("Something failed.", ex.Message); Assert.Equal(ConnectionState.Disconnected, connection.State); }
public void FaultedTaskShouldPropagateAsync() { Func <MessageResult, object, Task <bool> > callback = async(result, state) => { await Task.Delay(500); await TaskAsyncHelper.FromError(new Exception()); return(false); }; var subscription = new Mock <TestSubscription>("TestSub", new[] { "a" }, callback, 1) { CallBase = true }; using (subscription.Object) { Task task = subscription.Object.Work(); TestUtilities.AssertUnwrappedException <Exception>(() => task.Wait()); Assert.True(task.IsFaulted); } }
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 WebSocketTransportDoesntHangIfConnectReturnsFaultedTask() { RunWebSocketTransportWithConnectTask(() => TaskAsyncHelper.FromError(new Exception())); }
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.Create(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 RequestCompletesAfterFaultedWritesInTaskQueue() { Func <Task> writeFaulted = () => TaskAsyncHelper.FromError(new Exception()); EnqueAsyncWriteAndEndRequest(writeFaulted); }
public void RunPostReceiveWithFaultedTask() { RunWithPostReceive(() => TaskAsyncHelper.FromError(new Exception())); }
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); }
private Task <IClientResponse> ProcessRequest(string httpMethod, string url, Action <IClientRequest> prepareRequest, IDictionary <string, string> postData, bool disableWrites = false) { if (url == null) { throw new ArgumentNullException("url"); } if (prepareRequest == null) { throw new ArgumentNullException("prepareRequest"); } if (_appFunc == null) { throw new InvalidOperationException(); } if (_shutDownToken.IsCancellationRequested) { return(TaskAsyncHelper.FromError <IClientResponse>(new InvalidOperationException("Service unavailable"))); } var tcs = new TaskCompletionSource <IClientResponse>(); var clientTokenSource = new SafeCancellationTokenSource(); var env = new Dictionary <string, object>(); // Server specific setup env[OwinConstants.Version] = "1.0"; // Request specific setup var uri = new Uri(url); env[OwinConstants.RequestProtocol] = "HTTP/1.1"; env[OwinConstants.CallCancelled] = clientTokenSource.Token; env[OwinConstants.RequestMethod] = httpMethod; env[OwinConstants.RequestPathBase] = String.Empty; env[OwinConstants.RequestPath] = uri.LocalPath; env[OwinConstants.RequestQueryString] = uri.Query.Length > 0 ? uri.Query.Substring(1) : String.Empty; env[OwinConstants.RequestScheme] = uri.Scheme; env[OwinConstants.RequestBody] = GetRequestBody(postData); var headers = new Dictionary <string, string[]>(); env[OwinConstants.RequestHeaders] = headers; headers.SetHeader("X-Server", "MemoryHost"); headers.SetHeader("X-Server-Name", InstanceName); if (httpMethod == "POST") { headers.SetHeader("Content-Type", "application/x-www-form-urlencoded"); } // Run the client function to initialize the request prepareRequest(new Request(env, clientTokenSource.Cancel)); var networkObservable = new NetworkObservable(disableWrites); var clientStream = new ClientStream(networkObservable); var serverStream = new ServerStream(networkObservable); var response = new Response(clientStream); // Trigger the tcs on flush. This mimicks the client side networkObservable.OnFlush = () => tcs.TrySetResult(response); // Cancel the network observable on cancellation of the token clientTokenSource.Token.Register(networkObservable.Cancel); env[OwinConstants.ResponseBody] = serverStream; env[OwinConstants.ResponseHeaders] = new Dictionary <string, string[]>(); _appFunc(env).ContinueWith(task => { object statusCode; if (env.TryGetValue(OwinConstants.ResponseStatusCode, out statusCode) && (int)statusCode == 403) { tcs.TrySetException(new InvalidOperationException("Forbidden")); } else if (task.IsFaulted) { tcs.TrySetException(task.Exception.InnerExceptions); } else if (task.IsCanceled) { tcs.TrySetCanceled(); } else { tcs.TrySetResult(response); } // Close the server stream when the request has ended serverStream.Close(); clientTokenSource.Dispose(); }); return(tcs.Task); }
private Task ProcessRequestAsync(HttpListenerContext context) { try { Debug.WriteLine("Server: Incoming request to {0}.", context.Request.Url); PersistentConnection connection; string path = ResolvePath(context.Request.Url); foreach (var embeddedFileHandler in _embeddedFileHandlers) { var result = embeddedFileHandler.Handle(path, context); if (result != null) { return(result); } } if (_routingHost.TryGetConnection(path, out connection)) { // https://developer.mozilla.org/En/HTTP_Access_Control string origin = context.Request.Headers["Origin"]; if (!String.IsNullOrEmpty(origin)) { context.Response.AddHeader("Access-Control-Allow-Origin", origin); context.Response.AddHeader("Access-Control-Allow-Credentials", "true"); } var request = new HttpListenerRequestWrapper(context); var response = new HttpListenerResponseWrapper(context.Response, _disconnectHandler.GetDisconnectToken(context)); var hostContext = new HostContext(request, response); #if NET45 hostContext.Items[HostConstants.SupportsWebSockets] = Environment.OSVersion.Version.Major >= 6 && Environment.OSVersion.Version.Minor >= 2; #endif if (OnProcessRequest != null) { OnProcessRequest(hostContext); } #if DEBUG hostContext.Items[HostConstants.DebugMode] = true; #endif hostContext.Items["System.Net.HttpListenerContext"] = context; // Initialize the connection connection.Initialize(_routingHost.DependencyResolver); return(connection.ProcessRequestAsync(hostContext)); } if (path.Equals("/clientaccesspolicy.xml", StringComparison.InvariantCultureIgnoreCase)) { using (var stream = typeof(WebAppServer).Assembly.GetManifestResourceStream(typeof(WebAppServer), "clientaccesspolicy.xml")) { if (stream == null) { var response = new HttpResponseMessage(HttpStatusCode.NotFound); return(context.SendResponseAsync(response)); } var bytes = new byte[1024]; int byteCount = stream.Read(bytes, 0, bytes.Length); return(context.Response.WriteAsync(new ArraySegment <byte>(bytes, 0, byteCount))); } } HttpRequestMessage requestMessage = context.GetHttpRequestMessage(); return(_webApiServer.PublicSendAsync(requestMessage, _disconnectHandler.GetDisconnectToken(context)) .Then(response => { var responseMessage = response ?? new HttpResponseMessage(HttpStatusCode.InternalServerError) { RequestMessage = requestMessage }; return context.SendResponseAsync(responseMessage); })); } catch (Exception ex) { return(TaskAsyncHelper.FromError(ex)); } }
//[Fact(Skip = "Disable IIS Express tests because they fail to initialize")] public async Task WebSocketTransportDoesntHangIfConnectReturnsFaultedTask() { await RunWebSocketTransportWithConnectTask( () => TaskAsyncHelper.FromError(new InvalidOperationException())).OrTimeout(10000); }