use serde::{Deserialize, Serialize};
use std::path::Path;
pub const FILE: &str = "owner.json";
pub const DEFAULT_STALE_SECS: u64 = 90;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Snapshot {
pub idle: bool,
#[serde(default)]
pub on_battery: bool,
#[serde(default)]
pub memory_pressure: bool,
#[serde(default)]
pub cpu_pressure: bool,
pub at: u64,
#[serde(default)]
pub source: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Owner {
NoSignal,
Calm,
Active(&'static str),
Yielding(&'static str),
}
impl Owner {
pub fn blocks(&self, when: &str) -> Option<&'static str> {
match self {
Owner::Yielding(r) => Some(r),
Owner::Active(r) if when == "idle" => Some(r),
_ => None,
}
}
}
impl Snapshot {
pub fn owner(&self) -> Owner {
if self.on_battery {
Owner::Yielding("on-battery")
} else if self.memory_pressure {
Owner::Yielding("memory-pressure")
} else if self.cpu_pressure {
Owner::Yielding("cpu-pressure")
} else if !self.idle {
Owner::Active("owner-active")
} else {
Owner::Calm
}
}
}
pub fn stale_secs() -> u64 {
std::env::var("ZAKURO_OWNER_STALE_SECS")
.ok()
.and_then(|v| v.trim().parse().ok())
.filter(|s| *s > 0)
.unwrap_or(DEFAULT_STALE_SECS)
}
pub fn read(home: &Path, now_secs: u64, stale_secs: u64) -> Owner {
let Ok(text) = std::fs::read_to_string(home.join(FILE)) else {
return Owner::NoSignal;
};
let Ok(s) = serde_json::from_str::<Snapshot>(&text) else {
return Owner::Active("signal-stale");
};
if now_secs.saturating_sub(s.at) > stale_secs {
return Owner::Active("signal-stale");
}
s.owner()
}
pub fn live_yield(home: &Path, when: &str) -> Option<&'static str> {
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
read(home, now, stale_secs()).blocks(when)
}
pub fn write(home: &Path, s: &Snapshot) -> std::io::Result<()> {
std::fs::create_dir_all(home)?;
let tmp = home.join(".owner.json.tmp");
std::fs::write(&tmp, serde_json::to_string(s).unwrap_or_default())?;
std::fs::rename(&tmp, home.join(FILE))
}
#[cfg(test)]
mod tests {
use super::*;
fn snap(idle: bool, at: u64) -> Snapshot {
Snapshot {
idle,
on_battery: false,
memory_pressure: false,
cpu_pressure: false,
at,
source: "test".into(),
}
}
#[test]
fn no_file_means_no_signal_not_an_active_owner() {
let d = crate::policy::test_home();
assert_eq!(read(&d, 1000, 90), Owner::NoSignal);
}
#[test]
fn a_fresh_snapshot_is_read_and_a_stale_one_means_active() {
let d = crate::policy::test_home();
write(&d, &snap(true, 1000)).unwrap();
assert_eq!(read(&d, 1060, 90), Owner::Calm);
assert_eq!(read(&d, 1090, 90), Owner::Calm, "at the bound is fresh");
assert_eq!(read(&d, 1091, 90), Owner::Active("signal-stale"));
write(&d, &snap(false, 1000)).unwrap();
assert_eq!(read(&d, 1001, 90), Owner::Active("owner-active"));
}
#[test]
fn a_torn_file_fails_safe() {
let d = crate::policy::test_home();
std::fs::write(d.join(FILE), "{not json").unwrap();
assert_eq!(read(&d, 5, 90), Owner::Active("signal-stale"));
}
#[test]
fn battery_and_pressure_yield_whatever_when_says_and_activity_only_for_idle() {
let mut s = snap(true, 0);
s.on_battery = true;
assert_eq!(s.owner().blocks("always"), Some("on-battery"));
let mut s = snap(true, 0);
s.memory_pressure = true;
assert_eq!(s.owner().blocks("schedule"), Some("memory-pressure"));
let busy = snap(false, 0).owner();
assert_eq!(busy.blocks("idle"), Some("owner-active"));
assert_eq!(busy.blocks("always"), None);
assert_eq!(busy.blocks("schedule"), None);
assert_eq!(Owner::NoSignal.blocks("idle"), None);
assert_eq!(Owner::Calm.blocks("idle"), None);
}
}