#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FixedTiming {
pub(crate) interval: Duration,
pub(crate) grace: Duration,
}
impl FixedTiming {
#[must_use]
pub const fn new(interval: Duration) -> Self {
Self {
interval,
grace: Duration::ZERO,
}
}
#[must_use]
pub const fn with_grace(mut self, grace: Duration) -> Self {
self.grace = grace;
self
}
#[must_use]
pub const fn interval(self) -> Duration {
self.interval
}
#[must_use]
pub const fn grace(self) -> Duration {
self.grace
}
pub(crate) fn deadline(self) -> Duration {
self.interval.saturating_add(self.grace)
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct LearnedTiming {
pub(crate) minimum_samples: u32,
pub(crate) startup_grace: Duration,
pub(crate) minimum_grace: Duration,
pub(crate) sensitivity: f64,
pub(crate) adaptation: Adaptation,
pub(crate) model: LearningModel,
}
impl Default for LearnedTiming {
fn default() -> Self {
Self {
minimum_samples: 8,
startup_grace: Duration::from_secs(30),
minimum_grace: Duration::from_millis(10),
sensitivity: 4.0,
adaptation: Adaptation::Slow,
model: LearningModel::Ewma,
}
}
}
impl LearnedTiming {
#[must_use]
pub const fn with_minimum_samples(mut self, minimum_samples: u32) -> Self {
self.minimum_samples = minimum_samples;
self
}
#[must_use]
pub const fn with_startup_grace(mut self, startup_grace: Duration) -> Self {
self.startup_grace = startup_grace;
self
}
#[must_use]
pub const fn with_minimum_grace(mut self, minimum_grace: Duration) -> Self {
self.minimum_grace = minimum_grace;
self
}
#[must_use]
pub const fn with_sensitivity(mut self, sensitivity: f64) -> Self {
self.sensitivity = sensitivity;
self
}
#[must_use]
pub const fn with_adaptation(mut self, adaptation: Adaptation) -> Self {
self.adaptation = adaptation;
self
}
#[must_use]
pub const fn with_model(mut self, model: LearningModel) -> Self {
self.model = model;
self
}
#[must_use]
pub const fn minimum_samples(self) -> u32 {
self.minimum_samples
}
#[must_use]
pub const fn adaptation(self) -> Adaptation {
self.adaptation
}
#[must_use]
pub const fn model(self) -> LearningModel {
self.model
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Timing {
Fixed(FixedTiming),
Learned(LearnedTiming),
}
impl Timing {
#[must_use]
pub const fn fixed(interval: Duration) -> Self {
Self::Fixed(FixedTiming::new(interval))
}
#[must_use]
pub fn learned() -> Self {
Self::Learned(LearnedTiming::default())
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct TaskConfig {
pub(crate) name: Arc<str>,
pub(crate) timing: Timing,
startup_grace: Option<Duration>,
}
impl TaskConfig {
#[must_use]
pub fn new(name: impl Into<Arc<str>>, timing: Timing) -> Self {
Self {
name: name.into(),
timing,
startup_grace: None,
}
}
#[must_use]
pub const fn with_startup_grace(mut self, startup_grace: Duration) -> Self {
self.startup_grace = Some(startup_grace);
self
}
pub(crate) fn validate(&self) -> Result<(), ConfigError> {
if self.name.trim().is_empty() {
return Err(ConfigError::EmptyName);
}
if self
.startup_grace
.is_some_and(|duration| duration.is_zero())
{
return Err(ConfigError::ZeroStartupGrace);
}
match self.timing {
Timing::Fixed(fixed) => {
if fixed.interval.is_zero() {
return Err(ConfigError::ZeroInterval);
}
}
Timing::Learned(learned) => {
if learned.minimum_samples < 2 {
return Err(ConfigError::TooFewLearningSamples);
}
if learned.startup_grace.is_zero() {
return Err(ConfigError::ZeroStartupGrace);
}
if !learned.sensitivity.is_finite() || learned.sensitivity <= 0.0 {
return Err(ConfigError::InvalidSensitivity);
}
match learned.model {
LearningModel::Ewma => {}
LearningModel::RobustWindow { capacity } => {
let capacity = usize::from(capacity);
if !(5..=MAX_ROBUST_WINDOW).contains(&capacity) || capacity & 1 == 0 {
return Err(ConfigError::InvalidRobustWindowCapacity);
}
}
LearningModel::RepeatingPattern(pattern) => {
let maximum_period = usize::from(pattern.maximum_period);
let minimum_cycles = usize::from(pattern.minimum_cycles);
if !(2..=MAX_PATTERN_PERIOD).contains(&maximum_period) {
return Err(ConfigError::InvalidPatternMaximumPeriod);
}
if !(3..=MAX_PATTERN_CYCLES).contains(&minimum_cycles) {
return Err(ConfigError::InvalidPatternMinimumCycles);
}
if !(1..=50).contains(&pattern.tolerance_percent) {
return Err(ConfigError::InvalidPatternTolerance);
}
if !(1..=100).contains(&pattern.minimum_contrast_percent) {
return Err(ConfigError::InvalidPatternContrast);
}
}
}
}
}
Ok(())
}
pub(crate) fn effective_startup_grace(&self) -> Duration {
self.startup_grace.unwrap_or_else(|| match self.timing {
Timing::Fixed(fixed) => fixed.deadline(),
Timing::Learned(learned) => learned.startup_grace,
})
}
}