// internal virtual for testing
internal virtual void OnError(IConnection connection, Exception exception)
{
// Prevent the reconnecting -> connected transition from happening if it hasn't already.
_reconnectInvoker.Invoke();
if (TryFailStart(exception))
{
return;
}
if (!TransportHelper.VerifyLastActive(connection))
{
StopPolling();
}
else
{
// Do the connected -> reconnecting transition if it hasn't already occurred.
connection.EnsureReconnecting();
}
// Sometimes a connection might have been closed by the server before we get to write anything
// so just try again and raise OnError.
if (!ExceptionHelper.IsRequestAborted(exception) && !(exception is IOException))
{
connection.OnError(exception);
}
}
private void Reconnect(IConnection connection, string data, CancellationToken disconnectToken)
{
// Need to verify before the task delay occurs because an application sleep could occur during the delayed duration.
if (!TransportHelper.VerifyLastActive(connection))
{
return;
}
// Wait for a bit before reconnecting
TaskAsyncHelper.Delay(ReconnectDelay).Then(() =>
{
if (!TransportHelper.VerifyLastActive(connection))
{
return;
}
// FIX: Race if Connection is stopped and completely restarted between checking the token and calling
// connection.EnsureReconnecting()
if (!disconnectToken.IsCancellationRequested && connection.EnsureReconnecting())
{
// Now attempt a reconnect
OpenConnection(connection, data, disconnectToken, initializeCallback: null, errorCallback: null);
}
});
}
private async void DoReconnect()
{
while (TransportHelper.VerifyLastActive(_connectionInfo.Connection) && _connectionInfo.Connection.EnsureReconnecting())
{
try
{
await PerformConnect(reconnecting : true);
break;
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
if (ExceptionHelper.IsRequestAborted(ex))
{
break;
}
_connectionInfo.Connection.OnError(ex);
}
await Task.Delay(ReconnectDelay);
}
}
// fire and forget
private async void DoReconnect()
{
var reconnectUrl = UrlBuilder.BuildReconnect(_connection, Name, _connectionData);
while (TransportHelper.VerifyLastActive(_connection) && _connection.EnsureReconnecting())
{
try
{
await PerformConnect(reconnectUrl);
break;
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
if (ExceptionHelper.IsRequestAborted(ex))
{
break;
}
_connection.OnError(ex);
}
await Task.Delay(ReconnectDelay);
}
}
// internal for testing
internal async Task Reconnect(IConnection connection, string connectionData)
{
var reconnectUrl = UrlBuilder.BuildReconnect(connection, Name, connectionData);
while (TransportHelper.VerifyLastActive(connection) && connection.EnsureReconnecting() && !_disconnectToken.IsCancellationRequested)
{
try
{
await StartWebSocket(connection, reconnectUrl);
if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected))
{
connection.OnReconnected();
}
break;
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
connection.OnError(ex);
}
await Task.Delay(ReconnectDelay);
}
}
public void Abort(IConnection connection, TimeSpan timeout)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
lock (this)
{
if (AbortResetEvent == null)
{
AbortResetEvent = new ManualResetEvent(initialState: false);
string url = connection.Url + "abort" + String.Format(CultureInfo.InvariantCulture,
_sendQueryString,
_transport,
Uri.EscapeDataString(connection.ConnectionToken),
null);
url += TransportHelper.AppendCustomQueryString(connection, url);
_httpClient.Post(url, connection.PrepareRequest).Catch((ex, state) =>
{
// If there's an error making an http request set the reset event
((ManualResetEvent)state).Set();
},
AbortResetEvent);
}
}
if (!AbortResetEvent.WaitOne(timeout))
{
connection.Trace(TraceLevels.Events, "Abort never fired");
}
}
public Task <NegotiationResponse> Negotiate(IConnection connection, string connectionData)
{
if (_finished)
{
throw new InvalidOperationException(Resources.Error_TransportCannotBeReused);
}
return(TransportHelper.GetNegotiationResponse(HttpClient, connection, connectionData));
}
// fire and forget
private async void DoReconnect()
{
try
{
var reconnectUrl = UrlBuilder.BuildReconnect(_connection, Name, _connectionData);
while (TransportHelper.VerifyLastActive(_connection) && _connection.EnsureReconnecting())
{
try
{
await PerformConnect(reconnectUrl, _disconnectToken);
break;
}
catch (OperationCanceledException)
{
return;
}
catch (Exception ex)
{
if (ExceptionHelper.IsRequestAborted(ex))
{
return;
}
_connection.OnError(ex);
}
await Task.Delay(ReconnectDelay);
}
var linkedToken = CreateLinkedCancellationToken();
try
{
await _webSocketHandler.ProcessWebSocketRequestAsync(_webSocket, linkedToken);
}
catch
{
// Ignore any errors from ProcessWebSocketRequestAsync just as OnStart does after the init message is received.
// Any errors other than one thrown from the final CloseAsync is reported via OnError(Exception).
}
}
catch (Exception ex)
{
_connection.Trace(TraceLevels.Events, "WS DoReconnect() failed: {0}", ex);
}
}
public void VerifyLastActiveSetsLastErrorIfConnectionExpired()
{
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(c => c.LastActiveAt).Returns(new DateTime(1));
mockConnection.Setup(c => c.ReconnectWindow).Returns(new TimeSpan(42));
var connection = mockConnection.Object;
Assert.False(TransportHelper.VerifyLastActive(connection));
var expectedMessage =
string.Format(CultureInfo.CurrentCulture, Resources.Error_ReconnectWindowTimeout,
connection.LastActiveAt, connection.ReconnectWindow);
mockConnection.Verify(c => c.Stop(It.Is <TimeoutException>(e => e.Message == expectedMessage)));
}
public override void OnMessage(string message)
{
_connectionInfo.Connection.Trace(TraceLevels.Messages, "WS: OnMessage({0})", message);
bool timedOut;
bool disconnected;
TransportHelper.ProcessResponse(_connectionInfo.Connection,
message,
out timedOut,
out disconnected);
if (disconnected && !_disconnectToken.IsCancellationRequested)
{
_connectionInfo.Connection.Disconnect();
Close();
}
}
public override void OnMessage(string message)
{
_connectionInfo.Connection.Trace(TraceLevels.Messages, "WS: OnMessage({0})", message);
bool timedOut;
bool disconnected;
TransportHelper.ProcessResponse(_connectionInfo.Connection,
message,
out timedOut,
out disconnected,
_initializeHandler.InitReceived);
if (disconnected && !_disconnectToken.IsCancellationRequested)
{
_connectionInfo.Connection.Trace(TraceLevels.Messages, "Disconnect command received from server.");
_connectionInfo.Connection.Disconnect();
}
}
private async Task PerformConnect(bool reconnecting = false)
{
var url = _connectionInfo.Connection.Url + (reconnecting ? "reconnect" : "connect");
url += TransportHelper.GetReceiveQueryString(_connectionInfo.Connection, _connectionInfo.Data, "webSockets");
var builder = new UriBuilder(url);
builder.Scheme = builder.Scheme == "https" ? "wss" : "ws";
_connectionInfo.Connection.Trace(TraceLevels.Events, "WS: {0}", builder.Uri);
var webSocket = new ClientWebSocket();
_connectionInfo.Connection.PrepareRequest(new WebSocketWrapperRequest(webSocket));
await webSocket.ConnectAsync(builder.Uri, _disconnectToken);
await ProcessWebSocketRequestAsync(webSocket, _disconnectToken);
}
public void Abort(IConnection connection, TimeSpan timeout)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
// Abort should never complete before any of its previous calls
lock (_abortLock)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
// Ensure that an abort request is only made once
if (!_startedAbort)
{
_startedAbort = true;
string url = connection.Url + "abort" + String.Format(CultureInfo.InvariantCulture,
_sendQueryString,
_transport,
Uri.EscapeDataString(connection.ConnectionToken),
null);
url += TransportHelper.AppendCustomQueryString(connection, url);
_httpClient.Post(url, connection.PrepareRequest).Catch((ex, state) =>
{
// If there's an error making an http request set the reset event
((HttpBasedTransport)state).CompleteAbort();
},
this);
if (!_abortResetEvent.WaitOne(timeout))
{
connection.Trace(TraceLevels.Events, "Abort never fired");
}
}
}
}
internal ClientTransportBase(IHttpClient httpClient, string transportName, TransportHelper transportHelper, TransportAbortHandler abortHandler)
{
if (httpClient == null)
{
throw new ArgumentNullException("httpClient");
}
if (string.IsNullOrWhiteSpace(transportName))
{
throw new ArgumentNullException("transportName");
}
Debug.Assert(transportHelper != null, "transportHelper is null");
Debug.Assert(abortHandler != null, "abortHandler is null");
_httpClient = httpClient;
_transportName = transportName;
_transportHelper = transportHelper;
_abortHandler = abortHandler;
}
internal ClientTransportBase(IHttpClient httpClient, string transportName, TransportHelper transportHelper, TransportAbortHandler abortHandler)
{
if (httpClient == null)
{
throw new ArgumentNullException("httpClient");
}
if (string.IsNullOrWhiteSpace(transportName))
{
throw new ArgumentNullException("transportName");
}
Debug.Assert(transportHelper != null, "transportHelper is null");
Debug.Assert(abortHandler != null, "abortHandler is null");
_httpClient = httpClient;
_transportName = transportName;
_transportHelper = transportHelper;
_abortHandler = abortHandler;
}
// internal virtual for testing
internal virtual void OnError(IConnection connection, Exception exception)
{
TransportFailed(exception);
_reconnectInvoker.Invoke();
if (!TransportHelper.VerifyLastActive(connection))
{
StopPolling();
}
// Transition into reconnecting state
connection.EnsureReconnecting();
// Sometimes a connection might have been closed by the server before we get to write anything
// so just try again and raise OnError.
if (!ExceptionHelper.IsRequestAborted(exception) && !(exception is IOException))
{
connection.OnError(exception);
}
}
public TransportInitializationHandler(IHttpClient httpClient,
IConnection connection,
string connectionData,
string transport,
CancellationToken disconnectToken,
TransportHelper transportHelper)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
_connection = connection;
_httpClient = httpClient;
_connectionData = connectionData;
_transport = transport;
_transportHelper = transportHelper;
_initializationTask = new TaskCompletionSource<object>();
_initializationInvoker = new ThreadSafeInvoker();
// Default event
OnFailure = () => { };
// We want to fail if the disconnect token is tripped while we're waiting on initialization
_tokenCleanup = disconnectToken.SafeRegister(
_ => Fail(new OperationCanceledException(Resources.Error_ConnectionCancelled, disconnectToken)),
state: null);
TaskAsyncHelper.Delay(connection.TotalTransportConnectTimeout)
.Then(() =>
{
// don't timeout once connect request has finished
if (Interlocked.CompareExchange(ref _state, InitializationState.Failed, InitializationState.Initial) ==
InitializationState.Initial)
{
Fail(new TimeoutException(Resources.Error_TransportTimedOutTryingToConnect));
}
});
}
private async Task PerformConnect(bool reconnecting)
{
var url = _connectionInfo.Connection.Url + (reconnecting ? "reconnect" : "connect");
url += TransportHelper.GetReceiveQueryString(_connectionInfo.Connection, _connectionInfo.Data, "webSockets");
var builder = new UriBuilder(url);
builder.Scheme = builder.Scheme == "https" ? "wss" : "ws";
_connectionInfo.Connection.Trace(TraceLevels.Events, "WS Connecting to: {0}", builder.Uri);
// TODO: Revisit thread safety of this assignment
_webSocketTokenSource = new CancellationTokenSource();
_webSocket = new ClientWebSocket();
_connectionInfo.Connection.PrepareRequest(new WebSocketWrapperRequest(_webSocket, _connectionInfo.Connection));
CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_webSocketTokenSource.Token, _disconnectToken);
CancellationToken token = linkedCts.Token;
await _webSocket.ConnectAsync(builder.Uri, token);
await ProcessWebSocketRequestAsync(_webSocket, token);
}
private void PollingSetup(IConnection connection,
string data,
CancellationToken disconnectToken,
PollingRequestHandler requestHandler,
Action onInitialized)
{
// reconnectInvoker is created new on each poll
var reconnectInvoker = new ThreadSafeInvoker();
var disconnectRegistration = disconnectToken.SafeRegister(state =>
{
reconnectInvoker.Invoke();
requestHandler.Stop();
}, null);
requestHandler.ResolveUrl = () =>
{
var url = connection.Url;
if (connection.MessageId == null)
{
url += "connect";
connection.Trace(TraceLevels.Events, "LP Connect: {0}", url);
}
else if (IsReconnecting(connection))
{
url += "reconnect";
connection.Trace(TraceLevels.Events, "LP Reconnect: {0}", url);
}
else
{
url += "poll";
connection.Trace(TraceLevels.Events, "LP Poll: {0}", url);
}
url += GetReceiveQueryString(connection, data);
return(url);
};
requestHandler.PrepareRequest += req =>
{
connection.PrepareRequest(req);
};
requestHandler.OnMessage += message =>
{
var shouldReconnect = false;
var disconnectedReceived = false;
connection.Trace(TraceLevels.Messages, "LP: OnMessage({0})", message);
TransportHelper.ProcessResponse(connection,
message,
out shouldReconnect,
out disconnectedReceived,
onInitialized);
if (IsReconnecting(connection))
{
// If the timeout for the reconnect hasn't fired as yet just fire the
// event here before any incoming messages are processed
TryReconnect(connection, reconnectInvoker);
}
if (shouldReconnect)
{
// Transition into reconnecting state
connection.EnsureReconnecting();
}
if (disconnectedReceived)
{
connection.Trace(TraceLevels.Messages, "Disconnect command received from server.");
connection.Disconnect();
}
};
requestHandler.OnError += exception =>
{
reconnectInvoker.Invoke();
if (!TransportHelper.VerifyLastActive(connection))
{
return;
}
// Transition into reconnecting state
connection.EnsureReconnecting();
// Sometimes a connection might have been closed by the server before we get to write anything
// so just try again and raise OnError.
if (!ExceptionHelper.IsRequestAborted(exception) && !(exception is IOException))
{
connection.OnError(exception);
}
else
{
requestHandler.Stop();
}
};
requestHandler.OnPolling += () =>
{
// Capture the cleanup within a closure so it can persist through multiple requests
TryDelayedReconnect(connection, reconnectInvoker);
};
requestHandler.OnAfterPoll = exception =>
{
if (AbortHandler.TryCompleteAbort())
{
// Abort() was called, so don't reconnect
requestHandler.Stop();
}
else
{
reconnectInvoker = new ThreadSafeInvoker();
if (exception != null)
{
// Delay polling by the error delay
return(TaskAsyncHelper.Delay(ErrorDelay));
}
}
return(TaskAsyncHelper.Empty);
};
requestHandler.OnAbort += _ =>
{
disconnectRegistration.Dispose();
// Complete any ongoing calls to Abort()
// If someone calls Abort() later, have it no-op
AbortHandler.CompleteAbort();
};
}
private void OpenConnection(IConnection connection,
string data,
CancellationToken disconnectToken,
Action initializeCallback,
Action <Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnecting = initializeCallback == null;
var callbackInvoker = new ThreadSafeInvoker();
var requestDisposer = new Disposer();
Action initializeInvoke = () =>
{
callbackInvoker.Invoke(initializeCallback);
};
var url = connection.Url + (reconnecting ? "reconnect" : "connect") + GetReceiveQueryString(connection, data);
connection.Trace(TraceLevels.Events, "SSE: GET {0}", url);
HttpClient.Get(url, req =>
{
_request = req;
_request.Accept = "text/event-stream";
connection.PrepareRequest(_request);
}, isLongRunning: true).ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
Exception exception;
if (task.IsCanceled)
{
exception = new OperationCanceledException(Resources.Error_TaskCancelledException);
}
else
{
exception = task.Exception.Unwrap();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, ex) => cb(ex), errorCallback, exception);
}
else if (!_stop && reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
Reconnect(connection, data, disconnectToken);
}
requestDisposer.Dispose();
}
else
{
// If the disconnect token is canceled the response to the task doesn't matter.
if (disconnectToken.IsCancellationRequested)
{
return;
}
var response = task.Result;
Stream stream = response.GetStream();
var eventSource = new EventSourceStreamReader(connection, stream);
var esCancellationRegistration = disconnectToken.SafeRegister(state =>
{
_stop = true;
((IRequest)state).Abort();
},
_request);
eventSource.Opened = () =>
{
// This will noop if we're not in the reconnecting state
if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected))
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
};
eventSource.Message = sseEvent =>
{
if (sseEvent.EventType == EventType.Data)
{
if (sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase))
{
return;
}
bool shouldReconnect;
bool disconnected;
TransportHelper.ProcessResponse(connection, sseEvent.Data, out shouldReconnect, out disconnected, initializeInvoke);
if (disconnected)
{
_stop = true;
connection.Disconnect();
}
}
};
eventSource.Closed = exception =>
{
if (exception != null)
{
// Check if the request is aborted
bool isRequestAborted = ExceptionHelper.IsRequestAborted(exception);
if (!isRequestAborted)
{
// Don't raise exceptions if the request was aborted (connection was stopped).
connection.OnError(exception);
}
}
requestDisposer.Dispose();
esCancellationRegistration.Dispose();
response.Dispose();
if (_stop)
{
AbortHandler.CompleteAbort();
}
else if (AbortHandler.TryCompleteAbort())
{
// Abort() was called, so don't reconnect
}
else
{
Reconnect(connection, data, disconnectToken);
}
};
eventSource.Start();
}
});
var requestCancellationRegistration = disconnectToken.SafeRegister(state =>
{
if (state != null)
{
// This will no-op if the request is already finished.
((IRequest)state).Abort();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, token) =>
{
#if !NET35
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled, token));
#else
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled));
#endif
}, errorCallback, disconnectToken);
}
}, _request);
requestDisposer.Set(requestCancellationRegistration);
}
protected string GetReceiveQueryString(IConnection connection, string data)
{
return(TransportHelper.GetReceiveQueryString(connection, data, _transport));
}
private void OpenConnection(IConnection connection,
string data,
CancellationToken disconnectToken,
Action initializeCallback,
Action <Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnecting = initializeCallback == null;
var callbackInvoker = new ThreadSafeInvoker();
var requestDisposer = new Disposer();
var url = (reconnecting ? connection.Url : connection.Url + "connect") + GetReceiveQueryString(connection, data);
connection.Trace(TraceLevels.Events, "SSE: GET {0}", url);
HttpClient.Get(url, req =>
{
_request = req;
connection.PrepareRequest(_request);
_request.Accept = "text/event-stream";
}).ContinueWith(task =>
{
if (task.IsFaulted)
{
Exception exception = task.Exception.Unwrap();
if (!ExceptionHelper.IsRequestAborted(exception))
{
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, ex) => cb(ex), errorCallback, exception);
}
else if (reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
Reconnect(connection, data, disconnectToken);
}
}
requestDisposer.Dispose();
}
else
{
var response = task.Result;
Stream stream = response.GetStream();
var eventSource = new EventSourceStreamReader(connection, stream);
bool retry = true;
var esCancellationRegistration = disconnectToken.SafeRegister(state =>
{
retry = false;
((IRequest)state).Abort();
},
_request);
eventSource.Opened = () =>
{
// If we're not reconnecting, then we're starting the transport for the first time. Trigger callback only on first start.
if (!reconnecting)
{
callbackInvoker.Invoke(initializeCallback);
}
else if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected))
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
};
eventSource.Message = sseEvent =>
{
if (sseEvent.EventType == EventType.Data)
{
if (sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase))
{
return;
}
bool timedOut;
bool disconnected;
TransportHelper.ProcessResponse(connection, sseEvent.Data, out timedOut, out disconnected);
if (disconnected)
{
retry = false;
connection.Disconnect();
}
}
};
eventSource.Closed = exception =>
{
if (exception != null)
{
// Check if the request is aborted
bool isRequestAborted = ExceptionHelper.IsRequestAborted(exception);
if (!isRequestAborted)
{
// Don't raise exceptions if the request was aborted (connection was stopped).
connection.OnError(exception);
}
}
requestDisposer.Dispose();
esCancellationRegistration.Dispose();
response.Dispose();
if (AbortResetEvent != null)
{
AbortResetEvent.Set();
}
else if (retry)
{
Reconnect(connection, data, disconnectToken);
}
};
eventSource.Start();
}
});
var requestCancellationRegistration = disconnectToken.SafeRegister(state =>
{
if (state != null)
{
// This will no-op if the request is already finished.
((IRequest)state).Abort();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, token) =>
{
#if NET35 || WINDOWS_PHONE
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled));
#else
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled, token));
#endif
}, errorCallback, disconnectToken);
}
}, _request);
requestDisposer.Set(requestCancellationRegistration);
if (errorCallback != null)
{
TaskAsyncHelper.Delay(ConnectionTimeout).Then(() =>
{
callbackInvoker.Invoke((conn, cb) =>
{
// Abort the request before cancelling
_request.Abort();
// Connection timeout occurred
cb(new TimeoutException());
},
connection,
errorCallback);
});
}
}
private void PollingSetup(IConnection connection,
string data,
CancellationToken disconnectToken,
PollingRequestHandler requestHandler)
{
// These are created new on each poll
var reconnectInvoker = new ThreadSafeInvoker();
var requestDisposer = new Disposer();
requestHandler.ResolveUrl = () =>
{
var url = connection.Url;
if (connection.MessageId == null)
{
url += "connect";
}
else if (IsReconnecting(connection))
{
url += "reconnect";
}
else
{
url += "poll";
}
url += GetReceiveQueryString(connection, data);
return(url);
};
requestHandler.PrepareRequest += req =>
{
connection.PrepareRequest(req);
};
requestHandler.OnMessage += message =>
{
var shouldReconnect = false;
var disconnectedReceived = false;
connection.Trace(TraceLevels.Messages, "LP: OnMessage({0})", message);
TransportHelper.ProcessResponse(connection,
message,
out shouldReconnect,
out disconnectedReceived);
if (IsReconnecting(connection))
{
// If the timeout for the reconnect hasn't fired as yet just fire the
// event here before any incoming messages are processed
TryReconnect(connection, reconnectInvoker);
}
if (shouldReconnect)
{
// Transition into reconnecting state
connection.EnsureReconnecting();
}
if (AbortResetEvent != null)
{
AbortResetEvent.Set();
}
else if (disconnectedReceived)
{
connection.Disconnect();
}
};
requestHandler.OnError += exception =>
{
reconnectInvoker.Invoke();
// Transition into reconnecting state
connection.EnsureReconnecting();
// Sometimes a connection might have been closed by the server before we get to write anything
// so just try again and raise OnError.
if (!ExceptionHelper.IsRequestAborted(exception) && !(exception is IOException))
{
connection.OnError(exception);
}
else
{
// If we aborted purposely then we need to stop the request handler
requestHandler.Stop();
}
};
requestHandler.OnPolling += () =>
{
// Capture the cleanup within a closure so it can persist through multiple requests
TryDelayedReconnect(connection, reconnectInvoker);
requestDisposer.Set(disconnectToken.SafeRegister(state =>
{
reconnectInvoker.Invoke();
requestHandler.Stop();
}, null));
};
requestHandler.OnAfterPoll = exception =>
{
requestDisposer.Dispose();
requestDisposer = new Disposer();
reconnectInvoker = new ThreadSafeInvoker();
if (exception != null)
{
// Delay polling by the error delay
return(TaskAsyncHelper.Delay(ErrorDelay));
}
return(TaskAsyncHelper.Empty);
};
}
