yukari/src/main.rs

use std::{process};
use std::time::Duration;
use tokio::task::JoinSet;
use crate::reaper::Reaper;
use pkg_compile_time::{pkg_compile_date, pkg_compile_time};
use crate::logger::LoggerWriterSpawner;

mod shell;
mod syscall;
mod reaper;
mod logger;
mod sysinit;
mod cfg;
mod env;

const YUKARI_VERSION : &str = env!("CARGO_PKG_VERSION");

#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
async fn main() {

    println!("[   @yukari  ] ==== yukari - ELIP4NG Init Process. ====");
    println!();

    let pid = process::id();

    if pid != 1 {
        panic!("yukari must run as PID 1.");
    }

    println!("[   @yukari  ] hello, this is No.1 process (as init) 'yukari'.");
    println!("[   @yukari  ] version: {}", YUKARI_VERSION);
    println!("[   @yukari  ] compiled at: {} {}", pkg_compile_date!(), pkg_compile_time!());
    println!();

    println!("[   @yukari  ] load config...");
    cfg::init_config_manager().await;
    logger::set_debug_mode_by_cfg().await;

    println!("[   @yukari  ] you can < PRESS ENTER > at any time to enter maintenance shell.");
    println!();
    println!("[   @yukari  ] ---- yukari sysinit phase ----");

    let (reaper_waiter_tx, reaper_waiter_rx) = tokio::sync::oneshot::channel();

    let mut logmux = logger::Logger::new();
    let logger_reaper = logmux.get_writer("zombie_reaper");
    let logger_env_load = logmux.get_writer("env_load");
    let logger_spawner_sysinit = logmux.get_spawner();
    let zombie_reaper_res = Reaper::new(logger_reaper);
    let mut zombie_reaper = match zombie_reaper_res {
        Ok(r) => {r}
        Err(err) => {
            panic!("zombie reaper system init failed: {:?}", err);
        }
    };

    let mut sys_init = sysinit::SysInit::new(logger_spawner_sysinit);

    let mut task_set = JoinSet::new();

    task_set.spawn(async move {
        logmux.printing().await;
    });

    task_set.spawn(async move {
        env::load_env(logger_env_load).await;
        let res = sys_init.prepare().await;
        println!("[   @yukari  ] ---- yukari sysinit phase end ----");
        let _ = reaper_waiter_tx.send(());
        match res {
            Ok(_) => {
                println!("[   @yukari  ] service management handover to supervisor");
                println!();
                sys_init.run().await;
            }
            Err(err) => {
                println!("[   @yukari  ] error in sysinit phase: {:?}", err);
                println!();
                loop{
                    let _ = tokio::time::sleep(Duration::from_secs(10));
                }
            }
        }
    });

    task_set.spawn_blocking(move || {
        shell::shell_wait_enter();
        shell::shell_repl();
    });

    task_set.spawn( async move {
        let _ = reaper_waiter_rx.await;
        zombie_reaper.reap().await;
    });

    task_set.join_next().await;
    println!("[   @yukari  ] < !!! FATAL !!! > one of task exited. No.1 process will quit.");
    task_set.abort_all();
    println!("[   @yukari  ] No.1 process quit. system will reboot after 5 seconds...");
    let _ = tokio::time::sleep(Duration::from_secs(5));
    syscall::power::safe_reboot();
}