improved progress tracking for multi step commands

Author: Heliozoa

tmc-langs-cli/src/main.rs

@@ -1053,6 +1053,7 @@ fn run_core(matches: &ArgMatches) -> Result<PrintToken> {
             if save_old_state {
                 let submission_url = matches.value_of("submission_url").unwrap();
                 let submission_url = into_url(submission_url)?;
+                core.increment_progress_steps();
                 core.submit(submission_url, exercise_path, None)?;
             }
             core.reset(exercise_id, exercise_path)?;
@@ -1078,20 +1079,24 @@ fn run_core(matches: &ArgMatches) -> Result<PrintToken> {
 
             let save_old_state = matches.is_present("save-old-state");
 
+            core.increment_progress_steps();
             if save_old_state {
                 let submission_url = matches.value_of("submission_url").unwrap();
                 let submission_url = into_url(submission_url)?;
+                core.increment_progress_steps();
                 core.submit(submission_url, output_path, None)?;
+                log::debug!("finished submission");
             }
 
             // reset old exercise if it exists
-            if output_path.exists() {
-                core.reset(exercise_id, output_path)?;
-            }
+            core.reset(exercise_id, output_path)?;
+            log::debug!("reset exercise");
 
             let temp_zip = NamedTempFile::new().context("Failed to create a temporary archive")?;
             core.download_old_submission(submission_id, temp_zip.path())?;
-            task_executor::extract_project(temp_zip.path(), output_path)?;
+            log::debug!("downloaded old submission to {}", temp_zip.path().display());
+            task_executor::extract_project(temp_zip.path(), output_path, false)?;
+            log::debug!("extracted project");
 
             let output = Output::<()> {
                 status: Status::Finished,

tmc-langs-cli/src/output.rs

@@ -38,6 +38,7 @@ pub enum OutputResult {
     Sending,
     WaitingForResults,
     Finished,
+    IntermediateStepFinished,
 }
 
 impl From<StatusType> for OutputResult {
@@ -50,6 +51,7 @@ impl From<StatusType> for OutputResult {
             StatusType::Sending => OutputResult::Sending,
             StatusType::WaitingForResults => OutputResult::WaitingForResults,
             StatusType::Finished => OutputResult::Finished,
+            StatusType::IntermediateStepFinished => OutputResult::IntermediateStepFinished,
         }
     }
 }

tmc-langs-core/src/tmc_core.rs

@@ -12,6 +12,7 @@ use oauth2::{
 };
 use reqwest::{blocking::Client, Url};
 use serde::Serialize;
+use std::cell::Cell;
 use std::collections::HashMap;
 use std::error::Error as StdError;
 use std::fs;
@@ -45,6 +46,7 @@ pub enum StatusType {
     Sending,
     WaitingForResults,
     Finished,
+    IntermediateStepFinished,
 }
 
 // compatible with anyhow
@@ -60,6 +62,8 @@ pub struct TmcCore {
     auth_url: String,
     token: Option<Token>,
     progress_report: Option<UpdateClosure>,
+    progress_steps_done: Cell<u32>,
+    progress_steps_total: u32,
     client_name: String,
     client_version: String,
 }
@@ -103,6 +107,8 @@ impl TmcCore {
             auth_url,
             token: None,
             progress_report: None,
+            progress_steps_done: Cell::new(0),
+            progress_steps_total: 1,
             client_name,
             client_version,
         })
@@ -139,12 +145,14 @@ impl TmcCore {
         self.progress_report = Some(Box::new(progress_report));
     }
 
-    pub fn report_progress(
-        &self,
-        message: &'static str,
-        status_type: StatusType,
-        percent_done: f64,
-    ) {
+    pub fn increment_progress_steps(&mut self) {
+        self.progress_steps_total += 1;
+    }
+
+    fn report_progress(&self, message: &'static str, status_type: StatusType, percent_done: f64) {
+        let from_prev_steps = self.progress_steps_done.get() as f64;
+        let percent_done = (from_prev_steps + percent_done) / self.progress_steps_total as f64;
+
         self.progress_report.as_ref().map(|f| {
             f(StatusUpdate {
                 finished: false,
@@ -155,15 +163,21 @@ impl TmcCore {
         });
     }
 
-    pub fn report_complete(&self, message: &'static str) {
-        self.progress_report.as_ref().map(|f| {
-            f(StatusUpdate {
-                finished: true,
-                message,
-                percent_done: 1.0,
-                status_type: StatusType::Finished,
-            })
-        });
+    fn report_complete(&self, message: &'static str) {
+        self.progress_steps_done
+            .set(self.progress_steps_done.get() + 1);
+        if self.progress_steps_done.get() == self.progress_steps_total {
+            self.progress_report.as_ref().map(|f| {
+                f(StatusUpdate {
+                    finished: true,
+                    message,
+                    percent_done: 1.0,
+                    status_type: StatusType::Finished,
+                })
+            });
+        } else {
+            self.report_progress(message, StatusType::IntermediateStepFinished, 0.0);
+        }
     }
 
     /// Attempts to log in with the given credentials, returns an error if an authentication token is already present.
@@ -1286,4 +1300,36 @@ mod test {
             serde_json::to_string(&f).unwrap()
         );
     }
+
+    #[test]
+    fn multi_step_progress() {
+        use std::sync::{Arc, Mutex};
+
+        let (mut core, _) = init();
+        let report = Arc::new(Mutex::default());
+
+        let report_clone = Arc::clone(&report);
+        core.set_progress_report(move |rep| {
+            log::debug!("got {:#?}", rep);
+            let report = Arc::clone(&report_clone);
+            *report.lock().unwrap() = Some(rep);
+            Ok(())
+        });
+        core.increment_progress_steps();
+        core.increment_progress_steps();
+
+        core.report_progress("msg", StatusType::Downloading, 0.2);
+        let err = f64::EPSILON;
+        assert!((report.lock().unwrap().as_ref().unwrap().percent_done - (0.2 / 3.0)).abs() < err);
+        core.report_progress("msg", StatusType::Downloading, 0.8);
+        assert!((report.lock().unwrap().as_ref().unwrap().percent_done - (0.8 / 3.0)).abs() < err);
+        core.report_complete("msg");
+        assert!((report.lock().unwrap().as_ref().unwrap().percent_done - (1.0 / 3.0)).abs() < err);
+        core.report_complete("msg");
+        assert!((report.lock().unwrap().as_ref().unwrap().percent_done - (2.0 / 3.0)).abs() < err);
+        core.report_progress("msg", StatusType::Downloading, 0.5);
+        assert!((report.lock().unwrap().as_ref().unwrap().percent_done - (2.5 / 3.0)).abs() < err);
+        core.report_complete("msg");
+        assert!((report.lock().unwrap().as_ref().unwrap().percent_done - 1.0).abs() < err);
+    }
 }