2021-12-28 18:11:32 +01:00
|
|
|
use std::sync::mpsc::Receiver;
|
2018-04-13 22:46:17 +02:00
|
|
|
use std::sync::{Arc, Mutex};
|
2017-10-14 18:04:11 +02:00
|
|
|
|
2022-09-27 22:09:21 +02:00
|
|
|
use crate::config::Config;
|
2021-11-30 08:51:16 +01:00
|
|
|
use crate::dir_entry::DirEntry;
|
2020-04-03 21:18:54 +02:00
|
|
|
use crate::error::print_error;
|
|
|
|
use crate::exit_codes::{merge_exitcodes, ExitCode};
|
|
|
|
use crate::walk::WorkerResult;
|
|
|
|
|
2022-02-18 09:21:00 +01:00
|
|
|
use super::CommandSet;
|
2020-04-03 21:18:54 +02:00
|
|
|
|
2017-10-14 18:04:11 +02:00
|
|
|
/// An event loop that listens for inputs from the `rx` receiver. Each received input will
|
|
|
|
/// generate a command with the supplied command template. The generated command will then
|
|
|
|
/// be executed, and this process will continue until the receiver's sender has closed.
|
2018-09-30 22:56:32 +02:00
|
|
|
pub fn job(
|
|
|
|
rx: Arc<Mutex<Receiver<WorkerResult>>>,
|
2022-02-18 09:21:00 +01:00
|
|
|
cmd: Arc<CommandSet>,
|
2018-09-30 22:56:32 +02:00
|
|
|
out_perm: Arc<Mutex<()>>,
|
2022-09-27 22:09:21 +02:00
|
|
|
config: &Config,
|
2020-01-25 17:13:47 +01:00
|
|
|
) -> ExitCode {
|
2022-09-27 22:09:21 +02:00
|
|
|
// Output should be buffered when only running a single thread
|
|
|
|
let buffer_output: bool = config.threads > 1;
|
|
|
|
|
2020-01-25 17:13:47 +01:00
|
|
|
let mut results: Vec<ExitCode> = Vec::new();
|
2017-10-14 18:04:11 +02:00
|
|
|
loop {
|
|
|
|
// Create a lock on the shared receiver for this thread.
|
|
|
|
let lock = rx.lock().unwrap();
|
|
|
|
|
2018-10-01 21:29:54 +02:00
|
|
|
// Obtain the next result from the receiver, else if the channel
|
2017-10-14 18:04:11 +02:00
|
|
|
// has closed, exit from the loop
|
2021-11-30 08:52:39 +01:00
|
|
|
let dir_entry: DirEntry = match lock.recv() {
|
|
|
|
Ok(WorkerResult::Entry(dir_entry)) => dir_entry,
|
2018-10-01 21:29:54 +02:00
|
|
|
Ok(WorkerResult::Error(err)) => {
|
2022-09-27 22:09:21 +02:00
|
|
|
if config.show_filesystem_errors {
|
2020-04-03 21:18:54 +02:00
|
|
|
print_error(err.to_string());
|
2018-10-22 14:20:08 +02:00
|
|
|
}
|
2018-10-01 21:29:54 +02:00
|
|
|
continue;
|
|
|
|
}
|
2017-10-14 20:04:04 +02:00
|
|
|
Err(_) => break,
|
2017-10-14 18:04:11 +02:00
|
|
|
};
|
2021-08-09 09:02:30 +02:00
|
|
|
|
2020-01-25 17:13:47 +01:00
|
|
|
// Drop the lock so that other threads can read from the receiver.
|
2017-10-14 18:04:11 +02:00
|
|
|
drop(lock);
|
2020-01-26 14:06:18 +01:00
|
|
|
// Generate a command, execute it and store its exit code.
|
2022-09-27 22:09:21 +02:00
|
|
|
results.push(cmd.execute(
|
|
|
|
dir_entry.stripped_path(config),
|
|
|
|
Arc::clone(&out_perm),
|
|
|
|
buffer_output,
|
|
|
|
))
|
2017-10-14 18:04:11 +02:00
|
|
|
}
|
2020-01-25 17:13:47 +01:00
|
|
|
// Returns error in case of any error.
|
2021-08-21 22:43:17 +02:00
|
|
|
merge_exitcodes(results)
|
2017-10-14 20:04:04 +02:00
|
|
|
}
|
2018-11-11 18:00:01 +01:00
|
|
|
|
2022-09-27 22:09:21 +02:00
|
|
|
pub fn batch(rx: Receiver<WorkerResult>, cmd: &CommandSet, config: &Config) -> ExitCode {
|
2021-11-30 08:52:39 +01:00
|
|
|
let paths = rx
|
|
|
|
.into_iter()
|
|
|
|
.filter_map(|worker_result| match worker_result {
|
2022-09-27 22:09:21 +02:00
|
|
|
WorkerResult::Entry(dir_entry) => Some(dir_entry.into_stripped_path(config)),
|
2021-11-30 08:52:39 +01:00
|
|
|
WorkerResult::Error(err) => {
|
2022-09-27 22:09:21 +02:00
|
|
|
if config.show_filesystem_errors {
|
2021-11-30 08:52:39 +01:00
|
|
|
print_error(err.to_string());
|
|
|
|
}
|
|
|
|
None
|
2018-11-11 18:00:01 +01:00
|
|
|
}
|
2021-11-30 08:52:39 +01:00
|
|
|
});
|
2021-10-22 08:05:13 +02:00
|
|
|
|
2022-09-27 22:09:21 +02:00
|
|
|
cmd.execute_batch(paths, config.batch_size)
|
2018-11-11 18:00:01 +01:00
|
|
|
}
|