protected override void RunCore(ServerConfig config)
{
if (config is null)
{
throw new ArgumentNullException(nameof(config));
}
Trace.WriteLine(TraceCategory.Networking, $"Running {GetType().Name} :{config.EndPoints.First().Port}...");
lock (_tcpListenerEntries)
{
foreach (var item in config.EndPoints)
{
var listener = new TcpListener(item);
listener.Start();
var thread = new Thread(AcceptWorker);
ObjectTracker.Default.Register(thread);
thread.IsBackground = true;
thread.Name = "Listener for " + item;
var entry = new ListenerEntry
{
TcpListener = listener,
Thread = thread,
};
thread.Start(entry);
_tcpListenerEntries.Add(entry);
}
}
}
public void Send(NetworkMessage message, ListenerEntry dest)
{
if (message == null)
{
throw new ArgumentException(nameof(message));
}
message.Destinations = dest;
message.From = ListenerEntry.Local;
Dispatcher.Enqueue(message, Account);
}
/// <summary>
/// Gets the next listener that happens at the same time. Interruptions do not prevent/interrupt other responses that
/// also happened at the same time as the interruption.
/// </summary>
/// <returns></returns>
public IEventResponder GetNextCurrentResponder()
{
if (listeners.Count == 0)
{
return(null);
}
ListenerEntry entry = listeners[0];
if (entry.TickFraction != CurrentTickFraction)
{
return(null);
}
listeners.RemoveAt(0);
return(entry.Listener);
}
/// <summary>
/// Get the next listener to happen chronologically. Essentially the iterator for this event.
/// </summary>
/// <returns></returns>
public IEventResponder GetNextResponder()
{
if (listeners.Count == 0)
{
return(null);
}
ListenerEntry entry = listeners[0];
listeners.RemoveAt(0);
//This should be impossible.
if (CurrentTickFraction > entry.TickFraction)
{
throw new Exception("Listeners called in the wrong order!");
}
CurrentTickFraction = entry.TickFraction;
return(entry.Listener);
}
public void Send(NetworkMessage message, ListenerEntry dest)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
message.Destinations = dest;
message.From = ListenerEntry.Local;
Dispatcher.Enqueue(message, this);
if (Disposed)
{
logger.Error("Error the message {0} wont be dispatched because the bot {1} is disposed !", message, this);
}
else if (!Running)
{
logger.Warn("Warning, enqueue {0} but the bot is stopped, the message will be processed once the bot {1} restart", message, this);
}
}
private TraceListener LookupListener(string fileName)
{
ListenerEntry entry;
for (int i = 0; i < listeners.Count; i++)
{
entry = (ListenerEntry)listeners[i];
// FIXME: what to do on case-sensitive filesystems?
if (String.Compare(entry.fileName, fileName, true) == 0)
{
return(entry.listener);
}
}
entry = new ListenerEntry();
entry.fileName = fileName;
entry.listener = new TextWriterTraceListener(fileName);
listeners.Add(entry);
return(entry.listener);
}
public void Send(NetworkMessage message, ListenerEntry dest)
{
if (message == null) throw new ArgumentNullException("message");
message.Destinations = dest;
message.From = ListenerEntry.Local;
Dispatcher.Enqueue(message, this);
}
public void Send(NetworkMessage message, ListenerEntry dest)
{
if (message == null) throw new ArgumentNullException("message");
message.Destinations = dest;
message.From = ListenerEntry.Local;
Dispatcher.Enqueue(message, this);
if (Disposed)
logger.Error("Error the message {0} wont be dispatched because the bot {1} is disposed !", message, this);
else if (!Running)
logger.Warn("Warning, enqueue {0} but the bot is stopped, the message will be processed once the bot {1} restart", message, this);
}
private TraceListener LookupListener (string fileName)
{
ListenerEntry entry;
for (int i = 0; i < listeners.Count; i++)
{
entry = (ListenerEntry) listeners[i];
// FIXME: what to do on case-sensitive filesystems?
if (String.Compare (entry.fileName, fileName, true) == 0)
return entry.listener;
}
entry = new ListenerEntry ();
entry.fileName = fileName;
entry.listener = new TextWriterTraceListener (fileName);
listeners.Add (entry);
return entry.listener;
}
