protected virtual bool UpdateFilePath(LogFileInfo logFile, FileLogEntry entry, CancellationToken cancellationToken)
{
string filePath = FormatFilePath(logFile, entry);
if (logFile.MaxSize > 0)
{
while (!CheckFileSize(filePath, logFile, entry))
{
cancellationToken.ThrowIfCancellationRequested();
logFile.Counter++;
var newFilePath = FormatFilePath(logFile, entry);
if (filePath == newFilePath)
{
break;
}
filePath = newFilePath;
}
}
if (logFile.CurrentPath == filePath)
{
return(false);
}
logFile.CurrentPath = filePath;
return(true);
}
protected virtual bool CheckFileSize(string filePath, LogFileInfo logFile, FileLogEntry entry)
{
long currentFileSize;
if (logFile.AppendStream == null || logFile.CurrentPath != filePath)
{
IFileInfo fileInfo = logFile.FileAppender.FileProvider.GetFileInfo(Path.Combine(logFile.BasePath, filePath));
if (!fileInfo.Exists)
{
return(true);
}
if (fileInfo.IsDirectory)
{
return(false);
}
currentFileSize = fileInfo.Length;
}
else
{
currentFileSize = logFile.AppendStream.Length;
}
long expectedFileSize = currentFileSize > 0 ? currentFileSize : logFile.Encoding.GetPreamble().Length;
expectedFileSize += logFile.Encoding.GetByteCount(entry.Text);
return(expectedFileSize <= logFile.MaxSize);
}
public MonthlyHeuristicsExtractor(
LogFileInfo logFileInfo,
LogFileStreamReaderFactory logFileStreamReaderFactory,
IWurmApiLogger logger, [NotNull] IWurmApiConfig wurmApiConfig)
{
if (logFileInfo == null)
{
throw new ArgumentNullException(nameof(logFileInfo));
}
if (logFileStreamReaderFactory == null)
{
throw new ArgumentNullException(nameof(logFileStreamReaderFactory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (wurmApiConfig == null)
{
throw new ArgumentNullException(nameof(wurmApiConfig));
}
this.logFileInfo = logFileInfo;
this.logFileStreamReaderFactory = logFileStreamReaderFactory;
this.logger = logger;
this.wurmApiConfig = wurmApiConfig;
}
private WurmLogMonthlyFile GetEntityForFile(LogFileInfo logFileInfo)
{
WurmLogMonthlyFile fileData;
bool isNewFile = false;
bool needsSaving = false;
if (!persistentData.Entity.WurmLogFiles.TryGetValue(logFileInfo.FileNameNormalized, out fileData))
{
fileData = new WurmLogMonthlyFile { FileName = logFileInfo.FileNameNormalized };
isNewFile = true;
needsSaving = true;
}
FileInfo fileInfo = new FileInfo(logFileInfo.FullPath);
var fileLength = fileInfo.Length;
if (fileData.LastKnownSizeInBytes < fileLength)
{
var extractor = monthlyHeuristicsExtractorFactory.Create(logFileInfo);
var results = extractor.ExtractDayToPositionMap();
fileData.LogDate = results.LogDate;
fileData.DayToHeuristicsMap = results.Heuristics;
fileData.HasValidBytePositions = results.HasValidBytePositions;
fileData.LastKnownSizeInBytes = fileLength;
needsSaving = true;
}
fileData.LastUpdated = Time.Get.LocalNowOffset;
if (isNewFile) persistentData.Entity.WurmLogFiles.Add(fileData.FileName, fileData);
if (needsSaving) persistentData.FlagAsChanged();
return fileData;
}
public virtual SingleFileMonitor Create(LogFileInfo logFileInfo, long beginReaderOffsetBytes)
{
var monitor = new SingleFileMonitor(logFileInfo, streamReaderFactory, logFileParser);
monitor.OverrideCurrentPosition(beginReaderOffsetBytes);
return(monitor);
}
string GetPostfix(LogFileInfo logFile, IFileAppender fileAppender, Encoding fileEncoding, FileLogEntry entry)
{
if (HasPostfix(logFile, entry))
{
var sb = stringBuilder;
stringBuilder = null;
if (sb == null)
{
sb = new StringBuilder();
}
while (true)
{
BuildPostfix(sb, logFile, entry);
var postfix = sb.ToString();
sb.Clear();
if (CheckLogFile(logFile, postfix, fileAppender, fileEncoding, entry))
{
if (sb.Capacity > 64)
{
sb.Capacity = 64;
}
stringBuilder = sb;
return(postfix);
}
}
}
else
{
return(null);
}
}
public static IEnumerable <LogFileInfo> GetActiveFiles(List <LogFileInfo> lfn)
{
var rlfn = new List <LogFileInfo>();
var data = new List <string>();
foreach (var d in lfn)
{
if (!data.Contains(d.prefix))
{
data.Add(d.prefix);
}
}
foreach (var d in data)
{
LogFileInfo latest = null;
foreach (var lf in lfn)
{
if (d == lf.prefix)
{
if (latest == null)
{
latest = lf;
}
if (latest.lastWrite < lf.lastWrite)
{
latest = lf;
}
}
}
rlfn.Add(latest);
}
return(rlfn);
}
protected virtual LogFileInfo CreateLogFile(ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
LogFileInfo logFile = CreateLogFile();
logFile.BasePath = settings.BasePath ?? string.Empty;
logFile.PathFormat = fileSettings.Path;
logFile.FileAppender = settings.FileAppender ?? _fallbackFileAppender.Value;
logFile.AccessMode = fileSettings.FileAccessMode ?? settings.FileAccessMode ?? LogFileAccessMode.Default;
logFile.Encoding = fileSettings.FileEncoding ?? settings.FileEncoding ?? Encoding.UTF8;
logFile.DateFormat = fileSettings.DateFormat ?? settings.DateFormat ?? "yyyyMMdd";
logFile.CounterFormat = fileSettings.CounterFormat ?? settings.CounterFormat;
logFile.MaxSize = fileSettings.MaxFileSize ?? settings.MaxFileSize ?? 0;
// important: closure must pick up the current token!
CancellationToken forcedCompleteToken = _forcedCompleteTokenSource.Token;
logFile.Queue = new ActionBlock <FileLogEntry>(
e => WriteEntryAsync(logFile, e, forcedCompleteToken),
new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = 1,
BoundedCapacity = fileSettings.MaxQueueSize ?? settings.MaxQueueSize ?? -1,
});
return(logFile);
}
private static bool MatchesToDate(LogFileInfo logFileInfo, DateTime dailyAdjustedTo, DateTime monthlyAdjustedTo)
{
return((logFileInfo.LogFileDate.LogSavingType == LogSavingType.Daily &&
logFileInfo.LogFileDate.DateTime <= dailyAdjustedTo) ||
(logFileInfo.LogFileDate.LogSavingType == LogSavingType.Monthly &&
logFileInfo.LogFileDate.DateTime <= monthlyAdjustedTo));
}
private static bool MatchesToDate(LogFileInfo logFileInfo, DateTime dailyAdjustedTo, DateTime monthlyAdjustedTo)
{
return (logFileInfo.LogFileDate.LogSavingType == LogSavingType.Daily
&& logFileInfo.LogFileDate.DateTime <= dailyAdjustedTo)
|| (logFileInfo.LogFileDate.LogSavingType == LogSavingType.Monthly
&& logFileInfo.LogFileDate.DateTime <= monthlyAdjustedTo);
}
private static bool MatchesFromDate(LogFileInfo logFileInfo, DateTime dailyAdjustedFrom, DateTime monthlyAdjustedFrom)
{
return (logFileInfo.LogFileDate.LogSavingType == LogSavingType.Daily
&& logFileInfo.LogFileDate.DateTime >= dailyAdjustedFrom)
|| (logFileInfo.LogFileDate.LogSavingType == LogSavingType.Monthly
&& logFileInfo.LogFileDate.DateTime >= monthlyAdjustedFrom);
}
private static bool MatchesFromDate(LogFileInfo logFileInfo, DateTime dailyAdjustedFrom, DateTime monthlyAdjustedFrom)
{
return((logFileInfo.LogFileDate.LogSavingType == LogSavingType.Daily &&
logFileInfo.LogFileDate.DateTime >= dailyAdjustedFrom) ||
(logFileInfo.LogFileDate.LogSavingType == LogSavingType.Monthly &&
logFileInfo.LogFileDate.DateTime >= monthlyAdjustedFrom));
}
public static void PopulateLogFiles()
{
var st = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine($"Repo ThreadID {st}");
StreamReader sr = new StreamReader(@"config\LogFileNames.txt");
while (true)
{
var read = sr.ReadLine();
if (read == null)
{
break;
}
var lfi = new LogFileInfo {
fullName = read
};
lfiList.Add(lfi);
}
sr.Dispose();
}
protected virtual LogFileInfo CreateLogFile(ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
LogFileInfo logFile = CreateLogFile();
logFile.BasePath = settings.BasePath ?? string.Empty;
logFile.PathFormat = fileSettings.Path;
logFile.FileAppender = settings.FileAppender ?? _fallbackFileAppender.Value;
logFile.AccessMode = fileSettings.FileAccessMode ?? settings.FileAccessMode ?? LogFileAccessMode.Default;
logFile.Encoding = fileSettings.FileEncoding ?? settings.FileEncoding ?? Encoding.UTF8;
logFile.DateFormat = fileSettings.DateFormat ?? settings.DateFormat ?? "yyyyMMdd";
logFile.CounterFormat = fileSettings.CounterFormat ?? settings.CounterFormat;
logFile.MaxSize = fileSettings.MaxFileSize ?? settings.MaxFileSize ?? 0;
var maxQueueSize = fileSettings.MaxQueueSize ?? settings.MaxQueueSize ?? 0;
logFile.Queue =
maxQueueSize > 0 ?
Channel.CreateBounded <FileLogEntry>(ConfigureChannelOptions(new BoundedChannelOptions(maxQueueSize)
{
FullMode = BoundedChannelFullMode.DropWrite
})) :
Channel.CreateUnbounded <FileLogEntry>(ConfigureChannelOptions(new UnboundedChannelOptions()));
// important: closure must pick up the current token!
CancellationToken forcedCompleteToken = _forcedCompleteTokenSource.Token;
logFile.WriteFileTask = Task.Run(() => WriteFileAsync(logFile, forcedCompleteToken));
return(logFile);
public void SequenceIsOneWhenNoPreviousFile()
{
using (var dir = new TestDirectory())
{
var latest = LogFileInfo.GetLatestOrNew(new DateTime(2015, 01, 15), dir.LogDirectory);
Assert.That(latest.Sequence, Is.EqualTo(1));
}
}
private void NewWriter()
{
if (_writer != null)
{
_writer.Close();
_writer.Dispose();
}
LogFileInfo.Refresh();
CreateWriter();
}
public void LogStartActivity(string activity)
{
ActivityName = activity;
StreamWriter w = LogFileInfo.CreateText();
w.WriteLine("Name : " + PlayerName);
w.WriteLine("Language : " + LanguageName);
w.WriteLine("Activity : " + ActivityName);
w.Close();
}
public ConfigEntry(LogFileInfo logFileInfo, string key, string rootKey, string value)
{
FileLastModifiedUtc = logFileInfo.LastModifiedUtc;
FileName = logFileInfo.FileName;
FilePath = logFileInfo.FilePath;
Key = key;
RootKey = rootKey;
Value = value;
Worker = logFileInfo.Worker;
}
public static string OutOfMemoryError(LogFileInfo logFileInfo, IEnumerable <IPlugin> pluginsUsed)
{
var pluginNames = string.Join(", ", pluginsUsed.Select(plugin => plugin.Name));
var errorMessage = new StringBuilder();
errorMessage.AppendLine($"Out of memory exception occurred while processing log file `{logFileInfo.FilePath}`. Processing of the log set aborted. The most common reason for this to happen is a very wide line in a log file. It could still be possible to process this log set, but you will have to do one of the following:");
errorMessage.AppendLine("\t* Use a machine with more memory available.");
errorMessage.AppendLine($"\t* Skip the plugin(s) that ran out of memory. Plugins LogShark attempted to run were: `{pluginNames}`");
errorMessage.AppendLine("\t* Remove file in question from the log set. (sometimes other files of the same type might contain the same wide line though)");
return(errorMessage.ToString());
}
protected virtual async Task WriteEntryCoreAsync(LogFileInfo logFile, FileLogEntry entry, CancellationToken cancellationToken)
{
if (logFile.AppendStream.Length == 0)
{
var preamble = logFile.Encoding.GetPreamble();
await logFile.AppendStream.WriteAsync(preamble, 0, preamble.Length, cancellationToken).ConfigureAwait(false);
}
var data = logFile.Encoding.GetBytes(entry.Text);
await logFile.AppendStream.WriteAsync(data, 0, data.Length, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Parses lines with expectation, that they all come from single day indicated by originDate.
/// In other words, the first line MUST be the first entry on a given day.
/// </summary>
/// <returns></returns>
public IList <LogEntry> ParseLinesForDay(IReadOnlyList <string> lines, DateTime originDate,
LogFileInfo logFileInfo)
{
AssertOriginDate(originDate);
List <LogEntry> result = new List <LogEntry>(lines.Count);
TimeSpan currentLineStamp = TimeSpan.Zero;
foreach (var line in lines)
{
// handle special types of lines
if (IsLoggingStartedLine(line))
{
// skip, is of no concern at this point
continue;
}
// handle timestamp
var lineStamp = ParsingHelper.TryParseTimestampFromLogLine(line);
if (lineStamp == TimeSpan.MinValue)
{
// maybe just empty line (eg. happens on examining signs)
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
// bad timestamp may indicate corrupted file, special unforseen case
// or log file from when "log timestamps" was disabled in game.
HandleUnparseableTimestamp(logFileInfo, line, result);
continue;
}
if (lineStamp < currentLineStamp)
{
LogTimestampDiscrepancy(logFileInfo, result, line);
}
else
{
currentLineStamp = lineStamp;
}
string source = ParsingHelper.TryParseSourceFromLogLine(line);
string content = ParsingHelper.TryParseContentFromLogLine(line);
LogEntry entry = new LogEntry(originDate + currentLineStamp, source, content, logFileInfo.PmRecipientNormalized);
result.Add(entry);
}
return(result);
}
protected void dgrCongViec_RowCommand(object source, GridViewCommandEventArgs e)
{
if (e.CommandName == "delete")
{
try
{
int id = ConvertUtility.ToInt32(e.CommandArgument);
QuanLyCongViecKTXVaPSInfo info = QuanLyCongViecKTXVaPSController.GetInfo(id);
if (info == null)
{
cmdEmpty_Click(null, null);
return;
}
QuanLyCongViecKTXVaPSController.Delete(id, ConvertUtility.ToInt32(dropDotDanhGia.SelectedValue));
int ParentID = ConvertUtility.ToInt32(dropCongViecKPI.SelectedValue);
if (ParentID > 0)
{
UpdateTyTrongCongViecCha(ParentID, info.IsKPI);
string oldData = GetObjectInfo(info);
#region Log Action
LogFileInfo logFileInfo = new LogFileInfo();
logFileInfo.Log_Action = "Delete";
logFileInfo.Log_Type_Object = "QuanLyCongViecKPI";
logFileInfo.Item_CatID = "Cong Viec Thuong Xuyen";
logFileInfo.Item_ID = info.ID.ToString();
logFileInfo.Item_Name = info.Ten;
logFileInfo.Description_Before = "Old Data: " + oldData;
logFileInfo.Description_After = "Delete KPI with info: <br />" + GetObjectInfo(info);
logFileInfo.UserName = CurrentUser.Username;
logFileInfo.UserID = CurrentUser.UserID;
CreateLogFile.LogAction(logFileInfo);
#endregion
UpdateCapDoCongViec();
}
lblStatusUpdate.Text = MiscUtility.MSG_UPDATE_SUCCESS;
}
catch (Exception ex)
{
lblStatusUpdate.Text = ex.Message;
}
}
Session["Nav"] = "1";
}
void LogTimestampDiscrepancy(LogFileInfo logFileInfo, List <LogEntry> result, string line)
{
var lastEntry = result.LastOrDefault();
var lastLineContents = lastEntry?.ToString() ?? "No entries parsed yet";
Log(
string.Format(
"Parsed line has earlier timestamp, compared to last parsed line. Overriding this timestamp with stamp of last parsed line. Line contents: [{0}], Last entry data: [{1}]",
line,
lastLineContents),
logFileInfo,
LogLevel.Info);
}
public void SequenceIsEqualToTheHighestFileWritten()
{
var date = new DateTime(2015, 01, 15);
using (var dir = new TestDirectory())
{
dir.CreateLogFile(date, 1);
dir.CreateLogFile(date, 2);
dir.CreateLogFile(date, 3);
var latest = LogFileInfo.GetLatestOrNew(new DateTime(2015, 01, 15), dir.LogDirectory);
Assert.That(latest.Sequence, Is.EqualTo(3));
}
}
private ProcessFileResult ProcessFile(string rawFilePath, string normalizedFilePath, LogTypeInfo logTypeInfo, IList <IPlugin> plugins)
{
var fileInfo = new FileInfo(rawFilePath);
var logFileInfo = new LogFileInfo(
fileInfo.Name,
normalizedFilePath,
normalizedFilePath.GetWorkerIdFromFilePath(),
new DateTimeOffset(fileInfo.LastWriteTime.Ticks, TimeSpan.Zero).UtcDateTime
);
using var stream = File.Open(rawFilePath, FileMode.Open);
return(ProcessStream(stream, logTypeInfo, logFileInfo, plugins));
}
private static dynamic ExpectedConfigEntry(LogFileInfo logFileInfo, string key, string rootKey, string value)
{
return(new
{
FileLastModifiedUtc = logFileInfo.LastModifiedUtc,
FileName = logFileInfo.FileName,
FilePath = logFileInfo.FilePath,
Key = key,
RootKey = rootKey,
Value = value,
Worker = logFileInfo.Worker,
});
}
protected void btnCapNhatCVHomTruoc_Click(object sender, EventArgs e)
{
DateTime dtTime = new DateTime(ConvertUtility.ToInt32(dropYearCopy.SelectedValue), ConvertUtility.ToInt32(dropMonthCopy.SelectedValue), ConvertUtility.ToInt32(dropDayCopy.SelectedValue));
DateTime dtTimeNow = new DateTime(ConvertUtility.ToInt32(dropYear.SelectedValue), ConvertUtility.ToInt32(dropMonth.SelectedValue), ConvertUtility.ToInt32(dropDay.SelectedValue));
DataTable dt = QuanLyCongViecBaoCaoNgayController.GetAllByUserID(ConvertUtility.ToInt32(dropTrungTam.SelectedValue), 0, dtTime, ConvertUtility.ToInt32(dropDotDanhGia.SelectedValue), CurrentUser.UserID);
foreach (DataRow item in dt.Rows)
{
QuanLyCongViecBaoCaoNgayInfo info = new QuanLyCongViecBaoCaoNgayInfo();
info.IDCongViecKPI = ConvertUtility.ToInt32(item["IDCongViecKPI"]);
info.Ten = item["Ten"].ToString();
info.KeHoach = item["KeHoach"].ToString();
info.ParentID = item["ParentID"].ToString();
info.TyTrong = ConvertUtility.ToDouble(item["TyTrong"].ToString());
info.KetQua = item["KetQua"].ToString();
info.TyLeHoanThanh = item["TyLeHoanThanh"].ToString();
info.IDTrungTam = ConvertUtility.ToInt32(item["IDTrungTam"].ToString());
info.IDPhongBan = ConvertUtility.ToInt32(item["IDPhongBan"].ToString());
info.IDDotDanhGia = ConvertUtility.ToInt32(dropDotDanhGia.SelectedValue);
info.SoGio = ConvertUtility.ToDouble(item["SoGio"].ToString());
info.CreateBy = CurrentUser.UserID;
info.LyDo = item["LyDo"].ToString();
info.DeXuat = item["DeXuat"].ToString();
info.CreatedOn = dtTimeNow;
try
{
QuanLyCongViecBaoCaoNgayController.Insert(info);
#region Log Action
LogFileInfo logFileInfo = new LogFileInfo();
logFileInfo.Log_Action = "Add";
logFileInfo.Log_Type_Object = "QuanLyCongViecKPITheoNgay";
logFileInfo.Item_CatID = "Cong Viec Thuong Xuyen";
logFileInfo.Item_ID = info.ID.ToString();
logFileInfo.Item_Name = info.Ten;
logFileInfo.Description_Before = "Old Data: ";
logFileInfo.Description_After = "Add KPI with info: <br />" + GetObjectInfo(info);
logFileInfo.UserName = CurrentUser.Username;
logFileInfo.UserID = CurrentUser.UserID;
CreateLogFile.LogAction(logFileInfo);
#endregion
}
catch (Exception ex)
{
lblStatusUpdate.Text = ex.Message;
}
}
}
public ILogFileInfo GetLogfileInfo(string uriString)
{
Uri uri = new Uri(uriString);
if (uri.IsFile)
{
ILogFileInfo logFileInfo = new LogFileInfo(uri);
return(logFileInfo);
}
else
{
throw new UriFormatException("Uri " + uriString + " is no file Uri");
}
}
async Task WriteEntryAsync(LogFileInfo logFile, FileLogEntry entry, CancellationToken disposeToken)
{
// discarding remaining entries if queue got disposed
disposeToken.ThrowIfCancellationRequested();
Encoding fileEncoding;
string filePath;
bool ensureBasePath;
_settingsLock.EnterReadLock();
try
{
fileEncoding = GetFileEncoding(logFile, entry);
var postfix = GetPostfix(logFile, fileEncoding, entry);
filePath = logFile.GetFilePath(postfix);
ensureBasePath = Settings.EnsureBasePath;
}
finally { _settingsLock.ExitReadLock(); }
var fileInfo = Context.FileProvider.GetFileInfo(filePath);
while (true)
{
try
{
await Context.AppendAllTextAsync(fileInfo, entry.Text, fileEncoding).ConfigureAwait(false);
return;
}
catch
{
if (ensureBasePath)
{
try
{
if (await Context.EnsureDirAsync(fileInfo).ConfigureAwait(false))
{
await Context.AppendAllTextAsync(fileInfo, entry.Text, fileEncoding).ConfigureAwait(false);
return;
}
}
catch { }
}
}
// discarding failed entry if queue got disposed
await Task.Delay(1000, disposeToken).ConfigureAwait(false);
}
}
public MonthlyHeuristicsExtractor(
LogFileInfo logFileInfo,
LogFileStreamReaderFactory logFileStreamReaderFactory,
ILogger logger, [NotNull] IWurmApiConfig wurmApiConfig)
{
if (logFileInfo == null) throw new ArgumentNullException("logFileInfo");
if (logFileStreamReaderFactory == null) throw new ArgumentNullException("logFileStreamReaderFactory");
if (logger == null) throw new ArgumentNullException("logger");
if (wurmApiConfig == null) throw new ArgumentNullException("wurmApiConfig");
this.logFileInfo = logFileInfo;
this.logFileStreamReaderFactory = logFileStreamReaderFactory;
this.logger = logger;
this.wurmApiConfig = wurmApiConfig;
}
/// <summary>
/// Clean out any old log files in the same directory as this log
/// </summary>
/// <param name="OlderThanDays">Files older than this many days will be deleted</param>
public void CleanOutOldLogs(
int OlderThanDays
)
{
DirectoryInfo DirInfo = new DirectoryInfo(LogFolder);
foreach (FileInfo LogFileInfo in DirInfo.GetFiles())
{
if (LogFileInfo.LastWriteTimeUtc.AddDays(OlderThanDays) < DateTime.UtcNow)
{
LogFileInfo.Delete();
}
}
}
protected virtual void BuildPostfix(StringBuilder sb, LogFileInfo logFile, FileLogEntry entry)
{
if (!string.IsNullOrEmpty(logFile.Settings.DateFormat))
{
sb.Append('-');
sb.Append(entry.Timestamp.ToLocalTime().ToString(logFile.Settings.DateFormat, CultureInfo.InvariantCulture));
}
if (logFile.Settings.MaxFileSize > 0)
{
sb.Append('-');
sb.Append(logFile.Counter.ToString(logFile.Settings.CounterFormat, CultureInfo.InvariantCulture));
}
}
/// <summary>
/// Parses lines with expectation, that they all come from single day indicated by originDate.
/// In other words, the first line MUST be the first entry on a given day.
/// </summary>
/// <returns></returns>
public IList<LogEntry> ParseLinesForDay(IReadOnlyList<string> lines, DateTime originDate,
LogFileInfo logFileInfo)
{
AssertOriginDate(originDate);
List<LogEntry> result = new List<LogEntry>(lines.Count);
TimeSpan currentLineStamp = TimeSpan.Zero;
foreach (var line in lines)
{
// handle special types of lines
if (IsLoggingStartedLine(line))
{
// skip, is of no concern at this point
continue;
}
// handle timestamp
var lineStamp = ParsingHelper.TryParseTimestampFromLogLine(line);
if (lineStamp == TimeSpan.MinValue)
{
// bad timestamp may indicate corrupted file, special unforseen case
// or log file from when "log timestamps" was disabled in game.
HandleUnparseableTimestamp(logFileInfo, line, result);
continue;
}
//if (originDate == new DateTime(2012, 8, 26) || originDate == new DateTime(2012, 8, 27))
//{
// var debug = true;
//}
if (lineStamp < currentLineStamp)
{
LogTimestampDiscrepancy(logFileInfo, result, line);
}
else
{
currentLineStamp = lineStamp;
}
string source = ParsingHelper.TryParseSourceFromLogLine(line);
string content = ParsingHelper.TryParseContentFromLogLine(line);
LogEntry entry = new LogEntry(originDate + currentLineStamp, source, content, logFileInfo.PmRecipientNormalized);
result.Add(entry);
}
return result;
}
private ProcessFileResult ProcessZippedFile(ZipArchiveEntry fileEntry, string filePathWithPrefix, LogTypeInfo logTypeInfo, IList <IPlugin> plugins)
{
var logFileInfo = new LogFileInfo(
fileEntry.Name,
filePathWithPrefix,
filePathWithPrefix.GetWorkerIdFromFilePath(),
new DateTimeOffset(fileEntry.LastWriteTime.Ticks, TimeSpan.Zero).UtcDateTime // the ZipArchiveEntry doesn't currently support reading the timezone of the zip entry... so we strip it for consistency
);
// currently because of how zips store (or don't) timezone info for entries, the zipped and unzipped versions of this method produce different output. Perhaps we can do better in the future.
using var stream = fileEntry.Open();
return(ProcessStream(stream, logTypeInfo, logFileInfo, plugins));
}
async Task WriteEntryAsync(LogFileInfo logFile, FileLogEntry entry, CancellationToken shutdownToken)
{
// discarding remaining entries on shutdown
shutdownToken.ThrowIfCancellationRequested();
var fileAppender = GetFileAppender(logFile);
var fileEncoding = GetFileEncoding(logFile, entry);
var postfix = GetPostfix(logFile, fileAppender, fileEncoding, entry);
var filePath = logFile.GetFilePath(postfix);
var ensureBasePath = logFile.Settings.EnsureBasePath;
var fileInfo = fileAppender.FileProvider.GetFileInfo(filePath);
while (true)
{
try
{
await fileAppender.AppendAllTextAsync(fileInfo, entry.Text, fileEncoding, shutdownToken).ConfigureAwait(false);
return;
}
catch
{
if (ensureBasePath)
{
try
{
if (await fileAppender.EnsureDirAsync(fileInfo, shutdownToken).ConfigureAwait(false))
{
await fileAppender.AppendAllTextAsync(fileInfo, entry.Text, fileEncoding, shutdownToken).ConfigureAwait(false);
return;
}
}
catch { }
}
}
// discarding failed entry on shutdown
if (Context.WriteRetryDelay > TimeSpan.Zero)
{
await Task.Delay(Context.WriteRetryDelay, shutdownToken).ConfigureAwait(false);
}
else
{
shutdownToken.ThrowIfCancellationRequested();
}
}
}
public SingleFileMonitor(
LogFileInfo logFileInfo,
LogFileStreamReaderFactory streamReaderFactory,
LogFileParser logFileParser)
{
if (logFileInfo == null) throw new ArgumentNullException("logFileInfo");
if (streamReaderFactory == null) throw new ArgumentNullException("streamReaderFactory");
if (logFileParser == null) throw new ArgumentNullException("logFileParser");
this.logFileInfo = logFileInfo;
this.streamReaderFactory = streamReaderFactory;
this.logFileParser = logFileParser;
fileInfo = new FileInfo(logFileInfo.FullPath);
lastFileSize = fileInfo.Length;
}
private void LogTimestampDiscrepancy(LogFileInfo logFileInfo, List<LogEntry> result, string line)
{
string lastLineContents;
LogEntry lastEntry = result.LastOrDefault();
if (lastEntry != null)
{
lastLineContents = lastEntry.ToString();
}
else
{
lastLineContents = "No entries parsed yet";
}
Log(
string.Format(
"Parsed line has earlier timestamp, than last parsed line. Overriding this timestamp with stamp of last parsed line. Line contents: [{0}], Last entry data: [{1}]",
line,
lastLineContents),
logFileInfo);
}
public MonthlyHeuristicsExtractor Create(LogFileInfo logFileInfo)
{
return new MonthlyHeuristicsExtractor(logFileInfo, logFileStreamReaderFactory, logger, wurmApiConfig);
}
private void ParseDailyFile(LogFileInfo logFileInfo, List<LogEntry> result, LogFileParser logFileParser)
{
List<string> allLines = new List<string>();
using (var reader = streamReaderFactory.Create(logFileInfo.FullPath))
{
string currentLine;
while ((currentLine = reader.TryReadNextLine()) != null)
{
allLines.Add(currentLine);
}
}
IEnumerable<LogEntry> parsedLines = logFileParser.ParseLinesForDay(
allLines,
logFileInfo.LogFileDate.DateTime,
logFileInfo);
result.AddRange(parsedLines);
}
public virtual SingleFileMonitor Create(LogFileInfo logFileInfo, long beginReaderOffsetBytes)
{
var monitor = new SingleFileMonitor(logFileInfo, streamReaderFactory, logFileParser);
monitor.OverrideCurrentPosition(beginReaderOffsetBytes);
return monitor;
}
private void ParseMonthlyFile(
CharacterMonthlyLogHeuristics heuristicsFileMap,
LogFileInfo logFileInfo,
List<LogEntry> result,
LogFileParser logFileParser)
{
var heuristics = heuristicsFileMap.GetFullHeuristicsForMonth(logFileInfo);
var dayToSearchFrom = GetMinDayToSearchFrom(logSearchParameters.DateFrom, logFileInfo.LogFileDate.DateTime);
var dayToSearchTo = GetMaxDayToSearchUpTo(logSearchParameters.DateTo, logFileInfo.LogFileDate.DateTime);
LogFileStreamReader reader = null;
try
{
for (int day = dayToSearchFrom; day <= dayToSearchTo; day++)
{
var thisDayHeuristics = heuristics.GetForDay(day);
if (thisDayHeuristics.LinesLength == 0) continue;
if (reader == null)
{
if (heuristics.HasValidFilePositions)
{
reader = streamReaderFactory.Create(
logFileInfo.FullPath,
thisDayHeuristics.StartPositionInBytes);
}
else
{
reader = streamReaderFactory.CreateWithLineCountFastForward(
logFileInfo.FullPath,
thisDayHeuristics.TotalLinesSinceBeginFile);
}
}
var thisEntryDate = new DateTime(
logFileInfo.LogFileDate.DateTime.Year,
logFileInfo.LogFileDate.DateTime.Month,
day,
0,
0,
0);
int readLinesCount = 0;
List<string> allLines = new List<string>();
string currentLine;
while ((currentLine = reader.TryReadNextLine()) != null)
{
allLines.Add(currentLine);
readLinesCount++;
if (readLinesCount == thisDayHeuristics.LinesLength)
{
break;
}
}
IEnumerable<LogEntry> parsedLines = logFileParser.ParseLinesForDay(allLines,
thisEntryDate,
logFileInfo);
result.AddRange(parsedLines);
cancellationManager.ThrowIfCancelled();
}
}
finally
{
if (reader != null) reader.Dispose();
}
}
public virtual SingleFileMonitor Create(LogFileInfo logFileInfo)
{
return new SingleFileMonitor(logFileInfo, streamReaderFactory, logFileParser);
}
private void HandleUnparseableTimestamp(LogFileInfo logFileInfo, string line, List<LogEntry> result)
{
Log(
string.Format(
"Parsing timestamp from log line was not possible. Appending contents to previous logged line. Line contents: {0}",
line),
logFileInfo);
if (result.Any())
{
var lastIndex = result.Count - 1;
var oldEntry = result[lastIndex];
result[lastIndex] = new LogEntry(oldEntry.Timestamp, oldEntry.Source, oldEntry.Content + line);
}
else
{
Log("Appending impossible, no entries parsed yet.", logFileInfo);
}
}
public MonthlyFileHeuristics GetFullHeuristicsForMonth(LogFileInfo logFileInfo)
{
WurmLogMonthlyFile fileData = GetEntityForFile(logFileInfo);
return CreateMonthlyFileHeuristics(fileData);
}
public MonitorEvents(LogFileInfo logFileInfo)
{
LogFileInfo = logFileInfo;
PmRecipient = logFileInfo.PmRecipientNormalized;
}
private void Log(string message, LogFileInfo logFileInfo)
{
logger.Log(LogLevel.Warn, string.Format("{0}, Log file: [{1}]", message, logFileInfo.FullPath), this, null);
}