public static void RegisterListener(ICommandListener listener, bool showRegistration = false)
{
if (string.IsNullOrWhiteSpace(listener.GetPrefix()) || string.IsNullOrEmpty(listener.GetPrefix()))
{
Debug.Log("Command listeners cannot use empty, null, or whitespace prefixes. Skipping registration.", LogType.Warning);
return;
}
foreach (ICommandListener l in Listeners)
{
if (l.GetPrefix() == listener.GetPrefix())
{
Debug.Log("A command listener with the prefix <i>" + listener.GetPrefix() + "</i> alredy exists. Skipping registration.", LogType.Warning);
return;
}
}
Listeners.Add(listener);
foreach (KeyValuePair <string, string> kvp in listener.GetCommands())
{
try
{
Commands.Add(kvp.Key, kvp.Value);
if (showRegistration)
{
Debug.Log("Command <i>" + kvp.Key + "</i> registered successfully.", LogType.Info);
}
}
catch (Exception e)
{
Debug.Log("An exception occured while registering command <i>" + kvp.Key + "</i>: " + e.GetType().ToString() + " - " + e.Message, LogType.Severe);
continue;
}
}
}
/// <summary>
/// Add ad listener
/// </summary>
/// <param name="listener"></param>
public void RegisterListener(IListener listener)
{
if (Listeners.Contains(listener) == false)
{
Listeners.Add(listener);
}
}
public void Leave(Action <IResponse <LeaveMessage> > action)
{
Listeners.Add(new RosterListener(this, action)
{
Source = _scriptRunner.CurrentScriptSource
});
}
/// <summary>
/// Adds to the list of registered listeners the standard console one, if it has not been
/// added yet.
/// </summary>
public static void AddConsoleListener()
{
if (!IsConsoleListenerRegistered)
{
Listeners.Add(new TextWriterTraceListener(Console.Out));
}
}
public void Topic(Action <IResponse <TopicMessage> > action)
{
Listeners.Add(new TopicListener(this, action)
{
Source = _scriptRunner.CurrentScriptSource
});
}
private bool OnListenersViewFilter(object item)
{
_filterProgressScope?.ReportNext();
var l = (ListenerInfo)item;
if (!FilterIncludeSystemListeners && l.ListenerSource.IsSystemListener)
{
return(false);
}
if (!string.IsNullOrEmpty(FilterByName))
{
if (l.Name.IndexOf(FilterByName, StringComparison.OrdinalIgnoreCase) == -1)
{
return(false);
}
}
Parent.ExecuteGuarded(() => l.RefreshInfo());
if (FilterStatus.HasValue)
{
if (l.Status != FilterStatus.Value)
{
return(false);
}
}
Listeners.Add(l);
return(true);
}
private bool InitListeners()
{
IsStopped = false;
for (var i = 0; i < ListenerInfos.Length; i++)
{
var listener = new AsyncTcpListener(ListenerInfos[i]);
listener.Error += new ErrorHandler(OnListenerError);
listener.Stopped += new EventHandler(OnListenerStopped);
listener.NewClientAccepted += new NewClientAcceptHandler(OnNewClientAccepted);
if (listener.Start())
{
Listeners.Add(listener);
Logger.Debug(string.Format("Listener ({0}) was started", listener.Info.EndPoint));
}
else //如果有一个启动失败，则全部listener都关闭
{
Logger.Debug(string.Format("Listener ({0}) failed to start", listener.Info.EndPoint));
for (var j = 0; j < Listeners.Count; j++)
{
Listeners[j].Stop();
}
Listeners.Clear();
return(false);
}
}
IsRunning = true;
return(true);
}
public void Listen <T>(Func <T, MatchResult> matcher, Action <IResponse <T> > action) where T : Message
{
Listeners.Add(new Listener <T>(this, matcher, action)
{
Source = _scriptRunner.CurrentScriptSource
});
}
public void CatchAll(Action <IResponse <CatchAllMessage> > action)
{
Listeners.Add(new CatchAllListener(this, action)
{
Source = _scriptRunner.CurrentScriptSource
});
}
/// <summary>
/// Add <see cref="PostmanListener"/> to listeners />
/// </summary>
/// <param name="listeners">all listeners</param>
/// <param name="name">name of the collection</param>
/// <returns>listener created</returns>
public static PostmanListener AddPostman(this Listeners listeners, string name)
{
var listener = new PostmanListener(name);
listeners.Add(listener);
return(listener);
}
public InputListeners(Game game) : base(game)
{
KeyboardListener = new StackInputListener <NumericKeyboardListener>(new NumericKeyboardListener());
Listeners.Add(KeyboardListener);
MouseListener = new StackInputListener <MouseListener>(new MouseListener());
Listeners.Add(MouseListener);
}
public void AddEntranceListener(Action listener)
{
if (CalledListeners)
{
throw new Exception("Too late to add a listener!");
}
Listeners.Add(listener);
}
/// <summary>
/// Add <see cref="CurlListener"/> to listeners />.
/// </summary>
/// <param name="listeners">all listeners.</param>
/// <returns>listener created.</returns>
public static CurlListener AddCurl(this Listeners listeners)
{
var listener = new CurlListener();
listeners.Add(listener);
return(listener);
}
public override void Register(Action <TEntity> action)
{
var listener = new AddedActionEventDelegator <TEntity>(action);
if (!Listeners.Contains(listener))
{
Listeners.Add(listener);
}
}
private void ParseListeners(XPathNavigator navigator)
{
XPathNodeIterator xpni = navigator.Select(CfgXmlHelper.SessionFactoryListenersExpression);
while (xpni.MoveNext())
{
Listeners.Add(new ListenerConfiguration(xpni.Current));
}
}
public void SubscribeListener(IDomainEventListener listener)
{
lock (Listeners) {
if (!Listeners.Contains(listener))
{
Listeners.Add(listener);
}
}
}
private async void GetListeners()
{
var listeners = await ListenerAPI.GetAllListeners();
foreach (var listener in listeners)
{
Listeners.Add(string.Format("{0} : {1}", listener.ListenerId, listener.Type));
}
}
public void Respond(string regex, Action <IResponse <TextMessage> > action)
{
regex = PrepareRespondRegexPattern(regex);
Listeners.Add(new TextListener(this, new Regex(regex, RegexOptions.Compiled | RegexOptions.IgnoreCase), action)
{
Source = _scriptRunner.CurrentScriptSource
});
}
public void AddListener(AbstractListener listener, string methodName)
{
if (Listeners.ContainsKey(listener.GetType().Name) && Events.ContainsKey(listener.GetType().Name))
{
throw new Exception("Command already exists");
}
Listeners.Add(listener.GetType().Name, listener);
Events.Add(listener.GetType().Name, methodName);
}
private async void Refresh()
{
IsRefreshing = true;
Listeners.Clear();
(await Listener.GetAllActiveListenersAsync()).ForEach(x => Listeners.Add(x));
IsRefreshing = false;
}
public void PlaceListener(Listener listener)
{
if (listener is Entity)
{
Entities.Add(listener as Entity);
}
else
{
Listeners.Add(listener);
}
}
//----------------------------------------------------------------------
/// <summary>
/// Adds a listener for the value change.
/// When the property editor changes its value
/// it should fire a <seealso cref="PropertyChangeEvent"/>
/// on all registered <seealso cref="PropertyChangeListener"/>s,
/// specifying the {@code null} value for the property name.
/// If the source property is set,
/// it should be used as the source of the event.
/// <para>
/// The same listener object may be added more than once,
/// and will be called as many times as it is added.
/// If {@code listener} is {@code null},
/// no exception is thrown and no action is taken.
///
/// </para>
/// </summary>
/// <param name="listener"> the <seealso cref="PropertyChangeListener"/> to add </param>
public virtual void AddPropertyChangeListener(PropertyChangeListener listener)
{
lock (this)
{
if (Listeners == null)
{
Listeners = new List <>();
}
Listeners.Add(listener);
}
}
public void AddListener(IpAddressInfo ipAddress)
{
var listener = new Listener(IPAddress.Parse(ipAddress.Ip), ipAddress.Port);
Listeners.Add(listener);
if (IsRunning)
{
listener.Connect += ListenerOnConnect;
listener.Start();
}
}
protected override void OnStart(string[] args)
{
log.Info("Start service");
foreach (var instance in MainConfiguration.Instance.Listeners)
{
listener = new StorageListener(instance);
listener.StartListening();
Listeners.Add(listener);
}
}
public void RegisterListener(ITrackerListener listener)
{
CheckDisposed();
if (listener == null)
{
throw new ArgumentNullException("listener");
}
listener.AnnounceReceived += ListenerReceivedAnnounce;
listener.ScrapeReceived += ListenerReceivedScrape;
Listeners.Add(listener);
}
public void OnActivate()
{
ConsoleOut = Get <TextArea>("ConsoleOut");
Listeners.Add <Button>(ButtonEvents.Action, (b) => Clear(), "Clear");
Clear();
if (ConsoleOut != null)
{
ConsoleOut.Parameters.Text = "";
ConsoleOut.UpdateLayoutTree();
}
}
public void AddEventListener(string eventName, ParticleEventHandler handler)
{
if (!Listeners.ContainsKey(eventName))
{
Listeners.Add(eventName, handler);
OnMessage += handler;
}
else
{
throw new Exception("Event Name is present in dictionary. Consider using a GUID to ensure a unique number is generated");
}
}
private static void AddDirectoryListener(IDirectoryListener listener)
{
if (_watcher == null)
{
_watcher = new DirectoryWatcher(AcPaths.GetCarSetupsDirectory());
_watcher.Subscribe(new InternalListener());
Logging.Write("[CarSetupsDirectories.InternalListener] Start watching…");
}
Listeners.Purge();
Listeners.Add(listener);
}
private async void GetListeners()
{
var listeners = await ListenerAPI.GetAllListeners();
foreach (var listener in listeners)
{
Listeners.Add(new Listener {
ListenerName = listener.ListenerName, ListenerGuid = listener.ListenerGuid, ListenerType = listener.Type
});
ListenerList.Add(string.Format("{0} : {1}", listener.ListenerName, listener.Type));
}
}
public virtual bool Start()
{
IsStopped = false;
ILog log = AppServer.Logger;
var config = AppServer.Config;
var sendingQueuePool = new SmartPool <SendingQueue>();
sendingQueuePool.Initialize(Math.Max(config.MaxConnectionNumber / 6, 256),
Math.Max(config.MaxConnectionNumber * 2, 256),
new SendingQueueSourceCreator(config.SendingQueueSize));
SendingQueuePool = sendingQueuePool;
for (var i = 0; i < ListenerInfos.Length; i++)
{
var listener = CreateListener(ListenerInfos[i]);
listener.Error += new ErrorHandler(OnListenerError);
listener.Stopped += new EventHandler(OnListenerStopped);
listener.NewClientAccepted += new NewClientAcceptHandler(OnNewClientAccepted);
if (listener.Start(AppServer.Config))
{
Listeners.Add(listener);
if (log.IsDebugEnabled)
{
log.DebugFormat("Listener ({0}) was started", listener.EndPoint);
}
}
else //If one listener failed to start, stop started listeners
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Listener ({0}) failed to start", listener.EndPoint);
}
for (var j = 0; j < Listeners.Count; j++)
{
Listeners[j].Stop();
}
Listeners.Clear();
return(false);
}
}
IsRunning = true;
return(true);
}