/// <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);
}
private void ConfigureCompareType()
{
if (!Enum.TryParse(_options.TestType, true, out _arg_tagTestType))
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, _options.TestType));
}
}
/// <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);
}
public void ConfigureRules()
{
WriteOnce.SafeLog("TagTestCommand::ConfigRules", LogLevel.Trace);
if (string.IsNullOrEmpty(_options.CustomRulesPath))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
try
{
RulesVerifier verifier = new RulesVerifier(_options.CustomRulesPath, _options.Log);
verifier.Verify();
_rulesSet = verifier.CompiledRuleset;
}
catch (Exception e)
{
WriteOnce.SafeLog(e.Message + "\n" + e.StackTrace, NLog.LogLevel.Error);
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULE_FAILED, _options.CustomRulesPath));
}
//error check based on ruleset not path enumeration
if (_rulesSet.Count() == 0)
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
}
public void ConfigureRules()
{
WriteOnce.SafeLog("TagTestCommand::ConfigRules", LogLevel.Trace);
if (string.IsNullOrEmpty(_options.CustomRulesPath))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
RulesVerifier verifier = new RulesVerifier(_options.CustomRulesPath, _options.Log);
verifier.Verify();
if (!verifier.IsVerified)
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.VERIFY_RULES_RESULTS_FAIL));
}
_rulesSet = verifier.CompiledRuleset ?? new RuleSet(null);
//error check based on ruleset not path enumeration
if (!_rulesSet.Any())
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
}
/// <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);
}
}
private void ConfigRules()
{
_logger.LogTrace("ExportTagsCommand::ConfigRules");
_rules = new RuleSet(_loggerFactory);
if (!_options.IgnoreDefaultRules)
{
_rules = RuleSetUtils.GetDefaultRuleSet(_loggerFactory);
}
if (!string.IsNullOrEmpty(_options?.CustomRulesPath))
{
if (Directory.Exists(_options.CustomRulesPath))
{
_rules.AddDirectory(_options.CustomRulesPath);
}
else if (File.Exists(_options.CustomRulesPath))
{
_rules.AddFile(_options.CustomRulesPath);
}
else
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_RULE_PATH, _options.CustomRulesPath));
}
}
//error check based on ruleset not path enumeration
if (_rules == null || !_rules.Any())
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
}
/// <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()
{
_logger.LogTrace("VerifyRulesCommand::Run");
_logger.LogInformation(MsgHelp.GetString(MsgHelp.ID.CMD_RUNNING), "Verify Rules");
VerifyRulesResult verifyRulesResult = new() { AppVersion = Utils.GetVersionString() };
try
{
var analyzer = new ApplicationInspectorAnalyzer();
RulesVerifierOptions options = new()
{
Analyzer = analyzer,
FailFast = false,
LoggerFactory = _loggerFactory,
LanguageSpecs = Languages.FromConfigurationFiles(_loggerFactory, _options.CustomCommentsPath, _options.CustomLanguagesPath)
};
RulesVerifier verifier = new(options);
verifyRulesResult.ResultCode = VerifyRulesResult.ExitCode.Verified;
var stati = new List <RuleStatus>();
RuleSet?ruleSet = new(_loggerFactory);
if (_options.VerifyDefaultRules)
{
ruleSet = RuleSetUtils.GetDefaultRuleSet(_loggerFactory);
}
try
{
if (_options.CustomRulesPath != null)
{
if (Directory.Exists(_options.CustomRulesPath))
{
ruleSet.AddDirectory(_options.CustomRulesPath);
}
else if (File.Exists(_options.CustomRulesPath))
{
ruleSet.AddFile(_options.CustomRulesPath);
}
}
}
catch (JsonException e)
{
_logger.LogError(e.Message);
verifyRulesResult.ResultCode = VerifyRulesResult.ExitCode.CriticalError;
return(verifyRulesResult);
}
var verifyResult = verifier.Verify(ruleSet);
verifyRulesResult.RuleStatusList = verifyResult.RuleStatuses;
verifyRulesResult.ResultCode = verifyResult.Verified ? VerifyRulesResult.ExitCode.Verified : VerifyRulesResult.ExitCode.NotVerified;
}
catch (OpException e)
{
_logger.LogTrace(e.Message);
//caught for CLI callers with final exit msg about checking log or throws for DLL callers
throw;
}
return(verifyRulesResult);
}
}
private void ConfigSourceToScan()
{
WriteOnce.SafeLog("TagDiff::ConfigRules", LogLevel.Trace);
if ((!_options?.SourcePath1.Any() ?? true) || (!_options?.SourcePath2.Any() ?? true))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_INVALID_ARG_VALUE));
}
}
private void ConfigRules()
{
_logger.LogTrace("PackRulesCommand::ConfigRules");
if (string.IsNullOrEmpty(_options.CustomRulesPath) && !_options.PackEmbeddedRules)
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
}
private void ConfigRules()
{
_logger.LogTrace("VerifyRulesCommand::ConfigRules");
if (!_options.VerifyDefaultRules && string.IsNullOrEmpty(_options.CustomRulesPath))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
}
private void ConfigSourceToScan()
{
_logger.LogTrace("TagDiff::ConfigRules");
if ((!_options?.SourcePath1.Any() ?? true) || (!_options?.SourcePath2.Any() ?? true))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_INVALID_ARG_VALUE));
}
}
private void ConfigRules()
{
WriteOnce.SafeLog("VerifyRulesCommand::ConfigRules", LogLevel.Trace);
if (!_options.VerifyDefaultRules && string.IsNullOrEmpty(_options.CustomRulesPath))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
_rules_path = _options.VerifyDefaultRules ? null : _options.CustomRulesPath;
}
public static void OpenBrowser(string?url)
{
if (string.IsNullOrEmpty(url))
{
WriteOnce.Log?.Error("Bad url for OpenBrowser method");
return;
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
try
{
Process.Start(new ProcessStartInfo("cmd", $"/c start {url}"));
WriteOnce.General(MsgHelp.GetString(MsgHelp.ID.BROWSER_START_SUCCESS));
}
catch (Exception)
{
WriteOnce.General(MsgHelp.GetString(MsgHelp.ID.BROWSER_START_FAIL));//soft error
}
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("BROWSER")))
{
try
{
Process.Start("xdg-open", "\"" + url + "\"");
WriteOnce.General(MsgHelp.GetString(MsgHelp.ID.BROWSER_START_SUCCESS));
}
catch (Exception)
{
WriteOnce.General(MsgHelp.GetString(MsgHelp.ID.BROWSER_START_FAIL));//soft error
}
}
else
{
WriteOnce.General(MsgHelp.GetString(MsgHelp.ID.BROWSER_ENVIRONMENT_VAR));
}
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
try
{
Process.Start("open", "\"" + url + "\"");
WriteOnce.General(MsgHelp.GetString(MsgHelp.ID.BROWSER_START_SUCCESS));
}
catch (Exception)
{
WriteOnce.General(MsgHelp.GetString(MsgHelp.ID.BROWSER_START_FAIL));//soft error
}
}
}
private void ConfigSourceToScan()
{
WriteOnce.SafeLog("TagDiff::ConfigRules", LogLevel.Trace);
if (_options.SourcePath1 == _options.SourcePath2)
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.TAGDIFF_SAME_FILE_ARG));
}
else if (string.IsNullOrEmpty(_options.SourcePath1) || string.IsNullOrEmpty(_options.SourcePath2))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_INVALID_ARG_VALUE));
}
}
private void LoadFile(string file)
{
try
{
_rules?.AddFile(file, null);
}
catch (Exception e)
{
Debug.Write(e.Message);//Ensure console message indicates problem for Build process
WriteOnce.SafeLog(e.Message, NLog.LogLevel.Error);
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULE_LOADFILE_FAILED, file));
}
}
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);
}
}
private void ConfigRules()
{
WriteOnce.SafeLog("PackRulesCommand::ConfigRules", LogLevel.Trace);
if (_options.RepackDefaultRules && !Utils.CLIExecutionContext)
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.VERIFY_RULES_NO_CLI_DEFAULT));
}
if (!_options.RepackDefaultRules && string.IsNullOrEmpty(_options.CustomRulesPath))
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
_rules_path = _options.RepackDefaultRules ? Utils.GetPath(Utils.AppPath.defaultRulesSrc) : _options.CustomRulesPath;
}
public void Verify(bool failFast = true)
{
fail_fast = failFast;
if (Directory.Exists(_rulesPath))
{
LoadDirectory(_rulesPath);
}
else if (File.Exists(_rulesPath))
{
LoadFile(_rulesPath);
}
else
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_RULE_PATH, _rulesPath));
}
}
private void LoadFile(string file)
{
try
{
_rules.AddFile(file, null);
}
catch (Exception e)
{
Debug.Write(e.Message);//Ensure console message indicates problem for Build process
WriteOnce.SafeLog(e.Message, NLog.LogLevel.Error);
//allow caller to specify whether to continue
if (fail_fast)
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULE_FAILED, file));
}
}
}
/// <summary>
/// Intentional as no identified value in calling from DLL at this time
/// </summary>
/// <returns></returns>
public PackRulesResult GetResult()
{
_logger.LogTrace("PackRulesCommand::ConfigRules");
_logger.LogInformation(MsgHelp.GetString(MsgHelp.ID.CMD_RUNNING), "Pack Rules");
PackRulesResult packRulesResult = new()
{
AppVersion = Common.Utils.GetVersionString()
};
try
{
RulesVerifierOptions options = new()
{
FailFast = false,
LoggerFactory = _loggerFactory,
LanguageSpecs = Languages.FromConfigurationFiles(_loggerFactory, _options.CustomCommentsPath, _options.CustomLanguagesPath)
};
RulesVerifier verifier = new(options);
RuleSet? ruleSet = _options.PackEmbeddedRules ? RuleSetUtils.GetDefaultRuleSet() : new RuleSet();
if (!string.IsNullOrEmpty(_options.CustomRulesPath))
{
ruleSet.AddDirectory(_options.CustomRulesPath);
}
RulesVerifierResult result = verifier.Verify(ruleSet);
if (!result.Verified)
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.VERIFY_RULES_RESULTS_FAIL));
}
packRulesResult.Rules = result.CompiledRuleSet.GetAppInspectorRules().ToList();
packRulesResult.ResultCode = PackRulesResult.ExitCode.Success;
}
catch (OpException e)
{
_logger.LogError(e.Message);
//caught for CLI callers with final exit msg about checking log or throws for DLL callers
throw;
}
return(packRulesResult);
}
}
/// <summary>
/// Compile ruleset from a path to a directory or file containing a rule.json file and verify the status of the rules.
/// </summary>
/// <param name="fileName">Path to rules.</param>
/// <returns></returns>
/// <exception cref="OpException"></exception>
public RulesVerifierResult Verify(string rulesPath)
{
RuleSet CompiledRuleset = new(_loggerFactory);
if (!string.IsNullOrEmpty(rulesPath))
{
if (Directory.Exists(rulesPath))
{
CompiledRuleset.AddDirectory(rulesPath);
}
else if (File.Exists(rulesPath))
{
CompiledRuleset.AddFile(rulesPath);
}
else
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_RULE_PATH, rulesPath));
}
}
return(Verify(CompiledRuleset));
}
/// <summary>
/// Establish console verbosity
/// For NuGet DLL use, console is muted overriding any arguments sent
/// </summary>
private void ConfigureConsoleOutput()
{
WriteOnce.SafeLog("PackRulesCommand::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(_options.ConsoleVerbosityLevel, true, out verbosity))
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, "-x"));
}
else
{
WriteOnce.Verbosity = verbosity;
}
}
}
/// <summary>
/// Return list of rule verification results
/// </summary>
/// <returns></returns>
public List <RuleStatus> Verify()
{
_ruleStatuses = new List <RuleStatus>();
if (!string.IsNullOrEmpty(_rulesPath))
{
if (Directory.Exists(_rulesPath))
{
LoadDirectory(_rulesPath);
}
else if (File.Exists(_rulesPath))
{
LoadFile(_rulesPath);
}
else
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_RULE_PATH, _rulesPath));
}
CheckIntegrity();
}
return(_ruleStatuses);
}
/// <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);
}
private void ConfigRules()
{
WriteOnce.SafeLog("ExportTagsCommand::ConfigRules", LogLevel.Trace);
if (!_options.IgnoreDefaultRules)
{
_rules = Utils.GetDefaultRuleSet(_options.Log);
}
if (!string.IsNullOrEmpty(_options.CustomRulesPath))
{
if (_rules == null)
{
_rules = new RuleSet(_options.Log);
}
if (Directory.Exists(_options.CustomRulesPath))
{
_rules.AddDirectory(_options.CustomRulesPath);
}
else if (File.Exists(_options.CustomRulesPath))
{
_rules.AddFile(_options.CustomRulesPath);
}
else
{
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_RULE_PATH, _options.CustomRulesPath));
}
}
//error check based on ruleset not path enumeration
if (_rules == null || _rules.Count() == 0)
{
throw new OpException(MsgHelp.GetString(MsgHelp.ID.CMD_NORULES_SPECIFIED));
}
}
public List <RuleStatus> CheckIntegrity(RuleSet ruleSet)
{
List <RuleStatus> ruleStatuses = new();
foreach (ConvertedOatRule rule in ruleSet.GetOatRules() ?? Array.Empty <ConvertedOatRule>())
{
RuleStatus ruleVerified = CheckIntegrity(rule);
ruleStatuses.Add(ruleVerified);
if (_failFast && !ruleVerified.Verified)
{
break;
}
}
var duplicatedRules = ruleSet.GroupBy(x => x.Id).Where(y => y.Count() > 1);
if (duplicatedRules.Any())
{
foreach (var rule in duplicatedRules)
{
_logger.LogError(MsgHelp.GetString(MsgHelp.ID.VERIFY_RULES_DUPLICATEID_FAIL), rule.Key);
var relevantStati = ruleStatuses.Where(x => x.RulesId == rule.Key);
foreach (var status in relevantStati)
{
status.Errors = status.Errors.Append(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULES_DUPLICATEID_FAIL, rule.Key));
}
if (_failFast)
{
break;
}
}
}
return(ruleStatuses);
}
/// <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);
}
public bool CheckIntegrity(Rule rule)
{
bool isValid = true;
// Check for null Id
if (rule.Id == null)
{
_logger?.Error(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULES_NULLID_FAIL, rule.Name));
isValid = false;
}
else
{
// Check for same ID
Rule sameRule = _rules.FirstOrDefault(x => x.Id == rule.Id);
if (_rules.Count(x => x.Id == rule.Id) > 1)
{
_logger?.Error(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULES_DUPLICATEID_FAIL, rule.Id));
isValid = false;
}
}
//applicability
if (rule.AppliesTo != null)
{
string[] languages = Language.GetNames();
// Check for unknown language
foreach (string lang in rule.AppliesTo)
{
if (!string.IsNullOrEmpty(lang))
{
if (!languages.Any(x => x.Equals(lang, StringComparison.CurrentCultureIgnoreCase)))
{
_logger?.Error(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULES_LANGUAGE_FAIL, rule.Id ?? ""));
isValid = false;
}
}
}
}
//valid search pattern
foreach (SearchPattern searchPattern in rule.Patterns ?? new SearchPattern[] { })
{
try
{
Regex regex = new Regex(searchPattern.Pattern);
}
catch (Exception e)
{
_logger?.Error(MsgHelp.FormatString(MsgHelp.ID.VERIFY_RULES_REGEX_FAIL, rule.Id ?? "", searchPattern.Pattern ?? "", e.Message));
isValid = false;
break;
}
}
if (rule.Tags?.Length == 0)
{
isValid = false;
}
return(isValid);
}
