Add file change detection and reload.

Author: jarruda

Cargo.lock

@@ -15,6 +15,7 @@ regex = "^1.10"
 grep = "^0.3"
 grep-regex = "^0.1"
 wasm-bindgen-futures = "0.4.42"
+notify = "^6.1"
 
 egui = { version = "^0.27", default-features = false, features = [
     "log",
@@ -37,6 +38,7 @@ serde = { version = "1", features = ["derive"] }
 
 puffin = "^0.19"
 puffin_http = "^0.16"
+crossbeam-channel = "0.5.13"
 
 [profile.release]
 opt-level = 2 # fast and small

Cargo.toml

@@ -1,4 +1,5 @@
 use std::path::{Path, PathBuf};
+use std::time::Duration;
 
 use egui::{RichText, Ui};
 use egui_dock::DockState;
@@ -110,7 +111,7 @@ impl eframe::App for TemplateApp {
     /// Put your widgets into a `SidePanel`, `TopPanel`, `CentralPanel`, `Window` or `Area`.
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         puffin::profile_function!();
-        
+
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
             // The top panel is often a good place for a menu bar:
             egui::menu::bar(ui, |ui| {
@@ -172,6 +173,9 @@ impl eframe::App for TemplateApp {
                 });
             });
         }
+        
+        // Keep painting at least once a second to check for file changes
+        ctx.request_repaint_after(Duration::from_secs(1));
     }
 
     /// Called by the frame work to save state before shutdown.

src/app.rs

@@ -1,12 +1,19 @@
+use io::Error;
 use std::{
     fs::File,
     io::{self, BufReader, Read, Seek, SeekFrom},
     path::Path,
 };
+use crossbeam_channel::Receiver;
 
 use grep::searcher::{Searcher, Sink, SinkMatch};
-use grep_regex::{RegexMatcher};
+use grep_regex::RegexMatcher;
 use json::JsonValue;
+use notify::{Config, Event, RecommendedWatcher, RecursiveMode, Watcher};
+
+fn to_io_error(err: notify::Error) -> io::Error {
+    io::Error::new(io::ErrorKind::Other, err)
+}
 
 #[derive(Clone)]
 pub struct LogEntry {
@@ -20,13 +27,13 @@ type FileOffset = u64;
 
 struct AbsolutePositionSink<F>(pub F)
 where
-    F: FnMut(u64) -> Result<bool, io::Error>;
+    F: FnMut(u64) -> Result<bool, Error>;
 
 impl<F> Sink for AbsolutePositionSink<F>
 where
-    F: FnMut(u64) -> Result<bool, io::Error>,
+    F: FnMut(u64) -> Result<bool, Error>,
 {
-    type Error = io::Error;
+    type Error = Error;
 
     fn matched(&mut self, _searcher: &Searcher, mat: &SinkMatch<'_>) -> Result<bool, Self::Error> {
         (self.0)(mat.absolute_byte_offset())
@@ -37,15 +44,27 @@ pub struct LogFileReader {
     buf_reader: BufReader<File>,
     line_map: Vec<FileOffset>,
     file_size: FileOffset,
+    _watcher: Box<dyn Watcher>,
+    watcher_recv: Receiver<notify::Result<Event>>,
 }
 
 impl LogFileReader {
     pub fn open(path: &Path) -> io::Result<LogFileReader> {
+        // sync_channel of 0 makes it a "rendezvous" channel where the watching thread hands off to receiver
+        let (tx, rx) = crossbeam_channel::bounded(0);
+
+        let mut watcher = RecommendedWatcher::new(tx, Config::default()).map_err(to_io_error)?;
+        watcher
+            .watch(path, RecursiveMode::NonRecursive)
+            .map_err(to_io_error)?;
+
         let file = File::open(path)?;
         Ok(LogFileReader {
             buf_reader: BufReader::new(file),
             line_map: Vec::new(),
             file_size: 0,
+            _watcher: Box::new(watcher),
+            watcher_recv: rx,
         })
     }
 
@@ -67,7 +86,7 @@ impl LogFileReader {
         searcher.search_reader(
             matcher,
             self.buf_reader.get_ref(),
-            AbsolutePositionSink(|file_offset| -> Result<bool, io::Error> {
+            AbsolutePositionSink(|file_offset| -> Result<bool, Error> {
                 self.line_map.push(file_offset as FileOffset);
                 Ok(true)
             }),
@@ -80,6 +99,10 @@ impl LogFileReader {
         Ok(self.line_count())
     }
 
+    pub fn has_changed(&mut self) -> bool {
+        self.watcher_recv.try_recv().is_ok()
+    }
+
     /// Returns the total number of lines counted in the file
     /// Only valid after a successful load.
     pub fn line_count(&self) -> usize {

src/app/log_file_reader.rs

@@ -1,21 +1,23 @@
+use std::collections::HashMap;
+use std::default::Default;
+use std::time::SystemTime;
 use std::{
     io,
     path::{Path, PathBuf},
 };
-use std::collections::HashMap;
-use std::default::Default;
 
 use egui::{Align2, Color32, Direction, Id, Ui, WidgetText};
 use egui_dock::{DockArea, DockState, NodeIndex, SurfaceIndex, TabViewer};
 use egui_toast::{Toast, ToastKind, ToastOptions, Toasts};
+use log::{error, info};
 
+use super::log_file_reader::LogFileReader;
 use super::{
     filtered_log_entries_tab::FilteredLogEntriesTab,
     log_entries_tab::LogEntriesTab,
     log_entry_context_tab::LogEntryContextTab,
-    log_file_reader::{LineNumber, LogEntry},
+    log_file_reader::{LineNumber},
 };
-use super::log_file_reader::LogFileReader;
 
 #[derive(Default)]
 struct FilteredLogEntriesTabState {}
@@ -178,7 +180,7 @@ impl LogView {
         tree.main_surface_mut().split_right(
             new_nodes[1],
             0.5,
-            vec![FilteredLogEntriesTab::new(file_path.to_owned())]
+            vec![FilteredLogEntriesTab::new(file_path.to_owned())],
         );
 
         Ok(LogView {
@@ -193,6 +195,20 @@ impl LogView {
     }
 
     pub fn ui(self: &mut Self, ui: &mut Ui) {
+        if self.log_view_context.log_file_reader.has_changed() {
+            info!(
+                "File updated, reloading. {:?}",
+                self.log_view_context.log_file_path
+            );
+            let load_result = self.log_view_context.log_file_reader.load();
+            if let Err(e) = load_result {
+                error!(
+                    "Failed to reload file. file: {:?} error: {:?}",
+                    self.log_view_context.log_file_path, e
+                );
+            }
+        }
+
         DockArea::new(&mut self.tree)
             .id(Id::new(&self.file_path))
             .show_add_buttons(true)
@@ -225,11 +241,19 @@ impl LogViewContext {
             tabs_to_open: vec![],
             viewer_state: Default::default(),
         };
+
+        let load_start_time = SystemTime::now();
+
         match log_view.log_file_reader.load() {
             Ok(line_count) => {
                 log_view.viewer_state.add_toast(
                     ToastKind::Info,
-                    format!("File load complete. Loaded {} lines.", line_count).into(),
+                    format!(
+                        "File load complete. Loaded {} lines in {:?}.",
+                        line_count,
+                        load_start_time.elapsed().unwrap()
+                    )
+                    .into(),
                     10.0,
                 );
             }