use std::time::{Duration, Instant};
#[derive(Debug, Clone, Copy)]
pub struct ScanTimer {
hard_deadline: Instant,
min_runtime: Instant,
last_activity: Instant,
}
impl ScanTimer {
pub fn new(max_total_duration: Duration, min_runtime_duration: Duration) -> Self {
let now = Instant::now();
Self {
hard_deadline: now + max_total_duration,
min_runtime: now + min_runtime_duration,
last_activity: now,
}
}
pub fn mark_activity(&mut self) {
self.last_activity = Instant::now();
}
pub fn time_until_next_tick(&self, max_silence: Duration) -> Duration {
let now = Instant::now();
let time_since_last = now.duration_since(self.last_activity);
max_silence
.checked_sub(time_since_last)
.unwrap_or_else(|| Duration::from_millis(100))
}
pub fn has_expired(&self, max_silence: Duration) -> bool {
let now = Instant::now();
if now > self.hard_deadline {
return true;
}
let time_since_last = now.duration_since(self.last_activity);
now > self.min_runtime && time_since_last >= max_silence
}
pub fn should_break_on_timeout(&self) -> bool {
Instant::now() >= self.min_runtime
}
}
#[derive(Debug, Clone, Copy)]
pub struct ScanBudget {
base: Duration,
per_target: Duration,
ceiling: Duration,
}
impl ScanBudget {
pub const fn new(base: Duration, per_target: Duration, ceiling: Duration) -> Self {
Self {
base,
per_target,
ceiling,
}
}
pub fn for_target_count(&self, target_count: usize) -> Duration {
let target_count = u32::try_from(target_count).unwrap_or(u32::MAX);
let scaled = self
.base
.saturating_add(self.per_target.saturating_mul(target_count));
scaled.min(self.ceiling)
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::thread::sleep;
#[test]
fn test_initialization() {
let timer = ScanTimer::new(Duration::from_secs(10), Duration::from_secs(5));
assert!(!timer.has_expired(Duration::from_secs(1)));
assert!(!timer.should_break_on_timeout());
}
#[test]
fn test_mark_activity() {
let mut timer = ScanTimer::new(Duration::from_secs(10), Duration::from_secs(5));
let max_silence = Duration::from_millis(500);
let wait_time1 = timer.time_until_next_tick(max_silence);
sleep(Duration::from_millis(50));
let wait_time2 = timer.time_until_next_tick(max_silence);
assert!(wait_time2 < wait_time1);
timer.mark_activity();
let wait_time3 = timer.time_until_next_tick(max_silence);
assert!(wait_time3 > wait_time2);
}
#[test]
fn test_time_until_next_tick_fallback() {
let timer = ScanTimer::new(Duration::from_secs(10), Duration::from_secs(5));
let max_silence = Duration::from_millis(10);
sleep(Duration::from_millis(15));
assert_eq!(
timer.time_until_next_tick(max_silence),
Duration::from_millis(100)
);
}
#[test]
fn test_hard_deadline_expiration() {
let timer = ScanTimer::new(
Duration::from_millis(10), Duration::from_millis(100), );
let max_silence = Duration::from_secs(1);
assert!(!timer.has_expired(max_silence));
sleep(Duration::from_millis(15));
assert!(timer.has_expired(max_silence));
}
#[test]
fn test_silence_expiration() {
let timer = ScanTimer::new(
Duration::from_secs(10),
Duration::from_millis(10), );
let max_silence = Duration::from_millis(10);
assert!(!timer.has_expired(max_silence));
sleep(Duration::from_millis(25)); assert!(timer.has_expired(max_silence));
}
#[test]
fn test_should_break_on_timeout() {
let timer = ScanTimer::new(Duration::from_secs(10), Duration::from_millis(10));
assert!(!timer.should_break_on_timeout());
sleep(Duration::from_millis(15));
assert!(timer.should_break_on_timeout());
}
#[test]
fn budget_scales_linearly_with_target_count() {
let budget = ScanBudget::new(
Duration::from_millis(100),
Duration::from_millis(10),
Duration::from_secs(10),
);
assert_eq!(budget.for_target_count(0), Duration::from_millis(100));
assert_eq!(budget.for_target_count(10), Duration::from_millis(200));
}
#[test]
fn budget_is_clamped_to_its_ceiling() {
let budget = ScanBudget::new(
Duration::from_millis(100),
Duration::from_millis(10),
Duration::from_millis(500),
);
assert_eq!(budget.for_target_count(1000), Duration::from_millis(500));
}
}