rust/chg/src/main.rs

branchcache: unconditionally write delayed branchmap

// Copyright 2018 Yuya Nishihara <[e-mail]>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.

use chg::locator::{self, Locator};
use chg::procutil;
use chg::ChgUiHandler;
use std::env;
use std::io;
use std::io::Write;
use std::process;
use std::time::Instant;

struct DebugLogger {
    start: Instant,
}

impl DebugLogger {
    pub fn new() -> DebugLogger {
        DebugLogger {
            start: Instant::now(),
        }
    }
}

impl log::Log for DebugLogger {
    fn enabled(&self, metadata: &log::Metadata) -> bool {
        metadata.target().starts_with("chg::")
    }

    fn log(&self, record: &log::Record) {
        if self.enabled(record.metadata()) {
            // just make the output looks similar to chg of C
            let l = format!("{}", record.level()).to_lowercase();
            let t = self.start.elapsed();
            writeln!(
                io::stderr(),
                "chg: {}: {}.{:06} {}",
                l,
                t.as_secs(),
                t.subsec_micros(),
                record.args()
            )
            .unwrap_or(());
        }
    }

    fn flush(&self) {}
}

fn main() {
    if env::var_os("CHGDEBUG").is_some() {
        log::set_boxed_logger(Box::new(DebugLogger::new()))
            .expect("any logger should not be installed yet");
        log::set_max_level(log::LevelFilter::Debug);
    }

    // TODO: add loop detection by $CHGINTERNALMARK

    let umask = unsafe { procutil::get_umask() }; // not thread safe
    let code = run(umask).unwrap_or_else(|err| {
        writeln!(io::stderr(), "chg: abort: {}", err).unwrap_or(());
        255
    });
    process::exit(code);
}

#[tokio::main]
async fn run(umask: u32) -> io::Result<i32> {
    let mut loc = Locator::prepare_from_env()?;
    loc.set_early_args(locator::collect_early_args(env::args_os().skip(1)));
    let mut handler = ChgUiHandler::new();
    let mut client = loc.connect().await?;
    client
        .attach_io(&io::stdin(), &io::stdout(), &io::stderr())
        .await?;
    client.set_umask(umask).await?;
    let pid = client.server_spec().process_id.unwrap();
    let pgid = client.server_spec().process_group_id;
    procutil::setup_signal_handler_once(pid, pgid)?;
    let code = client
        .run_command_chg(&mut handler, env::args_os().skip(1))
        .await?;
    procutil::restore_signal_handler_once()?;
    handler.wait_pager().await?;
    Ok(code)
}