/// <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"));
RulesVerifier verifier = new RulesVerifier(_arg_customRulesPath);
if (!verifier.Verify())
{
return((int)ExitCode.NotVerified);
}
RuleSet rules = verifier.CompiledRuleset;
//report each add
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, "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 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);
}
/// <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 string GetResult()
{
Assembly assembly = Assembly.GetCallingAssembly();
if (!assembly.GetName().Name.Contains("ApplicationInspector.CLI"))
{
WriteOnce.FlushAll();
WriteOnce.Log = _arg_logger;
}
_arg_outputFile ??= "output.txt";
if ((int)ExitCode.CriticalError != Run())
{
return(File.ReadAllText(_arg_outputFile));
}
return(string.Empty);
}
/// <summary>
/// Note that WriteOnce.Writer is not used for AnalyzeCommand which has specific Writer classes for formattig to html, json, text unlike
/// other command classes to writting to a file here is handled by the AnalyzeCommand FlushAll() method
/// </summary>
void ConfigFileOutput()
{
WriteOnce.SafeLog("AnalyzeCommand::ConfigOutput", LogLevel.Trace);
WriteOnce.FlushAll();//in case called more than once
//error check for no output
if (string.IsNullOrEmpty(_arg_outputFile) && _arg_consoleVerbosityLevel.ToLower() == "none")
{
throw new Exception(ErrMsg.GetString(ErrMsg.ID.CMD_NO_OUTPUT));
}
if (_arg_fileFormat == "html")
{
if (!string.IsNullOrEmpty(_arg_outputFile)) //dependent local files won't be there; TODO look into dir copy to target!
{
_arg_outputFile = String.Empty;
WriteOnce.Info("output file argument ignored for html format");
}
if (!_arg_outputUniqueTagsOnly) //fix #183
{
throw new Exception(ErrMsg.GetString(ErrMsg.ID.ANALYZE_NODUPLICATES_HTML_FORMAT));
}
if (_arg_simpleTagsOnly) //won't work for html that expects full data
{
throw new Exception(ErrMsg.GetString(ErrMsg.ID.ANALYZE_SIMPLETAGS_HTML_FORMAT));
}
}
//Set outstream
_outputWriter = WriterFactory.GetWriter(_arg_fileFormat ?? "text", (string.IsNullOrEmpty(_arg_outputFile)) ? null : "text", _arg_outputTextFormat);
if (!string.IsNullOrEmpty(_arg_outputFile))
{
_outputWriter.TextWriter = File.CreateText(_arg_outputFile);//not needed if html output since application controlled
}
else
{
_outputWriter.TextWriter = Console.Out;
}
}
void ConfigureFileOutput()
{
WriteOnce.SafeLog("TagDiff::ConfigOutput", LogLevel.Trace);
WriteOnce.FlushAll();//in case called more than once
if (string.IsNullOrEmpty(_arg_outputFile) && _arg_consoleVerbosityLevel.ToLower() == "none")
{
throw new Exception(ErrMsg.GetString(ErrMsg.ID.CMD_NO_OUTPUT));
}
else if (!string.IsNullOrEmpty(_arg_outputFile))
{
WriteOnce.Writer = File.CreateText(_arg_outputFile);
WriteOnce.Writer.WriteLine(Utils.GetVersionString());
}
else
{
WriteOnce.Writer = Console.Out;
}
}
/// <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 string GetResult()
{
Assembly assembly = Assembly.GetCallingAssembly();
if (!assembly.GetName().Name.Contains("ApplicationInspector.CLI"))
{
WriteOnce.FlushAll();
WriteOnce.Log = _arg_logger;
}
_arg_fileFormat ??= "json";
_arg_outputFile ??= "output.json";
ConfigOutput();
if ((int)ExitCode.Success == Run())
{
return(File.ReadAllText(_arg_outputFile));
}
return(string.Empty);
}
//Main entry from CLI
public override int Run()
{
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "Exporttags"));
SortedDictionary <string, string> uniqueTags = new SortedDictionary <string, string>();
foreach (Rule r in _rules)
{
//builds a list of unique tags
foreach (string t in r.Tags)
{
if (uniqueTags.ContainsKey(t))
{
continue;
}
else
{
uniqueTags.Add(t, t);
}
}
}
//separate loop so results are sorted (Sorted type)
foreach (string s in uniqueTags.Values)
{
WriteOnce.Result(s, true);
}
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Exporttags"), true, WriteOnce.ConsoleVerbosity.Low);
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((int)ExitCode.Success);
}
/// <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 from CLI
/// </summary>
/// <returns></returns>
public override int Run()
{
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "tagtest"));
//init based on true or false present argument value
bool testSuccess = true;
//one file vs ruleset
string tmp1 = Path.GetTempFileName();
WriteOnce.ConsoleVerbosity saveVerbosity = WriteOnce.Verbosity;
AnalyzeCommand.ExitCode result = AnalyzeCommand.ExitCode.CriticalError;
//setup analyze call with silent option
#region analyzesetup
try
{
AnalyzeCommand cmd1 = new AnalyzeCommand(new AnalyzeCommandOptions
{
SourcePath = _arg_srcPath,
OutputFilePath = tmp1,
OutputFileFormat = "json",
CustomRulesPath = _arg_customRulesPath,
IgnoreDefaultRules = _arg_ignoreDefaultRules,
SimpleTagsOnly = true,
AllowDupTags = false,
FilePathExclusions = "sample,example,test,docs,.vs,.git",
ConsoleVerbosityLevel = "None",
Log = _arg_logger
});
//quiet analysis commands
result = (AnalyzeCommand.ExitCode)cmd1.Run();
}
catch (Exception e)
{
WriteOnce.Verbosity = saveVerbosity;
throw e;
}
//restore
WriteOnce.Verbosity = saveVerbosity;
if (result == AnalyzeCommand.ExitCode.CriticalError)
{
throw new OpException(ErrMsg.GetString(ErrMsg.ID.CMD_CRITICAL_FILE_ERR));
}
else if (result == AnalyzeCommand.ExitCode.NoMatches)
{
//results
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.FlushAll();
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Tagtest"));
return((int)ExitCode.CriticalError);
}
#endregion
//assumed (result == AnalyzeCommand.ExitCode.MatchesFound)
string file1TagsJson = File.ReadAllText(tmp1);
var file1TagsObj = JsonConvert.DeserializeObject <TagsFile[]>(file1TagsJson);
var file1Tags = file1TagsObj.First(); // here we have a single FileList object
File.Delete(tmp1);
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
{
testSuccess = false;
WriteOnce.Result(ErrMsg.FormatString(ErrMsg.ID.TAGTEST_RESULTS_TAGS_MISSING, t), true, WriteOnce.ConsoleVerbosity.High);
}
}
}
//results
WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.TAGTEST_RESULTS_TEST_TYPE, _arg_tagTestType.ToString()), false, WriteOnce.ConsoleVerbosity.Low);
if (testSuccess)
{
WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.TAGTEST_RESULTS_SUCCESS), true, ConsoleColor.Green, WriteOnce.ConsoleVerbosity.Low);
}
else
{
WriteOnce.Any(ErrMsg.GetString(ErrMsg.ID.TAGTEST_RESULTS_FAIL), true, ConsoleColor.Red, WriteOnce.ConsoleVerbosity.Low);
}
WriteOnce.FlushAll();
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Tagtest"));
return(testSuccess ? (int)ExitCode.NoDiff : (int)ExitCode.DiffFound);
}
/// <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);
}
public override int Run()
{
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "Tagdiff"));
//setup output
TextWriter outputWriter;
if (!string.IsNullOrEmpty(_arg_outputFile))
{
outputWriter = File.CreateText(_arg_outputFile);
outputWriter.WriteLine(Utils.GetVersionString());
WriteOnce.Writer = outputWriter;
}
if (_arg_src1 == _arg_src2)
{
throw new OpException(ErrMsg.GetString(ErrMsg.ID.TAGDIFF_SAME_FILE_ARG));
}
else if (string.IsNullOrEmpty(_arg_src1) || string.IsNullOrEmpty(_arg_src2))
{
throw new OpException(ErrMsg.GetString(ErrMsg.ID.CMD_INVALID_ARG_VALUE));
}
#region setup analyze calls
//save to quiet analyze cmd
WriteOnce.ConsoleVerbosity saveVerbosity = WriteOnce.Verbosity;
string tmp1 = Path.GetTempFileName();
string tmp2 = Path.GetTempFileName();
AnalyzeCommand.ExitCode result1 = AnalyzeCommand.ExitCode.CriticalError;
AnalyzeCommand.ExitCode result2 = AnalyzeCommand.ExitCode.CriticalError;
try
{
AnalyzeCommand cmd1 = new AnalyzeCommand(new AnalyzeCommandOptions
{
SourcePath = _arg_src1,
OutputFilePath = tmp1,
OutputFileFormat = "json",
CustomRulesPath = _arg_rulesPath,
IgnoreDefaultRules = _arg_ignoreDefault,
SimpleTagsOnly = true,
AllowDupTags = false,
FilePathExclusions = "sample,example,test,docs,.vs,.git",
ConsoleVerbosityLevel = "None"
});
AnalyzeCommand cmd2 = new AnalyzeCommand(new AnalyzeCommandOptions
{
SourcePath = _arg_src2,
OutputFilePath = tmp2,
OutputFileFormat = "json",
CustomRulesPath = _arg_rulesPath,
IgnoreDefaultRules = _arg_ignoreDefault,
SimpleTagsOnly = true,
AllowDupTags = false,
FilePathExclusions = "sample,example,test,docs,.vs,.git",
ConsoleVerbosityLevel = "None"
});
result1 = (AnalyzeCommand.ExitCode)cmd1.Run();
result2 = (AnalyzeCommand.ExitCode)cmd2.Run();
}
catch (Exception e)
{
//restore
WriteOnce.Verbosity = saveVerbosity;
throw e;
}
//restore
WriteOnce.Verbosity = saveVerbosity;
#endregion
bool successResult;
bool equal1 = true;
bool equal2 = true;
//process results for each analyze call before comparing results
if (result1 == AnalyzeCommand.ExitCode.CriticalError)
{
throw new OpException(ErrMsg.FormatString(ErrMsg.ID.CMD_CRITICAL_FILE_ERR, _arg_src1));
}
else if (result2 == AnalyzeCommand.ExitCode.CriticalError)
{
throw new OpException(ErrMsg.FormatString(ErrMsg.ID.CMD_CRITICAL_FILE_ERR, _arg_src2));
}
else if (result1 == AnalyzeCommand.ExitCode.NoMatches || result2 == AnalyzeCommand.ExitCode.NoMatches)
{
throw new OpException(ErrMsg.GetString(ErrMsg.ID.TAGDIFF_NO_TAGS_FOUND));
}
else //compare tag results; assumed (result1&2 == AnalyzeCommand.ExitCode.MatchesFound)
{
string file1TagsJson = File.ReadAllText(tmp1);
string file2TagsJson = File.ReadAllText(tmp2);
var file1Tags = JsonConvert.DeserializeObject <TagsFile[]>(file1TagsJson).First();
var file2Tags = JsonConvert.DeserializeObject <TagsFile[]>(file2TagsJson).First();
//can't simply compare counts as content may differ; must compare both in directions in two passes a->b; b->a
//first pass
WriteOnce.General(ErrMsg.FormatString(ErrMsg.ID.TAGDIFF_RESULTS_GAP, Path.GetFileName(_arg_src1), Path.GetFileName(_arg_src2)),
true, WriteOnce.ConsoleVerbosity.High);
equal1 = 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);
equal2 = CompareTags(file2Tags.Tags, file1Tags.Tags);
//final results
bool resultsDiffer = !(equal1 && equal2);
if (_arg_tagTestType == TagTestType.Inequality && resultsDiffer)
{
successResult = true;
}
else if (_arg_tagTestType == TagTestType.Equality && !resultsDiffer)
{
successResult = true;
}
else
{
successResult = false;
}
WriteOnce.General(ErrMsg.GetString(ErrMsg.ID.TAGDIFF_RESULTS_DIFFER), false);
WriteOnce.Result(resultsDiffer.ToString());
}
//cleanup
try
{
File.Delete(tmp1);
File.Delete(tmp2);
}
catch
{
//no action needed;
}
WriteOnce.FlushAll();
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Tagdiff"));
return(successResult ? (int)ExitCode.TestPassed : (int)ExitCode.TestFailed);
}
/// <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);
}
//Main entry from CLI
public override int Run()
{
WriteOnce.SafeLog("ExportTagsCommand::Run", LogLevel.Trace);
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_RUNNING, "Exporttags"));
SortedDictionary <string, string> uniqueTags = new SortedDictionary <string, string>();
try
{
foreach (Rule r in _rules)
{
//builds a list of unique tags
foreach (string t in r.Tags)
{
if (uniqueTags.ContainsKey(t))
{
continue;
}
else
{
uniqueTags.Add(t, t);
}
}
}
//separate loop so results are sorted (Sorted type)
foreach (string s in uniqueTags.Values)
{
WriteOnce.Result(s, true);
}
WriteOnce.Operation(ErrMsg.FormatString(ErrMsg.ID.CMD_COMPLETED, "Exporttags"));
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.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.Success);
}