add initial functionality for rich CLI interfaces

Author: koehlma

Cargo.lock

@@ -27,6 +27,7 @@ toml = "0.8.8"
 url = { version = "2.4.0", features = ["serde"] }
 uuid = { version = "1.8.0", features = ["v4"] }
 xscript.workspace = true
+tracing.workspace = true
 
 reportify.workspace = true
 rugpi-cli.workspace = true

crates/rugpi-bakery/Cargo.toml

@@ -11,6 +11,7 @@ use std::{
 use reportify::{bail, ResultExt};
 use rugpi_common::mount::{MountStack, Mounted};
 use tempfile::tempdir;
+use tracing::{error, info};
 use xscript::{cmd, run, vars, ParentEnv, Run};
 
 use crate::{

crates/rugpi-bakery/src/bake/customize.rs

@@ -17,6 +17,7 @@ use rugpi_common::{
     utils::{ascii_numbers, units::NumBytes},
 };
 use tempfile::tempdir;
+use tracing::info;
 use xscript::{run, Run};
 
 use crate::{

crates/rugpi-bakery/src/bake/image.rs

@@ -8,6 +8,7 @@ use std::{
 use reportify::{bail, whatever, ResultExt};
 use rugpi_common::{loop_dev::LoopDevice, mount::Mounted};
 use tempfile::tempdir;
+use tracing::info;
 use url::Url;
 use xscript::{run, Run};
 

crates/rugpi-bakery/src/bake/mod.rs

@@ -123,7 +123,7 @@ pub struct InitCommand {
 
 /// Entrypoint of the CLI.
 fn main() -> BakeryResult<()> {
-    rugpi_cli::init();
+    rugpi_cli::Initializer::new().init();
 
     let args = Args::parse();
     match &args.command {

crates/rugpi-bakery/src/main.rs

@@ -9,8 +9,8 @@ use std::{
 };
 
 use reportify::{bail, whatever, ResultExt};
-use rugpi_cli::warn;
 use serde::{Deserialize, Serialize};
+use tracing::warn;
 
 use super::repositories::RepositoryIdx;
 use crate::{

crates/rugpi-bakery/src/project/recipes.rs

@@ -31,14 +31,12 @@ use std::{
 use reportify::{bail, ResultExt};
 use serde::{Deserialize, Serialize};
 use sha1::{Digest, Sha1};
+use tracing::debug;
 use xscript::{read_str, run, LocalEnv, Run};
 
 use super::Project;
 use crate::{
-    utils::{
-        idx_vec::{new_idx_type, IdxVec},
-        prelude::*,
-    },
+    utils::idx_vec::{new_idx_type, IdxVec},
     BakeryResult,
 };
 

crates/rugpi-bakery/src/project/repositories.rs

@@ -1,8 +1,8 @@
 use std::{path::Path, time::Duration};
 
 use reportify::{bail, Report, ResultExt};
-use rugpi_cli::info;
 use tokio::{fs, task::spawn_blocking};
+use tracing::info;
 use workflow::{TestStep, TestWorkflow};
 
 use crate::{bake, project::Project};

crates/rugpi-bakery/src/test/mod.rs

@@ -2,7 +2,6 @@ use std::{path::Path, process::Stdio, sync::Arc, time::Duration};
 
 use async_trait::async_trait;
 use reportify::{bail, whatever, ErrorExt, Report, ResultExt, Whatever};
-use rugpi_cli::{error, info};
 use russh::{
     client::Handle,
     keys::{key::PrivateKeyWithHashAlg, load_secret_key, ssh_key, PrivateKey},
@@ -17,6 +16,7 @@ use tokio::{
     sync::{oneshot, Mutex},
     time,
 };
+use tracing::{error, info};
 
 use super::{workflow::TestSystemConfig, RugpiTestResult};
 

crates/rugpi-bakery/src/test/qemu.rs

@@ -11,6 +11,7 @@ use indicatif::{ProgressBar, ProgressStyle};
 use reportify::{bail, ResultExt};
 use serde::{Deserialize, Serialize};
 use sha1::{Digest, Sha1};
+use tracing::info;
 use url::Url;
 
 use crate::{utils::prelude::*, BakeryResult};

crates/rugpi-bakery/src/utils/caching.rs

@@ -1,7 +1,7 @@
 #[macro_export]
 macro_rules! bug {
     ($msg:literal) => {
-        rugpi_cli::error!("[BUG] {}", $msg)
+        tracing::error!("[BUG] {}", $msg)
     };
 }
 

crates/rugpi-bakery/src/utils/logging.rs

@@ -1,5 +1,3 @@
 //! Custom prelude.
 
-pub use rugpi_cli::{debug, error, info, trace, warn};
-
 pub use super::{logging::bug, once_cell_ext::OnceCellExt};

crates/rugpi-bakery/src/utils/prelude.rs

@@ -8,8 +8,10 @@ repository.workspace = true
 homepage.workspace = true
 
 [dependencies]
-tracing.workspace = true
+console = "0.15.10"
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 
+tracing.workspace = true
+
 [lints]
 workspace = true

crates/rugpi-cli/Cargo.toml

@@ -0,0 +1,135 @@
+use std::collections::VecDeque;
+use std::fmt::Display;
+use std::sync::Mutex;
+use std::time::Duration;
+
+use tracing::info;
+
+use rugpi_cli::style::{Styled, Stylize};
+use rugpi_cli::widgets::{Heading, ProgressBar, ProgressSpinner, Rule, Text, Widget};
+use rugpi_cli::{DrawCtx, StatusSegment};
+
+pub fn cli() {
+    let _hello_world = rugpi_cli::add_status(Styled::new("Hello World!").blue());
+    let task_progress = rugpi_cli::add_status(TaskProgress {
+        state: Mutex::new(TaskState {
+            current_step: 0,
+            total_steps: 1000,
+            title: String::new(),
+            message: String::new(),
+            log_lines: VecDeque::new(),
+        }),
+    });
+    let _rugpi_banner = rugpi_cli::add_status(
+        r#"
+         ____                    _           _
+        |  _ \ _   _  __ _ _ __ (_)   __   _/ |
+        | |_) | | | |/ _` | '_ \| |   \ \ / / |
+        |  _ <| |_| | (_| | |_) | |    \ V /| |
+        |_| \_\\__,_|\__, | .__/|_|     \_/ |_|     by Silitics
+                    |___/|_|
+
+        For more information, visit https://oss.silitics.com/rugpi/.
+        "#,
+    );
+
+    for step in 0..=1000 {
+        std::thread::sleep(Duration::from_millis(10));
+        task_progress.set_step(step);
+        if step % 10 == 0 {
+            task_progress.push_log_line(format!("Position {step} reached!"));
+        }
+        if step % 100 == 0 {
+            info!("Position {step} reached!");
+        }
+        if step % 400 == 0 {
+            task_progress.set_message("Doing work...");
+        } else if step % 400 == 200 {
+            task_progress.set_message("");
+        }
+        if step == 500 {
+            task_progress.set_title("Reached 500");
+        }
+        rugpi_cli::redraw();
+    }
+
+    rugpi_cli::hide_status();
+
+    std::thread::sleep(Duration::from_secs(2));
+
+    rugpi_cli::show_status();
+
+    std::thread::sleep(Duration::from_secs(5));
+}
+
+pub fn main() {
+    rugpi_cli::Initializer::new().init();
+    cli();
+    rugpi_cli::force_redraw();
+}
+
+struct TaskProgress {
+    state: Mutex<TaskState>,
+}
+
+impl TaskProgress {
+    pub fn set_step(&self, step: u64) {
+        self.state.lock().unwrap().current_step = step;
+    }
+
+    pub fn set_title<D: Display>(&self, title: D) {
+        self.state.lock().unwrap().title = title.to_string();
+    }
+
+    pub fn set_message<D: Display>(&self, message: D) {
+        self.state.lock().unwrap().message = message.to_string();
+    }
+
+    pub fn push_log_line(&self, line: String) {
+        let mut state = self.state.lock().unwrap();
+        state.log_lines.push_back(line);
+        while state.log_lines.len() > 5 {
+            state.log_lines.pop_front();
+        }
+    }
+}
+
+struct TaskState {
+    current_step: u64,
+    total_steps: u64,
+    title: String,
+    message: String,
+    log_lines: VecDeque<String>,
+}
+
+impl StatusSegment for TaskProgress {
+    fn draw(&self, ctx: &mut DrawCtx) {
+        let state = self.state.lock().unwrap();
+        if state.title.is_empty() {
+            Rule::new().draw(ctx)
+        } else {
+            Heading::new(&state.title).draw(ctx);
+        };
+        ProgressSpinner::new().draw(ctx);
+        write!(ctx, " Step [{}/{}] ", state.current_step, state.total_steps);
+        if !state.message.is_empty() {
+            ctx.write_str(&state.message);
+            ctx.write_char(' ');
+        }
+        ProgressBar::new(state.current_step, state.total_steps).draw(ctx);
+        let remaining_height = ctx.measure_remaining_height();
+        if !state.log_lines.is_empty() && remaining_height > 2 {
+            let show_lines = state
+                .log_lines
+                .len()
+                .min(5)
+                .min(remaining_height.into_u64() as usize);
+            let skip_lines = state.log_lines.len() - show_lines;
+            Text::new(state.log_lines.iter().skip(skip_lines))
+                .prefix("> ")
+                .styled()
+                .black()
+                .draw(ctx);
+        }
+    }
+}