public async Task <IActionResult> LogFileStatus()
{
var filterModel = new FileMonitorFilterModel().ApplyAuth(User);
var logFileMonitorStateDtos = await _logFileMonitorStateRepository.GetLogFileMonitorStates(filterModel);
return(View(logFileMonitorStateDtos));
}
public async Task <int> GetFileMonitorsCount(FileMonitorFilterModel filterModel)
{
if (filterModel == null)
{
throw new ArgumentNullException(nameof(filterModel));
}
return(await _legacyContext.FileMonitors.ApplyFilter(filterModel).CountAsync());
}
public async Task <IActionResult> Index()
{
var filterModel = new FileMonitorFilterModel
{
Order = FileMonitorFilterModel.OrderBy.BannerServerListPosition
}.ApplyAuth(User);
var fileMonitorsDtos = await _fileMonitorsRepository.GetFileMonitors(filterModel);
return(View(fileMonitorsDtos));
}
public static FileMonitorFilterModel ApplyAuth(this FileMonitorFilterModel filterModel, ClaimsPrincipal claimsPrincipal)
{
var requiredClaims = new[] { XtremeIdiotsClaimTypes.SeniorAdmin, XtremeIdiotsClaimTypes.HeadAdmin, XtremeIdiotsClaimTypes.GameAdmin, PortalClaimTypes.FileMonitor };
var(gameTypes, fileMonitorIds) = claimsPrincipal.ClaimedGamesAndItems(requiredClaims);
filterModel.GameTypes = gameTypes;
filterModel.FileMonitorIds = fileMonitorIds;
return(filterModel);
}
public async Task <List <FileMonitorDto> > GetFileMonitors(FileMonitorFilterModel filterModel)
{
if (filterModel == null)
{
throw new ArgumentNullException(nameof(filterModel));
}
var fileMonitors = await _legacyContext.FileMonitors
.ApplyFilter(filterModel)
.ToListAsync();
var models = fileMonitors.Select(fm => fm.ToDto()).ToList();
return(models);
}
public async Task <IActionResult> Details(Guid id)
{
var gameServerDto = await _gameServersRepository.GetGameServer(id);
if (gameServerDto == null)
{
return(NotFound());
}
var canEditGameServer = await _authorizationService.AuthorizeAsync(User, gameServerDto, AuthPolicies.ViewGameServer);
if (!canEditGameServer.Succeeded)
{
return(Unauthorized());
}
var banFileMonitorFilterModel = new BanFileMonitorFilterModel
{
Order = BanFileMonitorFilterModel.OrderBy.BannerServerListPosition,
ServerId = id
}.ApplyAuth(User);
var banFileMonitorDtos = await _banFileMonitorsRepository.GetBanFileMonitors(banFileMonitorFilterModel);
var fileMonitorFilterModel = new FileMonitorFilterModel
{
Order = FileMonitorFilterModel.OrderBy.BannerServerListPosition,
ServerId = id
}.ApplyAuth(User);
var fileMonitorsDtos = await _fileMonitorsRepository.GetFileMonitors(fileMonitorFilterModel);
var model = new GameServerDetailsViewModel
{
GameServerDto = gameServerDto,
BanFileMonitorDtos = banFileMonitorDtos,
FileMonitorDtos = fileMonitorsDtos
};
return(View(model));
}
public async Task <List <LogFileMonitorStateDto> > GetLogFileMonitorStates(FileMonitorFilterModel filterModel)
{
var query = new TableQuery <LogFileMonitorStateEntity>().AsTableQuery().ApplyFilter(filterModel);
var results = new List <LogFileMonitorStateDto>();
TableContinuationToken continuationToken = null;
do
{
var queryResult = await _stateTable.ExecuteQuerySegmentedAsync(query, continuationToken);
foreach (var entity in queryResult)
{
var fileMonitorStateDto = new LogFileMonitorStateDto
{
FileMonitorId = Guid.Parse(entity.RowKey),
ServerId = entity.ServerId,
GameType = entity.GameType,
ServerTitle = entity.ServerTitle,
FilePath = entity.FilePath,
FtpHostname = entity.FtpHostname,
FtpUsername = entity.FtpUsername,
FtpPassword = entity.FtpPassword,
RemoteSize = entity.RemoteSize,
LastReadAttempt = entity.LastReadAttempt,
LastRead = entity.LastRead,
PlayerCount = entity.PlayerCount
};
results.Add(fileMonitorStateDto);
}
continuationToken = queryResult.ContinuationToken;
} while (continuationToken != null);
return(results);
}
public static IQueryable <FileMonitors> ApplyFilter(this IQueryable <FileMonitors> fileMonitors, FileMonitorFilterModel filterModel)
{
fileMonitors = fileMonitors.Include(bfm => bfm.GameServerServer).AsQueryable();
if (filterModel.GameTypes != null)
{
fileMonitors = fileMonitors.Where(fm => filterModel.GameTypes.Contains(fm.GameServerServer.GameType)).AsQueryable();
}
if (filterModel.ServerId != Guid.Empty)
{
fileMonitors = fileMonitors.Where(fm => fm.GameServerServerId == filterModel.ServerId).AsQueryable();
}
fileMonitors = fileMonitors.Skip(filterModel.SkipEntries).AsQueryable();
switch (filterModel.Order)
{
case FileMonitorFilterModel.OrderBy.BannerServerListPosition:
fileMonitors = fileMonitors.OrderBy(fm => fm.GameServerServer.BannerServerListPosition).AsQueryable();
break;
case FileMonitorFilterModel.OrderBy.GameType:
fileMonitors = fileMonitors.OrderBy(fm => fm.GameServerServer.GameType).AsQueryable();
break;
}
if (filterModel.TakeEntries != 0)
{
fileMonitors = fileMonitors.Take(filterModel.TakeEntries).AsQueryable();
}
return(fileMonitors);
}
internal static TableQuery <LogFileMonitorStateEntity> ApplyFilter(this TableQuery <LogFileMonitorStateEntity> query, FileMonitorFilterModel filterModel)
{
if (filterModel.GameTypes != null)
{
var firstGameType = filterModel.GameTypes.First();
var gameTypesQuery = TableQuery.GenerateFilterCondition(nameof(LogFileMonitorStateEntity.GameType), QueryComparisons.Equal, firstGameType.ToString());
if (filterModel.GameTypes.Count > 1)
{
foreach (var gameType in filterModel.GameTypes.Skip(1))
{
var subCondition = TableQuery.GenerateFilterCondition(nameof(LogFileMonitorStateEntity.GameType), QueryComparisons.Equal, gameType.ToString());
gameTypesQuery = TableQuery.CombineFilters(gameTypesQuery, TableOperators.Or, subCondition);
}
}
query = query.Where(gameTypesQuery);
}
return(query);
}
// ReSharper disable once UnusedMember.Global
public async Task RunSyncLogFileMonitorState([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer, ILogger log)
{
log.LogDebug($"Start RunSyncLogFileMonitorState @ {DateTime.UtcNow}");
var stopWatch = new Stopwatch();
stopWatch.Start();
var filterModel = new FileMonitorFilterModel();
var fileMonitors = await _fileMonitorsRepository.GetFileMonitors(filterModel);
var fileMonitorStates = await _logFileMonitorStateRepository.GetLogFileMonitorStates(filterModel);
var gameServerStatus = await _gameServerStatusRepository.GetAllStatusModels(new GameServerStatusFilterModel(), TimeSpan.Zero);
foreach (var fileMonitorDto in fileMonitors)
{
var fileMonitorState = fileMonitorStates.SingleOrDefault(fm => fm.FileMonitorId == fileMonitorDto.FileMonitorId);
var statusModel = gameServerStatus.SingleOrDefault(s => s.ServerId == fileMonitorDto.ServerId);
var playerCount = 0;
if (statusModel != null)
{
playerCount = statusModel.PlayerCount;
}
if (fileMonitorState == null)
{
await _logFileMonitorStateRepository.UpdateState(new LogFileMonitorStateDto
{
FileMonitorId = fileMonitorDto.FileMonitorId,
ServerId = fileMonitorDto.ServerId,
GameType = fileMonitorDto.GameServer.GameType,
ServerTitle = fileMonitorDto.GameServer.Title,
FilePath = fileMonitorDto.FilePath,
FtpHostname = fileMonitorDto.GameServer.FtpHostname,
FtpUsername = fileMonitorDto.GameServer.FtpUsername,
FtpPassword = fileMonitorDto.GameServer.FtpPassword,
RemoteSize = -1,
LastReadAttempt = DateTime.UtcNow,
LastRead = DateTime.UtcNow,
PlayerCount = playerCount
});
log.LogInformation($"Creating new log file monitor state object for {fileMonitorDto.GameServer.Title} against path {fileMonitorDto.FilePath}");
}
else
{
fileMonitorState.ServerTitle = fileMonitorDto.GameServer.Title;
if (fileMonitorState.FilePath != fileMonitorDto.FilePath)
{
fileMonitorState.FilePath = fileMonitorDto.FilePath;
fileMonitorState.RemoteSize = -1;
fileMonitorState.LastReadAttempt = DateTime.UtcNow;
fileMonitorState.LastRead = DateTime.UtcNow;
}
if (fileMonitorState.FtpHostname != fileMonitorDto.GameServer.FtpHostname ||
fileMonitorState.FtpUsername != fileMonitorDto.GameServer.FtpUsername ||
fileMonitorState.FtpPassword != fileMonitorDto.GameServer.FtpPassword)
{
fileMonitorState.FtpHostname = fileMonitorDto.GameServer.FtpHostname;
fileMonitorState.FtpUsername = fileMonitorDto.GameServer.FtpUsername;
fileMonitorState.FtpPassword = fileMonitorDto.GameServer.FtpPassword;
if (FtpClients.ContainsKey(fileMonitorState.ServerId))
{
FtpClients.TryRemove(fileMonitorState.ServerId, out var ftpClient);
ftpClient?.Dispose();
}
}
fileMonitorState.PlayerCount = playerCount;
await _logFileMonitorStateRepository.UpdateState(fileMonitorState);
}
}
foreach (var fileMonitorState in fileMonitorStates)
{
var fileMonitor = fileMonitors.SingleOrDefault(fm => fm.FileMonitorId == fileMonitorState.FileMonitorId);
if (fileMonitor == null)
{
log.LogInformation($"Removing file monitor state object as file monitor no longer exists for {fileMonitorState.ServerTitle} against path {fileMonitorState.FilePath}");
await _logFileMonitorStateRepository.DeleteLogFileMonitorState(fileMonitorState);
}
}
stopWatch.Stop();
log.LogDebug($"Stop RunSyncLogFileMonitorState @ {DateTime.UtcNow} after {stopWatch.ElapsedMilliseconds} milliseconds");
}
// ReSharper disable once UnusedMember.Global
public async Task RunMonitorLogFile([TimerTrigger("*/5 * * * * *")] TimerInfo myTimer, ILogger log)
{
log.LogDebug($"Start RunMonitorLogFile @ {DateTime.UtcNow}");
var stopWatch = new Stopwatch();
stopWatch.Start();
var filterModel = new FileMonitorFilterModel();
var fileMonitorStates = (await _logFileMonitorStateRepository.GetLogFileMonitorStates(filterModel))
.Where(fm => fm.PlayerCount > 0)
.ToList();
if (!fileMonitorStates.Any())
{
return;
}
foreach (var logFileMonitor in fileMonitorStates)
{
logFileMonitor.LastReadAttempt = DateTime.UtcNow;
await _logFileMonitorStateRepository.UpdateState(logFileMonitor);
var requestPath = $"ftp://{logFileMonitor.FtpHostname}{logFileMonitor.FilePath}";
log.LogDebug($"Performing request for {logFileMonitor.ServerTitle} against file {requestPath} as player count is {logFileMonitor.PlayerCount}");
if (logFileMonitor.RemoteSize == -1 || logFileMonitor.LastRead < DateTime.UtcNow.AddMinutes(-1))
{
log.LogDebug($"The remote file for {logFileMonitor.ServerTitle} ({requestPath}) has not been read in the past minute");
try
{
var fileSize = _ftpHelper.GetFileSize(logFileMonitor.FtpHostname, logFileMonitor.FilePath, logFileMonitor.FtpUsername, logFileMonitor.FtpPassword);
log.LogDebug($"The remote file size for {logFileMonitor.ServerTitle} is {fileSize} bytes");
logFileMonitor.LastRead = DateTime.UtcNow;
logFileMonitor.RemoteSize = fileSize;
await _logFileMonitorStateRepository.UpdateState(logFileMonitor);
}
catch (Exception ex)
{
log.LogError(ex, $"Failed to read log file for {logFileMonitor.ServerTitle} against file {requestPath}");
log.LogError(ex.Message);
if (ex.InnerException != null)
{
log.LogError(ex.InnerException.Message);
}
}
}
else
{
try
{
FtpClient ftpClient;
if (FtpClients.ContainsKey(logFileMonitor.ServerId))
{
ftpClient = FtpClients[logFileMonitor.ServerId];
}
else
{
var ftpHostname = logFileMonitor.FtpHostname;
var ftpPort = 21;
var ftpParts = logFileMonitor.FtpHostname.Split(":");
if (ftpParts.Count() > 1)
{
ftpHostname = ftpParts[0];
ftpPort = Convert.ToInt32(ftpParts[1]);
}
ftpClient = new FtpClient
{
Host = ftpHostname,
Port = ftpPort,
Credentials = new NetworkCredential(logFileMonitor.FtpUsername, logFileMonitor.FtpPassword)
};
FtpClients.TryAdd(logFileMonitor.ServerId, ftpClient);
}
if (!ftpClient.IsConnected)
{
ftpClient.Connect();
}
using var streamReader = new StreamReader(ftpClient.OpenRead(logFileMonitor.FilePath, FtpDataType.ASCII, logFileMonitor.RemoteSize));
var prev = -1;
var byteList = new List <byte>();
while (true)
{
var cur = streamReader.Read();
if (cur == -1)
{
break;
}
byteList.Add((byte)cur);
if (prev == '\r' && cur == '\n')
{
logFileMonitor.RemoteSize += byteList.Count;
logFileMonitor.LastRead = DateTime.UtcNow;
await _logFileMonitorStateRepository.UpdateState(logFileMonitor);
var line = Encoding.UTF8.GetString(byteList.ToArray()).TrimEnd('\n');
try
{
line = line.Replace("\r\n", "");
line = line.Trim();
line = line.Substring(line.IndexOf(' ') + 1);
line = line.Replace("\u0015", "");
if (line.StartsWith("say;") || line.StartsWith("sayteam;"))
{
var chatType = ChatType.All;
if (line.StartsWith("sayteam;"))
{
chatType = ChatType.Team;
}
log.LogDebug($"[{logFileMonitor.ServerTitle}] {line}");
try
{
var parts = line.Split(';');
var guid = parts[1];
var name = parts[3];
var message = parts[4].Trim();
var chatMessageHandlers = _serviceProvider.GetServices <IChatMessageHandler>().ToList();
foreach (var handler in chatMessageHandlers)
{
await handler.HandleChatMessage(logFileMonitor.ServerId, name, guid, message, chatType);
}
}
catch (Exception ex)
{
log.LogWarning(ex, $"Failed to handle chat message for {logFileMonitor.ServerTitle} with data {line}");
log.LogWarning(ex.Message);
if (ex.InnerException != null)
{
log.LogWarning(ex.InnerException.Message);
}
}
}
}
catch (Exception ex)
{
log.LogWarning(ex, $"Failed to process chat message for {logFileMonitor.ServerTitle} with data {line}");
log.LogWarning(ex.Message);
if (ex.InnerException != null)
{
log.LogWarning(ex.InnerException.Message);
}
}
byteList = new List <byte>();
}
prev = cur;
}
}
catch (Exception ex)
{
log.LogError(ex, $"Failed to read log file for {logFileMonitor.ServerTitle} against file {requestPath}");
log.LogError(ex.Message);
if (ex.InnerException != null)
{
log.LogError(ex.InnerException.Message);
}
}
}
}
stopWatch.Stop();
log.LogDebug($"Stop RunMonitorLogFile @ {DateTime.UtcNow} after {stopWatch.ElapsedMilliseconds} milliseconds");
}
