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); }