/// <summary> /// Show a status message at the console and optionally include in the log file /// </summary> /// <param name="statusMessage">Status message</param> /// <param name="isError">True if this is an error</param> /// <param name="writeToLog">True to write to the log file; false to only display at console</param> public static void LogMessage(string statusMessage, bool isError = false, bool writeToLog = true) { if (writeToLog) { if (isError) { LogTools.LogError(statusMessage); } else { LogTools.LogMessage(statusMessage); } } else { if (isError) { ConsoleMsgUtils.ShowErrorCustom(statusMessage, false); } else { Console.WriteLine(statusMessage); } } }
/// <summary> /// The main entry point for the application. /// </summary> private static void Main() { // Start the main program running try { if (mMainProcess == null) { mMainProcess = new MainProgram(); if (!mMainProcess.InitMgr()) { PRISM.Logging.FileLogger.FlushPendingMessages(); return; } mMainProcess.DoDirectoryCreation(); } } catch (Exception ex) { var errMsg = "Critical exception starting application: " + ex.Message; ConsoleMsgUtils.ShowWarning(errMsg + "; " + StackTraceFormatter.GetExceptionStackTrace(ex)); ConsoleMsgUtils.ShowWarning("Exiting clsMainProcess.Main with error code = 1"); } PRISM.Logging.FileLogger.FlushPendingMessages(); }
/// <summary> /// Show a status message at the console and optionally include in the log file /// </summary> /// <param name="statusMessage">Status message</param> /// <param name="isError">True if this is an error</param> /// <param name="writeToLog">True to write to the log file; false to only display at console</param> public static void LogMessage(string statusMessage, bool isError = false, bool writeToLog = true) { if (isError) { ConsoleMsgUtils.ShowErrorCustom(statusMessage, false); } else { Console.WriteLine(statusMessage); } if (!writeToLog) { return; } try { if (isError) { WriteLog(LoggerTypes.LogFile, BaseLogger.LogLevels.ERROR, statusMessage); } else { WriteLog(LoggerTypes.LogFile, BaseLogger.LogLevels.INFO, statusMessage); } } catch (Exception ex) { ErrorWritingToLog(statusMessage, ex); } }
public MsScan(int scanNumber, XRawFileIO reader) { ScanNumber = scanNumber; if (!reader.GetScanInfo(scanNumber, out var scanInfo)) { ConsoleMsgUtils.ShowWarning("Scan {0} not found in {1}", scanNumber, Path.GetFileName(reader.RawFilePath)); return; } // Get centroided data var dataPointCount = GetScanData(reader, scanInfo, out var mzList, out var intensityList); MsLevel = scanInfo.MSLevel; PeaksCount = dataPointCount; switch (scanInfo.IonMode) { case IonModeConstants.Positive: Polarity = "+"; break; case IonModeConstants.Negative: Polarity = "-"; break; case IonModeConstants.Unknown: Polarity = string.Empty; break; } FilterLine = scanInfo.FilterText; ScanType = GetScanType(); RetentionTime = "PT" + Math.Round(scanInfo.RetentionTime * 60, 8) + "S"; TotIonCurrent = scanInfo.TotalIonCurrent; string encodedPeaks; if (PeaksCount == 0) { LowMz = 0; HighMz = 0; BasePeakMz = 0; BasePeakIntensity = 0; encodedPeaks = Base64EncodeMsData(mzList, intensityList); } else { LowMz = mzList.Min(); HighMz = mzList.Max(); BasePeakMz = scanInfo.BasePeakMZ; BasePeakIntensity = scanInfo.BasePeakIntensity; encodedPeaks = Base64EncodeMsData(mzList, intensityList); } PeakData = new Peaks(32, "network", "m/z-int", "none", 0, encodedPeaks); }
private static void ShowGUI() { Application.EnableVisualStyles(); Application.DoEvents(); try { var handle = GetConsoleWindow(); if (!mDebugMode) { // Hide the console ShowWindow(handle, SW_HIDE); } var objFormMain = new GUI() { KeepDB = mKeepDB }; objFormMain.ShowDialog(); if (!mDebugMode) { // Show the console ShowWindow(handle, SW_SHOW); } } catch (Exception ex) { ConsoleMsgUtils.ShowWarning("Error in ShowGUI: " + ex.Message); ConsoleMsgUtils.ShowWarning(StackTraceFormatter.GetExceptionStackTraceMultiLine(ex)); MessageBox.Show("Error in ShowGUI: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } }
private static void ProgressSubtaskChangedHandler() { #if GUI if (mProgressForm != null) { mProgressForm.UpdateCurrentSubTask(mMASIC.SubtaskDescription); mProgressForm.UpdateSubtaskProgressBar(mMASIC.SubtaskProgressPercentComplete); if (mProgressForm.KeyPressAbortProcess) { mMASIC.AbortProcessingNow(); } Application.DoEvents(); return; } #endif if (DateTime.UtcNow.Subtract(mLastSubtaskProgressTime).TotalSeconds < 10) { return; } mLastSubtaskProgressTime = DateTime.UtcNow; ConsoleMsgUtils.ShowDebug("{0}: {1}%", mMASIC.SubtaskDescription, mMASIC.SubtaskProgressPercentComplete); }
/// <summary> /// Find the best candidate folder with Python 3.x /// </summary> /// <returns>True if Python could be found, otherwise false</returns> protected static bool FindPython() { if (!string.IsNullOrWhiteSpace(PythonPath)) { return(true); } if (SystemInfo.IsLinux) { PythonPath = "/usr/bin/python3"; ConsoleMsgUtils.ShowDebug("Assuming Python 3 is at {0}", PythonPath); return(true); } foreach (var directoryPath in PythonPathsToCheck()) { var exePath = FindPythonExe(directoryPath); if (string.IsNullOrWhiteSpace(exePath)) { continue; } PythonPath = exePath; break; } return(!string.IsNullOrWhiteSpace(PythonPath)); }
/// <summary> /// Lookup the base name and dataset ID for the given dataset name /// </summary> /// <param name="baseNameByDatasetName"></param> /// <param name="datasetIDs"></param> /// <param name="datasetName"></param> /// <param name="baseDatasetName">Output: base dataset name, or empty string if not found</param> /// <param name="datasetID">Output: dataset ID, or 0 if not found</param> protected void GetBaseNameAndDatasetID( Dictionary <string, string> baseNameByDatasetName, Dictionary <string, int> datasetIDs, string datasetName, out string baseDatasetName, out int datasetID) { if (string.IsNullOrWhiteSpace(datasetName)) { baseDatasetName = string.Empty; datasetID = 0; return; } if (!baseNameByDatasetName.TryGetValue(datasetName, out baseDatasetName)) { ConsoleMsgUtils.ShowDebug( "The baseNameByDatasetName dictionary does not contain key {0}; this is unexpected", datasetName); } if (!datasetIDs.TryGetValue(datasetName, out datasetID)) { datasetID = 0; } }
private static int ProcessSQLiteDB(FileInfo fiSourceFile, string sourceTableName) { try { var runner = new Runner { ShowProgressAtConsole = true }; RegisterEvents(runner); var success = runner.ProcessSQLite(fiSourceFile.DirectoryName, fiSourceFile.Name, sourceTableName); if (success) { Console.WriteLine(); Console.WriteLine("Processing complete"); ProgRunner.SleepMilliseconds(750); return(0); } ConsoleMsgUtils.ShowWarning("Error computing protein parsimony: RunAlgorithm reports false"); ProgRunner.SleepMilliseconds(1500); return(-3); } catch (Exception ex) { ConsoleMsgUtils.ShowError("Error computing protein parsimony", ex); ProgRunner.SleepMilliseconds(1500); return(-2); } }
static int Main(string[] args) { var appName = System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name; var exeName = Path.GetFileName(PRISM.FileProcessor.ProcessFilesOrDirectoriesBase.GetAppPath()); var parser = new CommandLineParser <CommandLineOptions>(appName, PRISM.FileProcessor.ProcessFilesOrDirectoriesBase.GetAppVersion(PROGRAM_DATE)) { ProgramInfo = ConsoleMsgUtils.WrapParagraph( "This program contacts DMS to retrieve a list of Bionet computers (hosts). " + "It pings each computer to see which respond, then optionally contacts DMS with the list of active hosts.") + Environment.NewLine + Environment.NewLine + ConsoleMsgUtils.WrapParagraph( "By default, it contacts DMS to retrieve the list of bionet hosts, then pings each one (appending suffix .bionet)." + "Alternatively, use /Manual to define a list of hosts to contact (.bionet is not auto-appended). " + "Or use /File to specify a text file listing one host per line (.bionet is not auto-appended)." + "The /File switch is useful when used in conjunction with script Export_DNS_Entries.ps1, " + "which can be run daily via a scheduled task to export all hosts and IP addresses " + "tracked by the bionet DNS server (Gigasax).") + Environment.NewLine + Environment.NewLine + ConsoleMsgUtils.WrapParagraph( "When using /File, this program will still contact DMS to determine which hosts are inactive, " + "and it will skip those hosts. Use /HideInactive to not see the names of the skipped hosts"), ContactInfo = "Program written by Matthew Monroe for the Department of Energy (PNNL, Richland, WA)" + Environment.NewLine + "E-mail: [email protected] or [email protected]" + Environment.NewLine + "Website: https://github.com/PNNL-Comp-Mass-Spec/ or https://panomics.pnnl.gov/ or https://www.pnnl.gov/integrative-omics" }; parser.UsageExamples.Add( "Program syntax:" + Environment.NewLine + exeName + Environment.NewLine + " [/Manual:Host1,Host2,Host3] [/File:HostListFile] [/HideInactive]" + Environment.NewLine + " [/Simulate] [/DB] [/DBAdd] [/NoDB]"); var result = parser.ParseArgs(args); mOptions = result.ParsedResults; // Running with no command-line arguments specified is valid. if (args.Length > 0 && !result.Success) { if (parser.CreateParamFileProvided) { return(0); } // Delay for 750 msec in case the user double clicked this file from within Windows Explorer (or started the program via a shortcut) System.Threading.Thread.Sleep(750); return(-1); } try { PingBionetComputers(mOptions.HostNameFile, mOptions.HostOverrideList); return(0); } catch (Exception ex) { ShowErrorMessage("Error occurred in Program->Main", ex); return(-1); } }
private static void ShowWarning(string message) { Console.WriteLine(); var msg = "Warning: " + message; ConsoleMsgUtils.ShowWarning(msg); mLogFile?.WriteLine(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss tt") + "\t" + msg); }
private void WarnOnce(WriteWarnings code, string message) { if (warningTracker.Contains(code)) { return; } warningTracker.Add(code); ConsoleMsgUtils.ShowWarning(string.Format("WARNING: {0}!", message)); }
/// <summary> /// Report an important error /// </summary> /// <param name="message"></param> private void OnCriticalErrorEvent(string message) { if (CriticalErrorEvent == null && WriteToConsoleIfNoListener) { ConsoleMsgUtils.ShowError(message, false, false, EmptyLinesBeforeErrorMessages); } CriticalErrorEvent?.Invoke(message, null); }
/// <summary> /// Validate the options /// </summary> /// <returns>True if all options are valid</returns> /// <remarks>This method is called from Program.cs</remarks> // ReSharper disable once UnusedMember.Global public bool Validate() { if (string.IsNullOrWhiteSpace(InputFilePathSpec)) { ConsoleMsgUtils.ShowWarning("Error: Input file spec must be provided and non-empty, for example *.tsv"); return(false); } return(true); }
public bool Validate() { if (string.IsNullOrWhiteSpace(InputDataFilePath)) { ConsoleMsgUtils.ShowError($"ERROR: Input path must be provided and non-empty; \"{InputDataFilePath}\" was provided."); return(false); } return(true); }
private static void ValidateLoaderByPath() { if (string.IsNullOrWhiteSpace(PwizPath)) { var message = CannotFindExceptionMessage(); ConsoleMsgUtils.ShowError(message); throw new TypeLoadException(message); } }
private static void PeptideHitResultsProcRunner_WarningEvent(string message) { if (message.StartsWith("Warning", StringComparison.OrdinalIgnoreCase)) { ConsoleMsgUtils.ShowWarning(message); } else { ConsoleMsgUtils.ShowWarning("Warning: " + message); } }
private static void AssureDirectoryExists(DirectoryInfo directoryInfo) { if (directoryInfo == null || directoryInfo.Exists) { return; } ConsoleMsgUtils.ShowWarning("Creating missing directory: " + directoryInfo.FullName); directoryInfo.Create(); Console.WriteLine(); }
private void PeptideToProteinMapper_ProgressUpdate(string progressMessage, float percentComplete) { if (DateTime.UtcNow.Subtract(mLastProgressTime).TotalSeconds < 1) { return; } mLastProgressTime = DateTime.UtcNow; ConsoleMsgUtils.ShowDebug("Peptide to protein mapper is {0:F1}% complete: {1}", percentComplete, progressMessage); }
private void StoreKey(int linesRead, string sectionName, IDictionary <string, string> sectionInfo, string key, string value) { if (sectionInfo.ContainsKey(key)) { ConsoleMsgUtils.ShowWarning( "Line {0} has a duplicate key named {1} in section {2}; ignoring duplicate value {3}", linesRead, key, sectionName, value); } sectionInfo.Add(key, value); }
private void Parse() { _rows.Clear(); _data.Clear(); _header.Clear(); var headerParsed = false; using (var reader = new StreamReader(new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { while (!reader.EndOfStream) { var line = reader.ReadLine(); if (string.IsNullOrWhiteSpace(line)) { continue; } var token = line.Split(_delimeter); if (!headerParsed) { for (var i = 0; i < token.Length; i++) { if (_data.ContainsKey(token[i])) { ConsoleMsgUtils.ShowWarning("Warning: header line has duplicate column names; ignoring duplicate " + token[i]); continue; } _header.Add(i, token[i]); _data[token[i]] = new List <string>(); } headerParsed = true; continue; } if (token.Length > _header.Count) { continue; } for (var i = 0; i < token.Length; i++) { if (!_header.ContainsKey(i)) { continue; } _data[_header[i]].Add(token[i]); } _rows.Add(line); } } }
private static void ShowProgramHelp() { try { Console.WriteLine(ConsoleMsgUtils.WrapParagraph( "This program can be used to split apart a protein FASTA file into a number of sections. " + "Although the splitting is random, each section will have a nearly identical number of residues.")); Console.WriteLine(); Console.WriteLine("Program syntax:"); Console.WriteLine(Path.GetFileName(ProcessFilesOrDirectoriesBase.GetAppPath()) + " /I:SourceFastaFile [/O:OutputDirectoryPath]"); Console.WriteLine(" [/N:SplitCount] [/MB:TargetSizeMB] [/P:ParameterFilePath] "); Console.WriteLine(" [/S:[MaxLevel]] [/A:AlternateOutputDirectoryPath] [/R] [/L]"); Console.WriteLine(); Console.WriteLine(ConsoleMsgUtils.WrapParagraph( "The input file path can contain the wildcard character * and should point to a FASTA file. " + "The output directory switch is optional. " + "If omitted, the output file will be created in the same directory as the input file.")); Console.WriteLine(); Console.WriteLine("Use /N to define the number of parts to split the input file into."); Console.WriteLine("For example, /N:10 will split the input FASTA file into 10 parts"); Console.WriteLine(); Console.WriteLine("Alternatively, use /MB to specify the size of the split FASTA files, in MB (minimum {0} MB)", SplitterOptions.MINIMUM_TARGET_FILE_SIZE_MB); Console.WriteLine("For example, /MB:100 will create separate FASTA files that are each ~100 MB in size"); Console.WriteLine(); Console.WriteLine("If both /N and /MB are specified, /N will be ignored"); Console.WriteLine(); Console.WriteLine(ConsoleMsgUtils.WrapParagraph( "The parameter file path is optional. " + "If included, it should point to a valid XML parameter file.")); Console.WriteLine(); Console.WriteLine(ConsoleMsgUtils.WrapParagraph( "Use /S to process all valid files in the input directory and subdirectories. " + "Include a number after /S (like /S:2) to limit the level of subdirectories to examine. " + "When using /S, you can redirect the output of the results using /A. " + "When using /S, you can use /R to re-create the input directory hierarchy in the alternate output directory (if defined).")); Console.WriteLine("Use /L to log messages to a file."); Console.WriteLine(); Console.WriteLine("Program written by Matthew Monroe for the Department of Energy (PNNL, Richland, WA) in 2010"); Console.WriteLine("Version: " + GetAppVersion()); Console.WriteLine(); Console.WriteLine("E-mail: [email protected] or [email protected]"); Console.WriteLine("Website: https://omics.pnl.gov/ or https://panomics.pnnl.gov/"); Console.WriteLine(); // Delay for 750 msec in case the user double clicked this file from within Windows Explorer (or started the program via a shortcut) Thread.Sleep(750); } catch (Exception ex) { Console.WriteLine("Error displaying the program syntax: " + ex.Message); } }
private bool ReadAnnoFile() { _offsetList = new List <long>(); _nameToLength = new Dictionary <string, int>(); _names = new Dictionary <long, string>(); _descriptions = new Dictionary <long, string>(); _nameToOffset = new Dictionary <string, long>(); _duplicateNameCounts = new Dictionary <string, int>(); using (var reader = new StreamReader(_annoFilePath)) { string s; while ((s = reader.ReadLine()) != null) { var token = s.Split(FastaDatabaseConstants.AnnotationDelimiter); if (token.Length < 4) { break; } var offset = long.Parse(token[0]); _offsetList.Add(offset); var length = int.Parse(token[1]); var name = token[2]; if (_nameToLength.TryGetValue(name, out _)) { ConsoleMsgUtils.ShowWarning(string.Format( "Duplicate protein name, renaming {0} at offset {1} in {2} to avoid collisions", name, offset, Path.GetFileName(_annoFilePath))); if (_duplicateNameCounts.TryGetValue(name, out var duplicateSuffix)) { duplicateSuffix++; _duplicateNameCounts[name] = duplicateSuffix; } else { duplicateSuffix = 1; _duplicateNameCounts.Add(name, duplicateSuffix); } name += "_Duplicate" + duplicateSuffix.ToString("00"); } _nameToLength.Add(name, length); _names.Add(offset, name); _nameToOffset.Add(name, offset); _descriptions.Add(offset, token[3]); } } return(true); }
private static void ShowProgramHelp() { var exePath = PRISM.FileProcessor.ProcessFilesOrDirectoriesBase.GetAppPath(); Console.WriteLine("Program syntax:" + Environment.NewLine + Path.GetFileName(exePath)); Console.WriteLine(" InputFilePath.raw [/GetFilters] [/Centroid] [/Sum] [/Start:Scan] [/End:Scan]"); Console.WriteLine(" [/ScanInfo:IntervalScans] [/NoScanData] [/NoScanEvents] [/NoCE]"); Console.WriteLine(" [/NoMethods] [/MSLevelOnly] [/Trace]"); Console.WriteLine(); Console.WriteLine(ConsoleMsgUtils.WrapParagraph( "Running this program without any parameters it will process file " + DEFAULT_FILE_PATH)); Console.WriteLine(); Console.WriteLine("The first parameter specifies the file to read"); Console.WriteLine(); Console.WriteLine(ConsoleMsgUtils.WrapParagraph( "Use /GetFilters to compile and display a list of scan filters in any MASIC _ScanStatsEx.txt files in the working directory")); Console.WriteLine(); Console.WriteLine("Without /GetFilters, data is read from the file, either from all scans, or a scan range"); Console.WriteLine("Use /Start and /End to limit the scan range to process"); Console.WriteLine("If /Start and /End are not provided, will read every 21 scans"); Console.WriteLine(); Console.WriteLine("Use /Centroid to centroid the data when reading"); Console.WriteLine(ConsoleMsgUtils.WrapParagraph( "Use /Sum to test summing the data across 15 scans " + "(each spectrum will be shown twice; once with summing and once without)")); Console.WriteLine(); Console.WriteLine("While reading data, the scan number and elution time is displayed for each scan."); Console.WriteLine("To show this info every 5 scans, use /ScanInfo:5"); Console.WriteLine(); Console.WriteLine("Use /NoScanData to skip loading any scan data"); Console.WriteLine("Use /NoScanEvents to skip loading any scan events"); Console.WriteLine("Use /NoCE to skip trying to determine collision energies"); Console.WriteLine("Use /NoMethods to skip loading instrument methods"); Console.WriteLine(); Console.WriteLine("Use /MSLevelOnly to only load MS levels using GetMSLevel"); Console.WriteLine("Use /TestFilters to test the parsing of a set of standard scan filters"); Console.WriteLine(); Console.WriteLine("Use /Trace to display additional debug messages"); Console.WriteLine(); Console.WriteLine("Program written by Matthew Monroe for the Department of Energy (PNNL, Richland, WA) in 2012"); Console.WriteLine("Version: " + GetAppVersion()); Console.WriteLine(); Console.WriteLine("E-mail: [email protected] or [email protected]"); Console.WriteLine("Website: https://omics.pnl.gov or https://panomics.pnnl.gov/"); Console.WriteLine(); // Delay for 1.5 seconds in case the user double clicked this file from within Windows Explorer (or started the program via a shortcut) System.Threading.Thread.Sleep(1500); }
private static void ShowError(string message, Exception ex = null) { Console.WriteLine(); var msg = "Error: " + message; ConsoleMsgUtils.ShowError(msg, ex); mLogFile?.WriteLine(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss tt") + "\t" + msg); if (ex != null) { mLogFile?.WriteLine(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss tt") + "\t" + StackTraceFormatter.GetExceptionStackTrace(ex)); } }
/// <summary> /// Log a message to the local, generic log file /// </summary> /// <param name="logMessage"></param> /// <param name="localLogFilePath"></param> /// <remarks>Used to log errors and warnings when the standard log file (or database) cannot be written to</remarks> protected static void LogLocalMessage(LogMessage logMessage, string localLogFilePath = "FileLoggerErrors.txt") { switch (logMessage.LogLevel) { case LogLevels.DEBUG: ConsoleMsgUtils.ShowDebug(logMessage.Message); break; case LogLevels.WARN: ConsoleMsgUtils.ShowWarning(logMessage.Message); break; case LogLevels.ERROR: case LogLevels.FATAL: ConsoleMsgUtils.ShowError(logMessage.Message); break; default: Console.WriteLine(logMessage.Message); break; } if (string.IsNullOrWhiteSpace(localLogFilePath)) { localLogFilePath = "FileLoggerErrors.txt"; } try { var localLogFile = new FileInfo(localLogFilePath); localLogFilePath = localLogFile.FullName; using (var localLogWriter = new StreamWriter(new FileStream(localLogFile.FullName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite))) { localLogWriter.WriteLine(logMessage.GetFormattedMessage(TimestampFormat)); } } catch (Exception ex) { if (!mLocalLogFileAccessError) { mLocalLogFileAccessError = true; ConsoleMsgUtils.ShowError("Error writing to the local log file: " + localLogFilePath); } ConsoleMsgUtils.ShowErrorCustom( string.Format("Error writing '{0}' to the local log file: {1}", logMessage.GetFormattedMessage(TimestampFormat), ex), false, false); } }
/// <summary> /// Look for the mzML CacheInfo file /// If it exists, determine the path of the .mzML.gz file that it points to and verify that the file exists /// </summary> /// <param name="baseOutputFilePath"></param> /// <param name="cachedMzMLFile"></param> /// <param name="cacheInfoFileName"></param> /// <returns>True if the CacheInfo file was found and the .mzML.gz file was successfully retrieved; otherwise false</returns> private bool ResolveCachedMzMLFile(string baseOutputFilePath, out FileInfo cachedMzMLFile, out string cacheInfoFileName) { cacheInfoFileName = baseOutputFilePath + ".mzML.gz_CacheInfo.txt"; try { var cacheInfoFile = new FileInfo(cacheInfoFileName); if (!cacheInfoFile.Exists) { cachedMzMLFile = null; return(false); } string cachedMzMLFilePath; using (var reader = new StreamReader(new FileStream(cacheInfoFile.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { if (reader.EndOfStream) { cachedMzMLFilePath = string.Empty; } else { cachedMzMLFilePath = reader.ReadLine(); } } if (string.IsNullOrWhiteSpace(cachedMzMLFilePath)) { cachedMzMLFile = null; return(false); } cachedMzMLFile = new FileInfo(cachedMzMLFilePath); if (cachedMzMLFile.Exists) { return(true); } ConsoleMsgUtils.ShowWarning("Cached .mzML.gz file specified by {0} not found;\n" + "Cannot use: {1}", cacheInfoFile.Name, cachedMzMLFilePath); cachedMzMLFile = null; return(false); } catch (Exception ex) { ConsoleMsgUtils.ShowError("Error looking for the fixed mzML file using the CacheInfo file", ex); cachedMzMLFile = null; return(false); } }
/// <summary> /// Display a warning message at the console and write to the log file /// </summary> /// <param name="warningMessage">Warning message</param> /// <param name="logToDatabase">When true, log to the database (and to the file)</param> public static void LogWarning(string warningMessage, bool logToDatabase = false) { ConsoleMsgUtils.ShowWarning(warningMessage); try { var logType = logToDatabase ? LoggerTypes.LogDb : LoggerTypes.LogFile; WriteLog(logType, BaseLogger.LogLevels.WARN, warningMessage); } catch (Exception ex) { ErrorWritingToLog(warningMessage, ex); } }
public void TestWrapParagraph(string textToWrap, int wrapWidth, int spaceIndentCount, int expectedLineCount, int expectedCharacterCount) { if (spaceIndentCount > 0) { // Indent all of the wrapped lines by the given amount textToWrap = new string(' ', spaceIndentCount) + textToWrap; } var wrappedText = ConsoleMsgUtils.WrapParagraph(textToWrap, wrapWidth); Console.WriteLine(wrappedText); var wrappedLines = wrappedText.Split('\n'); var charCount = 0; var lineCount = 0; foreach (var textLine in wrappedLines) { charCount += textLine.Length; lineCount++; } Console.WriteLine(); Console.WriteLine("Wrapping to {0} characters per line gives {1} lines of wrapped text and {2} total characters", wrapWidth, lineCount, charCount); if (spaceIndentCount > 0) { Console.WriteLine("Indented text by {0} characters", spaceIndentCount); } if (expectedLineCount > 0) { Assert.AreEqual(expectedLineCount, lineCount, "Text wrapped to {0} lines instead of {1} lines", lineCount, expectedLineCount); } else { Console.WriteLine("Skipped line count validation"); } if (expectedCharacterCount > 0) { Assert.AreEqual(expectedCharacterCount, charCount, "Wrapped text has {0} characters instead of {1} characters", charCount, expectedCharacterCount); } else { Console.WriteLine("Skipped character count validation"); } }
public void TestSleep(int waitTimeSeconds) { var startTime = DateTime.UtcNow; Console.WriteLine("Sleeping for {0} seconds", waitTimeSeconds); ConsoleMsgUtils.SleepSeconds(waitTimeSeconds); var elapsedSeconds = DateTime.UtcNow.Subtract(startTime).TotalSeconds; Console.WriteLine("Done after {0:F3} seconds", elapsedSeconds); Assert.AreEqual(0, Math.Abs(elapsedSeconds - waitTimeSeconds), 0.1, "Did not sleep as long as expected"); }