kanit

control.rs (5431B)

---

 #[cfg(not(feature = "testing"))]
 use std::io::{Write, stdin, stdout};
 
 use async_process::driver;
 use log::{debug, error, info, warn};
 
 #[cfg(not(feature = "testing"))]
 use kanit_common::error::Context;
 use kanit_common::error::{Error, Result};
 use kanit_diagnostics::tap as kanit_tap;
 use kanit_diagnostics::timing as kanit_timing;
 use kanit_executor::{join_all, spawn};
 use kanit_unit::{RcUnit, UnitName};
 
 use crate::loader;
 use crate::loader::Loader;
 
 #[cfg(not(feature = "testing"))]
 fn critical_unit_fail(err: Error) -> Result<()> {
     loop {
         error!("a critical unit failed to start, continue? [y/n]: ");
 
         let _ = stdout().flush();
 
         let mut input = String::new();
 
         match stdin().read_line(&mut input) {
             Ok(_) => match input.chars().next() {
                 Some('y') => return Ok(()),
                 Some('n') => return Err(err),
                 _ => {}
             },
             Err(e) => return Err(e).context("failed to read stdin"),
         }
     }
 }
 
 #[cfg(feature = "testing")]
 fn critical_unit_fail(err: Error) -> Result<()> {
     kanit_tap::bail(Some(err.to_string()));
 
     Err(err)
 }
 
 async fn start_unit(tuple: (usize, RcUnit)) -> Result<Option<UnitName>> {
     let (j, unit) = tuple;
 
     let mut unit_b = unit.borrow_mut();
 
     debug!("loading unit {}", unit_b.name());
 
     let id = kanit_timing::push_scope(format!("unit:{}", unit_b.name()));
 
     if !unit_b.prepare().await? {
         warn!("failed preparations for {}", unit_b.name());
         kanit_tap::not_ok(j + 1, Some("failed preparations"));
         return Ok(None);
     }
 
     if let Err(e) = unit_b.start().await {
         if e.is_recoverable() {
             warn!("{e}");
             kanit_tap::not_ok(j + 1, Some(e));
         } else {
             error!("{e}");
             critical_unit_fail(e)?;
         }
 
         kanit_timing::pop_scope(id);
 
         return Ok(None);
     }
 
     kanit_timing::pop_scope(id);
 
     kanit_tap::ok(j + 1, Some(unit_b.name()));
 
     debug!("finished loading unit {}", unit_b.name());
 
     Ok(Some(unit_b.name().clone()))
 }
 
 async fn start_level(i: usize, name: Box<str>) -> Result<()> {
     let mut loader = Loader::obtain()?.borrow_mut();
     let level = loader.grouping.get(&name).cloned().unwrap_or_else(Vec::new);
 
     info!("starting level {name}");
 
     let scope_str = format!("level:{name}");
 
     kanit_tap::enter_subtest(Some(&scope_str));
 
     let id = kanit_timing::push_scope(&scope_str);
 
     kanit_tap::plan(level.len());
 
     for (j, group) in level.into_iter().enumerate() {
         let group_str = format!("group:{j}");
 
         kanit_tap::enter_subtest(Some(&group_str));
         kanit_tap::plan(group.len());
 
         let handles = join_all(group.into_iter().enumerate().map(start_unit)).await;
 
         for handle in handles {
             if let Some(n) = handle? {
                 loader.mark_started(n);
             }
         }
 
         kanit_tap::exit_subtest();
         kanit_tap::ok(j + 1, Some(&group_str));
     }
 
     kanit_timing::pop_scope(id);
 
     kanit_tap::exit_subtest();
     kanit_tap::ok(i + 1, Some(&scope_str));
 
     Ok(())
 }
 
 pub async fn start() -> Result<()> {
     kanit_timing::register();
 
     loader::init_loader()?;
 
     // include teardown as well
     // sysboot, boot, default * 2
     kanit_tap::plan(6);
 
     let driver_task = spawn(driver());
 
     start_level(0, Box::from("sysboot")).await?;
     start_level(1, Box::from("boot")).await?;
     start_level(2, Box::from("default")).await?;
 
     driver_task.cancel().await;
 
     {
         let loader = Loader::obtain()?;
 
         let _ = loader.borrow().save();
     }
 
     Ok(())
 }
 
 async fn stop_unit(tuple: (usize, RcUnit)) -> Result<()> {
     let (j, unit) = tuple;
 
     let mut unit_b = unit.borrow_mut();
 
     debug!("unloading unit {}", unit_b.name());
 
     match unit_b.stop().await {
         Ok(_) => kanit_tap::ok(j + 1, Some(unit_b.name())),
         Err(e) => {
             kanit_tap::not_ok(j + 1, Some(unit_b.name()));
 
             if e.is_recoverable() {
                 warn!("{e}")
             } else {
                 error!("{e}") // won't stop still
             }
         }
     }
 
     debug!("finished unloading unit {}", unit_b.name());
 
     Ok(())
 }
 
 async fn teardown_level(total: usize, i: usize, name: Box<str>) -> Result<()> {
     let loader = Loader::obtain()?.borrow();
     let level = loader.grouping.get(&name).cloned().unwrap_or_else(Vec::new);
 
     info!("stopping level {name}");
 
     let scope_str = format!("level:{name}-stop");
     kanit_tap::enter_subtest(Some(&scope_str));
 
     kanit_tap::plan(level.len());
 
     for (j, group) in level.into_iter().enumerate() {
         let group_str = format!("group:{j}");
 
         kanit_tap::enter_subtest(Some(&group_str));
         kanit_tap::plan(group.len());
 
         let handles = join_all(group.into_iter().enumerate().map(stop_unit)).await;
 
         for handle in handles {
             handle?;
         }
 
         kanit_tap::exit_subtest();
         kanit_tap::ok(j + 1, Some(&group_str));
     }
 
     kanit_tap::exit_subtest();
     kanit_tap::ok(total + (total - i), Some(&scope_str));
 
     Ok(())
 }
 
 pub async fn teardown() -> Result<()> {
     let driver_task = spawn(driver());
 
     teardown_level(3, 2, Box::from("default")).await?;
     teardown_level(3, 1, Box::from("boot")).await?;
     teardown_level(3, 0, Box::from("sysboot")).await?;
 
     driver_task.cancel().await;
 
     Ok(())
 }