public virtual async Task <PeerToPeerSessionState> StartNewGameAsync(PeerToPeerSessionState session)
{
PeerToPeerGameState game = PeerToPeerGameState.CreateNew();
session.GameId = game.GameId;
game = await _storage.AddP2PGameAsync(game);
return(await _storage.UpdateP2PSessionAsync(session));
}
public async Task StartNewGameAsync()
{
PeerToPeerGameService svc = new PeerToPeerGameService(_storage.Object);
PeerToPeerGameState game = PeerToPeerGameState.CreateNew();
PeerToPeerSessionState session = new PeerToPeerSessionState();
_storage.Setup(p => p.UpdateP2PSessionAsync(It.IsAny <PeerToPeerSessionState>())).ReturnsAsync(session);
PeerToPeerSessionState res = await svc.StartNewGameAsync(session);
_storage.Verify(p => p.AddP2PGameAsync(It.IsAny <PeerToPeerGameState>()), Times.Once);
_storage.Verify(p => p.UpdateP2PSessionAsync(It.IsAny <PeerToPeerSessionState>()), Times.Once);
Assert.IsNotNull(res);
}
public virtual async Task <PeerToPeerSessionState> StopGameAsync(PeerToPeerSessionState session)
{
PeerToPeerGameState game = await FindActiveP2PGameAsync(session.GameId);
if (game == null)
{
return(null);
}
game.DateEnd = DateTime.Now;
await _storage.UpdateP2PGameAsync(game);
session.PreviousGames.Add(session.GameId);
session.GameId = null;
return(await _storage.UpdateP2PSessionAsync(session));
}
/// <summary>
/// Cleanup old objects from memory storage
/// </summary>
/// <returns></returns>
public Task Cleanup()
{
DateTime now = DateTime.Now;
if (_games.Count > 500)
{
foreach (string key in _games.Keys)
{
GameState g = _games[key];
TimeSpan ts = now - g.LastUpdated;
if (ts.TotalHours >= HoursToLive)
{
_games.TryRemove(key, out _);
}
}
}
if (_p2pGames.Count > 500)
{
foreach (string key in _p2pGames.Keys)
{
PeerToPeerGameState g = _p2pGames[key];
TimeSpan ts = now - g.LastUpdated;
if (ts.TotalHours >= HoursToLive)
{
_p2pGames.TryRemove(key, out _);
}
}
}
if (_p2pSessions.Count > 500)
{
foreach (string key in _p2pSessions.Keys)
{
PeerToPeerSessionState g = _p2pSessions[key];
TimeSpan ts = now - g.LastUpdated;
if (ts.TotalHours >= HoursToLive)
{
_p2pSessions.TryRemove(key, out _);
}
}
}
return(Task.FromResult(0));
}
public async Task CleanupTest()
{
InMemoryStaticStorage s = new InMemoryStaticStorage
{
HoursToLive = 0
};
//clean results of older runs
await s.Cleanup();
for (int i = 0; i < 1000; i++)
{
var game = PeerToPeerGameState.CreateNew();
await s.AddP2PGameAsync(game);
}
for (int i = 0; i < 1000; i++)
{
var session = new PeerToPeerSessionState()
{
Code = i.ToString(),
};
await s.AddP2PSessionAsync(session);
}
for (int i = 0; i < 1000; i++)
{
var game = new GameState
{
GameId = Guid.NewGuid().ToString()
};
await s.AddGameAsync(game);
}
await s.Cleanup();
Assert.AreEqual(0, s.PeerToPeerGamesCount);
Assert.AreEqual(0, s.PeerToPeerSessionsCount);
Assert.AreEqual(0, s.GamesCount);
}
public virtual async Task <PeerToPeerGameState> FindActiveP2PGameAsync(string gameId)
{
PeerToPeerGameState g = await _storage.FindActiveP2PGameAsync(gameId);
return(g);
}
public Task <PeerToPeerGameState> UpdateP2PGameAsync(PeerToPeerGameState game)
{
//TODO: Implement
throw new NotImplementedException();
}
public Task <PeerToPeerGameState> UpdateP2PGameAsync(PeerToPeerGameState game)
{
game.LastUpdated = DateTime.Now;
game = _p2pGames.AddOrUpdate(game.GameId, game, (key, val) => game);
return(Task.FromResult(game));
}
public Task <PeerToPeerGameState> AddP2PGameAsync(PeerToPeerGameState game)
{
game.LastUpdated = DateTime.Now;
game = _p2pGames.GetOrAdd(game.GameId, game);
return(Task.FromResult(game));
}
