public DispatchManager(
object sender, // Agent reference for callbacks
Options options, WaterFlowManager incomingFlowManager,
IOWorker ioWorker,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
{
this.sender = sender;
this.incomingFlowManager = incomingFlowManager;
this.ioWorker = ioWorker;
this.logCallback = logCallback;
this.logLevel = logLevel;
messageQueue = new LinkedList<IncomingMessage>();
objectMap = new Dictionary<string, IncomingMessageHandler>();
anyObjectCallback = null;
int numOfThreads = options.dispatcherThreads;
dispatchers = new List<Thread>();
for (int i = 0; i != numOfThreads; ++i)
{
Thread th = new Thread((new Dispatcher(this)).run);
th.Name = "YAMI4 message dispatcher";
th.IsBackground = true;
th.Start();
dispatchers.Add(th);
}
}
private void call(IncomingMessageHandler callback,
IncomingMessage message, string objectName)
{
callback(outer.sender,
new IncomingMessageArgs(objectName, message));
outer.logCallback.Log(LogEventArgs.LogLevel.MEDIUM,
"Dispatched:" + " object: " + message.ObjectName
+ " message: " + message.MessageName);
}
public void registerObject(string objectName,
IncomingMessageHandler callback)
{
lock (objectMap)
{
if (objectName.Equals("*"))
{
anyObjectCallback = callback;
}
else
{
if(objectMap.ContainsKey(objectName))
objectMap[objectName] = callback;
else
objectMap.Add(objectName, callback);
}
}
}
public void unregisterObject(string objectName)
{
lock (objectMap)
{
if (objectName.Equals("*"))
{
anyObjectCallback = null;
}
else
{
objectMap.Remove(objectName);
}
}
}
/// <summary>
/// Initializes a new instance of <see cref="ValuePublisher"/>
/// </summary>
/// <remarks>
/// <para>
/// Creates the subscription publisher
/// that is not registered at any agent and that
/// delegates arbitrary remote commands to the given callback.
/// </para>
/// <para>
/// <b>Note:</b>
/// The "subscribe" and "unsubscribe" messages are also forwarded
/// to the user-provided callback, but these two messages are already
/// "replied-to" by the published value's implementation.
/// </para>
/// </remarks>
///
/// <param name="callback"> the callback implementation for unknown
/// commands </param>
public ValuePublisher(IncomingMessageHandler callback)
{
controllingAgent = null;
subscriptions = new Dictionary<string, SubscriptionState>();
userCommandCallback = callback;
}
public PacketHandler(short opCode, IncomingMessageHandler handler)
{
this.opCode = opCode;
this.handler = handler;
}
private void ConfigureConnectionChange(IncomingMessageHandler messageHandler)
{
messageHandler
.OnConnectionChange(NetConnectionStatus.Connected, im =>
Console.WriteLine($"Connected to {im.SenderEndPoint}"));
}
/// <summary>
/// Register a method handler
/// </summary>
/// <param name="opCode"></param>
/// <param name="handlerMethod"></param>
/// <returns></returns>
public PacketHandler RegisterHandler(short opCode, IncomingMessageHandler handlerMethod)
{
return(RegisterHandler(new PacketHandler(opCode, handlerMethod)));
}
public void ProcessMessagesInBackground()
{
asyncMessageProcessor = new ParallelTaskStarter(TimeSpan.Zero);
asyncMessageProcessor.Start(async() => await IncomingMessageHandler.ProcessNetworkMessages(Host));
}
public async Task ProcessMessages()
{
await IncomingMessageHandler.ProcessNetworkMessages(Host);
}
public IncomingMessageHandlerBuilder()
{
IncomingMessageHandler = new IncomingMessageHandler(BuildServiceProvider(), MockBuilder.BuildFakeLogger <IncomingMessageHandler>());
}
