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
  }
  }