public VerifyRulesCommand(VerifyRulesCommandOptions opt) { _arg_verify_default_rules = opt.VerifyDefaultRules; _arg_custom_rules_path = opt.CustomRulesPath; _arg_outputFile = opt.OutputFilePath; _arg_consoleVerbosityLevel = opt.ConsoleVerbosityLevel ?? "medium"; _arg_logger = opt.Log; _arg_log_file_path = opt.LogFilePath; _arg_log_level = opt.LogFileLevel; _arg_close_log_on_exit = Utils.CLIExecutionContext ? true : opt.CloseLogOnCommandExit; _rules_path = _arg_verify_default_rules ? Utils.GetPath(Utils.AppPath.defaultRulesSrc) : _arg_custom_rules_path; _arg_logger ??= Utils.SetupLogging(opt); WriteOnce.Log ??= _arg_logger; try { ConfigureConsoleOutput(); ConfigFileOutput(); ConfigRules(); } catch (Exception e) //group error handling { WriteOnce.Error(e.Message); if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } throw; } }
/// <summary> /// Intentional as no identified value in calling from DLL at this time /// </summary> /// <returns></returns> public PackRulesResult GetResult() { WriteOnce.SafeLog("PackRules::Run", LogLevel.Trace); WriteOnce.Operation(MsgHelp.FormatString(MsgHelp.ID.CMD_RUNNING, "Pack Rules")); PackRulesResult packRulesResult = new() { AppVersion = Common.Utils.GetVersionString() }; try { RulesVerifier verifier = new(_rules_path, _options?.Log); if (_options?.PackEmbeddedRules ?? false) { verifier.LoadRuleSet(RuleSetUtils.GetDefaultRuleSet()); } verifier.Verify(); if (!verifier.IsVerified) { throw new OpException(MsgHelp.GetString(MsgHelp.ID.VERIFY_RULES_RESULTS_FAIL)); } packRulesResult.Rules = verifier.CompiledRuleset?.GetAppInspectorRules().ToList() ?? new List <Rule>(); packRulesResult.ResultCode = PackRulesResult.ExitCode.Success; } catch (OpException e) { WriteOnce.Error(e.Message); //caught for CLI callers with final exit msg about checking log or throws for DLL callers throw; } return(packRulesResult); } }
/// <summary> /// Option for DLL use as alternate to Run which only outputs a file to return results as string /// CommandOption defaults will not have been set when used as DLL via CLI processing so some checks added /// </summary> /// <returns>output results</returns> public VerifyRulesResult GetResult() { WriteOnce.SafeLog("VerifyRulesCommand::Run", LogLevel.Trace); WriteOnce.Operation(MsgHelp.FormatString(MsgHelp.ID.CMD_RUNNING, "Verify Rules")); VerifyRulesResult verifyRulesResult = new VerifyRulesResult() { AppVersion = Utils.GetVersionString() }; try { RulesVerifier verifier = new RulesVerifier(_rules_path, _options.Log); verifyRulesResult.ResultCode = VerifyRulesResult.ExitCode.Verified; verifyRulesResult.RuleStatusList = verifier.Verify(); verifyRulesResult.ResultCode = verifier.IsVerified ? VerifyRulesResult.ExitCode.Verified : VerifyRulesResult.ExitCode.NotVerified; } catch (OpException e) { WriteOnce.Error(e.Message); //caught for CLI callers with final exit msg about checking log or throws for DLL callers throw; } return(verifyRulesResult); }
string _arg_fileExclusionList;//see exclusion list public TagDiffCommand(TagDiffCommandOptions opt) { _arg_src1 = opt.SourcePath1; _arg_src2 = opt.SourcePath2; _arg_customRulesPath = opt.CustomRulesPath; _arg_consoleVerbosityLevel = opt.ConsoleVerbosityLevel ?? "medium"; _arg_ignoreDefault = opt.IgnoreDefaultRules; _arg_outputFile = opt.OutputFilePath; _arg_test_type_raw = opt.TestType ?? "Equality"; _arg_logger = opt.Log; _arg_log_file_path = opt.LogFilePath; _arg_close_log_on_exit = Utils.CLIExecutionContext ? true : opt.CloseLogOnCommandExit; _arg_fileExclusionList = opt.FilePathExclusions; _arg_logger ??= Utils.SetupLogging(opt); WriteOnce.Log ??= _arg_logger; try { ConfigureConsoleOutput(); ConfigureCompareType(); ConfigSourceToScan(); } catch (Exception e) //group error handling { WriteOnce.Error(e.Message); if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } throw; } }
/// <summary> /// Intentional as no identified value in calling from DLL at this time /// </summary> /// <returns></returns> public PackRulesResult GetResult() { WriteOnce.SafeLog("PackRules::Run", LogLevel.Trace); WriteOnce.Operation(MsgHelp.FormatString(MsgHelp.ID.CMD_RUNNING, "Pack Rules")); if (!Utils.CLIExecutionContext) { //requires output format and filepath only supported via CLI use WriteOnce.Error("Command not supported for DLL calls"); throw new Exception("Command not supported for DLL calls"); } PackRulesResult packRulesResult = new PackRulesResult() { AppVersion = Utils.GetVersionString() }; try { RulesVerifier verifier = new RulesVerifier(_rules_path, _options.Log); verifier.Verify(); packRulesResult.Rules = new List <Rule>(verifier.CompiledRuleset.AsEnumerable()); packRulesResult.ResultCode = PackRulesResult.ExitCode.Success; } catch (OpException e) { WriteOnce.Error(e.Message); //caught for CLI callers with final exit msg about checking log or throws for DLL callers throw; } return(packRulesResult); }
string _arg_fileExclusionList;//see exclusion list /// Compares a set of rules against a source path... /// Used for both RulesPresent and RulesNotePresent options /// Focus is pass/fail not detailed comparison output -see Tagdiff for more public TagTestCommand(TagTestCommandOptions opt) { _arg_srcPath = opt.SourcePath; _arg_customRulesPath = opt.CustomRulesPath; _arg_outputFile = opt.OutputFilePath; _arg_consoleVerbosityLevel = opt.ConsoleVerbosityLevel ?? "medium"; _arg_tag_test_type_raw = opt.TestType ?? "RulesPresent"; _arg_logger = opt.Log; _arg_log_file_path = opt.LogFilePath; _arg_log_level = opt.LogFileLevel; _arg_close_log_on_exit = Utils.CLIExecutionContext ? true : opt.CloseLogOnCommandExit; _arg_fileExclusionList = opt.FilePathExclusions; _arg_logger ??= Utils.SetupLogging(opt); WriteOnce.Log ??= _arg_logger; _rulesSet = new RuleSet(_arg_logger); try { ConfigureConsoleOutput(); ConfigureCompareTest(); ConfigureRules(); } catch (Exception e) //group error handling { WriteOnce.Error(e.Message); if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } throw; } }
public ExportTagsCommand(ExportTagsCommandOptions opt) { _rules = new RuleSet(WriteOnce.Log); _arg_customRulesPath = opt.CustomRulesPath; _arg_outputFile = opt.OutputFilePath; _arg_ignoreDefaultRules = opt.IgnoreDefaultRules; _arg_consoleVerbosityLevel = opt.ConsoleVerbosityLevel ?? "medium"; _arg_logger = opt.Log; _arg_log_file_path = opt.LogFilePath; _arg_log_level = opt.LogFileLevel; _arg_close_log_on_exit = Utils.CLIExecutionContext ? true : opt.CloseLogOnCommandExit; _arg_logger ??= Utils.SetupLogging(opt); WriteOnce.Log ??= _arg_logger; try { ConfigureConsoleOutput(); ConfigFileOutput(); ConfigRules(); } catch (Exception e) { WriteOnce.Error(e.Message); if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } throw; } }
void ConfigureCompareType() { if (!Enum.TryParse(_arg_test_type_raw, true, out _arg_tagTestType)) { WriteOnce.Error((ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_ARG_VALUE, _arg_test_type_raw))); throw new Exception(ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_ARG_VALUE, _arg_test_type_raw)); } }
List <string> _fileExclusionList;//see exclusion list public AnalyzeCommand(AnalyzeCommandOptions opt) { _arg_sourcePath = opt.SourcePath; _arg_outputFile = opt.OutputFilePath; _arg_fileFormat = opt.OutputFileFormat ?? "html"; _arg_outputTextFormat = opt.TextOutputFormat; _arg_outputUniqueTagsOnly = !opt.AllowDupTags; _arg_customRulesPath = opt.CustomRulesPath; _arg_confidenceFilters = opt.ConfidenceFilters ?? "high,medium"; _arg_consoleVerbosityLevel = opt.ConsoleVerbosityLevel ?? "medium"; _arg_suppressBrowserOpen = opt.SuppressBrowserOpen; _arg_ignoreDefaultRules = opt.IgnoreDefaultRules; _arg_simpleTagsOnly = opt.SimpleTagsOnly; _arg_logger = opt.Log; _arg_log_file_path = opt.LogFilePath; _arg_log_level = opt.LogFileLevel; _arg_close_log_on_exit = Utils.CLIExecutionContext ? true : opt.CloseLogOnCommandExit; opt.FilePathExclusions ??= "sample,example,test,docs,.vs,.git"; if (!string.IsNullOrEmpty(opt.FilePathExclusions)) { _fileExclusionList = opt.FilePathExclusions.ToLower().Split(",").ToList <string>(); if (_fileExclusionList != null && (_fileExclusionList.Contains("none") || _fileExclusionList.Contains("None"))) { _fileExclusionList.Clear(); } } _arg_logger ??= Utils.SetupLogging(opt); WriteOnce.Log ??= _arg_logger; LastUpdated = DateTime.MinValue; DateScanned = DateTime.Now; try { ConfigureConsoleOutput(); ConfigFileOutput(); ConfigSourcetoScan(); ConfigConfidenceFilters(); ConfigRules(); } catch (Exception e) //group error handling { WriteOnce.Error(e.Message); if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } throw; } _uniqueTagsControl = new HashSet <string>(); }
void UnZipAndProcess(string filename, ArchiveFileType archiveFileType) { // zip itself may be in excluded list i.e. sample, test or similar unless ignore filter requested if (_fileExclusionList != null && _fileExclusionList.Any(v => filename.ToLower().Contains(v))) { WriteOnce.SafeLog(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_EXCLUDED_TYPE_SKIPPED, filename), LogLevel.Warn); _appProfile.MetaData.FilesSkipped++; return; } //zip itself may be too huge for timely processing if (new FileInfo(filename).Length > WARN_ZIP_FILE_SIZE) { WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_COMPRESSED_FILESIZE_WARN)); } else { WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_COMPRESSED_PROCESSING)); } LastUpdated = File.GetLastWriteTime(filename); _appProfile.MetaData.PackageTypes.Add(ErrMsg.GetString(ErrMsg.ID.ANALYZE_COMPRESSED_FILETYPE)); try { IEnumerable <FileEntry> files = Extractor.ExtractFile(filename); if (files.Count() > 0) { _appProfile.MetaData.TotalFiles += files.Count();//additive in case additional child zip files processed foreach (FileEntry file in files) { //check uncompressed file passes standard checks LanguageInfo languageInfo = new LanguageInfo(); if (FileChecksPassed(file.FullPath, ref languageInfo, file.Content.Length)) { byte[] streamByteArray = file.Content.ToArray(); ProcessInMemory(file.FullPath, Encoding.UTF8.GetString(streamByteArray, 0, streamByteArray.Length), languageInfo); } } } else { WriteOnce.SafeLog(string.Format("Decompression found no files in {0}", filename), LogLevel.Warn);//zero results can be valid } } catch (Exception) { string errmsg = ErrMsg.FormatString(ErrMsg.ID.ANALYZE_COMPRESSED_ERROR, filename); WriteOnce.Error(errmsg); throw; } }
/// <summary> /// Main entry from CLI /// </summary> /// <returns></returns> public override int Run() { WriteOnce.SafeLog("VerifyRulesCommand::Run", LogLevel.Trace); WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "verifyrules")); ExitCode exitCode = ExitCode.CriticalError; try { RulesVerifier verifier = new RulesVerifier(_rules_path); verifier.Verify(); exitCode = ExitCode.Verified; RuleSet rules = verifier.CompiledRuleset; //report each add to console if desired foreach (Rule rule in rules) { WriteOnce.Result(string.Format("Rule {0}-{1} verified", rule.Id, rule.Name), true, WriteOnce.ConsoleVerbosity.High); } WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.VERIFY_RULES_RESULTS_SUCCESS), true, ConsoleColor.Green, WriteOnce.ConsoleVerbosity.Low); WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "verifyrules")); if (!String.IsNullOrEmpty(_arg_outputFile) && Utils.CLIExecutionContext) { WriteOnce.Any(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_OUTPUT_FILE, _arg_outputFile), true, ConsoleColor.Gray, WriteOnce.ConsoleVerbosity.Low); } WriteOnce.FlushAll(); } catch (Exception e) { WriteOnce.Error(e.Message); //exit normaly for CLI callers and throw for DLL callers if (Utils.CLIExecutionContext) { return((int)ExitCode.CriticalError); } else { throw; } } finally { if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } } return((int)exitCode); }
/// <summary> /// After verifying rules are valid syntax and load; combines into a single .json file /// for ease in distribution including this application's defaultset which are /// added to the manifest as an embedded resource (see AppInspector.Commands.csproj) /// </summary> /// <returns></returns> public override int Run() { WriteOnce.SafeLog("PackRules::Run", LogLevel.Trace); WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "packrules")); try { RulesVerifier verifier = new RulesVerifier(_rules_path); verifier.Verify(); List <Rule> list = new List <Rule>(verifier.CompiledRuleset.AsEnumerable()); JsonSerializerSettings settings = new JsonSerializerSettings(); settings.Formatting = (_arg_indent) ? Formatting.Indented : Formatting.None; using (FileStream fs = File.Open(_arg_outputfile, FileMode.Create, FileAccess.Write)) { StreamWriter sw = new StreamWriter(fs); sw.Write(JsonConvert.SerializeObject(list, settings)); sw.Close(); fs.Close(); } WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "packrules")); WriteOnce.Any(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_OUTPUT_FILE, _arg_outputfile), true, ConsoleColor.Gray, WriteOnce.ConsoleVerbosity.Medium); WriteOnce.FlushAll(); } catch (Exception e) { WriteOnce.Error(e.Message); //exit normaly for CLI callers and throw for DLL callers if (Utils.CLIExecutionContext) { return((int)ExitCode.CriticalError); } else { throw; } } finally { if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } } return((int)ExitCode.NoIssues); }
public ExportTagsResult GetResult() { WriteOnce.SafeLog("ExportTagsCommand::Run", LogLevel.Trace); WriteOnce.Operation(MsgHelp.FormatString(MsgHelp.ID.CMD_RUNNING, "Export Tags")); ExportTagsResult exportTagsResult = new() { AppVersion = Common.Utils.GetVersionString() }; SortedDictionary <string, string> uniqueTags = new(); try { foreach (Rule?r in _rules) { //builds a list of unique tags foreach (string t in r?.Tags ?? Array.Empty <string>()) { if (uniqueTags.ContainsKey(t)) { continue; } else { uniqueTags.Add(t, t); } } } //generate results list foreach (string s in uniqueTags.Values) { exportTagsResult.TagsList.Add(s); } exportTagsResult.ResultCode = ExportTagsResult.ExitCode.Success; } catch (OpException e) { WriteOnce.Error(e.Message); //caught for CLI callers with final exit msg about checking log or throws for DLL callers throw; } return(exportTagsResult); } }
public PackRulesCommand(PackRulesOptions opt) { _options = opt; try { _options.Log ??= Utils.SetupLogging(_options); WriteOnce.Log ??= _options.Log; ConfigureConsoleOutput(); ConfigRules(); } catch (OpException e) { WriteOnce.Error(e.Message); throw; } }
public ExportTagsCommand(ExportTagsOptions opt) { _options = opt; try { _options.Log ??= Utils.SetupLogging(_options); WriteOnce.Log ??= _options.Log; _rules = new RuleSet(_options.Log); ConfigureConsoleOutput(); ConfigRules(); } catch (Exception e) { WriteOnce.Error(e.Message); throw new OpException(e.Message); } }
public TagDiffCommand(TagDiffOptions opt) { _options = opt; _options.TestType ??= "equality"; try { _options.Log ??= Utils.SetupLogging(_options); WriteOnce.Log ??= _options.Log; ConfigureConsoleOutput(); ConfigureCompareType(); ConfigSourceToScan(); } catch (OpException e) //group error handling { WriteOnce.Error(e.Message); throw; } }
/// <summary> /// Common validation called by ProcessAsFile and UnzipAndProcess to ensure same order and checks made /// </summary> /// <param name="filePath"></param> /// <param name="languageInfo"></param> /// <param name="fileLength">should be > zero if called from unzip method</param> /// <returns></returns> bool FileChecksPassed(string filePath, ref LanguageInfo languageInfo, long fileLength = 0) { _appProfile.MetaData.FileExtensions.Add(Path.GetExtension(filePath).Replace('.', ' ').TrimStart()); // 1. Skip files written in unknown language if (!Language.FromFileName(filePath, ref languageInfo)) { WriteOnce.SafeLog(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_LANGUAGE_NOTFOUND, filePath), LogLevel.Warn); _appProfile.MetaData.FilesSkipped++; return(false); } _appProfile.MetaData.AddLanguage(languageInfo.Name); // 2. Skip excluded files i.e. sample, test or similar unless ignore filter requested if (_fileExclusionList != null && _fileExclusionList.Any(v => filePath.ToLower().Contains(v))) { WriteOnce.SafeLog(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_EXCLUDED_TYPE_SKIPPED, filePath), LogLevel.Warn); _appProfile.MetaData.FilesSkipped++; return(false); } // 3. Skip if exceeds file size limits try { fileLength = fileLength <= 0 ? new FileInfo(filePath).Length : fileLength; if (fileLength > MAX_FILESIZE) { WriteOnce.SafeLog(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_FILESIZE_SKIPPED, filePath), LogLevel.Warn); _appProfile.MetaData.FilesSkipped++; return(false); } } catch (Exception) { WriteOnce.Error(ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_FILE_OR_DIR, filePath)); throw; } return(true); }
/// Compares a set of rules against a source path... /// Used for both RulesPresent and RulesNotePresent options /// Focus is pass/fail not detailed comparison output -see Tagdiff for more public TagTestCommand(TagTestOptions opt) { _options = opt; _options.TestType ??= "rulespresent"; try { _options.Log ??= Utils.SetupLogging(_options); WriteOnce.Log ??= _options.Log; _rulesSet = new RuleSet(_options.Log); ConfigureConsoleOutput(); ConfigureCompareTest(); ConfigureRules(); } catch (OpException e) //group error handling { WriteOnce.Error(e.Message); throw; } }
public void ConfigureRules() { WriteOnce.SafeLog("TagTestCommand::ConfigRules", LogLevel.Trace); if (string.IsNullOrEmpty(_arg_customRulesPath)) { WriteOnce.Error(ErrMsg.GetString(ErrMsg.ID.CMD_NORULES_SPECIFIED)); throw new Exception(ErrMsg.GetString(ErrMsg.ID.CMD_NORULES_SPECIFIED)); } List <string> rulePaths = new List <string>(); if (!string.IsNullOrEmpty(_arg_customRulesPath)) { rulePaths.Add(_arg_customRulesPath); } foreach (string rulePath in rulePaths) { if (Directory.Exists(rulePath)) { _rulesSet.AddDirectory(rulePath); } else if (File.Exists(rulePath)) { _rulesSet.AddFile(rulePath); } else { throw new Exception(ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_RULE_PATH, rulePath)); } } //error check based on ruleset not path enumeration if (_rulesSet.Count() == 0) { throw new Exception(ErrMsg.GetString(ErrMsg.ID.CMD_NORULES_SPECIFIED)); } }
/// <summary> /// Establish console verbosity /// For NuGet DLL use, console is muted overriding any arguments sent /// </summary> void ConfigureConsoleOutput() { WriteOnce.SafeLog("AnalyzeCommand::ConfigureConsoleOutput", LogLevel.Trace); //Set console verbosity based on run context (none for DLL use) and caller arguments if (!Utils.CLIExecutionContext) { WriteOnce.Verbosity = WriteOnce.ConsoleVerbosity.None; } else { WriteOnce.ConsoleVerbosity verbosity = WriteOnce.ConsoleVerbosity.Medium; if (!Enum.TryParse(_arg_consoleVerbosityLevel, true, out verbosity)) { WriteOnce.Error(ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_ARG_VALUE, "-x")); throw new Exception(ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_ARG_VALUE, "-x")); } else { WriteOnce.Verbosity = verbosity; } } }
/// <summary> /// Option for DLL use as alternate to Run which only outputs a file to return results as string /// CommandOption defaults will not have been set when used as DLL via CLI processing so some checks added /// </summary> /// <returns>output results</returns> public VerifyRulesResult GetResult() { WriteOnce.SafeLog("VerifyRulesCommand::Run", LogLevel.Trace); WriteOnce.Operation(MsgHelp.FormatString(MsgHelp.ID.CMD_RUNNING, "Verify Rules")); VerifyRulesResult verifyRulesResult = new VerifyRulesResult() { AppVersion = Utils.GetVersionString() }; try { RulesVerifier verifier = new RulesVerifier(_rules_path, _options.Log); verifier.Verify(_options.Failfast); verifyRulesResult.ResultCode = VerifyRulesResult.ExitCode.Verified; RuleSet rules = verifier.CompiledRuleset; foreach (Rule rule in rules) { verifyRulesResult.RuleStatusList.Add(new RuleStatus() { RulesId = rule.Id, RulesName = rule.Name, Verified = true }); } } catch (OpException e) { WriteOnce.Error(e.Message); //caught for CLI callers with final exit msg about checking log or throws for DLL callers throw;; } return(verifyRulesResult); }
public PackRulesCommand(PackRulesCommandOptions opt) { _arg_repack_default_rules = opt.RepackDefaultRules; _arg_indent = !opt.NotIndented; _arg_custom_rules_path = opt.CustomRulesPath; _arg_outputfile = opt.OutputFilePath; _arg_consoleVerbosityLevel = opt.ConsoleVerbosityLevel ?? "medium"; _arg_logger = opt.Log; _arg_log_file_path = opt.LogFilePath; _arg_log_level = opt.LogFileLevel; _arg_close_log_on_exit = Utils.CLIExecutionContext ? true : opt.CloseLogOnCommandExit; _rules_path = _arg_repack_default_rules ? Utils.GetPath(Utils.AppPath.defaultRulesSrc) : _arg_custom_rules_path; _arg_outputfile = _arg_repack_default_rules && String.IsNullOrEmpty(_arg_custom_rules_path) ? Utils.GetPath(Utils.AppPath.defaultRulesPackedFile) : _arg_outputfile; _arg_logger ??= Utils.SetupLogging(opt); WriteOnce.Log ??= _arg_logger; ConfigureConsoleOutput(); try { ConfigFileOutput(); ConfigRules(); } catch (Exception e) { WriteOnce.Error(e.Message); if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } throw; } }
/// <summary> /// Main entry point to start analysis from CLI; handles setting up rules, directory enumeration /// file type detection and handoff /// Pre: All Configure Methods have been called already and we are ready to SCAN /// </summary> /// <returns></returns> public override int Run() { WriteOnce.SafeLog("AnalyzeCommand::Run", LogLevel.Trace); WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "analyze")); try { _appProfile.MetaData.TotalFiles = _srcfileList.Count();//updated for zipped files later // Iterate through all files and process against rules foreach (string filename in _srcfileList) { ArchiveFileType archiveFileType = ArchiveFileType.UNKNOWN; try //fix for #146 { archiveFileType = MiniMagic.DetectFileType(filename); } catch (Exception e) { WriteOnce.SafeLog(e.Message + "\n" + e.StackTrace, LogLevel.Error); //log details Exception f = new Exception(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_FILE_TYPE_OPEN, filename)); //report friendly version throw f; } if (archiveFileType == ArchiveFileType.UNKNOWN)//not a known zipped file type { ProcessAsFile(filename); } else { UnZipAndProcess(filename, archiveFileType); } } WriteOnce.General("\r" + ErrMsg.FormatString(ErrMsg.ID.ANALYZE_FILES_PROCESSED_PCNT, 100)); WriteOnce.Operation(ErrMsg.GetString(ErrMsg.ID.CMD_PREPARING_REPORT)); //Prepare report results _appProfile.MetaData.LastUpdated = LastUpdated.ToString(); _appProfile.DateScanned = DateScanned.ToString(); _appProfile.PrepareReport(); FlushAll(); //wrapup result status if (_appProfile.MetaData.TotalFiles == _appProfile.MetaData.FilesSkipped) { WriteOnce.Error(ErrMsg.GetString(ErrMsg.ID.ANALYZE_NOSUPPORTED_FILETYPES)); } else if (_appProfile.MatchList.Count == 0) { WriteOnce.Error(ErrMsg.GetString(ErrMsg.ID.ANALYZE_NOPATTERNS)); } else { WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "analyze")); } } catch (Exception e) { WriteOnce.Error(e.Message); //exit normaly for CLI callers and throw for DLL callers if (Utils.CLIExecutionContext) { return((int)ExitCode.CriticalError); } else { throw; } } finally { if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } } return(_appProfile.MatchList.Count() == 0 ? (int)ExitCode.NoMatches : (int)Utils.ExitCode.Success); }
/// <summary> /// Main entry from CLI /// </summary> /// <returns></returns> public override int Run() { WriteOnce.SafeLog("TagTestCommand::Run", LogLevel.Trace); WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "tagtest")); //init based on true or false present argument value ExitCode exitCode = ExitCode.CriticalError; WriteOnce.ConsoleVerbosity saveVerbosity = WriteOnce.Verbosity; AnalyzeCommand.ExitCode analyzeCmdResult = AnalyzeCommand.ExitCode.CriticalError; try { //one file vs ruleset string tmp1 = Path.GetTempFileName(); //setup analyze call with silent option AnalyzeCommand cmd1 = new AnalyzeCommand(new AnalyzeCommandOptions { SourcePath = _arg_srcPath, OutputFilePath = tmp1, OutputFileFormat = "json", IgnoreDefaultRules = true, CustomRulesPath = _arg_customRulesPath, FilePathExclusions = _arg_fileExclusionList, SimpleTagsOnly = true, ConsoleVerbosityLevel = "None", Log = _arg_logger }); //get and perform initial analyze on results analyzeCmdResult = (AnalyzeCommand.ExitCode)cmd1.Run(); //must be done here to avoid losing our handle from analyze command overwriting WriteOnce.Writer ConfigureFileOutput(); //restore WriteOnce.Verbosity = saveVerbosity; if (analyzeCmdResult == AnalyzeCommand.ExitCode.CriticalError) { throw new Exception(ErrMsg.GetString(ErrMsg.ID.CMD_CRITICAL_FILE_ERR)); } else if (analyzeCmdResult == AnalyzeCommand.ExitCode.NoMatches) { WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.TAGTEST_RESULTS_TEST_TYPE, _arg_tagTestType.ToString()), false, WriteOnce.ConsoleVerbosity.Low); if (_arg_tagTestType == TagTestType.RulesPresent) { WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.TAGTEST_RESULTS_FAIL), true, ConsoleColor.Red, WriteOnce.ConsoleVerbosity.Low); } else { WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.TAGTEST_RESULTS_SUCCESS), true, ConsoleColor.Green, WriteOnce.ConsoleVerbosity.Low); } WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "tagtest")); exitCode = _arg_tagTestType == TagTestType.RulesPresent ? ExitCode.TestFailed : ExitCode.TestPassed; } else //assumed (result == AnalyzeCommand.ExitCode.MatchesFound) { string file1TagsJson = File.ReadAllText(tmp1); var file1Tags = JsonConvert.DeserializeObject <TagsFile>(file1TagsJson); File.Delete(tmp1); exitCode = ExitCode.TestPassed; foreach (Rule r in _rulesSet) { //supports both directions by generalizing string[] testList1 = _arg_tagTestType == TagTestType.RulesNotPresent ? r.Tags : file1Tags.Tags; string[] testList2 = _arg_tagTestType == TagTestType.RulesNotPresent ? file1Tags.Tags : r.Tags; foreach (string t in testList2) { if (TagTest(testList1, t)) { WriteOnce.Result(ErrMsg.FormatString(ErrMsg.ID.TAGTEST_RESULTS_TAGS_FOUND, t), true, WriteOnce.ConsoleVerbosity.High); } else { exitCode = ExitCode.TestFailed; WriteOnce.Result(ErrMsg.FormatString(ErrMsg.ID.TAGTEST_RESULTS_TAGS_MISSING, t), true, WriteOnce.ConsoleVerbosity.High); } if (exitCode != ExitCode.TestPassed) { break; } } if (exitCode != ExitCode.TestPassed) { break; } } //results WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.TAGTEST_RESULTS_TEST_TYPE, _arg_tagTestType.ToString()), false, WriteOnce.ConsoleVerbosity.Low); if (exitCode == ExitCode.TestFailed) { WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.TAGTEST_RESULTS_FAIL), true, ConsoleColor.Red, WriteOnce.ConsoleVerbosity.Low); } else { WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.TAGTEST_RESULTS_SUCCESS), true, ConsoleColor.Green, WriteOnce.ConsoleVerbosity.Low); } WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Tagtest")); if (!String.IsNullOrEmpty(_arg_outputFile) && Utils.CLIExecutionContext) { WriteOnce.Info(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_OUTPUT_FILE, _arg_outputFile), true, WriteOnce.ConsoleVerbosity.Low, false); } WriteOnce.FlushAll(); } } catch (Exception e) { WriteOnce.Verbosity = saveVerbosity; if (analyzeCmdResult == AnalyzeCommand.ExitCode.Success) //then error was not previously logged { WriteOnce.Error(e.Message); } else { WriteOnce.Error(e.Message, true, WriteOnce.ConsoleVerbosity.Low, false); } //exit normaly for CLI callers and throw for DLL callers if (Utils.CLIExecutionContext) { return((int)ExitCode.CriticalError); } else { throw; } } finally { if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } } return((int)exitCode); }
/// <summary> /// Main entry from CLI /// </summary> /// <returns></returns> public TagDiffResult GetResult() { WriteOnce.SafeLog("TagDiffCommand::Run", LogLevel.Trace); WriteOnce.Operation(MsgHelp.FormatString(MsgHelp.ID.CMD_RUNNING, "Tag Diff")); TagDiffResult tagDiffResult = new() { AppVersion = Common.Utils.GetVersionString() }; //save to quiet analyze cmd and restore WriteOnce.ConsoleVerbosity saveVerbosity = WriteOnce.Verbosity; try { if (_options is null) { throw new ArgumentNullException("_options"); } AnalyzeCommand cmd1 = new(new AnalyzeOptions() { SourcePath = _options.SourcePath1, CustomRulesPath = _options.CustomRulesPath, IgnoreDefaultRules = _options.IgnoreDefaultRules, FilePathExclusions = _options.FilePathExclusions, ConsoleVerbosityLevel = "none", Log = _options.Log, TagsOnly = true, ConfidenceFilters = _options.ConfidenceFilters, FileTimeOut = _options.FileTimeOut, ProcessingTimeOut = _options.ProcessingTimeOut, NoFileMetadata = true, NoShowProgress = true, ScanUnknownTypes = _options.ScanUnknownTypes, SingleThread = _options.SingleThread, }); AnalyzeCommand cmd2 = new(new AnalyzeOptions() { SourcePath = _options.SourcePath2, CustomRulesPath = _options.CustomRulesPath, IgnoreDefaultRules = _options.IgnoreDefaultRules, FilePathExclusions = _options.FilePathExclusions, ConsoleVerbosityLevel = "none", Log = _options.Log, TagsOnly = true, ConfidenceFilters = _options.ConfidenceFilters, FileTimeOut = _options.FileTimeOut, ProcessingTimeOut = _options.ProcessingTimeOut, NoFileMetadata = true, NoShowProgress = true, ScanUnknownTypes = _options.ScanUnknownTypes, SingleThread = _options.SingleThread, }); AnalyzeResult analyze1 = cmd1.GetResult(); AnalyzeResult analyze2 = cmd2.GetResult(); //restore WriteOnce.Verbosity = saveVerbosity; //process results for each analyze call before comparing results if (analyze1.ResultCode == AnalyzeResult.ExitCode.CriticalError) { throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_CRITICAL_FILE_ERR, string.Join(',', _options.SourcePath1))); } else if (analyze2.ResultCode == AnalyzeResult.ExitCode.CriticalError) { throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_CRITICAL_FILE_ERR, string.Join(',', _options.SourcePath2))); } else if (analyze1.ResultCode == AnalyzeResult.ExitCode.NoMatches || analyze2.ResultCode == AnalyzeResult.ExitCode.NoMatches) { throw new OpException(MsgHelp.GetString(MsgHelp.ID.TAGDIFF_NO_TAGS_FOUND)); } else //compare tag results; assumed (result1&2 == AnalyzeCommand.ExitCode.Success) { var list1 = analyze1.Metadata.UniqueTags ?? new List <string>(); var list2 = analyze2.Metadata.UniqueTags ?? new List <string>(); var removed = list1.Except(list2); var added = list2.Except(list1); foreach (var add in added) { tagDiffResult.TagDiffList.Add(new TagDiff() { Source = TagDiff.DiffSource.Source2, Tag = add }); } foreach (var remove in removed) { tagDiffResult.TagDiffList.Add(new TagDiff() { Source = TagDiff.DiffSource.Source1, Tag = remove }); } if (tagDiffResult.TagDiffList.Count > 0) { tagDiffResult.ResultCode = _arg_tagTestType == TagTestType.Inequality ? TagDiffResult.ExitCode.TestPassed : TagDiffResult.ExitCode.TestFailed; } else { tagDiffResult.ResultCode = _arg_tagTestType == TagTestType.Inequality ? TagDiffResult.ExitCode.TestFailed : TagDiffResult.ExitCode.TestPassed; } return(tagDiffResult); } } catch (OpException e) { WriteOnce.Verbosity = saveVerbosity; WriteOnce.Error(e.Message); //caught for CLI callers with final exit msg about checking log or throws for DLL callers throw; } } }
/// <summary> /// Main entry from CLI /// </summary> /// <returns></returns> public override int Run() { WriteOnce.SafeLog("TagDiffCommand::Run", LogLevel.Trace); WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "tagdiff")); ExitCode exitCode = ExitCode.CriticalError; //save to quiet analyze cmd and restore WriteOnce.ConsoleVerbosity saveVerbosity = WriteOnce.Verbosity; AnalyzeCommand.ExitCode analyzeCmdResult1 = AnalyzeCommand.ExitCode.CriticalError; AnalyzeCommand.ExitCode analyzeCmdResult2 = AnalyzeCommand.ExitCode.CriticalError; try { #region setup analyze calls string tmp1 = Path.GetTempFileName(); string tmp2 = Path.GetTempFileName(); AnalyzeCommand cmd1 = new AnalyzeCommand(new AnalyzeCommandOptions { SourcePath = _arg_src1, OutputFilePath = tmp1, OutputFileFormat = "json", CustomRulesPath = _arg_customRulesPath, IgnoreDefaultRules = _arg_ignoreDefault, FilePathExclusions = _arg_fileExclusionList, SimpleTagsOnly = true, ConsoleVerbosityLevel = "none", Log = _arg_logger }); AnalyzeCommand cmd2 = new AnalyzeCommand(new AnalyzeCommandOptions { SourcePath = _arg_src2, OutputFilePath = tmp2, OutputFileFormat = "json", CustomRulesPath = _arg_customRulesPath, IgnoreDefaultRules = _arg_ignoreDefault, FilePathExclusions = _arg_fileExclusionList, SimpleTagsOnly = true, ConsoleVerbosityLevel = "none", Log = _arg_logger }); analyzeCmdResult1 = (AnalyzeCommand.ExitCode)cmd1.Run(); analyzeCmdResult2 = (AnalyzeCommand.ExitCode)cmd2.Run(); ConfigureFileOutput(); //restore WriteOnce.Verbosity = saveVerbosity; #endregion bool equalTagsCompare1 = true; bool equalTagsCompare2 = true; //process results for each analyze call before comparing results if (analyzeCmdResult1 == AnalyzeCommand.ExitCode.CriticalError) { throw new Exception(ErrMsg.FormatString(ErrMsg.ID.CMD_CRITICAL_FILE_ERR, _arg_src1)); } else if (analyzeCmdResult2 == AnalyzeCommand.ExitCode.CriticalError) { throw new Exception(ErrMsg.FormatString(ErrMsg.ID.CMD_CRITICAL_FILE_ERR, _arg_src2)); } else if (analyzeCmdResult1 == AnalyzeCommand.ExitCode.NoMatches || analyzeCmdResult2 == AnalyzeCommand.ExitCode.NoMatches) { throw new Exception(ErrMsg.GetString(ErrMsg.ID.TAGDIFF_NO_TAGS_FOUND)); } else //compare tag results; assumed (result1&2 == AnalyzeCommand.ExitCode.Success) { //setup output here rather than top to avoid analyze command output in this command output ConfigureFileOutput(); ConfigureConsoleOutput();//recheck string file1TagsJson = File.ReadAllText(tmp1); string file2TagsJson = File.ReadAllText(tmp2); var file1Tags = JsonConvert.DeserializeObject <TagsFile>(file1TagsJson); var file2Tags = JsonConvert.DeserializeObject <TagsFile>(file2TagsJson); //can't simply compare counts as content may differ; must compare both in directions in two passes a->b; b->a WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.TAGDIFF_RESULTS_GAP, Path.GetFileName(_arg_src1), Path.GetFileName(_arg_src2)), true, WriteOnce.ConsoleVerbosity.High); equalTagsCompare1 = CompareTags(file1Tags.Tags, file2Tags.Tags); //reverse order for second pass WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.TAGDIFF_RESULTS_GAP, Path.GetFileName(_arg_src2), Path.GetFileName(_arg_src1)), true, WriteOnce.ConsoleVerbosity.High); equalTagsCompare2 = CompareTags(file2Tags.Tags, file1Tags.Tags); //final results bool resultsDiffer = !(equalTagsCompare1 && equalTagsCompare2); if (_arg_tagTestType == TagTestType.Inequality && !resultsDiffer) { exitCode = ExitCode.TestFailed; } else if (_arg_tagTestType == TagTestType.Equality && resultsDiffer) { exitCode = ExitCode.TestFailed; } else { exitCode = ExitCode.TestPassed; } WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.TAGDIFF_RESULTS_DIFFER), false); WriteOnce.Result(resultsDiffer.ToString()); WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "tagdiff")); if (!String.IsNullOrEmpty(_arg_outputFile) && Utils.CLIExecutionContext) { WriteOnce.Info(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_OUTPUT_FILE, _arg_outputFile), true, WriteOnce.ConsoleVerbosity.Low, false); } WriteOnce.FlushAll(); } //cleanup try { File.Delete(tmp1); File.Delete(tmp2); } catch { //no action needed; } } catch (Exception e) { WriteOnce.Verbosity = saveVerbosity; if (analyzeCmdResult1 == AnalyzeCommand.ExitCode.Success && analyzeCmdResult2 == AnalyzeCommand.ExitCode.Success) //error not previously logged { WriteOnce.Error(e.Message); } else { WriteOnce.Error(e.Message, true, WriteOnce.ConsoleVerbosity.Low, false);//console but don't log again } //exit normaly for CLI callers and throw for DLL callers if (Utils.CLIExecutionContext) { return((int)ExitCode.CriticalError); } else { throw; } } finally { if (_arg_close_log_on_exit) { Utils.Logger = null; WriteOnce.Log = null; } } return((int)exitCode); }
/// <summary> /// Setup application inspector logging; 1 file per process /// </summary> /// <param name="opts"></param> /// <returns></returns> public static Logger SetupLogging(CommandOptions opts, bool onErrorConsole = false) { //prevent being called again if already set unless closed first if (Logger != null) { return(Logger); } var config = new NLog.Config.LoggingConfiguration(); if (String.IsNullOrEmpty(opts.LogFilePath)) { opts.LogFilePath = Utils.GetPath(Utils.AppPath.defaultLog); } //clean up previous for convenience in reading if (File.Exists(opts.LogFilePath)) { // Read the file and display it line by line. System.IO.StreamReader file = new System.IO.StreamReader(opts.LogFilePath); String line = file.ReadLine(); file.Close(); if (!String.IsNullOrEmpty(line)) { if (line.Contains("AppInsLog"))//prevent file other than our logs from deletion { File.Delete(opts.LogFilePath); } else { if (Utils.CLIExecutionContext && onErrorConsole) { WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_LOG_PATH, opts.LogFilePath), true, WriteOnce.ConsoleVerbosity.Low, false); } throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_LOG_PATH, opts.LogFilePath)); } } } else { try { File.WriteAllText(opts.LogFilePath, "");//verify log file path is writable } catch (Exception e) { WriteOnce.SafeLog(e.Message + "\n" + e.StackTrace, NLog.LogLevel.Error); if (Utils.CLIExecutionContext && onErrorConsole) { WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_FILE_OR_DIR, opts.LogFilePath), true, WriteOnce.ConsoleVerbosity.Low, false); } throw new OpException((MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_FILE_OR_DIR, opts.LogFilePath))); } } LogLevel log_level = LogLevel.Error;//default if (String.IsNullOrEmpty(opts.LogFileLevel)) { opts.LogFileLevel = "Error"; } try { log_level = LogLevel.FromString(opts.LogFileLevel); } catch (Exception) { if (Utils.CLIExecutionContext && onErrorConsole) { WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, "-v"), true, WriteOnce.ConsoleVerbosity.Low, false); } throw new OpException((MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, "-v"))); } using (var fileTarget = new FileTarget() { Name = "LogFile", FileName = opts.LogFilePath, Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${threadid} ${level:uppercase=true} - AppInsLog - ${message}", ForceMutexConcurrentWrites = true }) { config.AddTarget(fileTarget); config.LoggingRules.Add(new LoggingRule("CST.ApplicationInspector", log_level, fileTarget)); } LogFilePath = opts.LogFilePath;//preserve for console path msg LogManager.Configuration = config; Logger = LogManager.GetLogger("CST.ApplicationInspector"); return(Logger); }
/// <summary> /// Main entry from CLI /// </summary> /// <returns></returns> public TagDiffResult GetResult() { WriteOnce.SafeLog("TagDiffCommand::Run", LogLevel.Trace); WriteOnce.Operation(MsgHelp.FormatString(MsgHelp.ID.CMD_RUNNING, "Tag Diff")); TagDiffResult tagDiffResult = new TagDiffResult() { AppVersion = Utils.GetVersionString() }; //save to quiet analyze cmd and restore WriteOnce.ConsoleVerbosity saveVerbosity = WriteOnce.Verbosity; try { #region setup analyze calls AnalyzeCommand cmd1 = new AnalyzeCommand(new AnalyzeOptions { SourcePath = _options.SourcePath1, CustomRulesPath = _options.CustomRulesPath, IgnoreDefaultRules = _options.IgnoreDefaultRules, FilePathExclusions = _options.FilePathExclusions, ConsoleVerbosityLevel = "none", Log = _options.Log }); AnalyzeCommand cmd2 = new AnalyzeCommand(new AnalyzeOptions { SourcePath = _options.SourcePath2, CustomRulesPath = _options.CustomRulesPath, IgnoreDefaultRules = _options.IgnoreDefaultRules, FilePathExclusions = _options.FilePathExclusions, ConsoleVerbosityLevel = "none", Log = _options.Log }); AnalyzeResult analyze1 = cmd1.GetResult(); AnalyzeResult analyze2 = cmd2.GetResult(); //restore WriteOnce.Verbosity = saveVerbosity; #endregion setup analyze calls bool equalTagsCompare1 = true; bool equalTagsCompare2 = true; //process results for each analyze call before comparing results if (analyze1.ResultCode == AnalyzeResult.ExitCode.CriticalError) { throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_CRITICAL_FILE_ERR, _options.SourcePath1)); } else if (analyze2.ResultCode == AnalyzeResult.ExitCode.CriticalError) { throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_CRITICAL_FILE_ERR, _options.SourcePath2)); } else if (analyze1.ResultCode == AnalyzeResult.ExitCode.NoMatches || analyze2.ResultCode == AnalyzeResult.ExitCode.NoMatches) { throw new OpException(MsgHelp.GetString(MsgHelp.ID.TAGDIFF_NO_TAGS_FOUND)); } else //compare tag results; assumed (result1&2 == AnalyzeCommand.ExitCode.Success) { int count1 = 0; int sizeTags1 = analyze1.Metadata.UniqueTags.Count; string[] file1Tags = new string[sizeTags1]; foreach (string tag in analyze1.Metadata.UniqueTags.Keys.ToList <string>()) { file1Tags[count1++] = tag; } int count2 = 0; int sizeTags2 = analyze2.Metadata.UniqueTags.Count; string[] file2Tags = new string[sizeTags2]; foreach (string tag in analyze2.Metadata.UniqueTags.Keys.ToList <string>()) { file2Tags[count2++] = tag; } //can't simply compare counts as content may differ; must compare both in directions in two passes a->b; b->a equalTagsCompare1 = CompareTags(file1Tags, file2Tags, ref tagDiffResult, TagDiff.DiffSource.Source1); //reverse order for second pass equalTagsCompare2 = CompareTags(file2Tags, file1Tags, ref tagDiffResult, TagDiff.DiffSource.Source2); //final results bool resultsDiffer = !(equalTagsCompare1 && equalTagsCompare2); if (_arg_tagTestType == TagTestType.Inequality && !resultsDiffer) { tagDiffResult.ResultCode = TagDiffResult.ExitCode.TestFailed; } else if (_arg_tagTestType == TagTestType.Equality && resultsDiffer) { tagDiffResult.ResultCode = TagDiffResult.ExitCode.TestFailed; } else { tagDiffResult.ResultCode = TagDiffResult.ExitCode.TestPassed; } } } catch (OpException e) { WriteOnce.Verbosity = saveVerbosity; WriteOnce.Error(e.Message); //caught for CLI callers with final exit msg about checking log or throws for DLL callers throw; } return(tagDiffResult); }
/// <summary> /// Main entry from CLI /// </summary> /// <returns></returns> public override int Run() { bool issues = false; WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "Verify Rules")); //load [each] rules file separately to report out where a failure is happening RuleSet rules = new RuleSet(WriteOnce.Log); IEnumerable <string> fileListing = new List <string>(); foreach (string rulePath in _rulePaths) { if (Directory.Exists(rulePath)) { fileListing = Directory.EnumerateFiles(rulePath, "*.json", SearchOption.AllDirectories); } else if (File.Exists(rulePath) && Path.GetExtension(rulePath) == ".json") { fileListing = new List <string>() { new string(rulePath) } } ; else { throw new OpException(ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_RULE_PATH, rulePath)); } //test loading each file foreach (string filename in fileListing) { try { rules.AddFile(filename); WriteOnce.Info(string.Format("Rule file added {0}", filename), true, WriteOnce.ConsoleVerbosity.High); } catch (Exception e) { WriteOnce.Error(string.Format("Rule file add failed {0}", filename)); WriteOnce.SafeLog(e.Message + "\n" + e.StackTrace, NLog.LogLevel.Error); issues = true; } } } //option to write validating data if (_arg_consoleVerbosityLevel.ToLower() == "high") { WritePartialRuleDetails(rules); } //final status report if (issues) { WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.VERIFY_RULES_RESULTS_FAIL), true, ConsoleColor.Red, WriteOnce.ConsoleVerbosity.Low); } else { WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.VERIFY_RULES_RESULTS_SUCCESS), true, ConsoleColor.Green, WriteOnce.ConsoleVerbosity.Low); } WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Verify Rules")); WriteOnce.FlushAll(); if (!String.IsNullOrEmpty(_arg_outputFile)) { WriteOnce.Any(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_OUTPUT_FILE, _arg_outputFile), true, ConsoleColor.Gray, WriteOnce.ConsoleVerbosity.Low); } return(issues ? (int)ExitCode.NotVerified : (int)ExitCode.Verified); }
/// <summary> /// Main entry point to start analysis; handles setting up rules, directory enumeration /// file type detection and handoff /// Pre: All Configure Methods have been called already and we are ready to SCAN /// </summary> /// <returns></returns> public override int Run() { WriteOnce.SafeLog("AnalyzeCommand::Run", LogLevel.Trace); DateTime start = DateTime.Now; WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "Analyze")); _appProfile.MetaData.TotalFiles = _srcfileList.Count();//updated for zipped files later // Iterate through all files and process against rules foreach (string filename in _srcfileList) { ArchiveFileType archiveFileType; try //fix for #146 { archiveFileType = MiniMagic.DetectFileType(filename); } catch (Exception e) { throw new OpException(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_FILE_TYPE_OPEN, filename)); } if (archiveFileType == ArchiveFileType.UNKNOWN)//not a known zipped file type { ProcessAsFile(filename); } else { UnZipAndProcess(filename, archiveFileType); } } WriteOnce.General("\r" + ErrMsg.FormatString(ErrMsg.ID.ANALYZE_FILES_PROCESSED_PCNT, 100)); WriteOnce.Operation(ErrMsg.GetString(ErrMsg.ID.CMD_PREPARING_REPORT)); //Prepare report results _appProfile.MetaData.LastUpdated = LastUpdated.ToString(); _appProfile.DateScanned = DateScanned.ToString(); _appProfile.PrepareReport(); TimeSpan timeSpan = start - DateTime.Now; WriteOnce.SafeLog(String.Format("Processing time: seconds:{0}", timeSpan.TotalSeconds * -1), LogLevel.Trace); FlushAll(); //wrapup result status if (_appProfile.MetaData.TotalFiles == _appProfile.MetaData.FilesSkipped) { WriteOnce.Error(ErrMsg.GetString(ErrMsg.ID.ANALYZE_NOSUPPORTED_FILETYPES)); } else if (_appProfile.MatchList.Count == 0) { WriteOnce.Error(ErrMsg.GetString(ErrMsg.ID.ANALYZE_NOPATTERNS)); } else { WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Analyze")); if (!_arg_autoBrowserOpen) { WriteOnce.Any(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_OUTPUT_FILE, "output.html")); } } return(_appProfile.MatchList.Count() == 0 ? (int)ExitCode.NoMatches : (int)ExitCode.Success); }