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