internal async Task HandleMessagesAsync(BaseClientState state, IEnumerable <Message> msgs)
{
foreach (Message msg in msgs)
{
await this.HandleMessageAsync(state, msg);
}
}
internal async Task HandleMessageAsync(BaseClientState state, Message msg)
{
switch (msg.Identifier)
{
case MessageConstants.REGISTER_IDENTIFIER:
await this.RegisterProcessAsync(state, msg.OriginName, msg.Data);
break;
case MessageConstants.TERMINATE_IDENTIFIER:
await this.TerminateProcessAsync(msg.OriginName, msg.Data);
break;
case MessageConstants.REQUEST_PROCESSES_INFO_IDENTIFIER:
string processesData = this.GetProcessesData(msg.OriginName);
await this.AnswerMessageAsync(state, msg, processesData);
break;
default:
await this.DispatchMessageAsync(state, msg);
break;
}
}
internal async Task DispatchMessageAsync(BaseClientState state, Message msg)
{
if (msg.IsMalformed)
{
if (state is TCPSocketClientState tcpState)
{
this.Logger.Warning($"Received a malformed message from \'{tcpState.RemoteEndPoint}\'\n{msg.Data}");
}
else
{
this.Logger.Warning($"Received a malformed message\n{msg.Data}");
}
return;
}
if (this.States.ContainsKey(msg.TargetName) && this.States.ContainsKey(msg.OriginName))
{
await this.ForwardMessageAsync(msg);
}
else if (this.States.ContainsKey(msg.OriginName) && !this.States.ContainsKey(msg.OriginName))
{
this.Logger.Warning($"{msg.OriginName} tried to forward {msg.DataLength} bytes to unknown remote process {msg.TargetName}");
await this.AnswerMessageAsync(state, msg, null, MessageStatus.ProcessNotFound);
}
}
private async Task ForwardMessageAsync(Message msg)
{
string tail;
BaseClientState state = this.States[msg.TargetName];
msg.Status = msg.Status != MessageStatus.Unknown ? msg.Status : MessageStatus.Success;
switch (msg.Type)
{
case MessageType.Request:
tail = $"| (ID: {msg.Identifier}) {msg.OriginName} -> {msg.TargetName}";
this.Logger.Nice("Message", ConsoleColor.Gray, $"Forwarded request {tail}");
break;
case MessageType.Response:
tail = $"| (ID: {msg.Identifier}) {msg.OriginName} -> {msg.TargetName}";
this.Logger.Nice("Message", ConsoleColor.Gray, $"Forwarded response {tail}");
break;
case MessageType.Unknown:
tail = $"| (ID: {msg.Identifier}) {msg.OriginName} ?? {msg.TargetName}";
this.Logger.Nice("Message", ConsoleColor.Yellow, $"Forwarded unknown message type {msg.DataLength} bytes {tail}");
break;
}
await this.SendAsync(state, msg);
}
private async Task SendAsync(BaseClientState state, Message msg)
{
try
{
await state.SendAsync(msg);
}
catch (Exception ex)
{
this.Logger.Danger(ex);
this.TerminateProcess(state.Name);
ProcessUpdateData endData = new ProcessUpdateData(true, state.Name);
await this.BroadcastMessageAsync(MessageConstants.TERMINATE_IDENTIFIER, endData.Serialize());
}
}
private async Task RegisterProcessAsync(BaseClientState state, string name, string token)
{
ProcessUpdateData data;
if (string.IsNullOrWhiteSpace(token) || token != this.Token)
{
this.Logger.Warning($"Attempt to register a remote process ({name}) with an invalid token ({token}).");
data = new ProcessUpdateData(false, name);
}
else if (this.States.Count >= Config.Instance.MaxProcesses)
{
this.Logger.Warning($"Could not register a remote process ({name}), exceeding the maximum amount of remote processes");
data = new ProcessUpdateData(false, name);
}
else
{
bool shouldLog = true;
if (this.States.ContainsKey(name))
{
shouldLog = false;
this.Logger.Nice("Process", ConsoleColor.Yellow, $"Overriding a remote process ({name})");
this.TerminateProcess(name, false);
}
state.Name = name;
if (this.States.TryAdd(name, state))
{
state.Register();
if (shouldLog)
{
this.Logger.Nice("Process", ConsoleColor.Magenta, $"Registering new remote process | {name}");
}
data = new ProcessUpdateData(true, name);
}
else
{
this.Logger.Warning($"Could not register a remote process ({name}), this is due to concurrency issues");
data = new ProcessUpdateData(false, name);
}
}
await this.BroadcastMessageAsync(MessageConstants.REGISTER_IDENTIFIER, data.Serialize());
}
internal async Task AnswerMessageAsync(BaseClientState state, Message msg, string data = null, MessageStatus status = MessageStatus.Success)
{
Message replyMsg = this.Factory.CreateMessageResponse(msg, data, status);
await this.SendAsync(state, replyMsg);
}
