public void RuleTriggeredByTimeout(TimeBetweenOperations rule)
{
var msg = new AlarmMessage(rule.AlarmLevel, rule.ProgramName, $"Rule {rule.RuleName} triggered. Message: {rule.AlarmMessage}");
AlarmMessageManager.RaiseAlarm(msg);
#if DEBUG
Debug.WriteLine($"ALARM! {rule.AlarmLevel} level. From {rule.ProgramName}. Message: {rule.AlarmMessage}");
#endif
}
public ProgramAnalyzer(AlarmMessageManager alarmMessageManager)
{
AlarmMessageManager = alarmMessageManager;
foreach (var rule in Rules.Where(x => x.Value is TimeBetweenOperations))
{
var realRule = (TimeBetweenOperations)rule.Value;
realRule.AttachObserver(this);
}
}
private void MainLoop()
{
if (EventQueue.TryDequeue(out SystemEvent fromQ))
{
Parallel.ForEach(Rules.Where(r => string.IsNullOrEmpty(r.Value.OperationName) || r.Value.OperationName.Equals(fromQ.OperationName)), rule =>
{
if (rule.Value.AddAndCheckIfTriggered(fromQ))
{
var msg = new AlarmMessage(rule.Value.AlarmLevel, fromQ.AppInfo.ApplicationName, $"Rule {rule.Value.RuleName} triggered. Message: {rule.Value.AlarmMessage}", fromQ.CaughtException.Message, fromQ.ID);
AlarmMessageManager.RaiseAlarm(msg);
#if DEBUG
Debug.WriteLine($"ALARM! {rule.Value.AlarmLevel} level. From {fromQ.AppInfo.ApplicationName}. Message: {rule.Value.AlarmMessage}");
#endif
}
});
}
else
{
AnalyzerChangeState(State.Stopped);
}
}
/// <summary>
/// Starts the engine. Reads <see cref="AnalyzeRule"/>s from storage and builds a collection of <see cref="ProgramAnalyzer"/>s to hold them.
/// </summary>
/// <param name="ruleStorage">The <see cref="AnalyzeRule"/> storage.</param>
/// <param name="alarmMessageManager">The alarm manager.</param>
public void StartEngine(IRuleStorage ruleStorage, AlarmMessageManager alarmMessageManager)
{
AddMessage($"Starting {nameof(AnalyzerEngine)} {Guid.NewGuid()}");
RuleStorage = ruleStorage;
AlarmMessageManager = alarmMessageManager;
Analyzers.Clear();
var allRules = RuleStorage.GetAllRules();
if (allRules.Count == 0)
{
AddMessage("Starting with no rules.");
}
else
{
AddRulesToAnalyzer(allRules);
}
foreach (var analyzer in Analyzers)
{
analyzer.Value.StartAnalyzer();
}
StartEngine();
}
public void StartAnalyzer()
{
var analyzerThread = new Thread(() =>
{
try
{
AnalyzerChangeState(State.Running);
while (State == State.Running)
{
MainLoop();
}
while (EventQueue.Count > 0)
{
MainLoop();
}
AnalyzerChangeState(State.Stopped);
}
catch (Exception ex)
{
try
{
AnalyzerChangeState(State.Stopped);
var message = $"Exception in {nameof(ProgramAnalyzer)}.{nameof(StartAnalyzer)} for {ProgramName}.";
OnReportException?.Invoke(message, ex);
var alarmMessage = new AlarmMessage(AlarmLevel.Medium, AppDomain.CurrentDomain.FriendlyName, message, ex.InnerException?.Message ?? ex.Message);
AlarmMessageManager.RaiseAlarm(alarmMessage);
}
catch (Exception ex2)
{
OnReportException?.Invoke("Exception in Exception handling", ex2);
}
}
}
);
analyzerThread.Priority = ThreadPriority.Highest;
analyzerThread.Name = nameof(analyzerThread) + "_" + ProgramName;
analyzerThread.Start();
}
/// <summary>
/// Starts the engine task.
/// </summary>
/// <returns></returns>
private void StartEngine()
{
var engineThread = new Thread(() =>
{
try
{
ChangeState(State.Running);
AddMessage("Main engine thread started.");
while (State == State.Running)
{
MainLoop();
}
AddMessage($"Shutting down. Running main loop until main queue is empty. {MainEventQueue.Count} events in queue.");
while (MainEventQueue.Count > 0)
{
MainLoop();
}
AddMessage("Main queue emptied. Shutting down analyzers");
foreach (var analyzer in Analyzers)
{
AddMessage($"Stopping analyzer for {analyzer.Key}");
analyzer.Value.StopAnalyzer();
}
}
catch (Exception ex)
{
ChangeState(State.Stopped);
var message = $"Exception in {nameof(AnalyzerEngine)}.{nameof(StartEngine)}. Engine is down. Engine will try to restart.";
OnReportException?.Invoke(message, ex);
var alarmMessage = new AlarmMessage(AlarmLevel.Medium, AppDomain.CurrentDomain.FriendlyName, message, ex.Message);
AlarmMessageManager.RaiseAlarm(alarmMessage);
}
});
engineThread.Priority = ThreadPriority.Highest;
engineThread.Name = nameof(engineThread);
engineThread.Start();
}
