/// <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"));
RulesVerifier verifier = new RulesVerifier(_path);
if (!verifier.Verify())//throws anyway
{
return((int)ExitCode.CriticalError);
}
List <Rule> list = new List <Rule>(verifier.CompiledRuleset.AsEnumerable());
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Formatting = (_indent) ? Formatting.Indented : Formatting.None;
using (FileStream fs = File.Open(_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, _outputfile), true, ConsoleColor.Gray, WriteOnce.ConsoleVerbosity.Medium);
return((int)ExitCode.NoIssues);
}
/// <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);
}
/// <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>
/// 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 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);
}
