public void MultipleDisposes()
{
bool disposed = false;
var disposable = new DisposableAction(() => { disposed = true; });
var disposer = new Disposer();
Assert.False(disposed);
disposer.Dispose();
disposer.Dispose();
disposer.Dispose();
disposer.Dispose();
disposer.Set(disposable);
Assert.True(disposed);
}
public void CanAddNonDisposableCasted()
{
object toAdd = new object();
var toTest = new Disposer();
toTest.AddIfDisposable(toAdd);
toTest.Dispose();
}
public void AddDisposeClosure()
{
var ran = false;
var toTest = new Disposer();
toTest.AddAsDisposable(() => { ran = true; });
toTest.Dispose();
Assert.IsTrue(ran);
}
public void AddCasted()
{
var toCheck = new AssertDisposable();
object toAdd = toCheck;
var toTest = new Disposer();
toTest.AddIfDisposable(toAdd);
toTest.Dispose();
toCheck.AssertDisposed();
}
public static IDisposable Create(Func<IDictionary<string, object>, Task> app, IDictionary<string, object> properties)
{
if (app == null)
{
throw new ArgumentNullException("app");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
var capabilities = properties.Get<IDictionary<string, object>>(OwinKeys.ServerCapabilitiesKey)
?? new Dictionary<string, object>();
var addresses = properties.Get<IList<IDictionary<string, object>>>("host.Addresses")
?? new List<IDictionary<string, object>>();
var servers = new List<INowinServer>();
var endpoints = new List<IPEndPoint>();
foreach (var address in addresses)
{
var builder = ServerBuilder.New().SetOwinApp(app);
int port;
if (!int.TryParse(address.Get<string>("port"), out port)) throw new ArgumentException("port must be number from 0 to 65535");
builder.SetPort(port);
builder.SetOwinCapabilities(capabilities);
var certificate = address.Get<X509Certificate>("certificate");
if (certificate != null)
builder.SetCertificate(certificate);
servers.Add(builder.Build());
endpoints.Add(new IPEndPoint(IPAddress.Loopback,port));
}
var disposer = new Disposer(servers.Cast<IDisposable>().ToArray());
try
{
foreach (var nowinServer in servers)
{
nowinServer.Start();
}
// This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away
foreach (var ipEndPoint in endpoints)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Connect(ipEndPoint);
socket.Close();
}
}
catch (Exception)
{
disposer.Dispose();
throw;
}
return disposer;
}
public void Dispose_Then_OnDisposedShouldBeCalledOncePerDisposableInOrder()
{
var disposableReporter = Mock.Create <IDisposableReporter>();
var disposable1 = Mock.Create <IDisposable>();
var disposable2 = Mock.Create <IDisposable>();
Mock.Arrange(() => disposableReporter.Disposed(disposable1)).InOrder().Occurs(1);
Mock.Arrange(() => disposableReporter.Disposed(disposable2)).InOrder().Occurs(1);
var testee = new Disposer(disposableReporter, disposable1, disposable2);
testee.Dispose();
Mock.Assert(disposableReporter);
}
private bool disposedValue = false; // 重複する呼び出しを検出するには
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: マネージ状態を破棄します (マネージ オブジェクト)。
Disposer.Dispose();
}
// TODO: アンマネージ リソース (アンマネージ オブジェクト) を解放し、下のファイナライザーをオーバーライドします。
// TODO: 大きなフィールドを null に設定します。
disposedValue = true;
}
}
public void SetIndices(AttributeBuffer data)
{
if (data == null)
{
Disposer.Dispose(ref _indexBuffer);
return;
}
Bind();
if (_indexBuffer == null)
{
_indexBuffer = new BufferObject(BufferObjectTypes.Index);
}
_indexBuffer.BufferData(data);
}
public void EventAsDisposable()
{
var eventObject = new EventObject();
var toTest = new Disposer();
toTest.Event<Action<string>>(e => Assert.Fail("Unexpected"),
e => eventObject.AEvent += e,
e => eventObject.AEvent -= e);
toTest.Event<Action<string, string>>((f, s) => Assert.Fail("Unexpected"),
e => eventObject.OtherEvent += e,
e => eventObject.OtherEvent -= e);
toTest.Event<Action<string, string, string>>((f, s, t) => Assert.Fail("Unexpected"),
e => eventObject.ThirdEvent += e,
e => eventObject.ThirdEvent -= e);
toTest.Dispose();
eventObject.Raise();
}
public void Dispose()
{
var ior = this.ior;
if (ior == null)
{
return;
}
ior.Run(() => {
Disposer.Dispose(master);
master = null;
uir = null; //disposed
});
//fixes block on close while connected
Task.Factory.StartNew(ior.Dispose);
}
public void Dispose()
{
if (_isDisposed)
{
return;
}
_isDisposed = true;
Disposer.Dispose(_vertexBufferArray);
Disposer.Dispose(_particlePositions);
Disposer.Dispose(_particleColors);
Disposer.Dispose(_particleData1);
Disposer.Dispose(_particleData2);
Disposer.Dispose(_particleData3);
Disposer.Dispose(_computeShader);
Disposer.Dispose(_computeDataBuffer);
}
public Task <IResponse> Post(string url, Action <IRequest> prepareRequest, IDictionary <string, string> postData, bool isLongRunning)
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var responseDisposer = new Disposer();
var cts = new CancellationTokenSource();
var requestMessage = new HttpRequestMessage(HttpMethod.Post, new Uri(url));
if (postData == null)
{
requestMessage.Content = new StringContent(String.Empty);
}
else
{
requestMessage.Content = new ByteArrayContent(HttpHelper.ProcessPostData(postData));
}
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
responseDisposer.Dispose();
});
prepareRequest(request);
HttpClient httpClient = GetHttpClient(isLongRunning);
return(httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cts.Token)
.Then(responseMessage =>
{
if (responseMessage.IsSuccessStatusCode)
{
responseDisposer.Set(responseMessage);
}
else
{
throw new HttpClientException(responseMessage);
}
return (IResponse) new HttpResponseMessageWrapper(responseMessage);
}));
}
public void EventAsDisposable()
{
var eventObject = new EventObject();
var toTest = new Disposer();
toTest.Event <Action <string> >(e => Assert.Fail("Unexpected"),
e => eventObject.AEvent += e,
e => eventObject.AEvent -= e);
toTest.Event <Action <string, string> >((f, s) => Assert.Fail("Unexpected"),
e => eventObject.OtherEvent += e,
e => eventObject.OtherEvent -= e);
toTest.Event <Action <string, string, string> >((f, s, t) => Assert.Fail("Unexpected"),
e => eventObject.ThirdEvent += e,
e => eventObject.ThirdEvent -= e);
toTest.Dispose();
eventObject.Raise();
}
public void CannotAddObjectsToDisposerAfterSyncDispose()
{
var instance = new DisposeTracker();
var disposer = new Disposer();
disposer.AddInstanceForDisposal(instance);
Assert.False(instance.IsDisposed);
Assert.False(instance.IsDisposed);
disposer.Dispose();
Assert.True(instance.IsDisposed);
Assert.Throws <ObjectDisposedException>(() =>
{
disposer.AddInstanceForDisposal(instance);
});
}
private void IoException(Exception ex)
{
//first connection attempt should not reconnect
var cancelReconnect = (master == null);
if (master != null)
{
LogDuration();
}
Log("error", "Error: {0}", ex.Message);
if (Config.ShowStacktrace)
{
Log("debug", "{0}", ex.ToString());
}
Disposer.Dispose(master);
master = null;
Ui(() => { connected(false, cancelReconnect); });
}
public Task <IResponse> Get(string url, Action <IRequest> prepareRequest, bool isLongRunning)
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var responseDisposer = new Disposer();
var cts = new CancellationTokenSource();
var requestMessage = new HttpRequestMessage(HttpMethod.Get, new Uri(url));
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
responseDisposer.Dispose();
});
prepareRequest(request);
var httpClient = GetHttpClient(isLongRunning);
return(httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cts.Token)
.Then(responseMessage =>
{
if (responseMessage.IsSuccessStatusCode)
{
responseDisposer.Set(responseMessage);
}
else
{
// Dispose the response (https://github.com/SignalR/SignalR/issues/4092)
responseMessage.RequestMessage.Dispose();
responseMessage.Dispose();
// None of the getters on HttpResponseMessage throw ODE, so it should be safe to give the catcher of the exception
// access to the response. They may get an ODE if they try to read the body, but that's OK.
throw new HttpClientException(responseMessage);
}
return (IResponse) new HttpResponseMessageWrapper(responseMessage);
}));
}
private static void AcceptLoop(int pid, TcpListener listener, Func <ProcessStartInfo> pir)
{
var disposer = new Disposer();
disposer.Add(() => Environment.Exit(1));
using (disposer)
{
while (true)
{
try
{
listener.Start();
break;
}
catch (Exception ex)
{
WriteState("Error listening on {0}", listener.LocalEndpoint);
WriteError(ex.Message);
Thread.Sleep(5000);
}
}
var endpoint = listener.LocalEndpoint as IPEndPoint;
SetState(endpoint, pid);
var currentClient = null as TcpClient;
var currentTask = null as Task;
while (true)
{
var accepted = listener.AcceptTcpClient();
Disposer.Dispose(currentClient);
if (currentTask != null)
{
currentTask.Wait();
}
currentClient = accepted;
currentTask = Task.Factory.StartNew(() => SafeClientLoop(pid, endpoint, accepted, pir()), opts);
}
}
}
public void DisposerDisposesContainedInstances_InReverseOfOrderAdded()
{
DisposeTracker lastDisposed = null;
var instance1 = new DisposeTracker();
instance1.Disposing += (s, e) => lastDisposed = instance1;
var instance2 = new DisposeTracker();
instance2.Disposing += (s, e) => lastDisposed = instance2;
var disposer = new Disposer();
disposer.AddInstanceForDisposal(instance1);
disposer.AddInstanceForDisposal(instance2);
disposer.Dispose();
Assert.Same(instance1, lastDisposed);
}
public void Dispose_When_SetReporterWasCalledMultipleTimes_Then_OnDisposedShouldBeCalledInOrder()
{
var callOrder = new List <IDisposableReporter>();
var disposable = Mock.Create <IDisposable>();
var disposableReporter1 = Mock.Create <IDisposableReporter>();
var disposableReporter2 = Mock.Create <IDisposableReporter>();
var disposableReporter3 = Mock.Create <IDisposableReporter>();
Mock.Arrange(() => disposableReporter1.Disposed(disposable)).DoInstead(() => callOrder.Add(disposableReporter1));
Mock.Arrange(() => disposableReporter2.Disposed(disposable)).DoInstead(() => callOrder.Add(disposableReporter2));
Mock.Arrange(() => disposableReporter3.Disposed(disposable)).DoInstead(() => callOrder.Add(disposableReporter3));
var testee = new Disposer(disposableReporter1, disposable);
((IReportingDisposable)testee).SetReporter(disposableReporter2);
((IReportingDisposable)testee).SetReporter(disposableReporter3);
testee.Dispose();
callOrder.Should().Equal(disposableReporter1, disposableReporter2, disposableReporter3);
}
private bool GetInputHostManagerBroker()
{
bool ret = false;
if (_inputHostManagerBroker != null)
{
Disposer.Dispose(ref _inputHostManagerBroker);
}
try
{
using (var shellBroker = ComPtr <IImmersiveShellBroker> .Create(ComTypes.ImmersiveShellBrokerType))
{
_inputHostManagerBroker = new ComPtr <IInputHostManagerBroker>(shellBroker.Instance.GetInputHostManagerBroker());
ret = _inputHostManagerBroker != null;
}
}
catch (Exception e)
{
}
return(ret);
}
public void Dispose()
{
if (IsDisposed)
{
return;
}
IsDisposed = true;
GC.SuppressFinalize(this);
_currentContext.Value = null;
Disposer.Dispose(_globalUniforms);
Disposer.Dispose(_standartUniforms);
Disposer.Dispose(_renderTechnique);
Disposer.Dispose(_meshVaoCollection);
Disposer.Dispose(_defaultMaterial);
Disposer.Dispose(_blankTexture);
Disposer.Dispose(_glContext);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
var handler = CurrentScopeEnding;
try
{
handler?.Invoke(this, new LifetimeScopeEndingEventArgs(this));
}
finally
{
Disposer.Dispose();
}
// ReSharper disable once InconsistentlySynchronizedField
_sharedInstances.Clear();
}
base.Dispose(disposing);
}
private void SaveAttachment(FramebufferAttachment attachmentPosition, UIntObject attachment)
{
switch (attachmentPosition)
{
case FramebufferAttachment.DepthAttachment:
Disposer.Dispose(_depthAttachment);
_depthAttachment = attachment;
break;
case FramebufferAttachment.ColorAttachment0:
case FramebufferAttachment.ColorAttachment1:
case FramebufferAttachment.ColorAttachment2:
case FramebufferAttachment.ColorAttachment3:
case FramebufferAttachment.ColorAttachment4:
case FramebufferAttachment.ColorAttachment5:
case FramebufferAttachment.ColorAttachment6:
case FramebufferAttachment.ColorAttachment7:
case FramebufferAttachment.ColorAttachment8:
case FramebufferAttachment.ColorAttachment9:
case FramebufferAttachment.ColorAttachment10:
case FramebufferAttachment.ColorAttachment11:
case FramebufferAttachment.ColorAttachment12:
case FramebufferAttachment.ColorAttachment13:
case FramebufferAttachment.ColorAttachment14:
case FramebufferAttachment.ColorAttachment15:
var index = attachmentPosition - FramebufferAttachment.ColorAttachment0;
Disposer.Dispose(_colorAttachments[index]);
_colorAttachments[index] = attachment;
break;
case FramebufferAttachment.StencilAttachement:
throw new NotSupportedException(attachmentPosition.ToString());
default:
throw new NotSupportedException(attachmentPosition.ToString());
}
}
protected override void Dispose(bool disposing)
{
if (disposing == false)
{
return;
}
if (_isDisposed)
{
return;
}
_isDisposed = true;
if (this.RenderDispatcher != null)
{
this.RenderDispatcher.Render -= Frame;
}
Disposer.Dispose(_timer);
Disposer.Dispose(_scene);
base.Dispose(disposing);
}
private void AcceptLoop()
{
TcpClient current = null;
Task reader = null;
Task writer = null;
var disposer = new Disposer();
//newer versions have the Active property
disposer.Add(() => { input.Enqueue(new byte[] { }); });
disposer.Add(listener.Stop);
disposer.Add(() => Disposer.Dispose(reader));
disposer.Add(() => Disposer.Dispose(writer));
disposer.Add(() => Disposer.Dispose(current));
using (disposer)
{
while (true)
{
var client = listener.AcceptTcpClient();
Disposer.Dispose(current);
Disposer.Dispose(reader);
Disposer.Dispose(writer);
current = client;
ClearOutput();
var stream = client.GetStream() as Stream;
if ("ssl" == uri.Protocol)
{
var ssl = new SslStream(client.GetStream());
ssl.AuthenticateAsServer(certificate);
stream = ssl;
}
reader = Task.Factory.StartNew(() => ReadLoop(client, stream), TaskCreationOptions.LongRunning);
writer = Task.Factory.StartNew(() => WriteLoop(client, stream), TaskCreationOptions.LongRunning);
}
}
}
public void Dispose()
{
Disposer.Dispose(_shader);
}
public void ThrowOnDisposed()
{
var toTest = new Disposer();
toTest.Dispose();
Assert.Throws(typeof(ObjectDisposedException), toTest.CheckNotDisposed);
}
public static IDisposable Create(Func <IDictionary <string, object>, Task> app, IDictionary <string, object> properties)
{
if (app == null)
{
throw new ArgumentNullException("app");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
var capabilities = properties.Get <IDictionary <string, object> >(OwinKeys.ServerCapabilitiesKey)
?? new Dictionary <string, object>();
var addresses = properties.Get <IList <IDictionary <string, object> > >("host.Addresses")
?? new List <IDictionary <string, object> >();
var servers = new List <INowinServer>();
var endpoints = new List <IPEndPoint>();
foreach (var address in addresses)
{
var builder = ServerBuilder.New().SetOwinApp(app);
int port;
if (!int.TryParse(address.Get <string>("port"), out port))
{
throw new ArgumentException("port must be number from 0 to 65535");
}
builder.SetPort(port);
builder.SetOwinCapabilities(capabilities);
var certificate = address.Get <X509Certificate>("certificate");
if (certificate != null)
{
builder.SetCertificate(certificate);
}
servers.Add(builder.Build());
endpoints.Add(new IPEndPoint(IPAddress.Loopback, port));
}
var disposer = new Disposer(servers.Cast <IDisposable>().ToArray());
try
{
foreach (var nowinServer in servers)
{
nowinServer.Start();
}
// This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away
foreach (var ipEndPoint in endpoints)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Connect(ipEndPoint);
socket.Close();
}
}
catch (Exception)
{
disposer.Dispose();
throw;
}
return(disposer);
}
protected override void Dispose(bool disposing)
{
Disposer.Dispose(ref _timer);
base.Dispose();
}
public void ThrowOnAdd()
{
var toTest = new Disposer();
toTest.Dispose();
Assert.Throws(typeof(ObjectDisposedException), () => toTest.Add(new AssertDisposable()));
}
protected override void OnDispose()
{
Disposer.Dispose(ref _particleRenderer);
base.OnDispose();
}
public void Dispose()
{
Disposer.Dispose(certificate);
Disposer.Close(listener);
Disposer.Dispose(accepter);
}
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 IoDispose()
{
Disposer.Dispose(master);
}
public void Dispose()
{
m_Disposer.Dispose();
}
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);
}
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);
};
}
protected override void OnDispose()
{
base.OnDispose();
Disposer.Dispose(ref _wellMaterial);
}
public void ExpectDisposes()
{
var dsp1 = new AssertDisposable();
var dsp2 = new AssertDisposable();
var dsp3 = new AssertDisposable();
var toTest = new Disposer();
toTest.Add(dsp1);
toTest.Add(dsp2);
toTest.Add(dsp3);
toTest.Dispose();
dsp1.AssertDisposed();
dsp2.AssertDisposed();
dsp3.AssertDisposed();
}
