added some type of logging for now

Author: Anirudh-S-Kumar

.gitignore

@@ -2,3 +2,6 @@
 
 # vscode settings
 .vscode
+
+# Temporary files
+tmp*

Cargo.lock

@@ -5,8 +5,12 @@ edition = "2021"
 
 [dependencies]
 clap = { version = "4.5.23", features = ["derive"] }
-lscolors = {version = "0.20.0", features = ["crossterm"]}
+lscolors = { version = "0.20.0", features = ["crossterm"] }
 nu-ansi-term = "0.50.1"
-chrono = "0.4.39"
+chrono = { version = "0.4.39", features = ["serde"] }
 uutils_term_grid = "0.6.0"
 terminal_size = "0.4.1"
+serde = { version = "1.0.217", features = ["derive"] }
+slog = "2.7.0"
+serde_json = "1.0.134"
+slog-json = "2.6.1"

Cargo.toml

@@ -1,4 +1,5 @@
 mod trm;
+pub mod utils;
 
 use clap::Parser;
 use std::path::PathBuf;
@@ -17,14 +18,6 @@ fn main() {
         files.push(PathBuf::from(file));
     }
 
-    match setup_logging() {
-        Ok(_) => {}
-        Err(e) => {
-            eprintln!("Could not setup logging: {}", e);
-            std::process::exit(1);
-        }
-    }
-
     let dir_path = match setup_directory(&args) {
         Ok(path) => path,
         Err(e) => {

src/main.rs

@@ -1,4 +1,4 @@
-use chrono::{DateTime, Local};
+use crate::utils::{append_to_logs, FileInfo, OpType};
 use clap::Parser;
 use lscolors::LsColors;
 use std::fs;
@@ -9,7 +9,7 @@ use std::{
 use term_grid::{Grid, GridOptions};
 
 pub static DEFAULT_DIR: &str = "/var/tmp/trm_files";
-pub static LOG_DIR: &str = "/var/log/trm";
+pub static LOG_FILE: &str = "/var/tmp/trm.log";
 
 #[derive(Parser, Debug, Default)]
 #[command(version, about = "trm - Temporary rm, a utility to reversibly remove your files", long_about=None)]
@@ -41,14 +41,6 @@ pub struct Args {
     pub dir: String,
 }
 
-struct _FileInfo {
-    /// The original path from where the path was copied
-    path: String,
-
-    /// The datetime when it was moved
-    moved_time: DateTime<Local>,
-}
-
 macro_rules! get_file_name {
     ($path:expr) => {
         $path.file_name().unwrap().to_str().unwrap().to_string()
@@ -93,22 +85,6 @@ pub fn display_files(files: &Vec<PathBuf>, only_filename: bool) {
     println!("{grid}");
 }
 
-pub fn setup_logging() -> Result<bool, Error> {
-    if let Err(e) = std::fs::create_dir_all(LOG_DIR) {
-        eprintln!("Failed to create logging directory {}: {}", LOG_DIR, e);
-        return Err(e);
-    }
-
-    let log_path = PathBuf::from(LOG_DIR);
-    let history_path = log_path.join("history");
-
-    if !history_path.try_exists().unwrap() {
-        std::fs::File::create(history_path).unwrap();
-    }
-
-    Ok(true)
-}
-
 pub fn setup_directory(args: &Args) -> Result<PathBuf, Error> {
     let dir: String;
     let mut var_dir: String = String::new();
@@ -220,6 +196,12 @@ pub fn move_files(args: &Args, dir_path: &PathBuf, files: &Vec<PathBuf>) {
                 if args.verbose {
                     println!("Successfully moved {} to trash", full_path.display());
                 }
+                append_to_logs(&FileInfo {
+                    src: full_path.display().to_string(),
+                    dst: new_location.display().to_string(),
+                    operation: OpType::TRASH,
+                    moved_time: chrono::offset::Local::now(),
+                });
             }
             Err(e) => {
                 eprintln!(
@@ -311,6 +293,13 @@ pub fn recover_files(args: &Args, dir_path: &PathBuf, files: &mut Vec<PathBuf>,
                             full_path.display()
                         );
                     }
+
+                    append_to_logs(&FileInfo {
+                        src: file.display().to_string(),
+                        dst: full_path.display().to_string(),
+                        operation: OpType::RESTORE,
+                        moved_time: chrono::offset::Local::now(),
+                    });
                 }
                 Err(e) => {
                     eprintln!(

src/trm.rs

@@ -0,0 +1,80 @@
+use crate::LOG_FILE;
+
+use chrono::{DateTime, Local};
+use serde::{Deserialize, Serialize};
+use slog::{info, o, Drain, Logger};
+use std::{
+    fs::{File, OpenOptions},
+    io,
+    io::{BufRead, BufReader},
+    sync::Mutex,
+};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum OpType {
+    TRASH,
+    RESTORE,
+}
+
+impl OpType {
+    #[allow(dead_code)]
+    fn as_str(&self) -> &str {
+        match self {
+            OpType::TRASH => "Trash",
+            OpType::RESTORE => "Restore",
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct FileInfo {
+    /// The original path from where the path was moved
+    pub src: String,
+
+    /// The path where the file ended up in  
+    pub dst: String,
+
+    /// Type of operation
+    pub operation: OpType,
+
+    /// The datetime when it was moved
+    pub moved_time: DateTime<Local>,
+}
+
+fn init_logger() -> Logger {
+    let file = OpenOptions::new()
+        .create(true)
+        .write(true)
+        .append(true)
+        .open(LOG_FILE)
+        .unwrap();
+
+    let drain = slog_json::Json::new(file).build().fuse();
+
+    Logger::root(Mutex::new(drain).fuse(), o!())
+}
+
+pub fn append_to_logs(info: &FileInfo) {
+    let logger = init_logger();
+    info!(logger, "File Operation";
+        "SRC" => &info.src,
+        "DST" => &info.dst,
+        "OPERATION" => &info.operation.as_str(),
+        "MOVED_TIME" => &info.moved_time.to_string()
+    );
+}
+
+pub fn read_logs() -> io::Result<Vec<FileInfo>> {
+    let file = File::open(LOG_FILE).unwrap();
+    let reader = BufReader::new(file);
+    let mut logs: Vec<FileInfo> = vec![];
+
+    for line in reader.lines() {
+        let line = line.unwrap();
+        if let Ok(log) = serde_json::from_str::<FileInfo>(&line) {
+            logs.push(log);
+        }
+    }
+
+    Ok(logs)
+}