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