public virtual Task Start(IConnection connection, string connectionData, CancellationToken disconnectToken)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
_initializeHandler = new TransportInitializationHandler(connection.TransportConnectTimeout, disconnectToken);
// Tie into the OnFailure event so that we can stop the transport silently.
_initializeHandler.OnFailure += () =>
{
Dispose();
};
_disconnectToken = disconnectToken;
_connectionInfo = new WebSocketConnectionInfo(connection, connectionData);
// We don't need to await this task
PerformConnect().ContinueWith(task =>
{
if (task.IsFaulted)
{
_initializeHandler.Fail(task.Exception);
}
else if (task.IsCanceled)
{
_initializeHandler.Fail();
}
},
TaskContinuationOptions.NotOnRanToCompletion);
return _initializeHandler.Task;
}
protected override void OnStart(IConnection connection,
string connectionData,
CancellationToken disconnectToken,
TransportInitializationHandler initializeHandler)
{
var requestHandler = new PollingRequestHandler(HttpClient);
var negotiateInitializer = new NegotiateInitializer(initializeHandler);
Action<IRequest> initializeAbort = request => { negotiateInitializer.Abort(disconnectToken); };
requestHandler.OnError += negotiateInitializer.Complete;
requestHandler.OnAbort += initializeAbort;
// If the transport fails to initialize we want to silently stop
initializeHandler.OnFailure += () =>
{
requestHandler.Stop();
};
// Once we've initialized the connection we need to tear down the initializer functions and assign the appropriate onMessage function
negotiateInitializer.Initialized += () =>
{
requestHandler.OnError -= negotiateInitializer.Complete;
requestHandler.OnAbort -= initializeAbort;
};
// Add additional actions to each of the PollingRequestHandler events
PollingSetup(connection, connectionData, disconnectToken, requestHandler, negotiateInitializer.Complete);
requestHandler.Start();
}
public NegotiateInitializer(TransportInitializationHandler initializeHandler)
{
_initializeCallback = initializeHandler.Success;
_errorCallback = initializeHandler.Fail;
_callbackInvoker = new ThreadSafeInvoker();
// Set default initialized function
Initialized += () => { };
}
public Task Start(IConnection connection, string connectionData, CancellationToken disconnectToken)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
var initializeHandler = new TransportInitializationHandler(connection.TotalTransportConnectTimeout, disconnectToken);
OnStart(connection, connectionData, disconnectToken, initializeHandler);
return initializeHandler.Task;
}
protected override void OnStart(IConnection connection,
string connectionData,
CancellationToken disconnectToken,
TransportInitializationHandler initializeHandler)
{
if (initializeHandler == null)
{
throw new ArgumentNullException("initializeHandler");
}
// Tie into the OnFailure event so that we can stop the transport silently.
initializeHandler.OnFailure += () =>
{
_stop = true;
_request.Abort();
};
OpenConnection(connection, connectionData, disconnectToken, initializeHandler.Success, initializeHandler.Fail);
}
public void InitTaskThrowsStartFailedExceptionIfStartRequestThrows()
{
var mockTransportHelper = new Mock <TransportHelper>();
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(5));
mockConnection.Setup(c => c.JsonSerializer).Returns(JsonSerializer.CreateDefault());
var initHandler = new TransportInitializationHandler(Mock.Of <IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
var onFailureInvoked = false;
initHandler.OnFailure += () => onFailureInvoked = true;
var exception = new Exception("test exception");
mockTransportHelper.Setup(
h => h.GetStartResponse(It.IsAny <IHttpClient>(), It.IsAny <IConnection>(),
It.IsAny <string>(), It.IsAny <string>()))
.Returns <IHttpClient, IConnection, string, string>(
(httpClient, connection, connectionData, transport) =>
{
var tcs = new TaskCompletionSource <string>();
tcs.SetException(exception);
return(tcs.Task);
});
initHandler.InitReceived();
var startException =
Assert.Throws <AggregateException>(
() => Assert.True(initHandler.Task.Wait(TimeSpan.FromSeconds(1)))).InnerException;
Assert.IsType <StartException>(startException);
// startException.InnerException is an AggregateException
Assert.Same(exception, startException.InnerException.InnerException);
Assert.True(onFailureInvoked);
}
public void InitTaskIsFailedIfFailureOccursAfterStartRequestStarted()
{
var mockTransportHelper = new Mock <TransportHelper>();
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(0.5));
mockConnection.Setup(c => c.JsonSerializer).Returns(JsonSerializer.CreateDefault());
var initHandler = new TransportInitializationHandler(Mock.Of <IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
var onFailureInvoked = false;
initHandler.OnFailure += () => onFailureInvoked = true;
var exception = new Exception("test exception");
mockTransportHelper.Setup(
h => h.GetStartResponse(It.IsAny <IHttpClient>(), It.IsAny <IConnection>(),
It.IsAny <string>(), It.IsAny <string>()))
.Returns <IHttpClient, IConnection, string, string>(
(httpClient, connection, connectionData, transport) =>
{
initHandler.Fail(exception);
return(Task.FromResult("{ \"Response\" : \"started\" }"));
});
initHandler.InitReceived();
Exception startException =
Assert.Throws <AggregateException>(
() => Assert.True(initHandler.Task.Wait(TimeSpan.FromSeconds(1)))).InnerException;
Assert.IsType <StartException>(startException);
Assert.Same(exception, startException.InnerException);
Assert.True(onFailureInvoked);
}
public void StartRequestNotCalledIfTransportAlreadyFailed()
{
var mockConnection = new Mock<IConnection>();
mockConnection.Setup(c => c.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(1));
var mockTransportHelper = new Mock<TransportHelper>();
var failureInvokedMre = new ManualResetEvent(false);
var initHandler = new TransportInitializationHandler(Mock.Of<IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
initHandler.OnFailure += () => failureInvokedMre.Set();
initHandler.Fail();
Assert.True(failureInvokedMre.WaitOne(1000));
initHandler.InitReceived();
mockTransportHelper.Verify(
h => h.GetStartResponse(It.IsAny<IHttpClient>(), It.IsAny<IConnection>(),
It.IsAny<string>(), It.IsAny<string>()), Times.Never());
}
public async Task StartRequestNotCalledIfTransportAlreadyFailed()
{
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(c => c.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(1));
var mockTransportHelper = new Mock <TransportHelper>();
var failureInvokedTcs = new TaskCompletionSource <object>();
var initHandler = new TransportInitializationHandler(Mock.Of <IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
initHandler.OnFailure += () => failureInvokedTcs.TrySetResult(null);
initHandler.Fail();
await failureInvokedTcs.Task.OrTimeout();
initHandler.InitReceived();
mockTransportHelper.Verify(
h => h.GetStartResponse(It.IsAny <IHttpClient>(), It.IsAny <IConnection>(),
It.IsAny <string>(), It.IsAny <string>()), Times.Never());
}
public void StartRequestNotCalledIfTransportAlreadyFailed()
{
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(c => c.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(1));
var mockTransportHelper = new Mock <TransportHelper>();
var failureInvokedMre = new ManualResetEvent(false);
var initHandler = new TransportInitializationHandler(Mock.Of <IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
initHandler.OnFailure += () => failureInvokedMre.Set();
initHandler.Fail();
Assert.True(failureInvokedMre.WaitOne(1000));
initHandler.InitReceived();
mockTransportHelper.Verify(
h => h.GetStartResponse(It.IsAny <IHttpClient>(), It.IsAny <IConnection>(),
It.IsAny <string>(), It.IsAny <string>()), Times.Never());
}
public void InitTaskIsFailedIfFailureOccursAfterStartRequestStarted()
{
var mockTransportHelper = new Mock<TransportHelper>();
var mockConnection = new Mock<IConnection>();
mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(0.5));
mockConnection.Setup(c => c.JsonSerializer).Returns(JsonSerializer.CreateDefault());
var initHandler = new TransportInitializationHandler(Mock.Of<IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
var onFailureInvoked = false;
initHandler.OnFailure += () => onFailureInvoked = true;
var exception = new Exception("test exception");
mockTransportHelper.Setup(
h => h.GetStartResponse(It.IsAny<IHttpClient>(), It.IsAny<IConnection>(),
It.IsAny<string>(), It.IsAny<string>()))
.Returns<IHttpClient, IConnection, string, string>(
(httpClient, connection, connectionData, transport) =>
{
initHandler.Fail(exception);
return Task.FromResult("{ \"Response\" : \"started\" }");
});
initHandler.InitReceived();
var startException =
Assert.Throws<AggregateException>(
() => Assert.True(initHandler.Task.Wait(TimeSpan.FromSeconds(1)))).InnerException;
Assert.IsType<StartException>(startException);
Assert.Same(exception, startException.InnerException);
Assert.True(onFailureInvoked);
}
protected abstract void OnStart(IConnection connection,
string connectionData,
CancellationToken disconnectToken,
TransportInitializationHandler initializeHandler);
public async Task TimeoutDoesNotFailTheTaskAfterInitReceived()
{
var mockTransportHelper = new Mock<TransportHelper>();
var mockConnection = new Mock<IConnection>();
mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromMilliseconds(200));
mockConnection.Setup(c => c.JsonSerializer).Returns(JsonSerializer.CreateDefault());
mockTransportHelper.Setup(
h => h.GetStartResponse(It.IsAny<IHttpClient>(), It.IsAny<IConnection>(),
It.IsAny<string>(), It.IsAny<string>()))
.Returns<IHttpClient, IConnection, string, string>(
(httpClient, connection, connectionData, transport) =>
// wait for the timeout to fire
Task.Delay(250).ContinueWith(t => "{ \"Response\" : \"started\" }"));
var initHandler = new TransportInitializationHandler(Mock.Of<IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
var onFailureInvoked = false;
initHandler.OnFailure += () => onFailureInvoked = true;
initHandler.InitReceived();
await initHandler.Task;
Assert.False(onFailureInvoked);
}
public void FailInvokedIfDisconnectTokenTripped()
{
var mockTransportHelper = new Mock<TransportHelper>();
var mockConnection = new Mock<IConnection>();
mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromMilliseconds(200));
var cancellationTokenSource = new CancellationTokenSource();
var initHandler = new TransportInitializationHandler(Mock.Of<IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", cancellationTokenSource.Token, mockTransportHelper.Object);
var onFailureInvoked = false;
initHandler.OnFailure += () => onFailureInvoked = true;
cancellationTokenSource.Cancel();
var exception =
Assert.Throws<AggregateException>(
() => initHandler.Task.Wait(TimeSpan.FromSeconds(1))).InnerException;
Assert.IsType<OperationCanceledException>(exception);
Assert.Equal(Resources.Error_ConnectionCancelled, exception.Message);
Assert.Equal(cancellationTokenSource.Token, ((OperationCanceledException) exception).CancellationToken);
Assert.True(onFailureInvoked);
}
public void InitTaskThrowsStartFailedExceptionIfStartRequestReturnsIncorrectResult()
{
var mockTransportHelper = new Mock<TransportHelper>();
var mockConnection = new Mock<IConnection>();
mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(5));
mockConnection.Setup(c => c.JsonSerializer).Returns(JsonSerializer.CreateDefault());
var initHandler = new TransportInitializationHandler(Mock.Of<IHttpClient>(), mockConnection.Object,
string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);
var onFailureInvoked = false;
initHandler.OnFailure += () => onFailureInvoked = true;
mockTransportHelper.Setup(
h => h.GetStartResponse(It.IsAny<IHttpClient>(), It.IsAny<IConnection>(),
It.IsAny<string>(), It.IsAny<string>()))
.Returns<IHttpClient, IConnection, string, string>(
(httpClient, connection, connectionData, transport)
=> Task.FromResult("{ \"foo\" : \"bar\" }"));
initHandler.InitReceived();
Assert.IsType<StartException>(
Assert.Throws<AggregateException>(
() => Assert.True(initHandler.Task.Wait(TimeSpan.FromSeconds(1)))).InnerException);
Assert.True(onFailureInvoked);
}
public Task Start(IConnection connection, string connectionData, CancellationToken disconnectToken)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
_initializationHandler = new TransportInitializationHandler(HttpClient, connection, connectionData, Name, disconnectToken, TransportHelper);
_initializationHandler.OnFailure += OnStartFailed;
OnStart(connection, connectionData, disconnectToken);
return _initializationHandler.Task;
}
