private void HandleWorkUnitRunning(LogLine logLine)
{
// If we've already seen a WorkUnitRunning line, ignore this one
if (_currentLineType == LogLineType.WorkUnitRunning)
{
return;
}
// Not Checking the Queue Slot - we don't care if we found a valid slot or not
if (_unitIndexData.ProcessingIndex > -1)
{
EnsureUnitRunExists(_unitIndexData.ProcessingIndex, _unitIndexData.QueueSlotIndex);
}
else if (_unitIndexData.WorkingIndex > -1)
{
EnsureUnitRunExists(_unitIndexData.WorkingIndex, _unitIndexData.QueueSlotIndex);
}
else if (_unitIndexData.StartIndex > -1)
{
EnsureUnitRunExists(_unitIndexData.StartIndex, _unitIndexData.QueueSlotIndex);
}
else
{
EnsureUnitRunExists(logLine.LineIndex, _unitIndexData.QueueSlotIndex);
}
_currentLineType = logLine.LineType;
// Re-initialize Values
_unitIndexData.Initialize();
}
protected override void HandleWorkUnitCoreDownload(LogLine logLine)
{
base.HandleWorkUnitCoreDownload(logLine);
_unitIndexData.CoreDownloadIndex = logLine.LineIndex;
_currentLineType = logLine.LineType;
}
/// <summary>
/// Adds a LogLine to the end of the List.
/// </summary>
/// <param name="logLine">The raw log line being added.</param>
internal void Add(string logLine)
{
LogLineType lineType = DetermineLineType(logLine);
var logLineObject = new LogLine {
LineType = lineType, LineIndex = Count, LineRaw = logLine
};
try
{
object lineData = _logLineParser.GetLineData(logLineObject);
if (lineData is LogLineError)
{
logLineObject.LineType = LogLineType.Error;
logLineObject.LineData = ((LogLineError)lineData).Message;
}
else
{
logLineObject.LineData = lineData;
}
}
catch (Exception ex)
{
logLineObject.LineType = LogLineType.Error;
logLineObject.LineData = ex.Message;
}
AddLast(logLineObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="LogLine"/> class.
/// </summary>
/// <param name="raw">The raw log line string.</param>
/// <param name="index">The index of the line in the log.</param>
/// <param name="lineType">The type of log line.</param>
/// <param name="timeStamp">The time stamp of the log line if the log line contains time information.</param>
/// <param name="data">The object that represents the data parsed from the raw log line.</param>
public LogLine(string raw, int index, LogLineType lineType, TimeSpan?timeStamp, object data)
{
_raw = raw;
_index = index;
_lineType = lineType;
_timeStamp = timeStamp;
_data = data;
}
/// <summary>
/// Occurs after a line was read from the <see cref="TextReader"/> and returns a new <see cref="LogLine"/> object.
/// </summary>
/// <param name="line">The line read from the <see cref="TextReader"/>.</param>
/// <param name="index">The index of the line read from the <see cref="TextReader"/>.</param>
/// <returns>A new <see cref="LogLine"/> object from the string line and line index.</returns>
protected override LogLine OnReadLine(string line, int index)
{
LogLineType lineType = LogLineTypeResolver.Resolve(line);
LogLineTimeStampParserFunction timeStampParser = LogLineTimeStampParser.ParseTimeStamp;
LogLineDataParserDictionary.TryGetValue(lineType, out LogLineDataParserFunction dataParser);
return(new LazyLogLine(line, index, lineType, timeStampParser, dataParser));
}
protected override void HandleWorkUnitCoreShutdown(LogLine logLine)
{
if (_currentLineType.Equals(LogLineType.WorkUnitRunning))
{
AddWorkUnitResult((WorkUnitResult)logLine.LineData);
}
_currentLineType = logLine.LineType;
}
private void AddInternal(string line)
{
LogLineType lineType = LogLineIdentifier.GetLogLineType(line, FahLogType);
var logLine = new LogLine {
LineRaw = line, LineType = lineType, LineIndex = _lineIndex
};
LogLineParser.SetLogLineParser(logLine, FahLogType);
AddLogLine(logLine);
_lineIndex++;
}
protected override void HandleWorkUnitWorking(LogLine logLine)
{
// This first check allows us to overlook the "+ Working ..." message
// that gets written after a client is Paused. We don't want to key
// work unit positions based on this log entry.
if (_currentLineType.Equals(LogLineType.WorkUnitPaused))
{
// Return to a Running state
_currentLineType = LogLineType.WorkUnitRunning;
}
else
{
_unitIndexData.WorkingIndex = logLine.LineIndex;
_currentLineType = logLine.LineType;
}
}
private void HandleWorkUnitProcessing(LogLine logLine)
{
// If we have not found a ProcessingIndex (== -1) then set it.
// Othwerwise, if ProcessingIndex (!= -1) and a CoreDownloadIndex
// has been observerd and is greater than the current ProcessingIndex,
// then update the ProcessingIndex to bypass the CoreDownload section
// of the log file.
if (_unitIndexData.ProcessingIndex == -1 ||
(_unitIndexData.ProcessingIndex != -1 &&
_unitIndexData.CoreDownloadIndex > _unitIndexData.ProcessingIndex))
{
_unitIndexData.ProcessingIndex = logLine.LineIndex;
}
_currentLineType = logLine.LineType;
}
private void HandleLogHeader(LogLine logLine)
{
// If the last line observed was a LogOpen or a LogHeader, return
// and don't use this as a signal to add a new ClientRun.
if (_currentLineType == LogLineType.LogOpen ||
_currentLineType == LogLineType.LogHeader)
{
return;
}
// Otherwise, if we see a LogHeader and the preceeding line was not
// a LogOpen or a LogHeader, then we use this as a signal to create
// a new ClientRun. This is a backup option and I don't expect this
// situtation to happen at all if the log file is not corrupt.
EnsureSlotRunExists(logLine.LineIndex, FoldingSlot, true);
_currentLineType = logLine.LineType;
}
protected override void HandleLogHeader(LogLine logLine)
{
base.HandleLogHeader(logLine);
// If the last line observed was a LogOpen or a LogHeader, return
// and don't use this as a signal to add a new ClientRun.
if (_currentLineType.Equals(LogLineType.LogOpen) ||
_currentLineType.Equals(LogLineType.LogHeader))
{
return;
}
// Otherwise, if we see a LogHeader and the preceeding line was not
// a LogOpen or a LogHeader, then we use this as a signal to create
// a new ClientRun. This is a backup option and I don't expect this
// situtation to happen at all if the log file is not corrupt.
Add(new ClientRun(logLine.LineIndex));
_currentLineType = logLine.LineType;
}
protected override void HandleWorkUnitRunning(LogLine logLine)
{
if (CurrentClientRun == null)
{
Add(new ClientRun(logLine.LineIndex));
}
Debug.Assert(CurrentClientRun != null);
// If we've already seen a WorkUnitRunning line, ignore this one.);
if (_currentLineType.Equals(LogLineType.WorkUnitRunning))
{
return;
}
// Not Checking the Queue Slot - we don't care if we found a valid slot or not
if (_unitIndexData.ProcessingIndex > -1)
{
CurrentClientRun.UnitIndexes.Add(new UnitIndex(_unitIndexData.QueueSlotIndex, _unitIndexData.ProcessingIndex));
}
else if (_unitIndexData.WorkingIndex > -1)
{
CurrentClientRun.UnitIndexes.Add(new UnitIndex(_unitIndexData.QueueSlotIndex, _unitIndexData.WorkingIndex));
}
else if (_unitIndexData.StartIndex > -1)
{
CurrentClientRun.UnitIndexes.Add(new UnitIndex(_unitIndexData.QueueSlotIndex, _unitIndexData.StartIndex));
}
else
{
CurrentClientRun.UnitIndexes.Add(new UnitIndex(_unitIndexData.QueueSlotIndex, logLine.LineIndex));
}
_currentLineType = logLine.LineType;
// Re-initialize Values
_unitIndexData.Initialize();
}
protected override void HandleLogOpen(LogLine logLine)
{
base.HandleLogOpen(logLine);
_currentLineType = logLine.LineType;
}
public ClientRunListLegacy()
{
_currentLineType = LogLineType.Unknown;
}
protected override void HandleWorkUnitPaused(LogLine logLine)
{
base.HandleWorkUnitPaused(logLine);
_currentLineType = logLine.LineType;
}
protected override void HandleWorkUnitStart(LogLine logLine)
{
_unitIndexData.StartIndex = logLine.LineIndex;
_currentLineType = logLine.LineType;
}
/// <summary>
/// Inspect the given raw log line and determine the line type.
/// </summary>
/// <param name="logLine">The raw log line being inspected.</param>
protected override LogLineType DetermineLineType(string logLine)
{
LogLineType baseLineType = base.DetermineLineType(logLine);
if (!baseLineType.Equals(LogLineType.Unknown))
{
return(baseLineType);
}
if (logLine.Contains("--- Opening Log file"))
{
return(LogLineType.LogOpen);
}
if (logLine.Contains("###############################################################################"))
{
return(LogLineType.LogHeader);
}
if (logLine.Contains("Folding@Home Client Version"))
{
return(LogLineType.ClientVersion);
}
if (logLine.Contains("] Sending work to server"))
{
return(LogLineType.ClientSendWorkToServer);
}
if (logLine.Contains("] - Autosending finished units..."))
{
return(LogLineType.ClientAutosendStart);
}
if (logLine.Contains("] - Autosend completed"))
{
return(LogLineType.ClientAutosendComplete);
}
if (logLine.Contains("] + Attempting to send results"))
{
return(LogLineType.ClientSendStart);
}
if (logLine.Contains("] + Could not connect to Work Server"))
{
return(LogLineType.ClientSendConnectFailed);
}
if (logLine.Contains("] - Error: Could not transmit unit"))
{
return(LogLineType.ClientSendFailed);
}
if (logLine.Contains("] + Results successfully sent"))
{
return(LogLineType.ClientSendComplete);
}
if (logLine.Contains("Arguments:"))
{
return(LogLineType.ClientArguments);
}
if (logLine.Contains("] - User name:"))
{
return(LogLineType.ClientUserNameTeam);
}
if (logLine.Contains("] + Requesting User ID from server"))
{
return(LogLineType.ClientRequestingUserID);
}
if (logLine.Contains("- Received User ID ="))
{
return(LogLineType.ClientReceivedUserID);
}
if (logLine.Contains("] - User ID:"))
{
return(LogLineType.ClientUserID);
}
if (logLine.Contains("] - Machine ID:"))
{
return(LogLineType.ClientMachineID);
}
if (logLine.Contains("] + Attempting to get work packet"))
{
return(LogLineType.ClientAttemptGetWorkPacket);
}
if (logLine.Contains("] - Will indicate memory of"))
{
return(LogLineType.ClientIndicateMemory);
}
if (logLine.Contains("] - Detect CPU. Vendor:"))
{
return(LogLineType.ClientDetectCpu);
}
if (logLine.Contains("] + Processing work unit"))
{
return(LogLineType.WorkUnitProcessing);
}
if (logLine.Contains("] + Downloading new core"))
{
return(LogLineType.WorkUnitCoreDownload);
}
if (logLine.Contains("] Working on Unit 0"))
{
return(LogLineType.WorkUnitIndex);
}
if (logLine.Contains("] Working on queue slot 0"))
{
return(LogLineType.WorkUnitQueueIndex);
}
if (logLine.Contains("] + Working ..."))
{
return(LogLineType.WorkUnitWorking);
}
if (logLine.Contains("] - Calling"))
{
return(LogLineType.WorkUnitCallingCore);
}
if (logLine.Contains("] *------------------------------*"))
{
return(LogLineType.WorkUnitStart);
}
/*** ProtoMol Only */
if (logLine.Contains("] ************************** ProtoMol Folding@Home Core **************************"))
{
return(LogLineType.WorkUnitStart);
}
/*******************/
if (logLine.Contains("] Version"))
{
return(LogLineType.WorkUnitCoreVersion);
}
/*** ProtoMol Only */
if (logLine.Contains("] Version:"))
{
return(LogLineType.WorkUnitCoreVersion);
}
/*******************/
if (logLine.Contains("] Project:"))
{
return(LogLineType.WorkUnitProject);
}
if (logLine.Contains("] Completed "))
{
return(LogLineType.WorkUnitFrame);
}
if (logLine.Contains("] + Paused"))
{
return(LogLineType.WorkUnitPaused);
}
if (logLine.Contains("] + Running on battery power"))
{
return(LogLineType.WorkUnitPausedForBattery);
}
if (logLine.Contains("] + Off battery, restarting core"))
{
return(LogLineType.WorkUnitResumeFromBattery);
}
if (logLine.Contains("] - Shutting down core"))
{
return(LogLineType.WorkUnitShuttingDownCore);
}
if (logLine.Contains("] Folding@home Core Shutdown:"))
{
return(LogLineType.WorkUnitCoreShutdown);
}
if (logLine.Contains("] + Number of Units Completed:"))
{
return(LogLineType.ClientNumberOfUnitsCompleted);
}
if (logLine.Contains("] Client-core communications error:"))
{
return(LogLineType.ClientCoreCommunicationsError);
}
if (logLine.Contains("] This is a sign of more serious problems, shutting down."))
{
//TODO: No unit test coverage - need test log that contains this string
return(LogLineType.ClientCoreCommunicationsErrorShutdown);
}
if (logLine.Contains("] EUE limit exceeded. Pausing 24 hours."))
{
return(LogLineType.ClientEuePauseState);
}
if (logLine.Contains("Folding@Home will go to sleep for 1 day"))
{
return(LogLineType.ClientEuePauseState);
}
if (logLine.Contains("Folding@Home Client Shutdown"))
{
return(LogLineType.ClientShutdown);
}
return(LogLineType.Unknown);
}
private void HandleWorkUnitPaused(LogLine logLine)
{
_currentLineType = logLine.LineType;
}
private void HandleWorkUnitCoreDownload(LogLine logLine)
{
_unitIndexData.CoreDownloadIndex = logLine.LineIndex;
_currentLineType = logLine.LineType;
}
private void HandleWorkUnitStart(LogLine logLine)
{
_unitIndexData.StartIndex = logLine.LineIndex;
_currentLineType = logLine.LineType;
}
/// <summary>
/// Inspect the given raw log line and determine the line type.
/// </summary>
/// <param name="logLine">The raw log line being inspected.</param>
protected override LogLineType DetermineLineType(string logLine)
{
LogLineType baseLineType = base.DetermineLineType(logLine);
if (!baseLineType.Equals(LogLineType.Unknown))
{
return(baseLineType);
}
if (logLine.Contains("*********************** Log Started"))
{
return(LogLineType.LogOpen);
}
if (logLine.Contains(":Sending unit results:"))
{
return(LogLineType.ClientSendWorkToServer);
}
if (logLine.Contains(": Uploading"))
{
return(LogLineType.ClientSendStart);
}
if (logLine.Contains(": Upload complete"))
{
return(LogLineType.ClientSendComplete);
}
if (logLine.Contains(":Requesting new work unit for slot"))
{
return(LogLineType.ClientAttemptGetWorkPacket);
}
if (logLine.Trim().EndsWith(":Starting"))
{
return(LogLineType.WorkUnitWorking);
}
/*** Appears to be for v7.1.38 and previous only ***/
if (logLine.Contains(":Starting Unit"))
{
return(LogLineType.WorkUnitWorking);
}
/***************************************************/
if (logLine.Contains(":*------------------------------*"))
{
return(LogLineType.WorkUnitStart);
}
if (logLine.Contains(":Version"))
{
return(LogLineType.WorkUnitCoreVersion);
}
if (logLine.Contains(":Project:"))
{
return(LogLineType.WorkUnitProject);
}
if (logLine.Contains(":Completed "))
{
return(LogLineType.WorkUnitFrame);
}
if (logLine.Contains(":- Shutting down core"))
{
return(LogLineType.WorkUnitShuttingDownCore);
}
if (logLine.Contains(":Folding@home Core Shutdown:"))
{
return(LogLineType.WorkUnitCoreShutdown);
}
if (Regex.IsMatch(logLine, "FahCore returned: "))
{
return(LogLineType.WorkUnitCoreReturn);
}
/*** Appears to be for v7.1.38 and previous only ***/
if (Regex.IsMatch(logLine, "FahCore, running Unit \\d{2}, returned: "))
{
return(LogLineType.WorkUnitCoreReturn);
}
/***************************************************/
if (logLine.Contains(":Cleaning up"))
{
return(LogLineType.WorkUnitCleaningUp);
}
/*** Appears to be for v7.1.38 and previous only ***/
if (logLine.Contains(":Cleaning up Unit"))
{
return(LogLineType.WorkUnitCleaningUp);
}
/***************************************************/
return(LogLineType.Unknown);
}
private void HandleLogOpen(LogLine logLine)
{
EnsureSlotRunExists(logLine.LineIndex, FoldingSlot, true);
_currentLineType = logLine.LineType;
}
