Feature position

src/lib.rs

@@ -9,6 +9,16 @@ use std::path::Path;
 use std::thread::sleep;
 use std::time::Duration;
 
+/// Where shall it starts to print from
+pub enum StartFrom {
+    /// The beginning of the file
+    Beginning,
+    /// Specify the cursor position offset
+    Offset(u64),
+    /// The end of the file, which is the last known position
+    End,
+}
+
 pub enum LogWatcherAction {
     None,
     SeekToEnd,
@@ -23,7 +33,10 @@ pub struct LogWatcher {
 }
 
 impl LogWatcher {
-    pub fn register<P: AsRef<Path>>(filename: P) -> Result<LogWatcher, io::Error> {
+    pub fn register<P: AsRef<Path>>(
+        filename: P,
+        starts_from: StartFrom,
+    ) -> Result<LogWatcher, io::Error> {
         let f = match File::open(&filename) {
             Ok(x) => x,
             Err(err) => return Err(err),
@@ -35,20 +48,27 @@ impl LogWatcher {
         };
 
         let mut reader = BufReader::new(f);
-        let pos = metadata.len();
-        reader.seek(SeekFrom::Start(pos)).unwrap();
+
+        let starts_from = match starts_from {
+            StartFrom::Beginning => 0u64,
+            StartFrom::Offset(pos) => pos,
+            StartFrom::End => metadata.len(),
+        };
+
+        reader.seek(SeekFrom::Start(starts_from)).unwrap();
+
         Ok(LogWatcher {
             filename: filename.as_ref().to_string_lossy().to_string(),
             inode: metadata.ino(),
-            pos: pos,
-            reader: reader,
+            pos: starts_from,
+            reader,
             finish: false,
         })
     }
 
     fn reopen_if_log_rotated<F: ?Sized>(&mut self, callback: &mut F)
     where
-        F: FnMut(String) -> LogWatcherAction,
+        F: FnMut(u64, usize, String) -> LogWatcherAction,
     {
         loop {
             match File::open(&self.filename) {
@@ -86,17 +106,18 @@ impl LogWatcher {
 
     pub fn watch<F: ?Sized>(&mut self, callback: &mut F)
     where
-        F: FnMut(String) -> LogWatcherAction,
+        F: FnMut(u64, usize, String) -> LogWatcherAction,
     {
         loop {
             let mut line = String::new();
             let resp = self.reader.read_line(&mut line);
             match resp {
                 Ok(len) => {
                     if len > 0 {
+                        let old_pos = self.pos;
                         self.pos += len as u64;
                         self.reader.seek(SeekFrom::Start(self.pos)).unwrap();
-                        match callback(line.replace("\n", "")) {
+                        match callback(old_pos, len, line.replace("\n", "")) {
                             LogWatcherAction::SeekToEnd => {
                                 println!("SeekToEnd");
                                 self.reader.seek(SeekFrom::End(0)).unwrap();

src/main.rs

@@ -1,9 +1,9 @@
+extern crate logwatcher;
+
+use logwatcher::{LogWatcher, LogWatcherAction, StartFrom};
 use std::env::args;
 use std::process::exit;
 
-extern crate logwatcher;
-use logwatcher::{LogWatcher, LogWatcherAction};
-
 fn main() {
     let filename = match args().nth(1) {
         Some(x) => x,
@@ -13,10 +13,10 @@ fn main() {
         }
     };
 
-    let mut log_watcher = LogWatcher::register(filename).unwrap();
+    let mut log_watcher = LogWatcher::register(filename, StartFrom::End).unwrap();
 
-    log_watcher.watch(&mut move |line: String| {
-        println!("Line {}", line);
+    log_watcher.watch(&mut move |pos: u64, len: usize, line: String| {
+        println!("Pos #{}, len {} char, Line: `{}`", pos, len, line);
         LogWatcherAction::None
     });
 }