Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

703 lines
29 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.Threading;
// Connector is responsible for transitioning neighbors to connected state.
class PeerConnector : IPeerConnectorContract
{
enum State
{
Created,
Opened,
Closed,
Closing
}
PeerNodeConfig config;
PeerMaintainer maintainer;
PeerNeighborManager neighborManager;
State state;
object thisLock;
// TypedMessageConverters:
TypedMessageConverter connectInfoMessageConverter;
TypedMessageConverter disconnectInfoMessageConverter;
TypedMessageConverter refuseInfoMessageConverter;
TypedMessageConverter welcomeInfoMessageConverter;
// To keep track of timers to transition neighbors to connected state
Dictionary<IPeerNeighbor, IOThreadTimer> timerTable;
public PeerConnector(PeerNodeConfig config, PeerNeighborManager neighborManager,
PeerMaintainer maintainer)
{
Fx.Assert(config != null, "Config is expected to non-null");
Fx.Assert(neighborManager != null, "NeighborManager is expected to be non-null");
Fx.Assert(maintainer != null, "Maintainer is expected to be non-null");
Fx.Assert(config.NodeId != PeerTransportConstants.InvalidNodeId, "Invalid NodeId");
Fx.Assert(config.MaxNeighbors > 0, "MaxNeighbors is expected to be non-zero positive value");
Fx.Assert(config.ConnectTimeout > 0, "ConnectTimeout is expected to be non-zero positive value");
this.thisLock = new object();
this.config = config;
this.neighborManager = neighborManager;
this.maintainer = maintainer;
this.timerTable = new Dictionary<IPeerNeighbor, IOThreadTimer>();
this.state = State.Created;
}
object ThisLock
{
get
{
return this.thisLock;
}
}
internal TypedMessageConverter ConnectInfoMessageConverter
{
get
{
if (connectInfoMessageConverter == null)
{
connectInfoMessageConverter = TypedMessageConverter.Create(typeof(ConnectInfo), PeerStrings.ConnectAction);
}
return connectInfoMessageConverter;
}
}
internal TypedMessageConverter DisconnectInfoMessageConverter
{
get
{
if (disconnectInfoMessageConverter == null)
{
disconnectInfoMessageConverter = TypedMessageConverter.Create(typeof(DisconnectInfo), PeerStrings.DisconnectAction);
}
return disconnectInfoMessageConverter;
}
}
internal TypedMessageConverter RefuseInfoMessageConverter
{
get
{
if (refuseInfoMessageConverter == null)
{
refuseInfoMessageConverter = TypedMessageConverter.Create(typeof(RefuseInfo), PeerStrings.RefuseAction);
}
return refuseInfoMessageConverter;
}
}
internal TypedMessageConverter WelcomeInfoMessageConverter
{
get
{
if (welcomeInfoMessageConverter == null)
{
welcomeInfoMessageConverter = TypedMessageConverter.Create(typeof(WelcomeInfo), PeerStrings.WelcomeAction);
}
return welcomeInfoMessageConverter;
}
}
// Add a timer for the specified neighbor to the timer table. The timer is only added
// if Connector is open and the neighbor is in Connecting state.
bool AddTimer(IPeerNeighbor neighbor)
{
bool added = false;
lock (ThisLock)
{
if (state == State.Opened && neighbor.State == PeerNeighborState.Connecting)
{
IOThreadTimer timer = new IOThreadTimer(new Action<object>(OnConnectTimeout), neighbor, true);
timer.Set(this.config.ConnectTimeout);
this.timerTable.Add(neighbor, timer);
added = true;
}
}
return added;
}
//this method takes care of closing the message.
void SendMessageToNeighbor(IPeerNeighbor neighbor, Message message, PeerMessageHelpers.CleanupCallback cleanupCallback)
{
bool fatal = false;
try
{
neighbor.Send(message);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
fatal = true;
throw;
}
if (e is CommunicationException ||
e is QuotaExceededException ||
e is ObjectDisposedException ||
e is TimeoutException)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
// Message failed to transmit due to quota exceeding or channel failure
if (cleanupCallback != null)
{
cleanupCallback(neighbor, PeerCloseReason.InternalFailure, e);
}
}
else
{
throw;
}
}
finally
{
if (!fatal)
message.Close();
}
}
// If neighbor cannot transition to connected state, this method cleans up the timer and
// closes the neighbor
void CleanupOnConnectFailure(IPeerNeighbor neighbor, PeerCloseReason reason,
Exception exception)
{
// timer will not be found if neighbor is already closed or connected.
if (RemoveTimer(neighbor))
{
this.neighborManager.CloseNeighbor(neighbor, reason,
PeerCloseInitiator.LocalNode, exception);
}
}
public void Close()
{
Dictionary<IPeerNeighbor, IOThreadTimer> table;
lock (ThisLock)
{
table = this.timerTable;
this.timerTable = null;
this.state = State.Closed;
}
// Cancel each timer
if (table != null)
{
foreach (IOThreadTimer timer in table.Values)
timer.Cancel();
}
}
public void Closing()
{
lock (ThisLock)
{
this.state = State.Closing;
}
}
// Complete processing of Disconnect or Refuse message from the neighbor
void CompleteTerminateMessageProcessing(IPeerNeighbor neighbor,
PeerCloseReason closeReason, IList<Referral> referrals)
{
// Close the neighbor after setting the neighbor state to Disconnected.
// The set can fail if the neighbor is already being closed and that is ok.
if (neighbor.TrySetState(PeerNeighborState.Disconnected))
this.neighborManager.CloseNeighbor(neighbor, closeReason, PeerCloseInitiator.RemoteNode);
else
if (!(neighbor.State >= PeerNeighborState.Disconnected))
{
throw Fx.AssertAndThrow("Unexpected neighbor state");
}
// Hand over the referrals to maintainer
this.maintainer.AddReferrals(referrals, neighbor);
}
void OnConnectFailure(IPeerNeighbor neighbor, PeerCloseReason reason,
Exception exception)
{
CleanupOnConnectFailure(neighbor, reason, exception);
}
void OnConnectTimeout(object asyncState)
{
CleanupOnConnectFailure((IPeerNeighbor)asyncState, PeerCloseReason.ConnectTimedOut, null);
}
// Process neighbor closed notification.
public void OnNeighborClosed(IPeerNeighbor neighbor)
{
// If the neighbor is closed abruptly by the remote node, OnNeighborClosing will
// not be invoked. Remove neighbor's timer from the table.
RemoveTimer(neighbor);
}
// Process neighbor closing notification.
public void OnNeighborClosing(IPeerNeighbor neighbor, PeerCloseReason closeReason)
{
// Send Disconnect message to a Connected neighbor
if (neighbor.IsConnected)
SendTerminatingMessage(neighbor, PeerStrings.DisconnectAction, closeReason);
}
// Process neighbor authenticated notification
public void OnNeighborAuthenticated(IPeerNeighbor neighbor)
{
if (!(this.state != State.Created))
{
throw Fx.AssertAndThrow("Connector not expected to be in Created state");
}
if (!(PeerNeighborStateHelper.IsAuthenticatedOrClosed(neighbor.State)))
{
throw Fx.AssertAndThrow(string.Format(CultureInfo.InvariantCulture, "Neighbor state expected to be Authenticated or Closed, actual state: {0}", neighbor.State));
}
// setting the state fails if neighbor is already closed or closing
// If so, we have nothing to do.
if (!neighbor.TrySetState(PeerNeighborState.Connecting))
{
if (!(neighbor.State >= PeerNeighborState.Faulted))
{
throw Fx.AssertAndThrow(string.Format(CultureInfo.InvariantCulture, "Neighbor state expected to be Faulted or Closed, actual state: {0}", neighbor.State));
}
return;
}
// Add a timer to timer table to transition the neighbor to connected state
// within finite duration. The neighbor is closed if the timer fires and the
// neighbor has not reached connected state.
// The timer is not added if neighbor or connector are closed
if (AddTimer(neighbor))
{
// Need to send connect message if the neighbor is the initiator
if (neighbor.IsInitiator)
{
if (this.neighborManager.ConnectedNeighborCount < this.config.MaxNeighbors)
SendConnect(neighbor);
else
{
// We have max connected neighbors already. So close this one.
this.neighborManager.CloseNeighbor(neighbor, PeerCloseReason.NodeBusy,
PeerCloseInitiator.LocalNode);
}
}
}
}
public void Open()
{
lock (ThisLock)
{
if (!(this.state == State.Created))
{
throw Fx.AssertAndThrow("Connector expected to be in Created state");
}
this.state = State.Opened;
}
}
//<Implementation of PeerConnector.IPeerConnectorContract>
// Process Connect from the neighbor
public void Connect(IPeerNeighbor neighbor, ConnectInfo connectInfo)
{
// Don't bother processing the message if Connector has closed
if (this.state != State.Opened)
return;
PeerCloseReason closeReason = PeerCloseReason.None;
// A connect message should only be received by a responder neighbor that is
// in Connecting state. If not, we close the neighbor without bothering
// to send a Refuse message
// A malicious neighbor can format a message with a null connectInfo as an argument
if (neighbor.IsInitiator || !connectInfo.HasBody() || (neighbor.State != PeerNeighborState.Connecting &&
neighbor.State != PeerNeighborState.Closed))
{
closeReason = PeerCloseReason.InvalidNeighbor;
}
// Remove the timer from the timer table for this neighbor. If the timer is not
// present, the neighbor is already being closed and the Connect message should
// be ignored.
else if (RemoveTimer(neighbor))
{
// Determine if Welcome or Refuse should be sent
// Refuse if node has maximum allowed connected neighbors?
if (this.neighborManager.ConnectedNeighborCount >= this.config.MaxNeighbors)
closeReason = PeerCloseReason.NodeBusy;
else
{
// Deserialization failed or connect info is invalid?
if (!PeerValidateHelper.ValidNodeAddress(connectInfo.Address))
{
closeReason = PeerCloseReason.InvalidNeighbor;
}
else
{
// Determine if neighbor should be accepted.
PeerCloseReason closeReason2;
IPeerNeighbor neighborToClose;
string action = PeerStrings.RefuseAction;
ValidateNeighbor(neighbor, connectInfo.NodeId, out neighborToClose, out closeReason2, out action);
if (neighbor != neighborToClose) // new neighbor should be accepted
{
SendWelcome(neighbor);
try
{
neighbor.ListenAddress = connectInfo.Address;
}
catch (ObjectDisposedException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
if (!neighbor.TrySetState(PeerNeighborState.Connected))
if (!(neighbor.State >= PeerNeighborState.Disconnecting))
{
throw Fx.AssertAndThrow("Neighbor state expected to be >= Disconnecting; it is " + neighbor.State.ToString());
}
if (neighborToClose != null)
{
// The other neighbor should be closed
SendTerminatingMessage(neighborToClose, action, closeReason2);
this.neighborManager.CloseNeighbor(neighborToClose, closeReason2, PeerCloseInitiator.LocalNode);
}
}
else
closeReason = closeReason2;
}
}
}
if (closeReason != PeerCloseReason.None)
{
SendTerminatingMessage(neighbor, PeerStrings.RefuseAction, closeReason);
this.neighborManager.CloseNeighbor(neighbor, closeReason, PeerCloseInitiator.LocalNode);
}
}
// Process Disconnect message from the neighbor
public void Disconnect(IPeerNeighbor neighbor, DisconnectInfo disconnectInfo)
{
// Don't bother processing the message if Connector has closed
if (this.state != State.Opened)
return;
PeerCloseReason closeReason = PeerCloseReason.InvalidNeighbor;
IList<Referral> referrals = null;
if (disconnectInfo.HasBody())
{
// We should only receive Disconnect message after the neighbor has transitioned
// to connected state.
if (neighbor.State >= PeerNeighborState.Connected)
{
if (PeerConnectorHelper.IsDefined(disconnectInfo.Reason))
{
closeReason = (PeerCloseReason)disconnectInfo.Reason;
referrals = disconnectInfo.Referrals;
}
}
}
// Complete processing of disconnect message
CompleteTerminateMessageProcessing(neighbor, closeReason, referrals);
}
// Process Refuse message from the neighbor
public void Refuse(IPeerNeighbor neighbor, RefuseInfo refuseInfo)
{
// Don't bother processing the message if Connector has closed
if (this.state != State.Opened)
return;
PeerCloseReason closeReason = PeerCloseReason.InvalidNeighbor;
IList<Referral> referrals = null;
if (refuseInfo.HasBody())
{
// Refuse message should only be received when neighbor is the initiator
// and is in connecting state --we accept in closed state to account for
// timeouts.
if (neighbor.IsInitiator && (neighbor.State == PeerNeighborState.Connecting ||
neighbor.State == PeerNeighborState.Closed))
{
// Remove the entry from timer table for this neighbor
RemoveTimer(neighbor);
if (PeerConnectorHelper.IsDefined(refuseInfo.Reason))
{
closeReason = (PeerCloseReason)refuseInfo.Reason;
referrals = refuseInfo.Referrals;
}
}
}
// Complete processing of refuse message
CompleteTerminateMessageProcessing(neighbor, closeReason, referrals);
}
// Process Welcome message from the neighbor
public void Welcome(IPeerNeighbor neighbor, WelcomeInfo welcomeInfo)
{
// Don't bother processing the message if Connector has closed
if (this.state != State.Opened)
return;
PeerCloseReason closeReason = PeerCloseReason.None;
// Welcome message should only be received when neighbor is the initiator
// and is in connecting state --we accept in closed state to account for
// timeouts.
if (!neighbor.IsInitiator || !welcomeInfo.HasBody() || (neighbor.State != PeerNeighborState.Connecting &&
neighbor.State != PeerNeighborState.Closed))
{
closeReason = PeerCloseReason.InvalidNeighbor;
}
// Remove the entry from timer table for this neighbor. If entry is still present,
// RemoveTimer returns true. Otherwise, neighbor is already being closed and
// welcome message will be ignored.
else if (RemoveTimer(neighbor))
{
// It is allowed for a node to have more than MaxNeighbours when processing a welcome message
// Determine if neighbor should be accepted.
PeerCloseReason closeReason2;
IPeerNeighbor neighborToClose;
string action = PeerStrings.RefuseAction;
ValidateNeighbor(neighbor, welcomeInfo.NodeId, out neighborToClose, out closeReason2, out action);
if (neighbor != neighborToClose)
{
// Neighbor should be accepted AddReferrals validates the referrals,
// if they are valid then the neighbor is accepted.
if (this.maintainer.AddReferrals(welcomeInfo.Referrals, neighbor))
{
if (!neighbor.TrySetState(PeerNeighborState.Connected))
{
if (!(neighbor.State >= PeerNeighborState.Faulted))
{
throw Fx.AssertAndThrow("Neighbor state expected to be >= Faulted; it is " + neighbor.State.ToString());
}
}
if (neighborToClose != null)
{
// The other neighbor should be closed
SendTerminatingMessage(neighborToClose, action, closeReason2);
this.neighborManager.CloseNeighbor(neighborToClose, closeReason2, PeerCloseInitiator.LocalNode);
}
}
else
{
// Referrals were invalid this node is suspicous
closeReason = PeerCloseReason.InvalidNeighbor;
}
}
else
{
closeReason = closeReason2;
}
}
if (closeReason != PeerCloseReason.None)
{
SendTerminatingMessage(neighbor, PeerStrings.DisconnectAction, closeReason);
this.neighborManager.CloseNeighbor(neighbor, closeReason, PeerCloseInitiator.LocalNode);
}
}
bool RemoveTimer(IPeerNeighbor neighbor)
{
IOThreadTimer timer = null;
bool removed = false;
// Remove the timer from the table and cancel it. Do this if Connector is
// still open. Otherwise, Close method will have already cancelled the timers.
lock (ThisLock)
{
if (this.state == State.Opened &&
this.timerTable.TryGetValue(neighbor, out timer))
{
removed = this.timerTable.Remove(neighbor);
}
}
if (timer != null)
{
timer.Cancel();
if (!removed)
{
throw Fx.AssertAndThrow("Neighbor key should have beeen removed from the table");
}
}
return removed;
}
void SendConnect(IPeerNeighbor neighbor)
{
// We do not attempt to send the message if PeerConnector is not open
if (neighbor.State == PeerNeighborState.Connecting && this.state == State.Opened)
{
// Retrieve the local address. The retrieved address may be null if the node
// is shutdown. In that case, don't bother to send connect message since the
// node is closing...
PeerNodeAddress listenAddress = this.config.GetListenAddress(true);
if (listenAddress != null)
{
ConnectInfo connectInfo = new ConnectInfo(this.config.NodeId, listenAddress);
Message message = ConnectInfoMessageConverter.ToMessage(connectInfo, MessageVersion.Soap12WSAddressing10);
SendMessageToNeighbor(neighbor, message, OnConnectFailure);
}
}
}
// Send Disconnect or Refuse message
void SendTerminatingMessage(IPeerNeighbor neighbor, string action, PeerCloseReason closeReason)
{
// We do not attempt to send the message if Connector is not open
// or if the close reason is InvalidNeighbor.
if (this.state != State.Opened || closeReason == PeerCloseReason.InvalidNeighbor)
return;
// Set the neighbor state to disconnecting. TrySetState can fail if the
// neighbor is already being closed. Disconnect/Refuse msg not sent in that case.
if (neighbor.TrySetState(PeerNeighborState.Disconnecting))
{
// Get referrals from the maintainer
Referral[] referrals = maintainer.GetReferrals();
// Build and send the message
Message message;
if (action == PeerStrings.DisconnectAction)
{
DisconnectInfo disconnectInfo = new DisconnectInfo((DisconnectReason)closeReason, referrals);
message = DisconnectInfoMessageConverter.ToMessage(disconnectInfo, MessageVersion.Soap12WSAddressing10);
}
else
{
RefuseInfo refuseInfo = new RefuseInfo((RefuseReason)closeReason, referrals);
message = RefuseInfoMessageConverter.ToMessage(refuseInfo, MessageVersion.Soap12WSAddressing10);
}
SendMessageToNeighbor(neighbor, message, null);
}
else
if (!(neighbor.State >= PeerNeighborState.Disconnecting))
{
throw Fx.AssertAndThrow("Neighbor state expected to be >= Disconnecting; it is " + neighbor.State.ToString());
}
}
void SendWelcome(IPeerNeighbor neighbor)
{
// We do not attempt to send the message if PeerConnector is not open
if (state == State.Opened)
{
// Get referrals from the maintainer
Referral[] referrals = maintainer.GetReferrals();
WelcomeInfo welcomeInfo = new WelcomeInfo(this.config.NodeId, referrals);
Message message = WelcomeInfoMessageConverter.ToMessage(welcomeInfo, MessageVersion.Soap12WSAddressing10);
SendMessageToNeighbor(neighbor, message, OnConnectFailure);
}
}
// Validates the new neighbor based on its node ID. If it detects duplicate neighbor condition,
// it will return reference to the neighbor that should be closed.
void ValidateNeighbor(IPeerNeighbor neighbor, ulong neighborNodeId,
out IPeerNeighbor neighborToClose, out PeerCloseReason closeReason, out string action)
{
neighborToClose = null;
closeReason = PeerCloseReason.None;
action = null;
// Invalid neighbor node Id?
if (neighborNodeId == PeerTransportConstants.InvalidNodeId)
{
neighborToClose = neighbor;
closeReason = PeerCloseReason.InvalidNeighbor;
}
// Neighbor's node ID matches local node Id?
else if (neighborNodeId == this.config.NodeId)
{
neighborToClose = neighbor;
closeReason = PeerCloseReason.DuplicateNodeId;
}
else
{
// Check for duplicate neighbors (i.e., if another neighbor has the
// same node Id as the new neighbor).
// Set neighbor's node Id prior to calling FindDuplicateNeighbor.
try
{
neighbor.NodeId = neighborNodeId;
}
catch (ObjectDisposedException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
return;
}
IPeerNeighbor duplicateNeighbor =
this.neighborManager.FindDuplicateNeighbor(neighborNodeId, neighbor);
if (duplicateNeighbor != null && this.neighborManager.PingNeighbor(duplicateNeighbor))
{
// We have a duplicate neighbor. Determine which one should be closed
closeReason = PeerCloseReason.DuplicateNeighbor;
// In the corner case where both neighbors are initiated by the same node,
// close the new neighbor -- Maintainer is expected to check if there is
// already a connection to a node prior to initiating a new connection.
if (neighbor.IsInitiator == duplicateNeighbor.IsInitiator)
neighborToClose = neighbor;
// Otherwise, close the neighbor that was initiated by the node with the
// larger node ID -- this ensures that both nodes tear down the same link.
else if (this.config.NodeId > neighborNodeId)
neighborToClose = (neighbor.IsInitiator ? neighbor : duplicateNeighbor);
else
neighborToClose = (neighbor.IsInitiator ? duplicateNeighbor : neighbor);
}
}
if (neighborToClose != null)
{
// If we decided to close the other neighbor, go ahead and do it.
if (neighborToClose != neighbor)
{
// Send Disconnect or Refuse message depending on its state
if (neighborToClose.State == PeerNeighborState.Connected)
{
action = PeerStrings.DisconnectAction;
}
else if (!neighborToClose.IsInitiator &&
neighborToClose.State == PeerNeighborState.Connecting)
{
action = PeerStrings.RefuseAction;
}
}
}
}
}
}