/// <summary> /// Converts event type to string. /// </summary> /// <param name="evType">Event type.</param> /// <returns>String.</returns> public static string EventTypeToString(ConnectionEventType evType) { switch (evType) { case ConnectionEventType.ConnectingFailed: return("Connecting failed"); case ConnectionEventType.ConnectionLost: return("Connection lost"); case ConnectionEventType.ConnectionRestored: return("Connection restored"); case ConnectionEventType.ConnectionRestoreFailed: return("Connection restore failed"); case ConnectionEventType.ConnectionTerminatedByUser: return("Connection terminated by user"); case ConnectionEventType.RestoringConnection: return("Restoring connection"); case ConnectionEventType.TerminatingConnectionByUser: return("User asked to terminate connection"); default: // Connecting // Connected return(evType.ToString()); } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: private void onEvent(final Connection conn, final String remoteAddress, final ConnectionEventType type) private void onEvent(Connection conn, string remoteAddress, ConnectionEventType type) { if (eventListener != null) { eventExecutor.onEvent(new TempRunnable(eventListener, type, remoteAddress, conn)); } }
public TempRunnable(ConnectionEventListener eventListener, ConnectionEventType type, string remoteAddress, Connection conn) { this.eventListener = eventListener; this.type = type; this.remoteAddress = remoteAddress; this.conn = conn; }
private void TelnetBufferWrite() { if (WriteBuffer == null) { return; } ConnectionEventType type = ConnectionEventType.Error; if (MyTelnetConnection.WriteLine(WriteBuffer)) { if ((Input == CommandState.AcceptSLID) && (_slid == null)) { // wrote a slid manually set via the console _slid = WriteBuffer; } type = ConnectionEventType.Write; } else { Input = CommandState.RejectAll; } OnCommunicationEvent(this, new ONTEventArgs(type, WriteBuffer)); WriteBuffer = null; }
private string GenerateDescription(ConnectionEventType eventType, string errorReason) { string description = ConnectionEvent.EventTypeToString(eventType); // Add more information to the description? switch (eventType) { case ConnectionEventType.Connecting: description += " to " + FormatConnectionInfo(); break; case ConnectionEventType.ConnectingFailed: description += string.Format(". Suspected reason: {0}. Check parameters and retry.", errorReason); break; case ConnectionEventType.ConnectionRestoreFailed: description += string.Format(". Suspected reason: {0}. Retrying in {1} s.", errorReason, RetryIntervalSeconds); break; default: break; } return(description); }
/// <summary> /// Constructor. Use this when the state is related to an error. /// </summary> /// <param name="connMaint">Whether the connection is being maintained or at least attempted.</param> /// <param name="evType">Current state of connection.</param> /// <param name="desc">Event description.</param> /// <param name="errReason">Error reason.</param> /// <param name="excep">Exception related to the error.</param> public ConnectionEvent(bool connMaint, ConnectionEventType evType, string desc, ErrorReasonType errReason, Exception excep) { IsConnectionMaintained = connMaint; EventType = evType; Description = desc; ErrorReason = errReason; RelatedException = excep; }
private bool CloseConnection(ConnectionEventType eventType) { if (this.OnConnectionEvent == null) { return(false); } ConnectionEventArgs args = new ConnectionEventArgs(eventType); this.OnConnectionEvent(this, args); return(args.Close); }
/// <summary> /// Construct a new <b>ConnectionEventArgs</b>. /// </summary> /// <param name="connection"> /// The <see cref="IConnection"/> for which the event applies. /// </param> /// <param name="eventType"> /// The event's type, one of <see cref="ConnectionEventType"/> /// enumeration values. /// </param> /// <param name="exc"> /// An optional <b>Exception</b> associated with the event. /// </param> public ConnectionEventArgs(IConnection connection, ConnectionEventType eventType, Exception exc) { m_connection = connection; if (eventType < ConnectionEventType.Opened || eventType > ConnectionEventType.Error) { throw new ArgumentException(); } m_eventType = eventType; m_exception = exc; }
/// <summary> /// Dispatch events. /// </summary> /// <param name="type"> ConnectionEventType </param> /// <param name="remoteAddress"> remoting address </param> /// <param name="connection"> Connection </param> public virtual void onEvent(ConnectionEventType type, string remoteAddress, Connection connection) { var isGetValue = processors.TryGetValue(type, out var processorList); if (isGetValue) { foreach (ConnectionEventProcessor processor in processorList) { processor.onEvent(remoteAddress, connection); } } }
/// <summary> /// Add event processor. /// </summary> /// <param name="type"> ConnectionEventType </param> /// <param name="processor"> ConnectionEventProcessor </param> public virtual void addConnectionEventProcessor(ConnectionEventType type, ConnectionEventProcessor processor) { var isGetValue = processors.TryGetValue(type, out var processorList); if (!isGetValue) { if (!processors.ContainsKey(type)) { processors.AddOrUpdate(type, new List <ConnectionEventProcessor>(1), (key, oldValue) => new List <ConnectionEventProcessor>(1)); } processors.TryGetValue(type, out processorList); } processorList.Add(processor); }
/// <summary> /// Sends a connection event. Use this for errors. /// </summary> /// <param name="connMaint">Whether connection is still being maintained or at least tried to reconnect.</param> /// <param name="evType">Event type.</param> /// <param name="exc">Related exception.</param> protected void SendConnectionEvent(bool connMaint, ConnectionEventType evType, Exception exc) { bool disposedTemp; lock (m_lockObject) { disposedTemp = m_disposed; } // No callbacks after dispose except termination. // If dispose is called right after the condition, the callback can // occur after it, but this is unlikely and unimportant. if (disposedTemp && evType != ConnectionEventType.TerminatingConnectionByUser && evType != ConnectionEventType.ConnectionTerminatedByUser) { return; } // Event related to an error? if (exc != null) { var errorReason = AmqpErrorHandler.GetErrorReason(exc); var description = GenerateDescription(evType, errorReason.ToString()); var connEvent = new ConnectionEvent(connMaint: connMaint, evType: evType, desc: description, errReason: errorReason, excep: exc); b_connectionEventCallback(connEvent); } else { var description = GenerateDescription(evType, ""); var connEvent = new ConnectionEvent(connMaint: connMaint, evType: evType, desc: description); b_connectionEventCallback(connEvent); } }
public ONTEventArgs(ConnectionEventType t, String s) { Type = t; Message = s; }
/// <summary> /// Construct a new <b>ConnectionEventArgs</b>. /// </summary> /// <param name="connection"> /// The <see cref="IConnection"/> for which the event applies. /// </param> /// <param name="eventType"> /// The event's type, one of <see cref="ConnectionEventType"/> /// enumeration values. /// </param> public ConnectionEventArgs(IConnection connection, ConnectionEventType eventType) : this(connection, eventType, null) { }
/// <summary> /// Add processor to process connection event. /// </summary> /// <param name="type"> connection event type </param> /// <param name="processor"> connection event processor </param> public virtual void addConnectionEventProcessor(ConnectionEventType type, ConnectionEventProcessor processor) { connectionEventListener.addConnectionEventProcessor(type, processor); }
public abstract void addConnectionEventProcessor(ConnectionEventType type, ConnectionEventProcessor processor);
public virtual void addConnectionEventProcessor(ConnectionEventType type, ConnectionEventProcessor processor) { this.server.addConnectionEventProcessor(type, processor); }
public ConnectionEvent(ClientContract source, ConnectionEventType type, DateTime eventTime) { Source = source; Type = type; EventTime = eventTime; }
private void InvokeConnectionEvent(ConnectionEventType evCtg, bool connectionMaintained) { SendConnectionEvent(connMaint: connectionMaintained, evType: evCtg); }
/// <summary> /// Constructor. Use this when the event is *not* related to an error. /// </summary> /// <param name="connMaint">Whether the connection is being maintained or at least attempted.</param> /// <param name="evType">Current state of connection.</param> /// <param name="desc">Event description.</param> public ConnectionEvent(bool connMaint, ConnectionEventType evType, string desc) : this(connMaint : connMaint, evType : evType, desc : desc, errReason : ErrorReasonType.Other, excep : null) { // Empty ctor body }
public AppConnectionEvent(AppConnectionDescriptor connection, ConnectionEventType type) { Connection = connection; Type = type; }
public override void addConnectionEventProcessor(ConnectionEventType type, ConnectionEventProcessor processor) { connectionEventListener.addConnectionEventProcessor(type, processor); }
internal SimConnectEventArgs(ConnectionEventType connectionEventType, string message) { Message = message; EventType = connectionEventType; }
/// <summary> /// Sends a connection event. Use this when there is no error. /// </summary> /// <param name="connMaint">Whether connection is still being maintained or at least tried to reconnect.</param> /// <param name="evType">Event type.</param> protected void SendConnectionEvent(bool connMaint, ConnectionEventType evType) { SendConnectionEvent(connMaint, evType, null); // No relevant exception in this overload }
public ConnectionEventArgs(ConnectionEventType t) { EventType = t; Close = false; }