watchexec/src/main.rs

217 lines
5.6 KiB
Rust
Raw Normal View History

#![feature(mpsc_select)]
#![feature(process_exec)]
#[macro_use]
extern crate clap;
extern crate globset;
2016-10-13 23:59:46 +02:00
extern crate env_logger;
extern crate libc;
#[macro_use]
extern crate log;
#[macro_use]
extern crate lazy_static;
2016-09-18 22:42:11 +02:00
extern crate notify;
2016-09-14 15:30:59 +02:00
#[cfg(unix)]
extern crate nix;
#[cfg(windows)]
extern crate winapi;
#[cfg(windows)]
extern crate kernel32;
2016-10-22 21:37:03 +02:00
2016-10-25 13:05:53 +02:00
#[cfg(test)]
extern crate mktemp;
mod cli;
2016-10-12 04:43:53 +02:00
mod gitignore;
2016-10-22 21:37:03 +02:00
mod interrupt_handler;
2016-09-23 21:52:50 +02:00
mod notification_filter;
mod process;
mod watcher;
2016-09-21 23:02:20 +02:00
use std::collections::HashMap;
use std::env;
use std::sync::mpsc::{channel, Receiver};
use std::time::Duration;
use std::path::{Path, PathBuf};
2016-09-18 22:42:11 +02:00
2016-09-23 21:52:50 +02:00
use notification_filter::NotificationFilter;
use process::{Process, ProcessReaper};
use watcher::{Event, Watcher};
2016-09-14 15:30:59 +02:00
// Starting at the specified path, search for gitignore files,
// stopping at the first one found.
fn find_gitignore_file(path: &Path) -> Option<PathBuf> {
let mut gitignore_path = path.join(".gitignore");
if gitignore_path.exists() {
return Some(gitignore_path);
}
let p = path.to_owned();
while let Some(p) = p.parent() {
gitignore_path = p.join(".gitignore");
if gitignore_path.exists() {
return Some(gitignore_path);
}
}
None
}
fn init_logger(debug: bool) {
2016-10-13 23:59:46 +02:00
let mut log_builder = env_logger::LogBuilder::new();
2016-10-18 15:39:40 +02:00
let level = if debug {
log::LogLevelFilter::Debug
} else {
log::LogLevelFilter::Warn
2016-10-18 15:39:40 +02:00
};
2016-10-13 23:59:46 +02:00
log_builder.format(|r| format!("*** {}", r.args()))
2016-10-13 23:59:46 +02:00
.filter(None, level);
log_builder.init().expect("unable to initialize logger");
}
2016-10-12 15:43:22 +02:00
fn main() {
let interrupt_rx = interrupt_handler::install();
let args = cli::get_args();
2016-10-13 23:59:46 +02:00
init_logger(args.debug);
2016-09-21 23:02:20 +02:00
2016-10-12 15:43:22 +02:00
let cwd = env::current_dir()
.expect("unable to get cwd")
.canonicalize()
.expect("unable to canonicalize cwd");
2016-10-12 04:43:53 +02:00
let mut gitignore_file = None;
if !args.no_vcs_ignore {
if let Some(gitignore_path) = find_gitignore_file(&cwd) {
2016-10-14 01:47:04 +02:00
debug!("Found .gitignore file: {:?}", gitignore_path);
2016-10-12 04:43:53 +02:00
2016-10-12 15:43:22 +02:00
gitignore_file = gitignore::parse(&gitignore_path).ok();
}
2016-10-12 04:43:53 +02:00
}
let filter = NotificationFilter::new(args.filters, args.ignores, gitignore_file)
.expect("unable to create notification filter");
2016-09-21 23:02:20 +02:00
2016-09-14 15:30:59 +02:00
let (tx, rx) = channel();
let mut watcher = Watcher::new(tx, args.poll, args.poll_interval)
.expect("unable to create watcher");
2016-10-20 02:19:01 +02:00
if watcher.is_polling() {
warn!("Polling for changes every {} ms", args.poll_interval);
}
2016-09-18 22:42:11 +02:00
for path in args.paths {
match Path::new(&path).canonicalize() {
Ok(canonicalized) => watcher.watch(canonicalized).expect("unable to watch path"),
Err(_) => {
2016-09-27 15:43:28 +02:00
println!("invalid path: {}", path);
return;
}
}
2016-09-18 22:42:11 +02:00
}
let cmd = args.cmd;
2016-09-14 15:30:59 +02:00
let (child_finish_tx, child_finish_rx) = channel();
let reaper = ProcessReaper::new(child_finish_tx);
let mut child_process = if args.run_initially {
if args.clear_screen {
cli::clear_screen();
}
Process::new(&cmd, vec![]).ok()
} else {
None
};
while !interrupt_handler::interrupt_requested() {
if let Some(paths) = wait(&rx, &interrupt_rx, &filter) {
2016-10-30 17:37:34 +01:00
if let Some(path) = paths.get(0) {
debug!("Path updated: {:?}", path);
}
if let Some(mut child) = child_process {
if args.restart {
debug!("Killing child process");
child.kill();
}
debug!("Waiting for process to exit...");
reaper.wait_process(child);
select! {
_ = child_finish_rx.recv() => {},
_ = interrupt_rx.recv() => break
};
}
if args.clear_screen {
cli::clear_screen();
}
child_process = Process::new(&cmd, paths).ok();
}
2016-09-14 15:30:59 +02:00
}
}
2016-10-12 15:43:22 +02:00
fn wait(rx: &Receiver<Event>,
interrupt_rx: &Receiver<()>,
filter: &NotificationFilter)
-> Option<Vec<PathBuf>> {
let mut paths = vec![];
let mut cache = HashMap::new();
2016-10-12 15:43:22 +02:00
loop {
select! {
_ = interrupt_rx.recv() => { return None; },
ev = rx.recv() => {
let e = ev.expect("error when reading event");
if let Some(ref path) = e.path {
// Ignore cache for the initial file. Otherwise, in
// debug mode it's hard to track what's going on
let excluded = filter.is_excluded(path);
if !cache.contains_key(path) {
cache.insert(path.to_owned(), excluded);
}
if !excluded {
paths.push(path.to_owned());
break;
}
}
2016-10-12 15:43:22 +02:00
}
};
}
2016-10-12 15:43:22 +02:00
// Wait for filesystem activity to cool off
// Unfortunately, we can't use select! with recv_timeout :(
let timeout = Duration::from_millis(500);
while let Ok(e) = rx.recv_timeout(timeout) {
if interrupt_handler::interrupt_requested() {
break;
2016-10-12 15:43:22 +02:00
}
if let Some(ref path) = e.path {
if cache.contains_key(path) {
continue;
}
let excluded = filter.is_excluded(path);
let p = path.to_owned();
cache.insert(p.clone(), excluded);
if !excluded {
paths.push(p);
}
}
2016-10-12 15:43:22 +02:00
}
Some(paths)
2016-10-12 15:43:22 +02:00
}