protected override void OnStart(IConnection connection,
string data,
CancellationToken disconnectToken,
Action initializeCallback,
Action <Exception> errorCallback)
{
var requestHandler = new PollingRequestHandler(HttpClient);
var negotiateInitializer = new NegotiateInitializer(initializeCallback, errorCallback, ConnectDelay);
// Save the success and abort cases so we can remove them after transport is initialized
Action <string> initializeSuccess = message => { negotiateInitializer.Complete(); };
Action <IRequest> initializeAbort = request => { negotiateInitializer.Abort(disconnectToken); };
requestHandler.OnMessage += initializeSuccess;
requestHandler.OnError += negotiateInitializer.Complete;
requestHandler.OnAbort += initializeAbort;
// Once we've initialized the connection we need to tear down the initializer functions
negotiateInitializer.Initialized += () =>
{
requestHandler.OnMessage -= initializeSuccess;
requestHandler.OnError -= negotiateInitializer.Complete;
requestHandler.OnAbort -= initializeAbort;
};
// Add additional actions to each of the PollingRequestHandler events
PollingSetup(connection, data, disconnectToken, requestHandler);
requestHandler.Start();
// Start initialization, essentially if we have an assume sucess clause in our negotiateInitializer
// then we will start the countdown from the point which we start initialization.
negotiateInitializer.Initialize();
}
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();
}
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();
}
protected override void OnStart(IConnection connection,
string data,
CancellationToken disconnectToken,
Action initializeCallback,
Action<Exception> errorCallback)
{
var requestHandler = new PollingRequestHandler(HttpClient);
var negotiateInitializer = new NegotiateInitializer(initializeCallback, errorCallback, ConnectDelay);
// Save the success and abort cases so we can remove them after transport is initialized
Action<string> initializeSuccess = message => { negotiateInitializer.Complete(); };
Action<IRequest> initializeAbort = request => { negotiateInitializer.Abort(disconnectToken); };
requestHandler.OnMessage += initializeSuccess;
requestHandler.OnError += negotiateInitializer.Complete;
requestHandler.OnAbort += initializeAbort;
// Once we've initialized the connection we need to tear down the initializer functions
negotiateInitializer.Initialized += () =>
{
requestHandler.OnMessage -= initializeSuccess;
requestHandler.OnError -= negotiateInitializer.Complete;
requestHandler.OnAbort -= initializeAbort;
};
// Add additional actions to each of the PollingRequestHandler events
PollingSetup(connection, data, disconnectToken, requestHandler);
requestHandler.Start();
// Start initialization, essentially if we have an assume sucess clause in our negotiateInitializer
// then we will start the countdown from the point which we start initialization.
negotiateInitializer.Initialize();
}
public void PollingRequestHandlerDoesNotPollAfterClose()
{
var httpClient = new CustomHttpClient();
var requestHandler = new PollingRequestHandler(httpClient);
var active = true;
Action verifyActive = () =>
{
Assert.True(active);
};
requestHandler.ResolveUrl = () =>
{
Assert.True(active);
return "";
};
requestHandler.PrepareRequest += request =>
{
verifyActive();
};
requestHandler.OnPolling += verifyActive;
requestHandler.OnAfterPoll += exception =>
{
verifyActive();
return TaskAsyncHelper.Empty;
};
requestHandler.OnError += exception =>
{
verifyActive();
};
requestHandler.OnMessage += message =>
{
verifyActive();
};
requestHandler.OnAbort += request =>
{
active = false;
};
requestHandler.Start();
// Let the request handler run for three seconds
Thread.Sleep(TimeSpan.FromSeconds(.1));
requestHandler.Stop();
// Let all requests finish to see if we get any unintended results
Thread.Sleep(TimeSpan.FromSeconds(1));
}
public void CancelledTaskHandledinLongPolling()
{
var tcs = new TaskCompletionSource<IResponse>();
var wh = new TaskCompletionSource<Exception>();
tcs.TrySetCanceled();
var httpClient = new Mock<Microsoft.AspNet.SignalR.Client.Http.IHttpClient>();
httpClient.Setup(c => c.Post(It.IsAny<string>(),
It.IsAny<Action<Client.Http.IRequest>>(), It.IsAny<IDictionary<string, string>>(), It.IsAny<bool>()))
.Returns(tcs.Task);
var pollingHandler = new PollingRequestHandler(httpClient.Object);
pollingHandler.Start();
pollingHandler.OnError += (ex) => { wh.TrySetResult(ex); };
Assert.True(wh.Task.Wait(TimeSpan.FromSeconds(5)));
Assert.IsType(typeof(OperationCanceledException), wh.Task.Result);
}
public void PollingRequestHandlerDoesNotPollAfterCloseMidRequest()
{
var httpClient = new CustomHttpClient();
var requestHandler = new PollingRequestHandler(httpClient);
var active = true;
var killRequest = false;
Action verifyActive = () =>
{
Assert.True(active);
};
requestHandler.ResolveUrl = () =>
{
Assert.True(active);
return "";
};
requestHandler.PrepareRequest += request =>
{
if (killRequest)
{
// Execute the stop on a different thread so it does not share the lock
// This is to simulate a real world situation in which the user requests the connection to stop
ThreadPool.QueueUserWorkItem(state =>
{
requestHandler.Stop();
});
}
verifyActive();
};
requestHandler.OnPolling += verifyActive;
requestHandler.OnMessage += message =>
{
verifyActive();
};
requestHandler.OnAfterPoll += exception =>
{
verifyActive();
return TaskAsyncHelper.Empty;
};
requestHandler.OnError += exception =>
{
verifyActive();
};
requestHandler.OnAbort += request =>
{
active = false;
};
requestHandler.Start();
// Let the request handler run for three seconds
Thread.Sleep(TimeSpan.FromSeconds(.1));
killRequest = true;
// Let all requests finish to see if we get any unintended results
Thread.Sleep(TimeSpan.FromSeconds(1));
}
