Merge pull request #39 from dark0dave/feature/timeout

feat(timeout): Add timeout

README.md

@@ -28,11 +28,13 @@ Options:
   -l, --language <LANGUAGE>
       Game Language [default: en_US]
   -d, --depth <DEPTH>
-      Depth to walk folder structure [default: 3]
+      Depth to walk folder structure [env: DEPTH=] [default: 3]
   -s, --skip-installed
-      Compare against installed weidu log, note this is best effort
+      Compare against installed weidu log, note this is best effort [env: SKIP_INSTALLED=]
   -a, --abort-on-warnings
-      If a warning occurs in the weidu child process exit
+      If a warning occurs in the weidu child process exit [env: ABORT_ON_WARNINGS=]
+  -t, --timeout <TIMEOUT>
+      Timeout time per mod in seconds, default is 1 hour [env: TIMEOUT=] [default: 3600]
   -h, --help
       Print help
   -V, --version

src/args.rs

@@ -34,16 +34,20 @@ pub struct Args {
     pub language: String,
 
     /// Depth to walk folder structure
-    #[clap(long, short, default_value = "3")]
+    #[clap(env, long, short, default_value = "3")]
     pub depth: usize,
 
     /// Compare against installed weidu log, note this is best effort
-    #[clap(long, short, action=ArgAction::SetTrue)]
+    #[clap(env, long, short, action=ArgAction::SetTrue)]
     pub skip_installed: bool,
 
     /// If a warning occurs in the weidu child process exit
-    #[clap(long, short, action=ArgAction::SetTrue)]
+    #[clap(env, long, short, action=ArgAction::SetTrue)]
     pub abort_on_warnings: bool,
+
+    /// Timeout time per mod in seconds, default is 1 hour
+    #[clap(env, long, short, default_value = "3600")]
+    pub timeout: usize,
 }
 
 fn parse_absolute_path(arg: &str) -> Result<PathBuf, String> {

src/main.rs

@@ -81,6 +81,7 @@ fn main() {
             &args.game_directory,
             &weidu_mod,
             &args.language,
+            args.timeout,
         ) {
             InstallationResult::Fail(message) => {
                 panic!(

src/state.rs

@@ -2,6 +2,7 @@
 pub enum State {
     RequiresInput { question: String },
     InProgress,
+    TimedOut,
     Completed,
     CompletedWithErrors { error_details: String },
     CompletedWithWarnings,

src/weidu.rs

@@ -3,7 +3,11 @@ use std::{
     panic,
     path::PathBuf,
     process::{Child, ChildStdout, Command, Stdio},
-    sync::mpsc::{self, Receiver, TryRecvError},
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        mpsc::{self, Receiver, TryRecvError},
+        Arc,
+    },
     thread,
 };
 
@@ -42,6 +46,7 @@ pub fn install(
     game_directory: &PathBuf,
     weidu_mod: &ModComponent,
     language: &str,
+    timeout: usize,
 ) -> InstallationResult {
     let weidu_args = generate_args(weidu_mod, language);
     let mut command = Command::new(weidu_binary);
@@ -54,16 +59,16 @@ pub fn install(
         .spawn()
         .expect("Failed to spawn weidu process");
 
-    handle_io(child)
+    handle_io(child, timeout)
 }
 
-pub fn handle_io(mut child: Child) -> InstallationResult {
+pub fn handle_io(mut child: Child, timeout: usize) -> InstallationResult {
     let mut weidu_stdin = child.stdin.take().unwrap();
+    let wait_counter = 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);
+    parse_raw_output(sender, raw_output_receiver, wait_counter.clone(), timeout);
 
-    let mut wait_counter = 0;
     loop {
         match parsed_output_receiver.try_recv() {
             Ok(state) => {
@@ -80,6 +85,13 @@ pub fn handle_io(mut child: Child) -> InstallationResult {
                             .expect("Failed to send final ENTER to weidu process");
                         return InstallationResult::Fail(error_details);
                     }
+                    State::TimedOut => {
+                        log::error!(
+                            "Weidu process seem to have been running for {} seconds, exiting",
+                            timeout
+                        );
+                        return InstallationResult::Fail("Timed out".to_string());
+                    }
                     State::CompletedWithWarnings => {
                         log::warn!("Weidu process seem to have completed with warnings");
                         weidu_stdin
@@ -103,11 +115,13 @@ pub fn handle_io(mut child: Child) -> InstallationResult {
                 }
             }
             Err(TryRecvError::Empty) => {
-                log::info!("{}\r", ".".repeat(wait_counter));
+                log::info!(
+                    "{}\r",
+                    ".".repeat(wait_counter.load(Ordering::Relaxed) % 10)
+                );
                 std::io::stdout().flush().expect("Failed to flush stdout");
 
-                wait_counter += 1;
-                wait_counter %= 10;
+                wait_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                 sleep(1000);
 
                 std::io::stdout().flush().expect("Failed to flush stdout");

src/weidu_parser.rs

@@ -1,5 +1,9 @@
 use std::{
-    sync::mpsc::{Receiver, Sender, TryRecvError},
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        mpsc::{Receiver, Sender, TryRecvError},
+        Arc,
+    },
     thread,
 };
 
@@ -40,7 +44,12 @@ enum ParserState {
     LookingForInterestingOutput,
 }
 
-pub fn parse_raw_output(sender: Sender<State>, receiver: Receiver<String>) {
+pub fn parse_raw_output(
+    sender: Sender<State>,
+    receiver: Receiver<String>,
+    wait_count: Arc<AtomicUsize>,
+    timeout: usize,
+) {
     let mut current_state = ParserState::LookingForInterestingOutput;
     let mut question = String::new();
     sender
@@ -101,7 +110,11 @@ pub fn parse_raw_output(sender: Sender<State>, receiver: Receiver<String>) {
                         question = String::new();
                     }
                     _ => {
-                        // TODO: Exit here if we come here too much
+                        if wait_count.load(Ordering::Relaxed) >= timeout {
+                            sender
+                                .send(State::TimedOut)
+                                .expect("Could send timeout error");
+                        }
                         // there is no new weidu output and we are not waiting for any, so there is nothing to do
                     }
                 }