// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkId=398940
public void ConfigureServices(IServiceCollection services)
{
PlayerConfiguration conf = new PlayerConfiguration();
Configuration.Bind("DefaultPlayerConfig", conf);
// For console override;
Configuration.Bind(conf);
services.AddSingleton(conf);
// 'Try' for tests override
var logger = GetLogger(conf.TeamID, conf.Verbose);
services.TryAddSingleton <ILogger>(logger);
services.AddSingleton <ISocketClient <Message, Message>, TcpSocketClient <Message, Message> >();
services.AddSingleton <BufferBlock <Message> >();
services.AddSingleton <Models.Player>();
var sync = new ServiceSynchronization(0, 1);
services.AddSingleton(sync);
services.AddHostedService <SocketService>();
services.AddHostedService <PlayerService>();
}
public PlayerService(Models.Player player, IApplicationLifetime lifetime,
ILogger logger, ServiceSynchronization serviceSync)
{
this.player = player;
this.logger = logger.ForContext <PlayerService>();
this.lifetime = lifetime;
this.synchronizationContext = serviceSync;
}
public CommunicationService(ISocketManager <ISocketClient <Message, Message>, Message> manager,
ServiceShareContainer container, BufferBlock <Message> queue, ILogger log, ServiceSynchronization sync)
{
this.manager = manager;
this.queue = queue;
this.container = container;
this.logger = log.ForContext <CommunicationService>();
this.sync = sync;
}
public SocketService(ISocketClient <Message, Message> client, PlayerConfiguration conf,
BufferBlock <Message> queue, IApplicationLifetime lifetime, ILogger log,
ServiceSynchronization serviceSync)
{
this.client = client;
this.conf = conf;
this.queue = queue;
this.lifetime = lifetime;
this.logger = log.ForContext <SocketService>();
this.synchronizationContext = serviceSync;
}
public PlayersTcpSocketService(ISocketManager <ISocketClient <Message, Message>, Message> manager,
BufferBlock <Message> queue, ServiceShareContainer container, ServerConfiguration conf, ILogger log,
ServiceSynchronization sync)
: base(log.ForContext <PlayersTcpSocketService>())
{
this.manager = manager;
this.queue = queue;
this.container = container;
this.conf = conf;
this.log = log;
this.sync = sync;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkId=398940
public void ConfigureServices(IServiceCollection services)
{
ServerConfiguration conf = new ServerConfiguration();
Configuration.Bind("DefaultCommunicationServerConfig", conf);
Configuration.Bind(conf); // For console override;
services.AddSingleton(conf);
var logger = GetLogger(conf.Verbose);
services.TryAddSingleton <ILogger>(logger);
services.AddSingleton <ServiceShareContainer>();
services.AddSingleton <ISocketManager <ISocketClient <Message, Message>, Message>,
TcpSocketManager <Message, Message> >();
services.AddSingleton <BufferBlock <Message> >();
var sync = new ServiceSynchronization(0, 3);
services.AddSingleton(sync);
services.AddHostedService <GMTcpSocketService>();
services.AddHostedService <PlayersTcpSocketService>();
services.AddHostedService <CommunicationService>();
}
public async Task TestExecuteAsyncShouldReadMessages()
{
// Arrange
IServiceCollection services = new ServiceCollection();
services.AddSingleton(logger);
var clientMock = MockGenerator.Get <ISocketClient <Message, Message> >();
services.AddSingleton(clientMock);
var queue = new BufferBlock <Message>();
StartGamePayload payloadStart = new StartGamePayload
{
AgentID = 1,
AlliesIDs = new int[2] {
1, 2
},
LeaderID = 1,
EnemiesIDs = new int[2] {
3, 4
},
TeamID = Team.Red,
BoardSize = new BoardSize {
X = 3, Y = 3
},
GoalAreaSize = 1,
NumberOfPlayers = new NumberOfPlayers {
Allies = 2, Enemies = 2
},
NumberOfPieces = 2,
NumberOfGoals = 2,
Penalties = new Penalties(),
ShamPieceProbability = 0.5f,
Position = new Position {
X = 1, Y = 1
},
};
Message messageStart = new Message()
{
MessageID = MessageID.StartGame,
Payload = payloadStart,
};
queue.Post(messageStart);
services.AddSingleton(queue);
services.AddSingleton <PlayerConfiguration>();
services.AddSingleton(MockGenerator.Get <IStrategy>());
services.AddSingleton <Models.Player>();
services.AddSingleton(Mock.Of <IApplicationLifetime>());
var context = new ServiceSynchronization(1, 1);
services.AddSingleton(context);
services.AddHostedService <PlayerService>();
var serviceProvider = services.BuildServiceProvider();
var hostedService = (PlayerService)serviceProvider.GetService <IHostedService>();
// Act
int delay = 500;
await Task.Run(async() =>
{
await hostedService.StartAsync(CancellationToken.None);
await Task.Delay(delay);
await hostedService.StopAsync(CancellationToken.None);
});
// Assert
Assert.Equal(0, queue.Count);
}
public async Task TestExecuteAsyncShouldReceiveAndSendMessages()
{
// Arrange
int numberOfMessages = 5;
var clientMock = new Mock <ISocketClient <Message, Message> >();
BufferBlock <Message> queue = new BufferBlock <Message>();
ServiceSynchronization context = new ServiceSynchronization(0, 1);
var calls = 0;
clientMock.Setup(m => m.ReceiveAsync(It.IsAny <CancellationToken>()))
.Returns(() =>
{
if (calls < numberOfMessages)
{
return(Task.FromResult((true, new Message())));
}
else
{
return(Task.FromResult((false, new Message())));
}
})
.Callback(() =>
{
calls++;
});
IServiceCollection services = new ServiceCollection();
services.AddSingleton(logger);
services.AddSingleton(clientMock.Object);
services.AddSingleton <PlayerConfiguration>();
services.AddSingleton(queue);
services.AddSingleton(Mock.Of <IApplicationLifetime>());
services.AddSingleton(context);
services.AddHostedService <SocketService>();
var serviceProvider = services.BuildServiceProvider();
var hostedService = (SocketService)serviceProvider.GetService <IHostedService>();
// Act
int socketDelay = 2000, syncDelay = 300;
Task socketTask = Task.Run(async() =>
{
await hostedService.StartAsync(CancellationToken.None);
await Task.Delay(socketDelay);
await hostedService.StopAsync(CancellationToken.None);
});
Task syncTask = Task.Run(async() =>
{
await context.SemaphoreSlim.WaitAsync(CancellationToken.None);
await Task.Delay(syncDelay);
context.SemaphoreSlim.Release();
});
await Task.WhenAll(new[] { socketTask, syncTask });
// Assert
Assert.Equal(numberOfMessages + 1, queue.Count);
}
