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; }