use std::path::PathBuf;
use blubat_core::{AdvertisedThresholds, Config, Engine, Paths, Raised, Snapshot};
use crate::config;
use crate::hooks::{self, Hooks, Outcome, Runner};
use crate::notify::{self, Desktop, Notifier};
type Deferring = Box<dyn Fn() -> bool + Send + Sync>;
#[derive(Debug, Default, PartialEq, Eq)]
pub struct Observed {
pub raised: Vec<Raised>,
pub problems: Vec<String>,
}
pub struct Effects {
config_file: PathBuf,
state_file: PathBuf,
engine: Engine,
saved: Engine,
advertised: AdvertisedThresholds,
notifier: Box<dyn Notifier>,
hooks: Box<dyn Hooks>,
deferring: Deferring,
deferred: bool,
}
impl Effects {
pub fn live(
paths: &Paths,
report: impl Fn(Outcome) + Send + Sync + 'static,
) -> (Self, Option<String>) {
let (engine, problem) = Engine::load(&paths.state_file());
(
Self::new(
paths,
engine,
blubat_core::advertised(),
Box::new(Desktop),
Box::new(Runner::reporting(report)),
),
problem,
)
}
pub fn new(
paths: &Paths,
engine: Engine,
advertised: AdvertisedThresholds,
notifier: Box<dyn Notifier>,
hooks: Box<dyn Hooks>,
) -> Self {
Self {
config_file: paths.config_file().to_path_buf(),
state_file: paths.state_file(),
saved: engine.clone(),
engine,
advertised,
notifier,
hooks,
deferring: Box::new(|| false),
deferred: false,
}
}
pub fn deferring_to(self, owner: impl Fn() -> bool + Send + Sync + 'static) -> Self {
Self {
deferring: Box::new(owner),
..self
}
}
pub fn advertised(&self) -> &AdvertisedThresholds {
&self.advertised
}
pub fn observe(&mut self, reading: &Snapshot, config: &Config) -> Observed {
let now = reading.read_at;
let mine = self.mine();
let mut problems: Vec<String> = self.resumed(mine).into_iter().collect();
let (engine, raised) =
std::mem::take(&mut self.engine).step(reading, config, &self.advertised, now);
self.engine = engine;
problems.extend(raised.iter().filter(|_| mine).filter_map(|raised| {
notify::announce(raised, &config.notifications, self.notifier.as_ref())
.and_then(Result::err)
}));
for raised in raised.iter().filter(|_| mine) {
hooks::dispatch(
raised,
reading,
config,
&mut self.engine,
self.hooks.as_ref(),
now,
);
}
if mine {
problems.extend(self.persist());
}
Observed { raised, problems }
}
fn mine(&self) -> bool {
!(self.deferring)()
}
fn resumed(&mut self, mine: bool) -> Option<String> {
let returned = mine && self.deferred;
self.deferred = !mine;
if !returned {
return None;
}
let (engine, problem) = Engine::load(&self.state_file);
self.saved = engine.clone();
self.engine = engine;
problem
}
pub fn reload(&self) -> Result<Config, String> {
Config::load(&self.config_file).map_err(|error| error.to_string())
}
pub fn save_hidden(&self, hidden: &[String]) -> Result<(), String> {
config::save_hidden(&self.config_file, hidden)
}
fn persist(&mut self) -> Option<String> {
if self.engine == self.saved {
return None;
}
match self.engine.save(&self.state_file) {
Ok(()) => {
self.saved = self.engine.clone();
None
}
Err(error) => Some(error.to_string()),
}
}
}
#[cfg(test)]
mod tests {
use std::fs;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use blubat_core::{
Address, ChargeState, Device, Event, Levels, Notifications, Source, Timestamp,
};
use crate::hooks::fake::Recorder as StartedHooks;
use crate::notify::fake::Recorder as PostedBanners;
use crate::scratch::Scratch;
use super::*;
const TRACKPAD: &str = "30-82-16-f2-24-90";
const READ_AT: i64 = 1_785_643_199;
fn device(level: Option<u8>, second: i64) -> Device {
Device {
address: Address::parse(TRACKPAD).expect("valid address"),
name: "Paul\u{2019}s Magic Trackpad".to_string(),
kind: None,
transport: None,
levels: Levels {
main: level,
..Levels::default()
},
charge: ChargeState::Discharging,
source: Source::IoKit,
connected: true,
read_at: Timestamp::from_unix(READ_AT + second),
}
}
fn reading(level: Option<u8>, second: i64) -> Snapshot {
Snapshot {
read_at: Timestamp::from_unix(READ_AT + second),
devices: vec![device(level, second)],
degraded: false,
warnings: Vec::new(),
}
}
fn away(second: i64) -> Snapshot {
Snapshot {
devices: vec![Device {
connected: false,
..device(Some(50), second)
}],
..reading(Some(50), second)
}
}
fn effects(scratch: &Scratch) -> (Effects, Arc<PostedBanners>, Arc<StartedHooks>) {
recording(scratch, PostedBanners::new())
}
fn recording(
scratch: &Scratch,
banners: PostedBanners,
) -> (Effects, Arc<PostedBanners>, Arc<StartedHooks>) {
let banners = Arc::new(banners);
let hooks = Arc::new(StartedHooks::new());
let effects = Effects::new(
&scratch.paths(),
Engine::default(),
AdvertisedThresholds::new(),
Box::new(Arc::clone(&banners)),
Box::new(Arc::clone(&hooks)),
);
(effects, banners, hooks)
}
fn observe(effects: &mut Effects, config: &Config, levels: &[u8]) -> Vec<String> {
levels
.iter()
.enumerate()
.flat_map(|(tick, level)| {
effects
.observe(&reading(Some(*level), tick as i64), config)
.problems
})
.collect()
}
#[test]
fn a_crossing_reaches_the_banner_and_the_hook_it_was_configured_for() {
let scratch = Scratch::new();
let config = Config::parse(
"[[hook]]\nevent = \"low_battery\"\ncommand = \"nag\"\n\n\
[[hook]]\nevent = \"charged\"\ncommand = \"unplug\"\n",
)
.expect("parses");
let (mut effects, banners, hooks) = effects(&scratch);
let problems = observe(&mut effects, &config, &[50, 19]);
assert!(problems.is_empty(), "{problems:?}");
assert_eq!(banners.posted().len(), 1);
assert_eq!(banners.posted()[0].body, "Battery low at 19%");
assert_eq!(banners.posted()[0].sound.as_deref(), Some("Glass"));
assert_eq!(hooks.commands(), ["nag"], "the charged hook waits its turn");
}
#[test]
fn what_a_reading_raised_travels_back_beside_what_went_wrong() {
let scratch = Scratch::new();
let (mut effects, _, _) = effects(&scratch);
effects.observe(&reading(Some(50), 0), &Config::default());
let observed = effects.observe(&reading(Some(19), 1), &Config::default());
assert!(observed.problems.is_empty(), "{:?}", observed.problems);
assert_eq!(
observed
.raised
.iter()
.map(|raised| (raised.event, raised.level))
.collect::<Vec<_>>(),
[(Event::LowBattery, Some(19))]
);
}
#[test]
fn what_was_raised_while_deferring_still_travels_back() {
let scratch = Scratch::new();
let (effects, banners, _) = effects(&scratch);
let mut effects = effects.deferring_to(|| true);
effects.observe(&reading(Some(50), 0), &Config::default());
let observed = effects.observe(&reading(Some(19), 1), &Config::default());
assert_eq!(observed.raised.len(), 1, "the dashboard still lists it");
assert!(banners.posted().is_empty(), "without announcing it");
}
#[test]
fn an_event_the_notification_toggles_silence_still_runs_its_hook() {
let scratch = Scratch::new();
let config = Config::parse(
"[notifications]\nlow = false\n\n\
[[hook]]\nevent = \"low_battery\"\ncommand = \"nag\"\n",
)
.expect("parses");
let (mut effects, banners, hooks) = effects(&scratch);
observe(&mut effects, &config, &[50, 19]);
assert!(
banners.posted().is_empty(),
"the toggle is honoured: {:?}",
banners.posted()
);
assert_eq!(hooks.commands(), ["nag"], "which says nothing about hooks");
}
#[test]
fn the_sound_and_the_toggles_are_the_ones_the_config_carries() {
let scratch = Scratch::new();
let config =
Config::parse("[notifications]\nconnect = true\nsound = \"Ping\"\n").expect("parses");
let (mut effects, banners, _) = effects(&scratch);
effects.observe(&reading(Some(50), 0), &config);
for second in [60, 120] {
effects.observe(&away(second), &config);
}
assert_eq!(banners.posted().len(), 1, "a link event, on by request");
assert_eq!(banners.posted()[0].body, "Disconnected");
assert_eq!(banners.posted()[0].sound.as_deref(), Some("Ping"));
assert!(
!Notifications::default().enabled(Event::Disconnected),
"which the built-in default would not have posted"
);
}
#[test]
fn the_thresholds_a_device_is_judged_by_are_the_configured_ones() {
let scratch = Scratch::new();
let config = Config::parse("[[device]]\nmatch = \"trackpad\"\nlow = 40\n").expect("parses");
let (mut effects, banners, _) = effects(&scratch);
observe(&mut effects, &config, &[50, 39]);
assert_eq!(banners.posted().len(), 1);
assert_eq!(banners.posted()[0].body, "Battery low at 39%");
}
#[test]
fn what_was_already_raised_survives_into_the_next_run() {
let scratch = Scratch::new();
let config = Config::default();
let (mut effects, first, _) = effects(&scratch);
observe(&mut effects, &config, &[50, 19]);
let (engine, problem) = Engine::load(&scratch.paths().state_file());
let banners = Arc::new(PostedBanners::new());
let mut restarted = Effects::new(
&scratch.paths(),
engine,
AdvertisedThresholds::new(),
Box::new(Arc::clone(&banners)),
Box::new(StartedHooks::new()),
);
restarted.observe(&reading(Some(19), 2), &config);
assert_eq!(problem, None, "the state file read back cleanly");
assert_eq!(first.posted().len(), 1, "the crossing was announced once");
assert!(
banners.posted().is_empty(),
"and a restart at the same level says nothing: {:?}",
banners.posted()
);
}
#[test]
fn a_banner_that_could_not_be_posted_comes_back_while_the_hook_still_runs() {
let scratch = Scratch::new();
let config = Config::parse("[[hook]]\nevent = \"low_battery\"\ncommand = \"nag\"\n")
.expect("parses");
let (mut effects, _, hooks) =
recording(&scratch, PostedBanners::failing("no notification centre"));
let problems = observe(&mut effects, &config, &[50, 19]);
assert_eq!(problems, ["no notification centre"]);
assert_eq!(
hooks.commands(),
["nag"],
"a banner nobody saw says nothing about the hooks"
);
}
#[test]
fn state_that_cannot_be_written_comes_back_rather_than_being_printed() {
let scratch = Scratch::new();
let (mut effects, _, _) = effects(&scratch);
fs::create_dir_all(scratch.paths().state_file()).expect("a directory in the way");
let problems = observe(&mut effects, &Config::default(), &[50, 19]);
assert_eq!(
problems.len(),
2,
"one per reading: a failed write is retried rather than assumed done"
);
assert!(
problems
.iter()
.all(|problem| problem.contains("state.toml")),
"each names the file: {problems:?}"
);
}
#[test]
fn a_reading_that_moved_nothing_leaves_the_state_file_alone() {
let scratch = Scratch::new();
let config = Config::default();
let (mut effects, _, _) = effects(&scratch);
observe(&mut effects, &config, &[50, 19]);
let written = fs::metadata(scratch.paths().state_file()).expect("a written state file");
effects.observe(&reading(Some(19), 2), &config);
assert_eq!(
fs::metadata(scratch.paths().state_file())
.expect("still there")
.modified()
.ok(),
written.modified().ok(),
"the level was already fired, so there was nothing to write"
);
}
#[test]
fn a_hooks_debounce_clock_is_in_the_state_the_reading_wrote() {
let scratch = Scratch::new();
let config = Config::parse(
"[[hook]]\nevent = \"low_battery\"\ncommand = \"nag\"\ndebounce = \"30m\"\n",
)
.expect("parses");
let (mut effects, _, _) = effects(&scratch);
observe(&mut effects, &config, &[50, 19]);
let written =
fs::read_to_string(scratch.paths().state_file()).expect("a written state file");
assert!(
written.contains("hook.nag"),
"the state was saved after dispatch, so the clock is in it: {written}"
);
}
#[test]
fn nothing_is_announced_run_or_written_while_another_blubat_owns_the_effects() {
let scratch = Scratch::new();
let config = Config::parse("[[hook]]\nevent = \"low_battery\"\ncommand = \"nag\"\n")
.expect("parses");
let (effects, banners, hooks) = effects(&scratch);
let mut effects = effects.deferring_to(|| true);
observe(&mut effects, &config, &[50, 19]);
assert!(banners.posted().is_empty(), "{:?}", banners.posted());
assert!(hooks.commands().is_empty(), "{:?}", hooks.commands());
assert!(
!scratch.paths().state_file().exists(),
"the state file belongs to whichever blubat is acting"
);
}
#[test]
fn a_crossing_the_owner_announced_is_not_announced_again_when_it_goes() {
let scratch = Scratch::new();
let config = Config::default();
let (mut owner, announced, _) = effects(&scratch);
let owned = Arc::new(AtomicBool::new(true));
let (deferring, banners, _) = effects(&scratch);
let elsewhere = Arc::clone(&owned);
let mut deferring = deferring.deferring_to(move || elsewhere.load(Ordering::SeqCst));
for (tick, level) in [50, 19].into_iter().enumerate() {
let reading = reading(Some(level), tick as i64);
owner.observe(&reading, &config);
deferring.observe(&reading, &config);
}
owned.store(false, Ordering::SeqCst);
deferring.observe(&reading(Some(19), 2), &config);
assert_eq!(announced.posted().len(), 1, "the owner announced it");
assert!(
banners.posted().is_empty(),
"so this one reads its state back and stays quiet: {:?}",
banners.posted()
);
}
#[test]
fn the_owner_going_away_restores_the_side_effects() {
let scratch = Scratch::new();
let config = Config::default();
let (mut owner, _, _) = effects(&scratch);
let owned = Arc::new(AtomicBool::new(true));
let (deferring, banners, _) = effects(&scratch);
let elsewhere = Arc::clone(&owned);
let mut deferring = deferring.deferring_to(move || elsewhere.load(Ordering::SeqCst));
owner.observe(&reading(Some(50), 0), &config);
deferring.observe(&reading(Some(50), 0), &config);
owned.store(false, Ordering::SeqCst);
deferring.observe(&reading(Some(19), 1), &config);
assert_eq!(banners.posted().len(), 1);
assert_eq!(banners.posted()[0].body, "Battery low at 19%");
}
#[test]
fn a_debounce_clock_the_owner_recorded_survives_the_handover() {
let scratch = Scratch::new();
let config = Config::parse(
"[[hook]]\nevent = \"low_battery\"\ncommand = \"nag\"\ndebounce = \"30m\"\n",
)
.expect("parses");
let (mut owner, _, ran) = effects(&scratch);
let (deferring, _, never_ran) = effects(&scratch);
let mut deferring = deferring.deferring_to(|| true);
for (tick, level) in [50, 19].into_iter().enumerate() {
let reading = reading(Some(level), tick as i64);
owner.observe(&reading, &config);
deferring.observe(&reading, &config);
}
assert_eq!(ran.commands(), ["nag"]);
assert!(never_ran.commands().is_empty());
assert!(
fs::read_to_string(scratch.paths().state_file())
.expect("a written state file")
.contains("hook.nag"),
"the owner's clock is the one on disk"
);
}
#[test]
fn one_reading_is_wholly_acted_on_or_wholly_deferred() {
let scratch = Scratch::new();
let config = Config::parse("[[hook]]\nevent = \"low_battery\"\ncommand = \"nag\"\n")
.expect("parses");
let (effects, banners, hooks) = effects(&scratch);
let asks = Arc::new(AtomicU32::new(0));
let counted = Arc::clone(&asks);
let mut effects = effects.deferring_to(move || counted.fetch_add(1, Ordering::SeqCst) >= 1);
observe(&mut effects, &config, &[50, 19]);
assert_eq!(
banners.posted().len(),
hooks.commands().len(),
"a banner without its hook means the answer moved mid reading"
);
assert_eq!(asks.load(Ordering::SeqCst), 2, "one answer per reading");
}
#[test]
fn a_reload_hands_back_the_file_or_the_reason_it_could_not() {
let scratch = Scratch::new();
let (effects, _, _) = effects(&scratch);
assert_eq!(
effects.reload(),
Ok(Config::default()),
"no file is the built-in defaults rather than a problem"
);
scratch.write_config("[defaults]\nlow = 30\n");
assert_eq!(
effects.reload().expect("parses").defaults.low,
Some(30),
"and the file once there is one"
);
scratch.write_config("[defaults]\nlow = 20\ncritical = \"ten\"\n");
let problem = effects
.reload()
.expect_err("a string threshold is not a number");
assert!(problem.contains("line 3"), "{problem}");
}
}