refactor: os dependent log reading loop

Author: SpontanCombust

src/core/scriptslog.rs

@@ -10,7 +10,64 @@ use crate::constants;
 /// the string passed to said printer will consist of one or more lines of text.
 pub fn tail_scriptslog<P>( printer: P, refresh_time_millis: u64, cancel_token: Receiver<()>, custom_path: Option<String> ) -> Option<String> 
 where P: Fn(&String) -> () {
-    match scriptslog_file(custom_path) {
+    if let Some(p) = custom_path {
+        tail_scriptslog_loop(Path::new(&p).to_path_buf(), printer, refresh_time_millis, cancel_token)
+    } else {
+        match scriptslog_file_path() {
+            Ok(p) => {
+                tail_scriptslog_loop(p, printer, refresh_time_millis, cancel_token)
+            }
+            Err(e) => {
+                Some(e)
+            }
+        }
+    }
+}
+
+fn scriptslog_file_path() -> Result<PathBuf, String> {
+    let mut docs = None;
+    if let Some(ud) = UserDirs::new() {
+        if cfg!(windows) {
+            if let Some(path) = ud.document_dir() {
+                docs = Some(path.to_owned());
+            }
+        } 
+        else if cfg!(unix) {
+            if let Some(path) = Some(ud.home_dir()) {
+                docs = Some(path.join(constants::LINUX_STEAM_PFX_PATH).to_owned());
+            }
+        } 
+        else {
+            unimplemented!();
+        }
+    }
+
+    if let Some(docs) = docs {
+        return Ok( docs.join(Path::new("The Witcher 3").join(constants::SCRIPTSLOG_FILE_NAME)) );
+    } else {
+        return Err( "Documents directory could not be found.".to_owned() );
+    }
+}
+
+fn open_scriptslog(path: &PathBuf) -> Result<File, String> {
+    let file = OpenOptions::new()
+        .read(true)
+        .write(true) // so that it can be created if doesn't exist
+        .create(true)
+        .open(path);
+
+    if let Err(e) = file {
+        println!("{:?}", e.kind());
+        return Err("File open error: ".to_owned() + &e.to_string());
+    } else {
+        return Ok(file.unwrap());
+    }
+}
+
+#[cfg(target_os = "windows")]
+fn tail_scriptslog_loop<P>(scriptslog_path: PathBuf, printer: P, refresh_time_millis: u64, cancel_token: Receiver<()>) -> Option<String> 
+where P: Fn(&String) -> () {
+    match open_scriptslog(&scriptslog_path) {
         Ok(file) => {
             let mut reader = BufReader::new(&file);
             // start from the end of the file
@@ -53,50 +110,61 @@ where P: Fn(&String) -> () {
         Err(e) => {
             Some(e)
         }
-    } 
+    }
 }
 
-fn scriptslog_file(custon_path: Option<String>) -> Result<File, String> {
-    let scriptslog_path: PathBuf;
-
-    if let Some(custom_path) = custon_path {
-        scriptslog_path = Path::new(&custom_path).to_owned();
-    } else if let Some(ud) = UserDirs::new() {
-        let mut docs = None;
-        if cfg!(windows) {
-            if let Some(path) = ud.document_dir() {
-                docs = Some(path.to_owned());
-            }
-        } 
-        else if cfg!(unix) {
-            if let Some(path) = Some(ud.home_dir()) {
-                docs = Some(path.join(constants::LINUX_STEAM_PFX_PATH).to_owned());
+#[cfg(target_os = "linux")]
+fn tail_scriptslog_loop<P>(scriptslog_path: PathBuf, printer: P, refresh_time_millis: u64, cancel_token: Receiver<()>) -> Option<String> 
+where P: Fn(&String) -> () {
+    let mut last_pos: u64;
+    match open_scriptslog(&scriptslog_path) {
+        Ok(file) => last_pos = file.metadata().unwrap().len(),
+        Err(e) => {
+            return Some(e)
+        }
+    }
+    
+    let mut text = String::new();
+    loop {
+        match cancel_token.try_recv() {
+            Ok(_) | Err(TryRecvError::Disconnected) => {
+                break;
             }
-        } 
-        else {
-            unimplemented!();
+            Err(_) => {}
         }
+        
+        // on linux file system is different in a sense that we have to reopen the file to see the changes made to it
+        match open_scriptslog(&scriptslog_path) {
+            Ok(file) => {
+                let mut reader = BufReader::new(&file);
+                let filesize = file.metadata().unwrap().len();
 
-        if let Some(docs) = docs {
-            scriptslog_path = docs.join(Path::new("The Witcher 3").join(constants::SCRIPTSLOG_FILE_NAME));
-        } else {
-            return Err( "Documents directory could not be found.".to_owned() );
-        }
+                if last_pos > filesize {
+                    last_pos = reader.seek(SeekFrom::Start(0)).unwrap();
+                } else {
+                    reader.seek(SeekFrom::Start(last_pos)).unwrap();
+                }
 
-    } else {
-        return Err("Scriptslog path could not be resolved".to_owned());
+                text.clear();
+                match reader.read_to_string(&mut text) {
+                    Ok(size) => {
+                        if size > 0 {
+                            last_pos += size as u64;
+                            printer(&text);
+                        }
+                    }
+                    Err(e) => {
+                        return Some("File read error: ".to_owned() + &e.to_string())
+                    }
+                }
+            }
+            Err(e) => {
+                return Some(e)
+            }
+        }
+        
+        std::thread::sleep( Duration::from_millis( refresh_time_millis ) );
     }
 
-    let file = OpenOptions::new()
-        .read(true)
-        .write(true) // so that it can be created if doesn't exist
-        .create(true)
-        .open(scriptslog_path);
-
-    if let Err(e) = file {
-        println!("{:?}", e.kind());
-        return Err("File open error: ".to_owned() + &e.to_string());
-    } else {
-        return Ok(file.unwrap());
-    }
+    None
 }