614 lines
25 KiB
C#
614 lines
25 KiB
C#
using Akka.Actor;
|
|
using Microsoft.CodeAnalysis.Scripting;
|
|
using Microsoft.Extensions.Logging;
|
|
using ScadaLink.Commons.Messages.Streaming;
|
|
using ScadaLink.Commons.Types.Enums;
|
|
using ScadaLink.Commons.Types.Flattening;
|
|
using ScadaLink.HealthMonitoring;
|
|
using ScadaLink.SiteRuntime.Scripts;
|
|
using System.Text.Json;
|
|
|
|
namespace ScadaLink.SiteRuntime.Actors;
|
|
|
|
/// <summary>
|
|
/// WP-16: Alarm Actor — coordinator actor, child of Instance Actor, peer to Script Actors.
|
|
/// Subscribes to attribute change notifications from Instance Actor.
|
|
///
|
|
/// Evaluates alarm conditions:
|
|
/// - ValueMatch: attribute equals a specific value
|
|
/// - RangeViolation: attribute outside min/max range
|
|
/// - RateOfChange: attribute rate exceeds threshold (configurable window, default per-second)
|
|
///
|
|
/// State (active/normal) is in memory only, NOT persisted.
|
|
/// On restart: starts normal, re-evaluates from incoming values.
|
|
///
|
|
/// WP-21: AlarmExecutionActor CAN call Instance.CallScript() (ask to sibling Script Actor).
|
|
/// Instance scripts CANNOT call alarm on-trigger scripts (no Instance.CallAlarmScript API).
|
|
///
|
|
/// Supervision: Resume on exception; AlarmExecutionActor stopped on exception.
|
|
/// </summary>
|
|
public class AlarmActor : ReceiveActor
|
|
{
|
|
private readonly string _alarmName;
|
|
private readonly string _instanceName;
|
|
private readonly IActorRef _instanceActor;
|
|
private readonly SharedScriptLibrary _sharedScriptLibrary;
|
|
private readonly SiteRuntimeOptions _options;
|
|
private readonly ILogger _logger;
|
|
private readonly ISiteHealthCollector? _healthCollector;
|
|
|
|
private AlarmState _currentState = AlarmState.Normal;
|
|
/// <summary>
|
|
/// Always <see cref="AlarmLevel.None"/> for binary trigger types. For
|
|
/// <see cref="AlarmTriggerType.HiLo"/> this is the source of truth — the
|
|
/// state machine transitions when the computed level changes.
|
|
/// </summary>
|
|
private AlarmLevel _currentLevel = AlarmLevel.None;
|
|
private readonly AlarmTriggerType _triggerType;
|
|
private readonly AlarmEvalConfig _evalConfig;
|
|
private readonly int _priority;
|
|
private readonly string? _onTriggerScriptName;
|
|
private readonly Script<object?>? _onTriggerCompiledScript;
|
|
|
|
// Expression trigger: compiled expression + the attribute snapshot it
|
|
// evaluates against. The compiled expression is also held on the
|
|
// ExpressionEvalConfig; this field caches it for the hot path.
|
|
private readonly Script<object?>? _compiledTriggerExpression;
|
|
private readonly Dictionary<string, object?> _attributeSnapshot = new();
|
|
|
|
// Rate of change tracking
|
|
private readonly Queue<(DateTimeOffset Timestamp, double Value)> _rateOfChangeWindow = new();
|
|
private readonly TimeSpan _rateOfChangeWindowDuration;
|
|
|
|
private int _executionCounter;
|
|
|
|
public AlarmActor(
|
|
string alarmName,
|
|
string instanceName,
|
|
IActorRef instanceActor,
|
|
ResolvedAlarm alarmConfig,
|
|
Script<object?>? onTriggerCompiledScript,
|
|
SharedScriptLibrary sharedScriptLibrary,
|
|
SiteRuntimeOptions options,
|
|
ILogger logger,
|
|
Script<object?>? compiledTriggerExpression = null,
|
|
ISiteHealthCollector? healthCollector = null)
|
|
{
|
|
_alarmName = alarmName;
|
|
_instanceName = instanceName;
|
|
_instanceActor = instanceActor;
|
|
_sharedScriptLibrary = sharedScriptLibrary;
|
|
_options = options;
|
|
_logger = logger;
|
|
_healthCollector = healthCollector;
|
|
_priority = alarmConfig.PriorityLevel;
|
|
_onTriggerScriptName = alarmConfig.OnTriggerScriptCanonicalName;
|
|
_onTriggerCompiledScript = onTriggerCompiledScript;
|
|
_compiledTriggerExpression = compiledTriggerExpression;
|
|
|
|
// Parse trigger type
|
|
_triggerType = Enum.TryParse<AlarmTriggerType>(alarmConfig.TriggerType, true, out var tt)
|
|
? tt : AlarmTriggerType.ValueMatch;
|
|
|
|
_evalConfig = ParseEvalConfig(alarmConfig.TriggerConfiguration);
|
|
_rateOfChangeWindowDuration = _evalConfig is RateOfChangeEvalConfig roc
|
|
? roc.WindowDuration
|
|
: TimeSpan.FromSeconds(1);
|
|
|
|
// Handle attribute value changes
|
|
Receive<AttributeValueChanged>(HandleAttributeValueChanged);
|
|
|
|
// Handle alarm execution completion
|
|
Receive<AlarmExecutionCompleted>(_ =>
|
|
_logger.LogDebug("Alarm {Alarm} execution completed on {Instance}", _alarmName, _instanceName));
|
|
}
|
|
|
|
protected override void PreStart()
|
|
{
|
|
base.PreStart();
|
|
_logger.LogInformation(
|
|
"AlarmActor {Alarm} started on instance {Instance}, trigger={TriggerType}",
|
|
_alarmName, _instanceName, _triggerType);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Supervision: Resume on exception; AlarmExecutionActor stopped on exception.
|
|
/// </summary>
|
|
protected override SupervisorStrategy SupervisorStrategy()
|
|
{
|
|
return new OneForOneStrategy(
|
|
maxNrOfRetries: -1,
|
|
withinTimeRange: TimeSpan.FromMinutes(1),
|
|
decider: Decider.From(ex =>
|
|
{
|
|
_logger.LogWarning(ex,
|
|
"AlarmExecutionActor for {Alarm} on {Instance} failed, stopping",
|
|
_alarmName, _instanceName);
|
|
return Directive.Stop;
|
|
}));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Evaluates alarm condition on attribute change. Alarm evaluation errors are logged,
|
|
/// actor continues (does not crash).
|
|
/// </summary>
|
|
private void HandleAttributeValueChanged(AttributeValueChanged changed)
|
|
{
|
|
// Expression triggers evaluate against a snapshot of every attribute,
|
|
// not a single monitored attribute. Keep the snapshot current for every
|
|
// change before the IsMonitoredAttribute gate (which does not apply).
|
|
if (_triggerType == AlarmTriggerType.Expression)
|
|
{
|
|
_attributeSnapshot[changed.AttributeName] = changed.Value;
|
|
}
|
|
else if (!IsMonitoredAttribute(changed.AttributeName))
|
|
{
|
|
// Only evaluate if this change is for an attribute we're monitoring
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (_triggerType == AlarmTriggerType.HiLo)
|
|
{
|
|
HandleHiLoTransition(EvaluateHiLo(changed.Value));
|
|
return;
|
|
}
|
|
|
|
var isTriggered = _triggerType switch
|
|
{
|
|
AlarmTriggerType.ValueMatch => EvaluateValueMatch(changed.Value),
|
|
AlarmTriggerType.RangeViolation => EvaluateRangeViolation(changed.Value),
|
|
AlarmTriggerType.RateOfChange => EvaluateRateOfChange(changed.Value, changed.Timestamp),
|
|
AlarmTriggerType.Expression => EvaluateExpression(),
|
|
_ => false
|
|
};
|
|
|
|
if (isTriggered && _currentState == AlarmState.Normal)
|
|
{
|
|
// Transition: Normal → Active
|
|
_currentState = AlarmState.Active;
|
|
_logger.LogInformation(
|
|
"Alarm {Alarm} ACTIVATED on instance {Instance}",
|
|
_alarmName, _instanceName);
|
|
|
|
// Notify Instance Actor of alarm state change
|
|
var alarmChanged = new AlarmStateChanged(
|
|
_instanceName, _alarmName, AlarmState.Active, _priority, DateTimeOffset.UtcNow);
|
|
_instanceActor.Tell(alarmChanged);
|
|
|
|
// Spawn AlarmExecutionActor if on-trigger script defined
|
|
if (_onTriggerCompiledScript != null)
|
|
{
|
|
SpawnAlarmExecution(AlarmLevel.None, _priority, string.Empty);
|
|
}
|
|
}
|
|
else if (!isTriggered && _currentState == AlarmState.Active)
|
|
{
|
|
// Transition: Active → Normal (no script on clear)
|
|
_currentState = AlarmState.Normal;
|
|
_logger.LogInformation(
|
|
"Alarm {Alarm} CLEARED on instance {Instance}",
|
|
_alarmName, _instanceName);
|
|
|
|
var alarmChanged = new AlarmStateChanged(
|
|
_instanceName, _alarmName, AlarmState.Normal, _priority, DateTimeOffset.UtcNow);
|
|
_instanceActor.Tell(alarmChanged);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_healthCollector?.IncrementAlarmError();
|
|
// Alarm evaluation errors logged, actor continues
|
|
_logger.LogError(ex,
|
|
"Alarm {Alarm} evaluation error on {Instance}",
|
|
_alarmName, _instanceName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// HiLo state machine: emit an AlarmStateChanged whenever the evaluated
|
|
/// level changes. Spawns the on-trigger script only on the Normal→Active
|
|
/// edge (i.e., when entering an alarm band from the normal band) — not on
|
|
/// level escalations like Hi→HiHi or Low→LowLow.
|
|
/// </summary>
|
|
private void HandleHiLoTransition(AlarmLevel newLevel)
|
|
{
|
|
if (newLevel == _currentLevel) return;
|
|
|
|
var previousLevel = _currentLevel;
|
|
_currentLevel = newLevel;
|
|
_currentState = newLevel == AlarmLevel.None ? AlarmState.Normal : AlarmState.Active;
|
|
var priority = LevelPriority(newLevel);
|
|
var message = LevelMessage(newLevel);
|
|
|
|
_logger.LogInformation(
|
|
"Alarm {Alarm} on {Instance} transitioned {Prev} → {New} (priority={Priority})",
|
|
_alarmName, _instanceName, previousLevel, newLevel, priority);
|
|
|
|
var alarmChanged = new AlarmStateChanged(
|
|
_instanceName, _alarmName, _currentState, priority, DateTimeOffset.UtcNow)
|
|
{
|
|
Level = newLevel,
|
|
Message = message
|
|
};
|
|
_instanceActor.Tell(alarmChanged);
|
|
|
|
if (previousLevel == AlarmLevel.None
|
|
&& newLevel != AlarmLevel.None
|
|
&& _onTriggerCompiledScript != null)
|
|
{
|
|
SpawnAlarmExecution(newLevel, priority, message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the per-setpoint priority for the given level. Falls back to
|
|
/// the alarm-level <see cref="_priority"/> when the HiLo config did not
|
|
/// override the priority for that band, or for <see cref="AlarmLevel.None"/>.
|
|
/// </summary>
|
|
private int LevelPriority(AlarmLevel level)
|
|
{
|
|
if (_evalConfig is not HiLoEvalConfig hiLo) return _priority;
|
|
return level switch
|
|
{
|
|
AlarmLevel.LowLow => hiLo.LoLoPriority ?? _priority,
|
|
AlarmLevel.Low => hiLo.LoPriority ?? _priority,
|
|
AlarmLevel.High => hiLo.HiPriority ?? _priority,
|
|
AlarmLevel.HighHigh => hiLo.HiHiPriority ?? _priority,
|
|
_ => _priority
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Per-band operator message. Empty string when no message is configured
|
|
/// for the band, or for non-HiLo trigger types, or for the None level
|
|
/// (alarm clear).
|
|
/// </summary>
|
|
private string LevelMessage(AlarmLevel level)
|
|
{
|
|
if (_evalConfig is not HiLoEvalConfig hiLo) return string.Empty;
|
|
return level switch
|
|
{
|
|
AlarmLevel.LowLow => hiLo.LoLoMessage ?? string.Empty,
|
|
AlarmLevel.Low => hiLo.LoMessage ?? string.Empty,
|
|
AlarmLevel.High => hiLo.HiMessage ?? string.Empty,
|
|
AlarmLevel.HighHigh => hiLo.HiHiMessage ?? string.Empty,
|
|
_ => string.Empty
|
|
};
|
|
}
|
|
|
|
private bool IsMonitoredAttribute(string attributeName)
|
|
{
|
|
return _evalConfig.MonitoredAttributeName == attributeName;
|
|
}
|
|
|
|
private bool EvaluateValueMatch(object? value)
|
|
{
|
|
if (_evalConfig is not ValueMatchEvalConfig config) return false;
|
|
if (config.MatchValue == null) return value == null;
|
|
|
|
var valueStr = value?.ToString() ?? "";
|
|
|
|
// Support "!=X" for not-equal matching
|
|
if (config.MatchValue.StartsWith("!="))
|
|
{
|
|
var expected = config.MatchValue[2..];
|
|
return !string.Equals(valueStr, expected, StringComparison.Ordinal);
|
|
}
|
|
|
|
return string.Equals(valueStr, config.MatchValue, StringComparison.Ordinal);
|
|
}
|
|
|
|
private bool EvaluateRangeViolation(object? value)
|
|
{
|
|
if (_evalConfig is not RangeViolationEvalConfig config) return false;
|
|
if (value == null) return false;
|
|
|
|
try
|
|
{
|
|
var numericValue = Convert.ToDouble(value);
|
|
return numericValue < config.Min || numericValue > config.Max;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private bool EvaluateRateOfChange(object? value, DateTimeOffset timestamp)
|
|
{
|
|
if (_evalConfig is not RateOfChangeEvalConfig config) return false;
|
|
if (value == null) return false;
|
|
|
|
try
|
|
{
|
|
var numericValue = Convert.ToDouble(value);
|
|
|
|
// Add to window
|
|
_rateOfChangeWindow.Enqueue((timestamp, numericValue));
|
|
|
|
// Remove old entries outside the window
|
|
var cutoff = timestamp - _rateOfChangeWindowDuration;
|
|
while (_rateOfChangeWindow.Count > 0 && _rateOfChangeWindow.Peek().Timestamp < cutoff)
|
|
{
|
|
_rateOfChangeWindow.Dequeue();
|
|
}
|
|
|
|
if (_rateOfChangeWindow.Count < 2) return false;
|
|
|
|
var oldest = _rateOfChangeWindow.Peek();
|
|
var timeDelta = (timestamp - oldest.Timestamp).TotalSeconds;
|
|
if (timeDelta <= 0) return false;
|
|
|
|
var signedRate = (numericValue - oldest.Value) / timeDelta;
|
|
return config.Direction switch
|
|
{
|
|
RateOfChangeDirection.Rising => signedRate > config.ThresholdPerSecond,
|
|
RateOfChangeDirection.Falling => -signedRate > config.ThresholdPerSecond,
|
|
_ => Math.Abs(signedRate) > config.ThresholdPerSecond
|
|
};
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Evaluates the compiled trigger expression against the current attribute
|
|
/// snapshot, returning the resulting bool. This bool feeds the existing
|
|
/// binary Normal↔Active state path — the alarm is active while true. A
|
|
/// throwing or non-bool expression is treated as false; the exception
|
|
/// propagates to the caller's catch, which logs it and continues.
|
|
/// </summary>
|
|
private bool EvaluateExpression()
|
|
{
|
|
if (_compiledTriggerExpression == null) return false;
|
|
|
|
var globals = new TriggerExpressionGlobals(_attributeSnapshot);
|
|
var state = _compiledTriggerExpression.RunAsync(globals).GetAwaiter().GetResult();
|
|
return state.ReturnValue is bool b && b;
|
|
}
|
|
|
|
/// <summary>
|
|
/// HiLo level evaluator: returns the most-severe matching band for the
|
|
/// given value. Severity order checked from highest to lowest so that a
|
|
/// value at exactly Hi==HiHi resolves to HighHigh. Unset setpoints (null)
|
|
/// are skipped, allowing partial configs (e.g., HighHigh only).
|
|
///
|
|
/// Hysteresis: when the alarm is already in a level whose threshold the
|
|
/// value would re-cross from inside, the threshold is relaxed by the
|
|
/// configured deadband. This prevents flapping at the boundary — once at
|
|
/// HighHigh with HiHi=100 and hiHiDeadband=5, the alarm stays HighHigh
|
|
/// until the value drops below 95.
|
|
/// </summary>
|
|
private AlarmLevel EvaluateHiLo(object? value)
|
|
{
|
|
if (_evalConfig is not HiLoEvalConfig config) return AlarmLevel.None;
|
|
if (value == null) return _currentLevel;
|
|
|
|
double numericValue;
|
|
try { numericValue = Convert.ToDouble(value); }
|
|
catch { return _currentLevel; }
|
|
|
|
// When the current level is at-or-above HighHigh, relax the HiHi exit.
|
|
// Same for the other directions.
|
|
var hiHiThreshold = config.HiHi;
|
|
if (hiHiThreshold is { } hh && _currentLevel == AlarmLevel.HighHigh)
|
|
hiHiThreshold = hh - Math.Max(0, config.HiHiDeadband ?? 0);
|
|
|
|
var hiThreshold = config.Hi;
|
|
if (hiThreshold is { } h && (_currentLevel == AlarmLevel.High || _currentLevel == AlarmLevel.HighHigh))
|
|
hiThreshold = h - Math.Max(0, config.HiDeadband ?? 0);
|
|
|
|
var loLoThreshold = config.LoLo;
|
|
if (loLoThreshold is { } ll && _currentLevel == AlarmLevel.LowLow)
|
|
loLoThreshold = ll + Math.Max(0, config.LoLoDeadband ?? 0);
|
|
|
|
var loThreshold = config.Lo;
|
|
if (loThreshold is { } l && (_currentLevel == AlarmLevel.Low || _currentLevel == AlarmLevel.LowLow))
|
|
loThreshold = l + Math.Max(0, config.LoDeadband ?? 0);
|
|
|
|
if (hiHiThreshold is { } effHiHi && numericValue >= effHiHi) return AlarmLevel.HighHigh;
|
|
if (hiThreshold is { } effHi && numericValue >= effHi) return AlarmLevel.High;
|
|
if (loLoThreshold is { } effLoLo && numericValue <= effLoLo) return AlarmLevel.LowLow;
|
|
if (loThreshold is { } effLo && numericValue <= effLo) return AlarmLevel.Low;
|
|
return AlarmLevel.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spawns an AlarmExecutionActor to run the on-trigger script.
|
|
/// Passes the firing alarm's level/priority/message so the script can
|
|
/// branch on severity via the <c>Alarm</c> global.
|
|
/// </summary>
|
|
private void SpawnAlarmExecution(AlarmLevel level, int priority, string message)
|
|
{
|
|
if (_onTriggerCompiledScript == null) return;
|
|
|
|
var executionId = $"{_alarmName}-alarm-exec-{_executionCounter++}";
|
|
|
|
// NOTE: In production, configure a dedicated blocking I/O dispatcher via HOCON.
|
|
var props = Props.Create(() => new AlarmExecutionActor(
|
|
_alarmName,
|
|
_instanceName,
|
|
level,
|
|
priority,
|
|
message,
|
|
_onTriggerCompiledScript,
|
|
_instanceActor,
|
|
_sharedScriptLibrary,
|
|
_options,
|
|
_logger));
|
|
|
|
Context.ActorOf(props, executionId);
|
|
}
|
|
|
|
private AlarmEvalConfig ParseEvalConfig(string? triggerConfigJson)
|
|
{
|
|
if (string.IsNullOrEmpty(triggerConfigJson))
|
|
return new ValueMatchEvalConfig("", null);
|
|
|
|
try
|
|
{
|
|
var doc = JsonDocument.Parse(triggerConfigJson);
|
|
var root = doc.RootElement;
|
|
|
|
// Support both "attributeName" and "attribute" keys
|
|
var attr = root.TryGetProperty("attributeName", out var attrEl)
|
|
? attrEl.GetString() ?? ""
|
|
: root.TryGetProperty("attribute", out var attrEl2)
|
|
? attrEl2.GetString() ?? ""
|
|
: "";
|
|
|
|
return _triggerType switch
|
|
{
|
|
AlarmTriggerType.ValueMatch => new ValueMatchEvalConfig(
|
|
attr,
|
|
root.TryGetProperty("matchValue", out var mv) ? mv.GetString()
|
|
: root.TryGetProperty("value", out var mv2) ? mv2.GetString()
|
|
: null),
|
|
|
|
AlarmTriggerType.RangeViolation => new RangeViolationEvalConfig(
|
|
attr,
|
|
root.TryGetProperty("min", out var minEl) ? minEl.GetDouble()
|
|
: root.TryGetProperty("low", out var lowEl) ? lowEl.GetDouble()
|
|
: double.MinValue,
|
|
root.TryGetProperty("max", out var maxEl) ? maxEl.GetDouble()
|
|
: root.TryGetProperty("high", out var highEl) ? highEl.GetDouble()
|
|
: double.MaxValue),
|
|
|
|
AlarmTriggerType.RateOfChange => new RateOfChangeEvalConfig(
|
|
attr,
|
|
root.TryGetProperty("thresholdPerSecond", out var tps) ? tps.GetDouble() : 10.0,
|
|
root.TryGetProperty("windowSeconds", out var ws)
|
|
? TimeSpan.FromSeconds(ws.GetDouble())
|
|
: TimeSpan.FromSeconds(1),
|
|
root.TryGetProperty("direction", out var dirEl)
|
|
? ParseDirection(dirEl.GetString())
|
|
: RateOfChangeDirection.Either),
|
|
|
|
AlarmTriggerType.HiLo => new HiLoEvalConfig(
|
|
attr,
|
|
LoLo: TryReadDouble(root, "loLo"),
|
|
Lo: TryReadDouble(root, "lo"),
|
|
Hi: TryReadDouble(root, "hi"),
|
|
HiHi: TryReadDouble(root, "hiHi"),
|
|
LoLoPriority: TryReadInt(root, "loLoPriority"),
|
|
LoPriority: TryReadInt(root, "loPriority"),
|
|
HiPriority: TryReadInt(root, "hiPriority"),
|
|
HiHiPriority: TryReadInt(root, "hiHiPriority"),
|
|
LoLoDeadband: TryReadDouble(root, "loLoDeadband"),
|
|
LoDeadband: TryReadDouble(root, "loDeadband"),
|
|
HiDeadband: TryReadDouble(root, "hiDeadband"),
|
|
HiHiDeadband: TryReadDouble(root, "hiHiDeadband"),
|
|
LoLoMessage: TryReadString(root, "loLoMessage"),
|
|
LoMessage: TryReadString(root, "loMessage"),
|
|
HiMessage: TryReadString(root, "hiMessage"),
|
|
HiHiMessage: TryReadString(root, "hiHiMessage")),
|
|
|
|
// Expression triggers have no single monitored attribute; they
|
|
// evaluate the compiled expression (passed into the actor) over
|
|
// the full attribute snapshot. MonitoredAttributeName is unused.
|
|
AlarmTriggerType.Expression => new ExpressionEvalConfig(
|
|
"",
|
|
TryReadString(root, "expression") ?? "",
|
|
_compiledTriggerExpression),
|
|
|
|
_ => new ValueMatchEvalConfig(attr, null)
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to parse alarm trigger config for {Alarm}", _alarmName);
|
|
return new ValueMatchEvalConfig("", null);
|
|
}
|
|
}
|
|
|
|
private static RateOfChangeDirection ParseDirection(string? raw) => raw?.ToLowerInvariant() switch
|
|
{
|
|
"rising" or "up" or "positive" => RateOfChangeDirection.Rising,
|
|
"falling" or "down" or "negative" => RateOfChangeDirection.Falling,
|
|
_ => RateOfChangeDirection.Either
|
|
};
|
|
|
|
private static double? TryReadDouble(JsonElement el, string name)
|
|
{
|
|
if (!el.TryGetProperty(name, out var p)) return null;
|
|
return p.ValueKind switch
|
|
{
|
|
JsonValueKind.Number => p.GetDouble(),
|
|
JsonValueKind.String when double.TryParse(p.GetString(), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var v) => v,
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
private static int? TryReadInt(JsonElement el, string name)
|
|
{
|
|
if (!el.TryGetProperty(name, out var p)) return null;
|
|
return p.ValueKind switch
|
|
{
|
|
JsonValueKind.Number when p.TryGetInt32(out var i) => i,
|
|
JsonValueKind.Number => (int)p.GetDouble(),
|
|
JsonValueKind.String when int.TryParse(p.GetString(), System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out var v) => v,
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
private static string? TryReadString(JsonElement el, string name)
|
|
{
|
|
if (!el.TryGetProperty(name, out var p)) return null;
|
|
return p.ValueKind == JsonValueKind.String ? p.GetString() : null;
|
|
}
|
|
|
|
// ── Internal messages ──
|
|
internal record AlarmExecutionCompleted(string AlarmName, bool Success);
|
|
}
|
|
|
|
internal enum RateOfChangeDirection { Either, Rising, Falling }
|
|
|
|
// ── Alarm evaluation config types ──
|
|
internal abstract record AlarmEvalConfig(string MonitoredAttributeName);
|
|
internal record ValueMatchEvalConfig(string MonitoredAttributeName, string? MatchValue) : AlarmEvalConfig(MonitoredAttributeName);
|
|
internal record RangeViolationEvalConfig(string MonitoredAttributeName, double Min, double Max) : AlarmEvalConfig(MonitoredAttributeName);
|
|
internal record RateOfChangeEvalConfig(
|
|
string MonitoredAttributeName,
|
|
double ThresholdPerSecond,
|
|
TimeSpan WindowDuration,
|
|
RateOfChangeDirection Direction) : AlarmEvalConfig(MonitoredAttributeName);
|
|
|
|
/// <summary>
|
|
/// Expression evaluation config: a read-only boolean C# expression evaluated
|
|
/// over the full attribute snapshot. Has no single monitored attribute
|
|
/// (<see cref="AlarmEvalConfig.MonitoredAttributeName"/> is empty); the
|
|
/// compiled expression is passed into the actor and cached here.
|
|
/// </summary>
|
|
internal record ExpressionEvalConfig(
|
|
string MonitoredAttributeName,
|
|
string Expression,
|
|
Script<object?>? CompiledExpression) : AlarmEvalConfig(MonitoredAttributeName);
|
|
|
|
/// <summary>
|
|
/// HiLo evaluation config: any subset of the four setpoints may be set; null
|
|
/// means "don't evaluate that band". Per-setpoint priorities override the
|
|
/// alarm-level priority for AlarmStateChanged messages emitted for that band.
|
|
/// </summary>
|
|
internal record HiLoEvalConfig(
|
|
string MonitoredAttributeName,
|
|
double? LoLo,
|
|
double? Lo,
|
|
double? Hi,
|
|
double? HiHi,
|
|
int? LoLoPriority,
|
|
int? LoPriority,
|
|
int? HiPriority,
|
|
int? HiHiPriority,
|
|
double? LoLoDeadband = null,
|
|
double? LoDeadband = null,
|
|
double? HiDeadband = null,
|
|
double? HiHiDeadband = null,
|
|
string? LoLoMessage = null,
|
|
string? LoMessage = null,
|
|
string? HiMessage = null,
|
|
string? HiHiMessage = null) : AlarmEvalConfig(MonitoredAttributeName);
|