bool Begin() { if (TD.EstablishConnectionStartIsEnabled()) { TD.EstablishConnectionStart(this.EventTraceActivity, this.parent.connectionKey); } IConnection connection = parent.TakeConnection(timeoutHelper.RemainingTime()); TrackConnection(connection); // first try and use a connection from our pool bool openingFromPool; if (OpenUsingConnectionPool(out openingFromPool)) { return(true); } if (openingFromPool) { return(false); } else { // if there isn't anything in the pool, we need to use a new connection return(OpenUsingNewConnection()); } }
public IConnection EstablishConnection(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); IConnection localRawConnection = null; IConnection localUpgradedConnection = null; bool localIsConnectionFromPool = true; EventTraceActivity localEventTraceActivity = this.EventTraceActivity; if (TD.EstablishConnectionStartIsEnabled()) { TD.EstablishConnectionStart(localEventTraceActivity, this.via != null ? this.via.AbsoluteUri : string.Empty); } // first try and use a connection from our pool (and use it if we successfully receive an ACK) while (localIsConnectionFromPool) { localRawConnection = this.TakeConnection(timeoutHelper.RemainingTime()); if (localRawConnection == null) { localIsConnectionFromPool = false; } else { bool preambleSuccess = false; try { localUpgradedConnection = AcceptPooledConnection(localRawConnection, ref timeoutHelper); preambleSuccess = true; break; } catch (CommunicationException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); // CommmunicationException is ok since it was a cached connection of unknown state } catch (TimeoutException e) { if (TD.OpenTimeoutIsEnabled()) { TD.OpenTimeout(e.Message); } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); // ditto for TimeoutException } finally { if (!preambleSuccess) { if (TD.ConnectionPoolPreambleFailedIsEnabled()) { TD.ConnectionPoolPreambleFailed(localEventTraceActivity); } if (DiagnosticUtility.ShouldTraceInformation) { TraceUtility.TraceEvent( TraceEventType.Information, TraceCode.FailedAcceptFromPool, SR.GetString( SR.TraceCodeFailedAcceptFromPool, timeoutHelper.RemainingTime())); } // This cannot throw TimeoutException since isConnectionStillGood is false (doesn't attempt a Close). this.connectionPool.ReturnConnection(connectionKey, localRawConnection, false, TimeSpan.Zero); } } } } // if there isn't anything in the pool, we need to use a new connection if (!localIsConnectionFromPool) { bool success = false; TimeSpan connectTimeout = timeoutHelper.RemainingTime(); try { try { localRawConnection = this.connectionInitiator.Connect(this.via, connectTimeout); } catch (TimeoutException e) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateNewConnectionTimeoutException( connectTimeout, e)); } this.connectionInitiator = null; localUpgradedConnection = AcceptPooledConnection(localRawConnection, ref timeoutHelper); success = true; } finally { if (!success) { connectionKey = null; if (localRawConnection != null) { localRawConnection.Abort(); } } } } SnapshotConnection(localUpgradedConnection, localRawConnection, localIsConnectionFromPool); if (TD.EstablishConnectionStopIsEnabled()) { TD.EstablishConnectionStop(localEventTraceActivity); } return(localUpgradedConnection); }