lw 0.8.0

Log-Watcher utility - replacement for: `tail -F /some/path/*` - that uses Kqueue to watch for new files as well…
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! "lw" log-watcher utility — binary entry point.

#![forbid(unsafe_code)]
#![deny(
    missing_debug_implementations,
    missing_copy_implementations,
    trivial_casts,
    trivial_numeric_casts,
    unused_import_braces,
    unused_qualifications,
    bad_style,
    dead_code,
    unused,
    while_true
)]

/// Use MiMalloc as default allocator:
#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;


#[macro_use]
extern crate log;

use chrono::Local;
use colored::Colorize;
use fern::Dispatch;
use kqueue2::{Ident::*, Watcher};
use lw::config::Config;
use lw::consts::DEFAULT_THEME;
use lw::types::FileAndPosition;
use lw::utils::{process_file_event, walkdir_recursive, watch_the_watcher};
use std::{env, fs::OpenOptions, path::Path, process::exit, thread, time::Duration};


fn main() {
    // Note whether a config existed *before* loading, since load() creates a
    // default one when missing. We report it once the logger is initialised.
    let wrote_default_config = Config::existing_config_path().is_none();
    let config = Config::load();
    let log_level = config.get_log_level();
    let output = config.output.clone().unwrap_or_default();

    // read paths given as arguments:
    let paths_to_watch: Vec<String> = env::args()
        .skip(1) // first arg is $0
        .collect();

    // mutable hashmap keeping position of all watched files:
    let mut watched_file_states = FileAndPosition::new();

    // mutable kqueue watcher:
    let mut kqueue_watcher = Watcher::new().expect("Could not create kqueue watcher!");

    // name of the last logged file:
    let mut last_file = String::new();

    // Dispatch logger:
    Dispatch::new()
        .format(|out, message, _record| {
            out.finish(format_args!(
                "{}: {}",
                Local::now().to_rfc3339().black(),
                message
            ))
        })
        .level(log_level)
        .chain(
            OpenOptions::new()
                .create(true)
                .append(true)
                .open(output.clone())
                .unwrap_or_else(|_| {
                    panic!("{}: Couldn't open: {}!", "FATAL ERROR".red(), output.cyan())
                }),
        )
        .apply()
        .expect("Couldn't initialize Fern logger!");

    if wrote_default_config {
        info!(
            "No configuration file found — wrote defaults to: {}",
            Config::default_config_path().cyan()
        );
    }

    // Initialise syntax highlighting with the configured theme.
    lw::highlight::init(config.theme.as_deref().unwrap_or(DEFAULT_THEME));

    debug!("Watching paths: {}", paths_to_watch.join(", "));
    if paths_to_watch.is_empty() {
        error!("FATAL ERROR: {}", "No paths specified as arguments! You have to specify at least a single directory/file to watch!".red());
        exit(1)
    }

    // initial watches for specified dirs/files:
    paths_to_watch.into_iter().for_each(|a_path| {
        // Handle case when given a file as argument
        walkdir_recursive(
            &mut kqueue_watcher,
            &mut watched_file_states,
            &mut last_file,
            Path::new(&a_path),
            &config,
        );
    });

    // handle events dynamically, including new files
    loop {
        watch_the_watcher(&mut kqueue_watcher);
        while let Some(an_event) = kqueue_watcher.iter().next() {
            debug!("Watched files: {}", watched_file_states.len());
            match an_event.ident {
                Filename(_file_descriptor, abs_file_name) => {
                    process_file_event(
                        &abs_file_name,
                        &mut kqueue_watcher,
                        &mut watched_file_states,
                        &mut last_file,
                        &config,
                    );
                    watch_the_watcher(&mut kqueue_watcher);
                }

                event => warn!("Unknown event: {}", format!("{event:?}").cyan()),
            }
        }

        // throttle 100ms
        thread::sleep(Duration::from_millis(100));
    }
}