use core::future::Future;
use core::pin::Pin;
use core::time::Duration;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::sync::{Mutex, PoisonError};
use chrono::{DateTime, Utc};
use shep_core::config::{ProbeConfig, ProbeKind, ProbeTarget};
use shep_core::values::{MemSize, UpDuration};
use crate::cron::Clock;
use crate::limits::LimitEnforcer;
use crate::limits::sample::{MemorySampler, ProcessIdentity, ProcessRss};
use crate::probes::{ProbeFailure, Prober};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct ArmCall {
pub(crate) id: u32,
pub(crate) root_pid: u32,
pub(crate) limit: MemSize,
}
#[derive(Debug, Default)]
pub(crate) struct RecordingEnforcer {
arms: Mutex<Vec<ArmCall>>,
disarms: Mutex<Vec<u32>>,
}
impl RecordingEnforcer {
pub(crate) fn arms(&self) -> Vec<ArmCall> {
self.arms
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
pub(crate) fn disarms(&self) -> Vec<u32> {
self.disarms
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
}
impl LimitEnforcer for RecordingEnforcer {
fn arm(&self, id: u32, root_pid: u32, limit: MemSize) {
self.arms
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push(ArmCall {
id,
root_pid,
limit,
});
}
fn disarm(&self, id: u32) {
self.disarms
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push(id);
}
}
pub(crate) struct TestClock {
epoch: DateTime<Utc>,
started: tokio::time::Instant,
reads: AtomicUsize,
}
impl TestClock {
pub(crate) fn starting_at(epoch: DateTime<Utc>) -> Self {
Self {
epoch,
started: tokio::time::Instant::now(),
reads: AtomicUsize::new(0),
}
}
pub(crate) fn reads(&self) -> usize {
self.reads.load(Ordering::Relaxed)
}
}
impl Clock for TestClock {
fn now_utc(&self) -> DateTime<Utc> {
self.reads.fetch_add(1, Ordering::Relaxed);
let elapsed =
chrono::Duration::from_std(self.started.elapsed()).unwrap_or(chrono::Duration::MAX);
self.epoch + elapsed
}
}
pub(crate) fn rss(pid: u32, parent: Option<u32>, bytes: u64) -> ProcessRss {
rss_cpu(pid, parent, bytes, 0)
}
pub(crate) fn rss_cpu(pid: u32, parent: Option<u32>, bytes: u64, cpu_ms: u64) -> ProcessRss {
ProcessRss {
pid,
parent,
bytes,
cpu_ms,
}
}
pub(crate) struct ScriptedSampler {
readings: Vec<Vec<ProcessRss>>,
calls: AtomicUsize,
identities: Vec<Vec<ProcessIdentity>>,
identify_calls: AtomicUsize,
}
impl ScriptedSampler {
pub(crate) fn new(readings: Vec<Vec<ProcessRss>>) -> Self {
assert!(
!readings.is_empty(),
"ScriptedSampler needs at least one reading to replay"
);
Self {
readings,
calls: AtomicUsize::new(0),
identities: Vec::new(),
identify_calls: AtomicUsize::new(0),
}
}
pub(crate) fn identifying(tables: Vec<Vec<ProcessIdentity>>) -> Self {
assert!(
!tables.is_empty(),
"ScriptedSampler::identifying needs at least one table to replay"
);
Self {
readings: vec![vec![]],
calls: AtomicUsize::new(0),
identities: tables,
identify_calls: AtomicUsize::new(0),
}
}
pub(crate) fn calls(&self) -> usize {
self.calls.load(Ordering::Relaxed)
}
}
impl MemorySampler for ScriptedSampler {
fn sample(&self) -> Vec<ProcessRss> {
let call = self.calls.fetch_add(1, Ordering::Relaxed);
let index = call.min(self.readings.len() - 1);
self.readings[index].clone()
}
fn identify(&self) -> Vec<ProcessIdentity> {
if self.identities.is_empty() {
return Vec::new();
}
let call = self.identify_calls.fetch_add(1, Ordering::Relaxed);
let index = call.min(self.identities.len() - 1);
self.identities[index].clone()
}
}
pub(crate) struct ScriptedProber {
script: Vec<Result<(), ProbeFailure>>,
calls: AtomicUsize,
delay: Duration,
last_timeout_ms: AtomicU64,
}
impl ScriptedProber {
pub(crate) fn new(script: Vec<Result<(), ProbeFailure>>) -> Self {
Self {
script,
calls: AtomicUsize::new(0),
delay: Duration::ZERO,
last_timeout_ms: AtomicU64::new(0),
}
}
pub(crate) fn with_delay(mut self, delay: Duration) -> Self {
self.delay = delay;
self
}
pub(crate) fn calls(&self) -> usize {
self.calls.load(Ordering::Relaxed)
}
pub(crate) fn last_timeout(&self) -> Duration {
Duration::from_millis(self.last_timeout_ms.load(Ordering::Relaxed))
}
}
impl Prober for ScriptedProber {
fn probe<'a>(
&'a self,
_target: &'a ProbeTarget,
timeout: Duration,
) -> Pin<Box<dyn Future<Output = Result<(), ProbeFailure>> + Send + 'a>> {
Box::pin(async move {
let call = self.calls.fetch_add(1, Ordering::Relaxed);
self.last_timeout_ms
.store(timeout.as_millis() as u64, Ordering::Relaxed);
tokio::time::sleep(self.delay).await;
if self.script.is_empty() {
return Ok(());
}
let index = call.min(self.script.len() - 1);
self.script[index].clone()
})
}
}
pub(crate) fn probe_config(kind: ProbeKind, target: &str) -> ProbeConfig {
ProbeConfig {
kind,
target: target.to_string(),
interval: UpDuration::from_millis(10_000),
timeout: UpDuration::from_millis(5_000),
failure_threshold: 3,
}
}