private void FindNearestBeginEventPosition(ref bool isCorrectBeginEvent, string currentFilePath, ref long newStreamPosition, int stepSize = 1)
{
int attemptToFoundBeginEventLine = 0;
while (!isCorrectBeginEvent && attemptToFoundBeginEventLine < 10)
{
string beginEventLine;
using (FileStream fileStreamCheckPosition =
new FileStream(currentFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
fileStreamCheckPosition.Seek(newStreamPosition, SeekOrigin.Begin);
using (StreamReader fileStreamCheckReader = new StreamReader(fileStreamCheckPosition))
beginEventLine = fileStreamCheckReader.ReadLineWithoutNull();
}
if (beginEventLine == null)
{
isCorrectBeginEvent = false;
break;
}
isCorrectBeginEvent = LogParserLGF.ItsBeginOfEvent(beginEventLine);
if (!isCorrectBeginEvent)
{
newStreamPosition -= stepSize;
attemptToFoundBeginEventLine += 1;
}
}
}
public override bool GoToEvent(long eventNumber)
{
Reset();
int fileIndex = -1;
long currentLineNumber = -1;
long currentEventNumber = 0;
bool moved = false;
foreach (string logFile in _logFilesWithData)
{
fileIndex += 1;
currentLineNumber = -1;
IEnumerable <string> allLines = File.ReadLines(logFile);
foreach (string line in allLines)
{
currentLineNumber += 1;
if (LogParserLGF.ItsBeginOfEvent(line))
{
currentEventNumber += 1;
}
if (currentEventNumber == eventNumber)
{
moved = true;
break;
}
}
if (currentEventNumber == eventNumber)
{
moved = true;
break;
}
}
if (moved && fileIndex >= 0 && currentLineNumber >= 0)
{
InitializeStream(currentLineNumber, fileIndex);
_eventCount = eventNumber - 1;
_currentFileEventNumber = eventNumber;
return(true);
}
else
{
return(false);
}
}
public LogParserReferencesLGF(EventLogLGFReader readerLGF)
{
string textReferencesData;
using (FileStream fs = new FileStream(readerLGF.LogFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (StreamReader sr = new StreamReader(fs))
textReferencesData = sr.ReadToEnd();
int beginBlockIndex = textReferencesData.IndexOf("{", StringComparison.Ordinal);
if (beginBlockIndex < 0)
{
return;
}
textReferencesData = textReferencesData.Substring(beginBlockIndex);
_objectReferencesTexts = LogParserLGF.ParseEventLogString("{" + textReferencesData + "}");
}
private long GetEventCount()
{
long eventCount = 0;
foreach (var logFile in _logFilesWithData)
{
using (StreamReader logFileStream = new StreamReader(File.Open(logFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
do
{
string logFileCurrentString = logFileStream.ReadLine();
if (LogParserLGF.ItsBeginOfEvent(logFileCurrentString))
{
eventCount++;
}
} while (!logFileStream.EndOfStream);
}
}
return(eventCount);
}
private bool NextLineIsBeginEvent()
{
if (CurrentFile == null || _stream == null)
{
return(false);
}
bool nextIsBeginEvent;
long currentStreamPosition = _stream.GetPosition();
using (FileStream fileStreamCheckReader = new FileStream(CurrentFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (StreamReader checkReader = new StreamReader(fileStreamCheckReader))
{
checkReader.SetPosition(currentStreamPosition);
string lineContent = checkReader.ReadLineWithoutNull();
nextIsBeginEvent = LogParserLGF.ItsBeginOfEvent(lineContent);
}
}
return(nextIsBeginEvent);
}
public void ReadReferencesByType <T>(Dictionary <long, T> referenceCollection)
where T : IReferenceObject, new()
{
referenceCollection.Clear();
if (_objectReferencesTexts == null)
{
return;
}
if (_mapTypeAndReferenceTypeId.ContainsKey(typeof(T)) == false)
{
return;
}
string filterReferenceTypeId = _mapTypeAndReferenceTypeId[typeof(T)];
foreach (string textObject in _objectReferencesTexts)
{
string[] parsedEventData = LogParserLGF.ParseEventLogString(textObject);
if (parsedEventData != null)
{
string referenceTypeId = parsedEventData[0];
if (filterReferenceTypeId != referenceTypeId)
{
continue;
}
IReferenceObject referenceObject = new T();
referenceObject.FillByStringParsedData(parsedEventData);
if (referenceCollection.ContainsKey(referenceObject.GetKeyValue()))
{
referenceCollection.Remove(referenceObject.GetKeyValue());
}
referenceCollection.Add(referenceObject.GetKeyValue(), (T)referenceObject);
}
}
}
public override bool Read()
{
try
{
if (_stream == null)
{
if (_logFilesWithData.Length <= _indexCurrentFile)
{
_currentRow = null;
return(false);
}
InitializeStream(_defaultBeginLineForLGF, _indexCurrentFile);
_currentFileEventNumber = 0;
}
_eventSource.Clear();
BeforeReadFileEventArgs beforeReadFileArgs = new BeforeReadFileEventArgs(CurrentFile);
if (_currentFileEventNumber == 0)
{
RaiseBeforeReadFile(beforeReadFileArgs);
}
if (beforeReadFileArgs.Cancel)
{
NextFile();
return(Read());
}
string sourceData;
bool newLine = true;
int countBracket = 0;
bool textBlockOpen = false;
while (true)
{
sourceData = _stream.ReadLine();
if (sourceData == null)
{
NextFile();
return(Read());
}
if (newLine)
{
_eventSource.Append(sourceData);
}
else
{
_eventSource.AppendLine();
_eventSource.Append(sourceData);
}
if (LogParserLGF.ItsEndOfEvent(sourceData, ref countBracket, ref textBlockOpen))
{
newLine = true;
_currentFileEventNumber += 1;
string prepearedSourceData = _eventSource.ToString();
RaiseBeforeRead(new BeforeReadEventArgs(prepearedSourceData, _currentFileEventNumber));
try
{
RowData eventData = LogParser.Parse(prepearedSourceData);
if (eventData.Period >= ReferencesReadDate)
{
ReadEventLogReferences();
eventData = LogParser.Parse(prepearedSourceData);
}
_currentRow = eventData;
}
catch (Exception ex)
{
RaiseOnError(new OnErrorEventArgs(ex, prepearedSourceData, false));
_currentRow = null;
}
RaiseAfterRead(new AfterReadEventArgs(_currentRow, _currentFileEventNumber));
return(true);
}
else
{
newLine = false;
}
}
}
catch (Exception ex)
{
RaiseOnError(new OnErrorEventArgs(ex, null, true));
_currentRow = null;
return(false);
}
}
public override bool Read()
{
bool output;
try
{
if (!InitializeReadFileStream())
{
return(false);
}
RaiseBeforeReadFileEvent(out bool cancelBeforeReadFile);
if (cancelBeforeReadFile)
{
NextFile();
return(Read());
}
bool newLine = true, textBlockOpen = false;
int countBracket = 0;
while (true)
{
string sourceData = ReadSourceDataFromStream();
if (sourceData == null)
{
NextFile();
output = Read();
break;
}
AddNewLineToSource(sourceData, newLine);
if (LogParserLGF.ItsEndOfEvent(sourceData, ref countBracket, ref textBlockOpen))
{
_currentFileEventNumber += 1;
string preparedSourceData = _eventSource.ToString();
RaiseBeforeRead(new BeforeReadEventArgs(preparedSourceData, _currentFileEventNumber));
try
{
RowData eventData = ReadRowData(preparedSourceData);
_currentRow = eventData;
RaiseAfterRead(new AfterReadEventArgs(_currentRow, _currentFileEventNumber));
output = true;
break;
}
catch (Exception ex)
{
RaiseOnError(new OnErrorEventArgs(ex, preparedSourceData, false));
_currentRow = null;
output = true;
break;
}
}
newLine = false;
}
}
catch (Exception ex)
{
RaiseOnError(new OnErrorEventArgs(ex, null, true));
_currentRow = null;
output = false;
}
return(output);
}
