feat(log): Dump log at end (#139)

Author: dark0dave

Cargo.lock

@@ -5,7 +5,7 @@ use std::{
     sync::{
         atomic::{AtomicUsize, Ordering},
         mpsc::{self, Receiver, TryRecvError},
-        Arc,
+        Arc, RwLock,
     },
     thread,
 };
@@ -15,6 +15,8 @@ use crate::{
     weidu_parser::parse_raw_output,
 };
 
+const TICK: u64 = 1000;
+
 pub(crate) fn get_user_input() -> String {
     let stdin = io::stdin();
     let mut input = String::new();
@@ -70,15 +72,17 @@ pub(crate) fn handle_io(
     parser_config: Arc<ParserConfig>,
     timeout: usize,
 ) -> InstallationResult {
+    let log = Arc::new(RwLock::new(String::new()));
     let mut weidu_stdin = child.stdin.take().unwrap();
-    let wait_counter = Arc::new(AtomicUsize::new(0));
+    let wait_count = Arc::new(AtomicUsize::new(0));
     let raw_output_receiver = create_output_reader(child.stdout.take().unwrap());
     let (sender, parsed_output_receiver) = mpsc::channel::<State>();
     parse_raw_output(
         sender,
         raw_output_receiver,
         parser_config,
-        wait_counter.clone(),
+        wait_count.clone(),
+        log.clone(),
         timeout,
     );
 
@@ -93,6 +97,7 @@ pub(crate) fn handle_io(
                     }
                     State::CompletedWithErrors { error_details } => {
                         log::error!("Weidu process seem to have completed with errors");
+                        log::error!("Dumping log: {}", log.read().unwrap());
                         weidu_stdin
                             .write_all("\n".as_bytes())
                             .expect("Failed to send final ENTER to weidu process");
@@ -103,10 +108,12 @@ pub(crate) fn handle_io(
                             "Weidu process seem to have been running for {} seconds, exiting",
                             timeout
                         );
+                        log::error!("Dumping log: {}", log.read().unwrap());
                         return InstallationResult::Fail("Timed out".to_string());
                     }
                     State::CompletedWithWarnings => {
                         log::warn!("Weidu process seem to have completed with warnings");
+                        log::warn!("Dumping log: {}", log.read().unwrap());
                         weidu_stdin
                             .write_all("\n".as_bytes())
                             .expect("Failed to send final ENTER to weidu process");
@@ -127,14 +134,11 @@ pub(crate) fn handle_io(
                 }
             }
             Err(TryRecvError::Empty) => {
-                log::info!(
-                    "{}\r",
-                    ".".repeat(wait_counter.load(Ordering::Relaxed) % 10)
-                );
+                log::info!("{}", ".".repeat(wait_count.load(Ordering::Relaxed) % 10));
                 std::io::stdout().flush().expect("Failed to flush stdout");
 
-                wait_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-                sleep(1000);
+                wait_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                sleep(TICK);
 
                 std::io::stdout().flush().expect("Failed to flush stdout");
             }

src/weidu.rs

@@ -2,7 +2,7 @@ use std::{
     sync::{
         atomic::{AtomicUsize, Ordering},
         mpsc::{Receiver, Sender, TryRecvError},
-        Arc,
+        Arc, RwLock,
     },
     thread,
 };
@@ -21,6 +21,7 @@ pub(crate) fn parse_raw_output(
     receiver: Receiver<String>,
     parser_config: Arc<ParserConfig>,
     wait_count: Arc<AtomicUsize>,
+    log: Arc<RwLock<String>>,
     timeout: usize,
 ) {
     let mut current_state = ParserState::LookingForInterestingOutput;
@@ -32,6 +33,9 @@ pub(crate) fn parse_raw_output(
         match receiver.try_recv() {
             Ok(string) => match current_state {
                 ParserState::CollectingQuestion | ParserState::WaitingForMoreQuestionContent => {
+                    if let Ok(mut writer) = log.write() {
+                        writer.push_str(&string);
+                    }
                     if parser_config.useful_status_words.contains(&string) {
                         log::debug!(
                             "Weidu seems to know an answer for the last question, ignoring it"
@@ -45,7 +49,9 @@ pub(crate) fn parse_raw_output(
                     }
                 }
                 ParserState::LookingForInterestingOutput => {
-                    log::trace!("{}", string);
+                    if let Ok(mut writer) = log.write() {
+                        writer.push_str(&string);
+                    }
                     if let Some(weidu_finished_state) =
                         parser_config.detect_weidu_finished_state(&string)
                     {