internal static void CloseNoThrow(IConnection connection, TimeSpan timeout) { bool success = false; try { connection.Close(timeout, false); success = true; } catch (TimeoutException e) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(e.Message); } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } catch (CommunicationException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } finally { if (!success) { connection.Abort(); } } }
void OnClose(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); foreach (EndpointConnectionPool pool in endpointPools.Values) { try { pool.Close(timeoutHelper.RemainingTime()); } catch (CommunicationException exception) { if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.ConnectionPoolCloseException, SR.GetString(SR.TraceCodeConnectionPoolCloseException), this, exception); } } catch (TimeoutException exception) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(exception.Message); } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.ConnectionPoolCloseException, SR.GetString(SR.TraceCodeConnectionPoolCloseException), this, exception); } } } endpointPools.Clear(); }
protected override void OnClose(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); TChannel[] channels = GetChannels(); for (int i = 0; i < channels.Length; i++) { bool success = false; try { channels[i].Close(timeoutHelper.RemainingTime()); success = true; } catch (CommunicationException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } catch (TimeoutException e) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(e.Message); } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } finally { if (!success) { channels[i].Abort(); } } } }
protected async Task CloseOutputSessionAsync(TimeSpan timeout) { ThrowIfNotOpened(); ThrowIfFaulted(); TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); // If timeout == TimeSpan.MaxValue, then we want to pass Timeout.Infinite as // SemaphoreSlim doesn't accept timeouts > Int32.MaxValue. // Using TimeoutHelper.RemainingTime() would yield a value less than TimeSpan.MaxValue // and would result in the value Int32.MaxValue so we must use the original timeout specified. if (!await _sendLock.WaitAsync(TimeoutHelper.ToMilliseconds(timeout))) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(SR.Format(SR.CloseTimedOut, timeout)); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException( SR.Format(SR.CloseTimedOut, timeout), TimeoutHelper.CreateEnterTimedOutException(timeout))); } try { // check again in case the previous send faulted while we were waiting for the lock ThrowIfFaulted(); // we're synchronized by sendLock here if (_isOutputSessionClosed) { return; } _isOutputSessionClosed = true; bool shouldFault = true; try { await this.CloseOutputSessionCoreAsync(timeout); this.OnOutputSessionClosed(ref timeoutHelper); shouldFault = false; } finally { if (shouldFault) { this.Fault(); } } } finally { _sendLock.Release(); } }
protected void CloseOutputSession(TimeSpan timeout) { ThrowIfNotOpened(); ThrowIfFaulted(); TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); if (!this.sendLock.TryEnter(timeoutHelper.RemainingTime())) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(SR.GetString(SR.CloseTimedOut, timeout)); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException( SR.GetString(SR.CloseTimedOut, timeout), ThreadNeutralSemaphore.CreateEnterTimedOutException(timeout))); } try { // check again in case the previous send faulted while we were waiting for the lock ThrowIfFaulted(); // we're synchronized by sendLock here if (this.isOutputSessionClosed) { return; } this.isOutputSessionClosed = true; bool shouldFault = true; try { this.CloseOutputSessionCore(timeout); this.OnOutputSessionClosed(ref timeoutHelper); shouldFault = false; } finally { if (shouldFault) { this.Fault(); } } } finally { this.sendLock.Exit(); } }
// for cached connections -- try to shut down gracefully if possible public void CloseFromPool(TimeSpan timeout) { try { Close(timeout); } catch (CommunicationException communicationException) { DiagnosticUtility.TraceHandledException(communicationException, TraceEventType.Information); } catch (TimeoutException timeoutException) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(timeoutException.Message); } DiagnosticUtility.TraceHandledException(timeoutException, TraceEventType.Information); } }
void IDisposable.Dispose() { bool success = false; RequestContext thisContext; lock (this.thisLock) { if (this.context == null) { return; } thisContext = this.context; this.context = null; } try { thisContext.Close(); success = true; } catch (CommunicationException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } catch (TimeoutException e) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(e.Message); } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } finally { if (!success) { thisContext.Abort(); } } }
void OnReceive(IAsyncResult result) { IDuplexSessionChannel channel = (IDuplexSessionChannel)result.AsyncState; bool success = false; try { Message message = channel.EndReceive(result); if (message == null) { channel.Close(this.channelPool.IdleTimeout); success = true; } else { message.Close(); } } catch (CommunicationException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } catch (TimeoutException e) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(e.Message); } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } finally { if (!success) { channel.Abort(); } } }
void IDisposable.Dispose() { bool success = false; RequestContext thisContext; lock (_thisLock) { if (_context == null) { return; } thisContext = _context; _context = null; } try { thisContext.Close(); success = true; } catch (CommunicationException) { } catch (TimeoutException e) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(e.Message); } } finally { if (!success) { thisContext.Abort(); } } }
private void OnClose(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); foreach (EndpointConnectionPool pool in _endpointPools.Values) { try { pool.Close(timeoutHelper.RemainingTime()); } catch (CommunicationException) { } catch (TimeoutException exception) { if (TD.CloseTimeoutIsEnabled()) { TD.CloseTimeout(exception.Message); } } } _endpointPools.Clear(); }