.travis.yml

@@ -1,10 +0,0 @@
-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.1"
+version = "0.1.0"
 authors = ["Aravinda VK <mail@aravindavk.in>"]
 
 description = "A lib to watch log files for new Changes, just like tail -f"

README.md

@@ -1,7 +1,5 @@
 # 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
@@ -14,25 +12,22 @@ Note: Tested only in Linux
 
 First, add the following to your `Cargo.toml`
 
-```toml
+    [dependencies]
-[dependencies]
+    logwatcher = "0.1"
-logwatcher = "0.1"
-```
 
 Add to your code,
 
-```rust
+    extern crate logwatcher;
-extern crate logwatcher;
+    use logwatcher::LogWatcher;
-use logwatcher::LogWatcher;
-```
 
-Register the logwatcher, pass a closure and watch it!
+Create a callback function, which accepts String as input
 
-```rust
+    fn parse_line(line: String) {
-let mut log_watcher = LogWatcher::register("/var/log/check.log".to_string()).unwrap();
+        println!("Line {}", line);
+    }
+
+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,57 +1,46 @@
 use std::fs::File;
-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::io::BufReader;
-use std::path::Path;
+use std::io::prelude::*;
+use std::io;
 use std::thread::sleep;
 use std::time::Duration;
+use std::os::unix::fs::MetadataExt;
+use std::io::ErrorKind;
 
-pub enum LogWatcherAction {
+pub struct LogWatcher{
-    None,
-    SeekToEnd,
-}
-
-pub struct LogWatcher {
     filename: String,
     inode: u64,
     pos: u64,
     reader: BufReader<File>,
-    finish: bool,
+    finish: bool
 }
 
 impl LogWatcher {
-    pub fn register<P: AsRef<Path>>(filename: P) -> Result<LogWatcher, io::Error> {
+    pub fn register(filename: String) -> Result<LogWatcher, io::Error> {
-        let f = match File::open(&filename) {
+        let f = match File::open(filename.clone()) {
             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 pos = metadata.len();
         reader.seek(SeekFrom::Start(pos)).unwrap();
-        Ok(LogWatcher {
+        Ok(LogWatcher{filename: filename,
-            filename: filename.as_ref().to_string_lossy().to_string(),
+                      inode: metadata.ino(),
-            inode: metadata.ino(),
+                      pos: pos,
-            pos: pos,
+                      reader: reader,
-            reader: reader,
+                      finish: false})
-            finish: false,
-        })
     }
 
-    fn reopen_if_log_rotated<F: ?Sized>(&mut self, callback: &mut F)
+    fn reopen_if_log_rotated(&mut self, callback: fn (line: String)){
-    where
-        F: FnMut(String) -> LogWatcherAction,
-    {
         loop {
-            match File::open(&self.filename) {
+            match File::open(self.filename.clone()) {
                 Ok(x) => {
                     let f = x;
                     let metadata = match f.metadata() {
@@ -61,7 +50,7 @@ impl LogWatcher {
                             continue;
                         }
                     };
-                    if metadata.ino() != self.inode {
+                    if metadata.ino() != self.inode{
                         self.finish = true;
                         self.watch(callback);
                         self.finish = false;
@@ -69,13 +58,14 @@ 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;
                     }
@@ -84,35 +74,27 @@ impl LogWatcher {
         }
     }
 
-    pub fn watch<F: ?Sized>(&mut self, callback: &mut F)
+    pub fn watch(&mut self, callback: fn (line: String)) {
-    where
+        loop{
-        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();
-                        match callback(line.replace("\n", "")) {
+                        callback(line.replace("\n", ""));
-                            LogWatcherAction::SeekToEnd => {
-                                println!("SeekToEnd");
-                                self.reader.seek(SeekFrom::End(0)).unwrap();
-                            }
-                            LogWatcherAction::None => {}
-                        }
                         line.clear();
-                    } else {
+                    }else {
-                        if self.finish {
+                        if self.finish{
                             break;
-                        } else {
+                        }
+                        else{
                             self.reopen_if_log_rotated(callback);
                             self.reader.seek(SeekFrom::Start(self.pos)).unwrap();
                         }
                     }
-                }
+                },
                 Err(err) => {
                     println!("{}", err);
                 }
@@ -120,3 +102,8 @@ impl LogWatcher {
         }
     }
 }
+
+
+#[test]
+fn it_works() {
+}

src/main.rs

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