/// <inheritdoc cref="IMessageProcessor.ProcessMessageAsync(IMessage, INetworkConnector)"/>
public Task ProcessMessageAsync(IMessage message, INetworkConnector networkConnector)
{
return(Task.Run(() =>
{
_clientMessageProcessorLogger.LogInformation($"Started Processing message: {message} from {networkConnector.EndPoint}");
// TODO: Detect RateLimiting here
if (_messageToServiceMapper.MessageToServiceMap.TryGetValue(message.GetType(), out IServiceConnector serviceConnector))
{
_serviceMessageProcessor.AddClientMessage(message.Id, networkConnector);
serviceConnector.EnqueueMessage(message);
}
else
{
throw new InvalidMessageException($"Unknown message of type: {message.GetType().Name}");
}
}));
}
/// <inheritdoc cref="IServiceConnector.StartPublishingAsync(CancellationToken)" />
public async Task StartPublishingAsync(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
await TaskEx.WaitUntil(() => _networkConnectors.Count != 0, cancellationToken : cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
IMessage message = await _messageQueue.DequeueAsync(cancellationToken);
INetworkConnector networkConnector = null;
while (networkConnector == null)
{
networkConnector = GetNetworkConnector();
cancellationToken.ThrowIfCancellationRequested();
}
_ = Task.Run(() => networkConnector.SendMessageAsync(message, cancellationToken), cancellationToken);
}
}
public NetworkAwareLobby(string lobbyName, User user, INetworkConnector networkConnector)
{
Name = lobbyName;
_users = new List <User>(Capacity)
{
user
};
_networkAwareUsers = new ConcurrentDictionary <int, INetworkConnector>();
_networkAwareUsers.TryAdd(user.Id, networkConnector);
_cancellationTokenSource = new CancellationTokenSource();
Game = new Game(new[]
{
new Tank(0, -1, -1, -1, -1, -1),
new Tank(1, -1, -1, -1, -1, -1),
new Tank(2, -1, -1, -1, -1, -1),
new Tank(3, -1, -1, -1, -1, -1)
});
Console.WriteLine("I pretty much created this object");
}
public void TryConnect_WithNetworkAddress_ShouldCreateSocket()
{
var wasCalledTimes = 0;
_socketFactory = (a, s, p) =>
{
wasCalledTimes++;
return(Mock.Create <ISocket>());
};
_sut = new NetworkConnector(socket => Mock.Create <INetworkTunnel>(),
_socketFactory);
var networkAddress = Mock.Create <INetworkAddress>();
Mock.Arrange(() => networkAddress.IP).Returns(IPAddress.Parse("192.168.0.1"));
_sut.TryConnect(networkAddress, out INetworkTunnel tunnel);
Assert.Equal(1, wasCalledTimes);
}
/// <inheritdoc cref="IMessageProcessor.ProcessRequest"/>
public async Task <IResponse> ProcessRequest(Type type, IRequest request, INetworkConnector networkConnector)
{
object response;
Console.WriteLine($"ProcessRequest: {request}");
if (_messageToServiceMapper.MessageToServiceMap.TryGetValue(type, out (object service, MethodInfo methodInfo)a))
{
dynamic task = a.methodInfo.Invoke(a.service, new object[] { request });
response = await task;
}
else
{
throw new ArgumentOutOfRangeException(nameof(request), $"Unknown Request message of type: {type.Name}");
}
Console.WriteLine($"ProcessRequest-Response: {response}");
// ReSharper disable once PossibleInvalidCastException
return((IResponse)response);
}
public Task ProcessResponse(Type type, IResponse response, INetworkConnector networkConnector)
{
return(clientMessageProcessor.ProcessResponse(type, response, networkConnector));
}
public NetworkConnectorTests()
{
_socketFactory = (a, s, p) => Mock.Create <ISocket>();
_sut = new NetworkConnector(socket => Mock.Create <INetworkTunnel>(),
_socketFactory);
}
public Task ProcessMessageAsync(IMessage message, INetworkConnector networkConnector)
{
_messages.Enqueue(message);
Console.WriteLine(Encoding.UTF8.GetString(_messageSerializer.Serialize(message).ToArray()));
return(Task.CompletedTask);
}
public void SetNetworkConnector(INetworkConnector networkConnector)
{
_networkConnector = networkConnector;
}
public NetworkTextMessageReceiver(INetworkConnector<Udt.Socket> connector)
{
_connector = connector;
}
public NetworkFileReceiver(INetworkConnector<Udt.Socket> connector)
{
_connector = connector;
}
/// <inheritdoc cref="IServiceMessageProcessor.AddClientMessage(Guid, INetworkConnector)"/>
public void AddClientMessage(Guid messageId, INetworkConnector networkConnector)
{
_messageToClientDictionary.TryAdd(messageId, networkConnector);
}
/// <inheritdoc cref="IServiceConnector.AddService(INetworkConnector, Guid)" />
public void AddService(INetworkConnector networkConnector, Guid id)
{
_networkConnectors.TryAdd(id, networkConnector);
}
public Task <IResponse> ProcessRequest(Type type, IRequest request, INetworkConnector networkConnector)
{
return(clientMessageProcessor.ProcessRequest(type, request, networkConnector));
}
public Task ProcessEvent(Type type, IEvent eventImplementer, INetworkConnector baseNetworkConnector)
{
return(clientMessageProcessor.ProcessEvent(type, eventImplementer, baseNetworkConnector));
}
public Task ProcessCommand(Type type, ICommand command, INetworkConnector networkConnector)
{
return(clientMessageProcessor.ProcessCommand(type, command, networkConnector));
}
public AuthenticationService(INetworkConnector networkConnector, IMessageProcessor messageProcessor)
{
_messageProcessor = messageProcessor;
_networkConnector = networkConnector;
}
public LobbyService(INetworkConnector networkConnector, IMessageProcessor messageProcessor, UserDto loggedInUser)
{
_messageProcessor = messageProcessor;
_networkConnector = networkConnector;
_loggedInUser = loggedInUser;
}
private static async Task SendMessageToClientAsync(IMessage message, INetworkConnector clientNetworkConnector)
{
await clientNetworkConnector.SendMessageAsync(message, CancellationToken.None);
}
/// <inheritdoc cref="IMessageProcessor.ProcessMessageAsync(IMessage, INetworkConnector)"/>
public Task ProcessMessageAsync(IMessage message, INetworkConnector networkConnector)
{
_logger.LogInformation($"Received a {message.GetType().FullName} in the message processor: {message}");
return(Task.CompletedTask);
}
