Updated README page to reflect latest changes

Signed-off-by: Aravinda Vishwanathapura <mail@aravindavk.in>

.travis.yml

@@ -0,0 +1,10 @@
+language: rust
+
+before_script:
+  - rustup component add rustfmt-preview
+
+script:
+  - cargo fmt --all -- --check
+  - cargo build
+  - cargo test
+

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "logwatcher"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Aravinda VK <mail@aravindavk.in>"]
 
 description = "A lib to watch log files for new Changes, just like tail -f"

README.md

@@ -1,5 +1,7 @@
 # Log Watcher
 
+[![Build Status](https://travis-ci.org/aravindavk/logwatcher.svg?branch=master)](https://travis-ci.org/aravindavk/logwatcher)
+
 A [Rust](https://www.rust-lang.org/) library to watch the log files.
 
 Note: Tested only in Linux
@@ -12,22 +14,25 @@ Note: Tested only in Linux
 
 First, add the following to your `Cargo.toml`
 
-    [dependencies]
+```toml
-    logwatcher = "0.1"
+[dependencies]
+logwatcher = "0.1"
+```
 
 Add to your code,
 
-    extern crate logwatcher;
+```rust
-    use logwatcher::LogWatcher;
+extern crate logwatcher;
+use logwatcher::LogWatcher;
+```
 
-Create a callback function, which accepts String as input
+Register the logwatcher, pass a closure and watch it!
 
-    fn parse_line(line: String) {
+```rust
-        println!("Line {}", line);
+let mut log_watcher = LogWatcher::register("/var/log/check.log".to_string()).unwrap();
-    }
-
-Register the logwatcher and watch it!
-
-    let mut log_watcher = LogWatcher::register("/var/log/check.log".to_string()).unwrap();
-    log_watcher.watch(parse_line);
 
+log_watcher.watch(&mut move |line: String| {
+    println!("Line {}", line);
+    LogWatcherAction::None
+});
+```

src/lib.rs

@@ -1,46 +1,57 @@
 use std::fs::File;
-use std::io::SeekFrom;
-use std::io::BufReader;
-use std::io::prelude::*;
 use std::io;
+use std::io::prelude::*;
+use std::io::BufReader;
+use std::io::ErrorKind;
+use std::io::SeekFrom;
+use std::os::unix::fs::MetadataExt;
+use std::path::Path;
 use std::thread::sleep;
 use std::time::Duration;
-use std::os::unix::fs::MetadataExt;
-use std::io::ErrorKind;
 
-pub struct LogWatcher{
+pub enum LogWatcherAction {
+    None,
+    SeekToEnd,
+}
+
+pub struct LogWatcher {
     filename: String,
     inode: u64,
     pos: u64,
     reader: BufReader<File>,
-    finish: bool
+    finish: bool,
 }
 
 impl LogWatcher {
-    pub fn register(filename: String) -> Result<LogWatcher, io::Error> {
+    pub fn register<P: AsRef<Path>>(filename: P) -> Result<LogWatcher, io::Error> {
-        let f = match File::open(filename.clone()) {
+        let f = match File::open(&filename) {
             Ok(x) => x,
-            Err(err) => return Err(err)
+            Err(err) => return Err(err),
         };
-        
+
         let metadata = match f.metadata() {
             Ok(x) => x,
-            Err(err) => return Err(err)
+            Err(err) => return Err(err),
         };
 
-        let mut reader = BufReader::new(f);        
+        let mut reader = BufReader::new(f);
         let pos = metadata.len();
         reader.seek(SeekFrom::Start(pos)).unwrap();
-        Ok(LogWatcher{filename: filename,
+        Ok(LogWatcher {
-                      inode: metadata.ino(),
+            filename: filename.as_ref().to_string_lossy().to_string(),
-                      pos: pos,
+            inode: metadata.ino(),
-                      reader: reader,
+            pos: pos,
-                      finish: false})
+            reader: reader,
+            finish: false,
+        })
     }
 
-    fn reopen_if_log_rotated(&mut self, callback: fn (line: String)){
+    fn reopen_if_log_rotated<F: ?Sized>(&mut self, callback: &mut F)
+    where
+        F: FnMut(String) -> LogWatcherAction,
+    {
         loop {
-            match File::open(self.filename.clone()) {
+            match File::open(&self.filename) {
                 Ok(x) => {
                     let f = x;
                     let metadata = match f.metadata() {
@@ -50,7 +61,7 @@ impl LogWatcher {
                             continue;
                         }
                     };
-                    if metadata.ino() != self.inode{
+                    if metadata.ino() != self.inode {
                         self.finish = true;
                         self.watch(callback);
                         self.finish = false;
@@ -58,14 +69,13 @@ impl LogWatcher {
                         self.reader = BufReader::new(f);
                         self.pos = 0;
                         self.inode = metadata.ino();
-                    }
+                    } else {
-                    else{
                         sleep(Duration::new(1, 0));
                     }
                     break;
-                },
+                }
                 Err(err) => {
-                    if err.kind() == ErrorKind::NotFound{
+                    if err.kind() == ErrorKind::NotFound {
                         sleep(Duration::new(1, 0));
                         continue;
                     }
@@ -74,27 +84,35 @@ impl LogWatcher {
         }
     }
 
-    pub fn watch(&mut self, callback: fn (line: String)) {
+    pub fn watch<F: ?Sized>(&mut self, callback: &mut F)
-        loop{
+    where
+        F: FnMut(String) -> LogWatcherAction,
+    {
+        loop {
             let mut line = String::new();
             let resp = self.reader.read_line(&mut line);
-            match resp{
+            match resp {
                 Ok(len) => {
-                    if len > 0{
+                    if len > 0 {
                         self.pos += len as u64;
                         self.reader.seek(SeekFrom::Start(self.pos)).unwrap();
-                        callback(line.replace("\n", ""));
+                        match callback(line.replace("\n", "")) {
-                        line.clear();
+                            LogWatcherAction::SeekToEnd => {
-                    }else {
+                                println!("SeekToEnd");
-                        if self.finish{
+                                self.reader.seek(SeekFrom::End(0)).unwrap();
-                            break;
+                            }
+                            LogWatcherAction::None => {}
                         }
-                        else{
+                        line.clear();
+                    } else {
+                        if self.finish {
+                            break;
+                        } else {
                             self.reopen_if_log_rotated(callback);
                             self.reader.seek(SeekFrom::Start(self.pos)).unwrap();
                         }
                     }
-                },
+                }
                 Err(err) => {
                     println!("{}", err);
                 }
@@ -102,8 +120,3 @@ impl LogWatcher {
         }
     }
 }
-
-
-#[test]
-fn it_works() {
-}

src/main.rs

@@ -2,14 +2,9 @@ use std::env::args;
 use std::process::exit;
 
 extern crate logwatcher;
-use logwatcher::LogWatcher;
+use logwatcher::{LogWatcher, LogWatcherAction};
 
-
+fn main() {
-fn parse_line(line: String) {
-    println!("Line {}", line);
-}
-
-fn main(){
     let filename = match args().nth(1) {
         Some(x) => x,
         None => {
@@ -17,6 +12,11 @@ fn main(){
             exit(1);
         }
     };
+
     let mut log_watcher = LogWatcher::register(filename).unwrap();
-    log_watcher.watch(parse_line);
+
+    log_watcher.watch(&mut move |line: String| {
+        println!("Line {}", line);
+        LogWatcherAction::None
+    });
 }