private IPeerNeighbor GetNeighbor()
{
IPeerNeighbor neighbor = this.getNeighborCallback(OperationContext.Current.GetCallbackChannel <IPeerProxy>());
if ((neighbor == null) || (neighbor.State == PeerNeighborState.Closed))
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(TraceEventType.Warning, 0x40036, System.ServiceModel.SR.GetString("TraceCodePeerNeighborNotFound"), new PeerNodeTraceRecord(this.config.NodeId), OperationContext.Current.IncomingMessage);
}
return(null);
}
if (DiagnosticUtility.ShouldTraceVerbose)
{
PeerNeighborState state = neighbor.State;
PeerNodeAddress listenAddress = null;
IPAddress connectIPAddress = null;
if ((state >= PeerNeighborState.Opened) && (state <= PeerNeighborState.Connected))
{
listenAddress = this.config.GetListenAddress(true);
connectIPAddress = this.config.ListenIPAddress;
}
PeerNeighborTraceRecord extendedData = new PeerNeighborTraceRecord(neighbor.NodeId, this.config.NodeId, listenAddress, connectIPAddress, neighbor.GetHashCode(), neighbor.IsInitiator, state.ToString(), null, null, OperationContext.Current.IncomingMessage.Headers.Action);
TraceUtility.TraceEvent(TraceEventType.Verbose, 0x4003a, System.ServiceModel.SR.GetString("TraceCodePeerNeighborMessageReceived"), extendedData, this, null);
}
return(neighbor);
}
public static bool IsSettable(PeerNeighborState state)
{
if (((state != PeerNeighborState.Authenticated) && (state != PeerNeighborState.Connecting)) && ((state != PeerNeighborState.Connected) && (state != PeerNeighborState.Disconnecting)))
{
return(state == PeerNeighborState.Disconnected);
}
return(true);
}
public static bool IsAuthenticatedOrClosed(PeerNeighborState state)
{
if ((state != PeerNeighborState.Authenticated) && (state != PeerNeighborState.Faulted))
{
return(state == PeerNeighborState.Closed);
}
return(true);
}
public static bool IsAuthenticatedOrClosed(PeerNeighborState state)
{
if ((state != PeerNeighborState.Authenticated) && (state != PeerNeighborState.Faulted))
{
return (state == PeerNeighborState.Closed);
}
return true;
}
public static bool IsSettable(PeerNeighborState state)
{
if (((state != PeerNeighborState.Authenticated) && (state != PeerNeighborState.Connecting)) && ((state != PeerNeighborState.Connected) && (state != PeerNeighborState.Disconnecting)))
{
return (state == PeerNeighborState.Disconnected);
}
return true;
}
// Returns true if the specified state can be set for the neighbor
public static bool IsSettable(PeerNeighborState state)
{
return(
(state == PeerNeighborState.Authenticated) ||
(state == PeerNeighborState.Connecting) ||
(state == PeerNeighborState.Connected) ||
(state == PeerNeighborState.Disconnecting) ||
(state == PeerNeighborState.Disconnected));
}
IPeerNeighbor GetNeighbor()
{
IPeerNeighbor neighbor = (IPeerNeighbor)getNeighborCallback(OperationContext.Current.GetCallbackChannel <IPeerProxy>());
if (neighbor == null || neighbor.State == PeerNeighborState.Closed)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.PeerNeighborNotFound,
SR.GetString(SR.TraceCodePeerNeighborNotFound),
new PeerNodeTraceRecord(config.NodeId),
OperationContext.Current.IncomingMessage);
}
return(null);
}
if (DiagnosticUtility.ShouldTraceVerbose)
{
PeerNeighborState state = neighbor.State;
PeerNodeAddress listenAddr = null;
IPAddress connectIPAddr = null;
if (state >= PeerNeighborState.Opened && state <= PeerNeighborState.Connected)
{
listenAddr = config.GetListenAddress(true);
connectIPAddr = config.ListenIPAddress;
}
PeerNeighborTraceRecord record = new PeerNeighborTraceRecord(neighbor.NodeId,
this.config.NodeId, listenAddr, connectIPAddr, neighbor.GetHashCode(),
neighbor.IsInitiator, state.ToString(), null, null,
OperationContext.Current.IncomingMessage.Headers.Action);
TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.PeerNeighborMessageReceived, SR.GetString(SR.TraceCodePeerNeighborMessageReceived), record, this, null);
}
return(neighbor);
}
public void TraceClosedEvent(PeerNeighborState previousState)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceEventType severity = TraceEventType.Information;
// Override tracing severity based on close reason
switch (this.closeReason)
{
case PeerCloseReason.InvalidNeighbor:
case PeerCloseReason.DuplicateNodeId:
severity = TraceEventType.Error;
break;
case PeerCloseReason.ConnectTimedOut:
case PeerCloseReason.InternalFailure:
case PeerCloseReason.Faulted:
severity = TraceEventType.Warning;
break;
}
PeerNeighborCloseTraceRecord record = new PeerNeighborCloseTraceRecord(
this.nodeId, this.config.NodeId, null, null,
this.GetHashCode(), this.initiator,
PeerNeighborState.Closed.ToString(), previousState.ToString(), null,
this.closeInitiator.ToString(), this.closeReason.ToString()
);
TraceUtility.TraceEvent(severity, TraceCode.PeerNeighborStateChanged,
SR.GetString(SR.TraceCodePeerNeighborStateChanged), record, this, this.closeException);
}
}
// Throws if the new state being set on the neighbor is invalid compared to the
// current state (such as setting state to connecting when it is already in
// disconnected state). Also throws if neighbor is already closed.
// NOTE: This method should be called within the lock.
void ThrowIfInvalidState(PeerNeighborState newState)
{
if (this.state == PeerNeighborState.Closed)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(
this.ToString()));
}
if (this.state >= newState)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.PeerNeighborInvalidState, this.state.ToString(),
newState.ToString())));
}
}
// Attempts to set to specified state.
// Returns true if succeed and false otherwise.
public bool TrySetState(PeerNeighborState newState)
{
if (!(PeerNeighborStateHelper.IsSettable(newState)))
{
throw Fx.AssertAndThrow("A valid settable state is expected");
}
return SetState(newState, SetStateBehavior.TrySet);
}
// WARNING: This method should not be called within the lock -- it may invoke state
// changed event handlers
bool SetState(PeerNeighborState newState, SetStateBehavior behavior)
{
bool stateChanged = false;
PeerNeighborState oldState;
// Attempt to set the state
lock (ThisLock)
{
oldState = this.State;
if (behavior == SetStateBehavior.ThrowException)
ThrowIfInvalidState(newState);
if (newState > this.state)
{
this.state = newState;
stateChanged = true;
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceEventHelper(TraceEventType.Information, TraceCode.PeerNeighborStateChanged, SR.GetString(SR.TraceCodePeerNeighborStateChanged), null, null, newState, oldState);
}
}
else
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceEventHelper(TraceEventType.Information, TraceCode.PeerNeighborStateChangeFailed, SR.GetString(SR.TraceCodePeerNeighborStateChangeFailed), null, null, oldState, newState);
}
}
}
if (stateChanged)
{
// Pass state change notification on to interested subscribers.
OnStateChanged(newState);
}
return stateChanged;
}
// Register for channel events
void RegisterForChannelEvents()
{
this.state = PeerNeighborState.Created; // reset state if the previous proxy failed
this.proxyChannel.Opened += OnChannelOpened;
this.proxyChannel.Closed += OnChannelClosed;
this.proxyChannel.Faulted += OnChannelFaulted;
}
//
// Invokes the appropriate state changed event handler.
// WARNING: This method should not be called within lock.
//
void OnStateChanged(PeerNeighborState newState)
{
EventHandler handler = null;
switch (newState)
{
case PeerNeighborState.Opened:
handler = this.Opened;
break;
case PeerNeighborState.Closed:
handler = this.Closed;
break;
case PeerNeighborState.Connected:
handler = this.Connected;
break;
case PeerNeighborState.Disconnecting:
handler = this.Disconnecting;
break;
case PeerNeighborState.Disconnected:
handler = this.Disconnected;
break;
}
if (handler != null)
handler(this, EventArgs.Empty);
}
// Returns true if the specified state is a "connected" state
public static bool IsConnected(PeerNeighborState state)
{
return((state == PeerNeighborState.Connected));
}
public static bool IsConnected(PeerNeighborState state)
{
return (state == PeerNeighborState.Connected);
}
// Returns true if the specified state is either authenticated or closing
public static bool IsAuthenticatedOrClosed(PeerNeighborState state)
{
return((state == PeerNeighborState.Authenticated) ||
(state == PeerNeighborState.Faulted) ||
(state == PeerNeighborState.Closed));
}
public void TraceEventHelper(TraceEventType severity, int traceCode, string traceDescription, Exception e,
string action, PeerNeighborState nbrState, PeerNeighborState previousOrAttemptedState)
{
if (DiagnosticUtility.ShouldTrace(severity))
{
string attemptedState = null;
string previousState = null;
PeerNodeAddress listenAddr = null;
IPAddress connectIPAddr = null;
if (nbrState >= PeerNeighborState.Opened && nbrState <= PeerNeighborState.Connected)
{
listenAddr = this.ListenAddress;
connectIPAddr = this.ConnectIPAddress;
}
if (traceCode == TraceCode.PeerNeighborStateChangeFailed)
attemptedState = previousOrAttemptedState.ToString();
else if (traceCode == TraceCode.PeerNeighborStateChanged)
previousState = previousOrAttemptedState.ToString();
PeerNeighborTraceRecord record = new PeerNeighborTraceRecord(this.nodeId,
this.config.NodeId, listenAddr, connectIPAddr, this.GetHashCode(),
this.initiator, nbrState.ToString(), previousState, attemptedState, action);
if (severity == TraceEventType.Verbose && e != null)
severity = TraceEventType.Information; // need to be >= info for exceptions
TraceUtility.TraceEvent(severity, traceCode, traceDescription, record, this, e);
}
}
public PeerNeighbor(PeerNodeConfig config,
IPeerNodeMessageHandling messageHandler)
{
this.closeReason = PeerCloseReason.None;
this.closeInitiator = PeerCloseInitiator.LocalNode;
this.config = config;
this.state = PeerNeighborState.Created;
this.extensions = new ExtensionCollection<IPeerNeighbor>(this, thisLock);
this.messageHandler = messageHandler;
}
// Does heavy-lifting of processing closed/faulted events
void OnChannelClosedOrFaulted(PeerCloseReason reason)
{
PeerNeighborState oldState;
lock (ThisLock)
{
// We don't call SetState here because it should not be called inside lock,
// and to avoid race conditions, we need to set the state before the lock
// can be released.
oldState = this.state;
this.state = PeerNeighborState.Closed;
// Set close reason etc. if they are not already set (as a result of local
// node initiating Close)
if (!this.isClosing)
{
this.isClosing = true;
this.closeReason = reason;
this.closeInitiator = PeerCloseInitiator.RemoteNode;
}
TraceClosedEvent(oldState);
}
// Update traces and counters and notify interested parties
OnStateChanged(PeerNeighborState.Closed);
}
