ognibuild 0.2.19

Detect and run any build system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use axum::{routing::get, Router};
use clap::Parser;
use ognibuild::debian::apt::AptManager;
use ognibuild::session::{Session, SessionKind};
use std::io::Write;

#[derive(Parser)]
struct Args {
    #[clap(short, long)]
    listen_address: String,

    #[clap(short, long)]
    port: u16,

    #[cfg(target_os = "linux")]
    #[clap(short, long)]
    /// schroot chroot to run in (shorthand for --session schroot:<name>)
    schroot: Option<String>,

    #[clap(long)]
    /// Session backend to run in: "plain", "schroot:<name>", or "unshare:<suite>"
    session: Option<SessionKind>,

    #[clap(short, long)]
    debug: bool,
}

#[tokio::main]
async fn main() -> Result<(), i8> {
    let args = Args::parse();

    env_logger::builder()
        .format(|buf, record| writeln!(buf, "{}", record.args()))
        .filter(
            None,
            if args.debug {
                log::LevelFilter::Debug
            } else {
                log::LevelFilter::Info
            },
        )
        .init();

    #[cfg(target_os = "linux")]
    let schroot = args.schroot;
    #[cfg(not(target_os = "linux"))]
    let schroot = None;
    let session_kind = ognibuild::session::resolve_session_kind(args.session, schroot)
        .unwrap_or_else(|e| {
            eprintln!("Error: {}", e);
            std::process::exit(1);
        });

    let session: Box<dyn Session> = session_kind.build(None).unwrap();

    let _apt_mgr = AptManager::from_session(session.as_ref());

    let app = Router::new()
        .route("/health", get(|| async { "ok" }))
        .route("/version", get(|| async { env!("CARGO_PKG_VERSION") }))
        .route("/ready", get(|| async { "ok" }));

    let listener = tokio::net::TcpListener::bind((args.listen_address.as_str(), args.port))
        .await
        .unwrap();
    log::info!("listening on {}", listener.local_addr().unwrap());
    axum::serve(listener, app).await.unwrap();
    Ok(())
}