add basic job logging

gregory.example.toml

@@ -27,15 +27,15 @@ max-threads = 10
   [packages.some-librewolf-dependency]
 
     [packages.some-librewolf-dependency.compilation]
-    id = "1"
+    id = "2"
-    revision = "2"
+    revision = "4"
     threads = 2
     image = "docker.io/library/debian"
-    commands = ["echo hi", "echo helloooooooooo"]
+    commands = ["echo hi", "echo helloooooooooo >&2"]
     volumes = ["other-workspace"]
 
     [packages.some-librewolf-dependency.packaging.fedora]
-    id = "1"
+    id = "3"
     revision = "2"
     threads = 2
     image = "docker.io/library/fedora"

src/logging.rs

@@ -0,0 +1,84 @@
+use crate::errors::Error;
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+use std::{
+    fs::{File, OpenOptions},
+    os::unix::fs::FileExt,
+};
+
+/// The logger for gregory itself - NOT for jobs
+pub(crate) struct Logger {
+    log_file: File,
+}
+
+impl Logger {
+    pub(crate) fn new(path: String) -> Result<Logger, Error> {
+        match OpenOptions::new().append(true).open(path) {
+            Ok(f) => return Ok(Logger { log_file: f }),
+            Err(e) => {
+                return Err(Error::IOError(e));
+            }
+        }
+    }
+
+    /// Log a warning
+    ///
+    /// Fun gregory lore: I originally typo'd this as "Strign" and the linter didn't catch it for some reason
+    pub(crate) fn warning(&mut self, text: String) -> Result<(), Error> {
+        match writeln!(&mut self.log_file, "[WARNING] {}", text) {
+            Ok(_) => return Ok(()),
+            Err(e) => {
+                return Err(Error::IOError(e));
+            }
+        }
+    }
+
+    /// Log an error
+    pub(crate) fn error(&mut self, text: String) -> Result<(), Error> {
+        match writeln!(&mut self.log_file, "[ERROR] {}", text) {
+            Ok(_) => return Ok(()),
+            Err(e) => {
+                return Err(Error::IOError(e));
+            }
+        }
+    }
+}
+
+/// Logging for a [`Job`]
+pub(crate) struct JobLogger {
+    log_file: File,
+}
+
+impl JobLogger {
+    pub(crate) fn new(path: String) -> Result<JobLogger, Error> {
+        match OpenOptions::new().create_new(true).append(true).open(path) {
+            Ok(f) => return Ok(JobLogger { log_file: f }),
+            Err(e) => {
+                return Err(Error::IOError(e));
+            }
+        }
+    }
+
+    /// Log something printed to stdout
+    ///
+    /// Fun gregory lore: I originally typo'd this as "Strign" and the linter didn't catch it for some reason
+    pub(crate) fn stdout(&mut self, text: String) -> Result<(), Error> {
+        match writeln!(&mut self.log_file, "[stdout] {}", text) {
+            Ok(_) => return Ok(()),
+            Err(e) => {
+                return Err(Error::IOError(e));
+            }
+        }
+    }
+
+    /// Log something printed to stderr
+    pub(crate) fn stderr(&mut self, text: String) -> Result<(), Error> {
+        match writeln!(&mut self.log_file, "[stderr] {}", text) {
+            Ok(_) => return Ok(()),
+            Err(e) => {
+                return Err(Error::IOError(e));
+            }
+        }
+    }
+
+}

src/main.rs

@@ -1,6 +1,7 @@
 use crate::cli::*;
 use crate::data::*;
 use alphanumeric_sort::sort_str_slice;
+use better_commands;
 use clap::{CommandFactory, Parser};
 use clap_complete::aot::{generate, Bash, Elvish, Fish, PowerShell, Zsh};
 use std::fs;
@@ -12,13 +13,15 @@ use std::io::stdout;
 use std::os::unix::fs::PermissionsExt;
 use std::path::Path;
 use std::process::Command;
+use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::Instant;
 use uuid::Uuid;
-use better_commands;
 
 mod cli;
 mod data;
 mod errors;
+mod logging;
 mod tests;
 
 fn main() {
@@ -85,28 +88,21 @@ fn run_job(conf: Config, job: Job) -> JobExitStatus {
 
     let container_name: String = format!("gregory-{}-{}-{}", job.id, job.revision, Uuid::now_v7());
 
-    // create log path
+    // do job log setup
     let log_path = &format!("{}/logs/{container_name}", conf.data_dir); // can't select fields in the format!() {} thing, have to do this
     let log_dir: &Path = Path::new(log_path).parent().unwrap();
     create_dir_all(log_dir).unwrap();
 
+    let job_logger = Arc::new(Mutex::new(
+        logging::JobLogger::new(log_path.clone()).unwrap(),
+    ));
+
+
     // write the script
     let script_path = &format!("{}/tmp/{container_name}.sh", conf.data_dir); // can't select fields in the format!() {} thing, have to do this
-                                                                             // create dir for the script
+    let script_dir: &Path = Path::new(script_path).parent().unwrap(); // create dir for the script
-    let script_dir: &Path = Path::new(script_path).parent().unwrap();
     create_dir_all(script_dir).unwrap();
-    write(
+    write(script_path, job.commands.join("\n")).unwrap();
-        script_path,
-        job.commands
-            //.iter()
-            //.map(|item| {
-            //    // TODO: FIGURE OUT HOW TO HANDLE IT ESCAPING IT OR WHATEVER AAAAAAAAAAAAA
-            //    // update: i have no idea what i was talking about previously
-            //})
-            //.collect::<Vec<String>>()
-            .join("\n"),
-    )
-    .unwrap();
 
     // set permissions - *unix specific*
     let mut perms = File::open(script_path)
@@ -138,19 +134,26 @@ fn run_job(conf: Config, job: Job) -> JobExitStatus {
         &job.shell
     ));
     cmd_args.push(job.clone().image);
-    // TODO: TEMPORARY - update to actually write it in the future
+
-    let cmd_output = better_commands::run_funcs(Command::new("podman").args(cmd_args),  {
+    let cmd_output = better_commands::run_funcs(
-        |stdout_lines|
+        Command::new("podman").args(cmd_args),
+        {
+            let logger_clone = Arc::clone(&job_logger);
+            move |stdout_lines| {
                 for line in stdout_lines {
-            println!("[stdout] {}", line.unwrap());
+                    let _ = logger_clone.lock().unwrap().stdout(line.unwrap());
+                }
             }
         },
         {
-    |stderr_lines|
+            let logger_clone = Arc::clone(&job_logger);
+            move |stderr_lines| {
                 for line in stderr_lines {
-        println!("[stderr] {}", line.unwrap());
+                    let _ = logger_clone.lock().unwrap().stderr(line.unwrap());
                 }
-});
+            }
+        },
+    );
     // remove tmp dir
     remove_dir_all(script_dir).unwrap();
 
@@ -164,3 +167,4 @@ fn run_job(conf: Config, job: Job) -> JobExitStatus {
         log_path: log_path.clone(),
     };
 }
+// .