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