mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
408 lines
18 KiB
C#
408 lines
18 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Threading;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
|
|
// Graph maintainence algorithms.
|
|
sealed class ConnectAlgorithms : IConnectAlgorithms
|
|
{
|
|
static Random random = new Random();
|
|
|
|
int wantedConnectionCount = 0;
|
|
EventWaitHandle addNeighbor = new EventWaitHandle(true, EventResetMode.ManualReset);
|
|
EventWaitHandle maintainerClosed = new EventWaitHandle(false, EventResetMode.ManualReset);
|
|
EventWaitHandle welcomeReceived = new EventWaitHandle(false, EventResetMode.ManualReset);
|
|
|
|
Dictionary<Uri, PeerNodeAddress> nodeAddresses = new Dictionary<Uri, PeerNodeAddress>();
|
|
PeerNodeConfig config;
|
|
Dictionary<Uri, PeerNodeAddress> pendingConnectedNeighbor = new Dictionary<Uri, PeerNodeAddress>();
|
|
object thisLock = new object();
|
|
IPeerMaintainer maintainer = null;
|
|
bool disposed = false;
|
|
|
|
public void Initialize(IPeerMaintainer maintainer, PeerNodeConfig config, int wantedConnectionCount, Dictionary<EndpointAddress, Referral> referralCache)
|
|
{
|
|
this.maintainer = maintainer;
|
|
this.config = config;
|
|
this.wantedConnectionCount = wantedConnectionCount;
|
|
UpdateEndpointsCollection(referralCache.Values); // Add to the endpoints connection anything in the referralsCache
|
|
|
|
// Hook up the event handlers
|
|
maintainer.NeighborClosed += OnNeighborClosed;
|
|
maintainer.NeighborConnected += OnNeighborConnected;
|
|
maintainer.MaintainerClosed += OnMaintainerClosed;
|
|
maintainer.ReferralsAdded += OnReferralsAdded;
|
|
}
|
|
|
|
// instance lock
|
|
object ThisLock
|
|
{
|
|
get { return thisLock; }
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void IDisposable.Dispose()
|
|
{
|
|
if (!disposed)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!disposed)
|
|
{
|
|
disposed = true;
|
|
maintainer.ReferralsAdded -= OnReferralsAdded;
|
|
maintainer.MaintainerClosed -= OnMaintainerClosed;
|
|
maintainer.NeighborClosed -= OnNeighborClosed;
|
|
maintainer.NeighborConnected -= OnNeighborConnected;
|
|
|
|
addNeighbor.Close();
|
|
maintainerClosed.Close();
|
|
welcomeReceived.Close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This method exists to minimize code churn if PeerNodeAddress is refactored later to derive from EndpointAddress
|
|
static Uri GetEndpointUri(PeerNodeAddress address)
|
|
{
|
|
return address.EndpointAddress.Uri;
|
|
}
|
|
|
|
// Algorithm to prune connections
|
|
// This implementation will reduce the number of connections to config.IdealNeighbors
|
|
// by examining LinkUtility and selecting the neighbor with the lowest and then disconnecting it
|
|
public void PruneConnections()
|
|
{
|
|
while (maintainer.NonClosingNeighborCount > config.IdealNeighbors && maintainer.IsOpen)
|
|
{
|
|
IPeerNeighbor leastUseful = maintainer.GetLeastUsefulNeighbor();
|
|
if (leastUseful == null)
|
|
break;
|
|
maintainer.CloseNeighbor(leastUseful, PeerCloseReason.NotUsefulNeighbor);
|
|
}
|
|
}
|
|
|
|
// Helper method for updating the end points list
|
|
public void UpdateEndpointsCollection(ICollection<PeerNodeAddress> src)
|
|
{
|
|
if (src != null)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
foreach (PeerNodeAddress address in src)
|
|
{
|
|
UpdateEndpointsCollection(address);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UpdateEndpointsCollection(ICollection<Referral> src)
|
|
{
|
|
if (src != null)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
foreach (Referral referral in src)
|
|
{
|
|
UpdateEndpointsCollection(referral.Address);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UpdateEndpointsCollection(PeerNodeAddress address)
|
|
{
|
|
// Don't accept invalid addresses
|
|
if (PeerValidateHelper.ValidNodeAddress(address))
|
|
{
|
|
Uri key = GetEndpointUri(address);
|
|
if (!nodeAddresses.ContainsKey(key) && key != GetEndpointUri(maintainer.GetListenAddress()))
|
|
{
|
|
nodeAddresses[key] = address;
|
|
}
|
|
}
|
|
}
|
|
|
|
// When a connection occurs remove it from the list to look at
|
|
void OnNeighborClosed(IPeerNeighbor neighbor)
|
|
{
|
|
if (neighbor.ListenAddress != null)
|
|
{
|
|
Uri address = GetEndpointUri(neighbor.ListenAddress);
|
|
|
|
if (!disposed)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!disposed)
|
|
{
|
|
if (address != null && pendingConnectedNeighbor.ContainsKey(address))
|
|
{
|
|
pendingConnectedNeighbor.Remove(address);
|
|
addNeighbor.Set();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// When a connection occurs remove it from the list to look at
|
|
void OnNeighborConnected(IPeerNeighbor neighbor)
|
|
{
|
|
Uri address = GetEndpointUri(neighbor.ListenAddress);
|
|
|
|
if (!disposed)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!disposed)
|
|
{
|
|
if (address != null && pendingConnectedNeighbor.ContainsKey(address))
|
|
{
|
|
pendingConnectedNeighbor.Remove(address);
|
|
}
|
|
welcomeReceived.Set();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnMaintainerClosed()
|
|
{
|
|
if (!disposed)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!disposed)
|
|
{
|
|
maintainerClosed.Set();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// When a connection occurs add those to the group I look at
|
|
void OnReferralsAdded(IList<Referral> referrals, IPeerNeighbor neighbor)
|
|
{
|
|
bool added = false;
|
|
|
|
// Do some stuff here
|
|
foreach (Referral referral in referrals)
|
|
{
|
|
if (!disposed)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!disposed)
|
|
{
|
|
if (!maintainer.IsOpen)
|
|
return;
|
|
|
|
Uri key = GetEndpointUri(referral.Address);
|
|
if (key != GetEndpointUri(maintainer.GetListenAddress())) // make sure the referral is not mine
|
|
{
|
|
if (!nodeAddresses.ContainsKey(key)
|
|
&& !pendingConnectedNeighbor.ContainsKey(key)
|
|
&& maintainer.FindDuplicateNeighbor(referral.Address) == null)
|
|
{
|
|
nodeAddresses[key] = referral.Address;
|
|
added = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (added)
|
|
{
|
|
if (maintainer.ConnectedNeighborCount < wantedConnectionCount)
|
|
{
|
|
addNeighbor.Set();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|