private ReadOnlyCollection <PeerNodeAddress> ResolveNewAddresses(TimeSpan timeLeft, bool retryResolve) { TimeoutHelper helper = new TimeoutHelper(timeLeft); Dictionary <string, PeerNodeAddress> dictionary = new Dictionary <string, PeerNodeAddress>(); List <PeerNodeAddress> list = new List <PeerNodeAddress>(); PeerNodeAddress listenAddress = this.config.GetListenAddress(true); dictionary.Add(listenAddress.ServicePath, listenAddress); int num = retryResolve ? 2 : 1; if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord extendedData = new PeerMaintainerTraceRecord("Resolving"); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), extendedData, this, null); } for (int i = 0; ((i < num) && (list.Count < this.config.MaxResolveAddresses)) && (this.isOpen && (helper.RemainingTime() > TimeSpan.Zero)); i++) { ReadOnlyCollection <PeerNodeAddress> onlys; try { onlys = this.config.Resolver.Resolve(this.config.MeshId, this.config.MaxResolveAddresses, helper.RemainingTime()); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record2 = new PeerMaintainerTraceRecord("Resolve exception " + exception.Message); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), record2, this, null); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("ResolverException"), exception)); } if (onlys != null) { foreach (PeerNodeAddress address2 in onlys) { if (!dictionary.ContainsKey(address2.ServicePath)) { dictionary.Add(address2.ServicePath, address2); if (((IPeerMaintainer)this).FindDuplicateNeighbor(address2) == null) { list.Add(address2); } } } } } return(new ReadOnlyCollection <PeerNodeAddress>(list)); }
public void Connect(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); addNeighbor.Set(); // We are trying to add a neighbor List <IAsyncResult> results = new List <IAsyncResult>(); List <WaitHandle> handles = new List <WaitHandle>(); // While we have more to endpoints try and we have connections pending and we are not connected upto ideal yet, and the maintainer is still open while (results.Count != 0 || (((nodeAddresses.Count != 0 || pendingConnectedNeighbor.Count != 0) && maintainer.IsOpen) && maintainer.ConnectedNeighborCount < wantedConnectionCount)) { try { handles.Clear(); foreach (IAsyncResult iar in results) { handles.Add(iar.AsyncWaitHandle); } handles.Add(welcomeReceived); // One of our connect requests resulted in a welcome or neighborManager was shutting down handles.Add(maintainerClosed); // One of our connect requests resulted in a welcome or neighborManager was shutting down handles.Add(addNeighbor); // Make the last waithandle the add a neighbor signal int index = WaitHandle.WaitAny(handles.ToArray(), config.ConnectTimeout, false); if (index == results.Count) // welcomeReceived was signalled { welcomeReceived.Reset(); } else if (index == results.Count + 1) // maintainerClosed was signalled { maintainerClosed.Reset(); lock (ThisLock) { nodeAddresses.Clear(); } } else if (index == results.Count + 2) // addNeighbor was signalled { // We need to open a new neighbor if (nodeAddresses.Count > 0) { if (pendingConnectedNeighbor.Count + maintainer.ConnectedNeighborCount < wantedConnectionCount) { PeerNodeAddress epr = null; lock (ThisLock) { if (nodeAddresses.Count == 0 || !maintainer.IsOpen) // nodeAddresses or maintainer is closed got updated better cycle { addNeighbor.Reset(); continue; } int index2 = random.Next() % nodeAddresses.Count; ICollection <Uri> keys = nodeAddresses.Keys; int i = 0; Uri key = null; foreach (Uri uri in keys) { if (i++ == index2) { key = uri; break; } } Fx.Assert(key != null, "key cannot be null here"); epr = nodeAddresses[key]; Fx.Assert(epr != null, "epr cannot be null here"); nodeAddresses.Remove(key); } if (maintainer.FindDuplicateNeighbor(epr) == null && pendingConnectedNeighbor.ContainsKey(GetEndpointUri(epr)) == false) { lock (ThisLock) { pendingConnectedNeighbor.Add(GetEndpointUri(epr), epr); } // If the neighborManager is not open this call is going to throw. // It throws ObjectDisposed exception. // This check merely eliminates the perf hit, this check is not strictly necessary // but cuts down the window for the ---- that will result in a throw to a miniscule level // We ---- the throw because we are closing down try { if (maintainer.IsOpen) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord(SR.GetString(SR.PeerMaintainerConnect, epr, this.config.MeshId)); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } IAsyncResult iar = maintainer.BeginOpenNeighbor(epr, timeoutHelper.RemainingTime(), null, epr); results.Add(iar); } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord(SR.GetString(SR.PeerMaintainerConnectFailure, epr, this.config.MeshId, e.Message)); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } // I need to remove the epr just began because the BeginOpen threw. // However Object Disposed can arise as a result of a ---- between PeerNode.Close() // and Connect trying to reconnect nodes. pendingConnectedNeighbor.Remove(GetEndpointUri(epr)); if (!(e is ObjectDisposedException)) { throw; } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } } } } if (nodeAddresses.Count == 0 || pendingConnectedNeighbor.Count + maintainer.ConnectedNeighborCount == wantedConnectionCount) { addNeighbor.Reset(); } } else if (index != WaitHandle.WaitTimeout) { // We have completed this thing remove it from results IAsyncResult iar = results[index]; results.RemoveAt(index); IPeerNeighbor neighbor = null; try { // Get opened neighbor and fire NeighborOpened notification neighbor = maintainer.EndOpenNeighbor(iar); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } pendingConnectedNeighbor.Remove(GetEndpointUri((PeerNodeAddress)iar.AsyncState)); throw; } } else { //A timeout occured no connections progressed, try some more connections //This may result in more than wantedConnectionCount connections if the timeout connections were // merely being slow pendingConnectedNeighbor.Clear(); results.Clear(); addNeighbor.Set(); } } catch (CommunicationException e) { // mostly likely the endpoint could not be reached, but any channel exception means we should try another node DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); addNeighbor.Set(); } catch (TimeoutException e) { if (TD.OpenTimeoutIsEnabled()) { TD.OpenTimeout(e.Message); } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); addNeighbor.Set(); } } }
public void Connect(TimeSpan timeout) { TimeoutHelper helper = new TimeoutHelper(timeout); this.addNeighbor.Set(); List <IAsyncResult> list = new List <IAsyncResult>(); List <WaitHandle> list2 = new List <WaitHandle>(); while ((list.Count != 0) || (((this.nodeAddresses.Count != 0) || (this.pendingConnectedNeighbor.Count != 0)) && (this.maintainer.IsOpen && (this.maintainer.ConnectedNeighborCount < this.wantedConnectionCount)))) { try { list2.Clear(); foreach (IAsyncResult result in list) { list2.Add(result.AsyncWaitHandle); } list2.Add(this.welcomeReceived); list2.Add(this.maintainerClosed); list2.Add(this.addNeighbor); int index = WaitHandle.WaitAny(list2.ToArray(), this.config.ConnectTimeout, false); if (index == list.Count) { this.welcomeReceived.Reset(); continue; } if (index == (list.Count + 1)) { this.maintainerClosed.Reset(); lock (this.ThisLock) { this.nodeAddresses.Clear(); continue; } } if (index == (list.Count + 2)) { if ((this.nodeAddresses.Count > 0) && ((this.pendingConnectedNeighbor.Count + this.maintainer.ConnectedNeighborCount) < this.wantedConnectionCount)) { PeerNodeAddress address = null; lock (this.ThisLock) { if ((this.nodeAddresses.Count == 0) || !this.maintainer.IsOpen) { this.addNeighbor.Reset(); continue; } int num2 = random.Next() % this.nodeAddresses.Count; ICollection <Uri> keys = this.nodeAddresses.Keys; int num3 = 0; Uri key = null; foreach (Uri uri2 in keys) { if (num3++ == num2) { key = uri2; break; } } address = this.nodeAddresses[key]; this.nodeAddresses.Remove(key); } if ((this.maintainer.FindDuplicateNeighbor(address) == null) && !this.pendingConnectedNeighbor.ContainsKey(GetEndpointUri(address))) { lock (this.ThisLock) { this.pendingConnectedNeighbor.Add(GetEndpointUri(address), address); } try { if (this.maintainer.IsOpen) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord extendedData = new PeerMaintainerTraceRecord(System.ServiceModel.SR.GetString("PeerMaintainerConnect", new object[] { address, this.config.MeshId })); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), extendedData, this, null); } IAsyncResult item = this.maintainer.BeginOpenNeighbor(address, helper.RemainingTime(), null, address); list.Add(item); } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record2 = new PeerMaintainerTraceRecord(System.ServiceModel.SR.GetString("PeerMaintainerConnectFailure", new object[] { address, this.config.MeshId, exception.Message })); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), record2, this, null); } this.pendingConnectedNeighbor.Remove(GetEndpointUri(address)); if (!(exception is ObjectDisposedException)) { throw; } DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information); } } } if ((this.nodeAddresses.Count == 0) || ((this.pendingConnectedNeighbor.Count + this.maintainer.ConnectedNeighborCount) == this.wantedConnectionCount)) { this.addNeighbor.Reset(); } continue; } if (index != 0x102) { IAsyncResult result3 = list[index]; list.RemoveAt(index); try { this.maintainer.EndOpenNeighbor(result3); continue; } catch (Exception exception2) { if (Fx.IsFatal(exception2)) { throw; } this.pendingConnectedNeighbor.Remove(GetEndpointUri((PeerNodeAddress)result3.AsyncState)); throw; } } this.pendingConnectedNeighbor.Clear(); list.Clear(); this.addNeighbor.Set(); } catch (CommunicationException exception3) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Information); this.addNeighbor.Set(); } catch (TimeoutException exception4) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Information); this.addNeighbor.Set(); } } }
private void MaintainConnections(object dummy) { if (this.isOpen) { bool flag = false; if (!this.isRunningMaintenance) { lock (this.ThisLock) { if (!this.isRunningMaintenance) { this.isRunningMaintenance = true; flag = true; } } } if (flag) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord extendedData = new PeerMaintainerTraceRecord(System.ServiceModel.SR.GetString("PeerMaintainerStarting", new object[] { this.config.MeshId })); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), extendedData, this, null); } TimeoutHelper helper = new TimeoutHelper(this.config.MaintainerTimeout); try { this.maintainerTimer.Cancel(); int connectedNeighborCount = this.neighborManager.ConnectedNeighborCount; if (connectedNeighborCount != this.config.IdealNeighbors) { using (IConnectAlgorithms algorithms = (default(TConnectAlgorithms) == null) ? ((IConnectAlgorithms)Activator.CreateInstance <TConnectAlgorithms>()) : ((IConnectAlgorithms)default(TConnectAlgorithms))) { algorithms.Initialize(this, this.config, this.config.IdealNeighbors, this.referralCache); if (connectedNeighborCount > this.config.IdealNeighbors) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record2 = new PeerMaintainerTraceRecord(System.ServiceModel.SR.GetString("PeerMaintainerPruneMode", new object[] { this.config.MeshId })); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), record2, this, null); } algorithms.PruneConnections(); } if (this.neighborManager.ConnectedNeighborCount < this.config.IdealNeighbors) { if (this.referralCache.Count == 0) { ReadOnlyCollection <PeerNodeAddress> src = this.ResolveNewAddresses(helper.RemainingTime(), true); algorithms.UpdateEndpointsCollection(src); } if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record3 = new PeerMaintainerTraceRecord(System.ServiceModel.SR.GetString("PeerMaintainerConnectMode", new object[] { this.config.MeshId })); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), record3, this, null); } algorithms.Connect(helper.RemainingTime()); } } } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information); } finally { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record4 = new PeerMaintainerTraceRecord("Maintainer cycle finish"); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), record4, this, null); } } this.ResetMaintenance(); } } }
private void InitialConnection(object dummy) { if (this.isOpen) { bool flag = false; if (!this.isRunningMaintenance) { lock (this.ThisLock) { if (!this.isRunningMaintenance) { this.isRunningMaintenance = true; flag = true; } } } if (flag) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord extendedData = new PeerMaintainerTraceRecord(System.ServiceModel.SR.GetString("PeerMaintainerInitialConnect", new object[] { this.config.MeshId })); TraceUtility.TraceEvent(TraceEventType.Information, 0x40051, System.ServiceModel.SR.GetString("TraceCodePeerMaintainerActivity"), extendedData, this, null); } TimeoutHelper helper = new TimeoutHelper(this.config.MaintainerTimeout); Exception e = null; try { this.maintainerTimer.Cancel(); using (IConnectAlgorithms algorithms = (default(TConnectAlgorithms) == null) ? ((IConnectAlgorithms)Activator.CreateInstance <TConnectAlgorithms>()) : ((IConnectAlgorithms)default(TConnectAlgorithms))) { algorithms.Initialize(this, this.config, this.config.MinNeighbors, this.referralCache); if (this.referralCache.Count == 0) { ReadOnlyCollection <PeerNodeAddress> src = this.ResolveNewAddresses(helper.RemainingTime(), false); algorithms.UpdateEndpointsCollection(src); } if (this.isOpen) { algorithms.Connect(helper.RemainingTime()); } } } catch (Exception exception2) { if (Fx.IsFatal(exception2)) { throw; } DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Information); e = exception2; } if (this.isOpen) { try { lock (this.ThisLock) { if (this.isOpen) { if (this.neighborManager.ConnectedNeighborCount < 1) { this.maintainerTimer.Set(this.config.MaintainerRetryInterval); } else { this.maintainerTimer.Set(this.config.MaintainerInterval); } } } } catch (Exception exception3) { if (Fx.IsFatal(exception3)) { throw; } DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Information); if (e == null) { e = exception3; } } } lock (this.ThisLock) { this.isRunningMaintenance = false; } if (this.connectCallback != null) { this.connectCallback(e); } } } }
// Get some addresses and make sure they are not in my neighborlist ReadOnlyCollection <PeerNodeAddress> ResolveNewAddresses(TimeSpan timeLeft, bool retryResolve) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeLeft); Dictionary <string, PeerNodeAddress> alreadySeen = new Dictionary <string, PeerNodeAddress>(); List <PeerNodeAddress> reply = new List <PeerNodeAddress>(); // Is this address me PeerNodeAddress lclNodeAddress = config.GetListenAddress(true); alreadySeen.Add(lclNodeAddress.ServicePath, lclNodeAddress); // Maximum of 2 resolves to get new addresses - if the resolver doesn't return us good addresses in 2 goes (8 randomly returned addresses) // it is probably messing with us int nresolves = (retryResolve) ? 2 : 1; if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord("Resolving"); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } for (int i = 0; i < nresolves && reply.Count < config.MaxResolveAddresses && isOpen && timeoutHelper.RemainingTime() > TimeSpan.Zero; i++) { ReadOnlyCollection <PeerNodeAddress> addresses; try { addresses = config.Resolver.Resolve(config.MeshId, config.MaxResolveAddresses, timeoutHelper.RemainingTime()); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord("Resolve exception " + e.Message); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.ResolverException), e)); } if (addresses != null) { foreach (PeerNodeAddress address in addresses) { if (!alreadySeen.ContainsKey(address.ServicePath)) { alreadySeen.Add(address.ServicePath, address); if (((IPeerMaintainer)this).FindDuplicateNeighbor(address) == null) { reply.Add(address); } } } } } return(new ReadOnlyCollection <PeerNodeAddress>(reply)); }
// This activity maintains the connected nodes void MaintainConnections(object dummy) { // Are we open and is any maintenance activity occuring if (isOpen) { bool continueMaintenance = false; if (!isRunningMaintenance) { lock (ThisLock) { if (!isRunningMaintenance) { isRunningMaintenance = true; continueMaintenance = true; } } } if (continueMaintenance) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord(SR.GetString(SR.PeerMaintainerStarting, this.config.MeshId)); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } TimeoutHelper timeoutHelper = new TimeoutHelper(config.MaintainerTimeout); try { maintainerTimer.Cancel(); // No reconnect until after connect has succeeded int currentlyConnected = neighborManager.ConnectedNeighborCount; if (currentlyConnected != config.IdealNeighbors) // Already at ideal no work to do { using (IConnectAlgorithms connectAlgorithm = (IConnectAlgorithms) new TConnectAlgorithms()) { connectAlgorithm.Initialize(this, config, config.IdealNeighbors, referralCache); if (currentlyConnected > config.IdealNeighbors) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord(SR.GetString(SR.PeerMaintainerPruneMode, this.config.MeshId)); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } connectAlgorithm.PruneConnections(); } // During Prune some other neighbor may have gone away which leaves us below Ideal // So try to reconnect currentlyConnected = neighborManager.ConnectedNeighborCount; if (currentlyConnected < config.IdealNeighbors) { if (referralCache.Count == 0) { ReadOnlyCollection <PeerNodeAddress> addresses = ResolveNewAddresses(timeoutHelper.RemainingTime(), true); connectAlgorithm.UpdateEndpointsCollection(addresses); } if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord(SR.GetString(SR.PeerMaintainerConnectMode, this.config.MeshId)); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } connectAlgorithm.Connect(timeoutHelper.RemainingTime()); } } } } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); // We ---- all non Fatal exceptions because this is a worker thread, with no user code waiting } finally { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord("Maintainer cycle finish"); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } } ResetMaintenance(); } } }
void InitialConnection(object dummy) { // Are we open and is any maintenance activity occuring if (isOpen) { bool continueMaintenance = false; if (!isRunningMaintenance) { lock (ThisLock) { if (!isRunningMaintenance) { isRunningMaintenance = true; continueMaintenance = true; } } } if (continueMaintenance) { if (DiagnosticUtility.ShouldTraceInformation) { PeerMaintainerTraceRecord record = new PeerMaintainerTraceRecord(SR.GetString(SR.PeerMaintainerInitialConnect, this.config.MeshId)); TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerMaintainerActivity, SR.GetString(SR.TraceCodePeerMaintainerActivity), record, this, null); } TimeoutHelper timeoutHelper = new TimeoutHelper(config.MaintainerTimeout); Exception exception = null; // The connection algorithm may be pluggable if we provide an api or metadata to enable it. // I am sure that research would be interested in doing such a thing. try { maintainerTimer.Cancel(); // No reconnect until after connect has succeeded using (IConnectAlgorithms connectAlgorithm = (IConnectAlgorithms) new TConnectAlgorithms()) { connectAlgorithm.Initialize(this, config, config.MinNeighbors, referralCache); if (referralCache.Count == 0) { ReadOnlyCollection <PeerNodeAddress> addresses = ResolveNewAddresses(timeoutHelper.RemainingTime(), false); connectAlgorithm.UpdateEndpointsCollection(addresses); } if (isOpen) { connectAlgorithm.Connect(timeoutHelper.RemainingTime()); } } } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); exception = e; // Exeption is saved and transferred } if (isOpen) { try { lock (ThisLock) { if (isOpen) { // No reconnect until after connect has succeeded if (neighborManager.ConnectedNeighborCount < 1) { maintainerTimer.Set(config.MaintainerRetryInterval); } else { maintainerTimer.Set(config.MaintainerInterval); } } } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); if (exception == null) { exception = e; // Exeption is saved and transferred via callback } } } lock (ThisLock) { isRunningMaintenance = false; } if (connectCallback != null) { connectCallback(exception); } } } }