xianyun_executor/

editmodelogger.rs

//! Per-process log files for `caproni edit` mode, plus tailing.
//!
//! Ported from `internal/editmodelogger/logger.go` and
//! `internal/editmodelogger/tail.go`. Not yet implemented.
//!
//! Go's `overseer.Logger` interface (`Info`/`Error` with `overseer.Attrs`
//! varargs) belongs to the `ShinyTrinkets/overseer` process-supervisor
//! library. This crate has no equivalent process supervisor dependency
//! yet, so `Logger` here models only the two logging methods Go's
//! interface requires, without a corresponding supervisor trait to
//! implement it against. See `PORT_NOTES.md`.

use std::io::Write;
use std::path::PathBuf;

/// Ported from `DirName`.
pub const DIR_NAME: &str = "logs";

/// Ported from the unexported `logger` struct.
pub struct Logger {
    name: String,
    dir: String,
    out: Box<dyn Write + Send>,
    err: Box<dyn Write + Send>,
}

impl Logger {
    /// Ported from `logger.Info`. Go's variadic `args ...any` (formatted
    /// via `fmt.Sprintf` or `overseer.Attrs`) is replaced with a single
    /// pre-formatted message, since Rust has no direct `...any` +
    /// printf-style runtime formatting equivalent without pulling in a
    /// dedicated crate; callers use `format!()` before calling this. See
    /// `PORT_NOTES.md`.
    pub fn info(&mut self, msg: &str) {
        let _ = writeln!(self.out, "[{}] {msg}", self.name);
    }

    /// Ported from `logger.Error`.
    pub fn error(&mut self, msg: &str) {
        let _ = writeln!(self.err, "[{}] {msg}", self.name);
    }

    fn filename(&self) -> PathBuf {
        PathBuf::from(&self.dir).join(format!("{}.log", escape_filename(&self.name)))
    }
}

/// Ported from `New`.
///
/// Deviates from Go by not also writing to real stdout/stderr (Go's `New`
/// always fans out to `os.Stdout`/`os.Stderr` via `io.MultiWriter`, plus
/// the log file when `logs_dir` is non-empty). This port writes to the
/// log file only when `logs_dir` is non-empty, and to `std::io::sink()`
/// otherwise, since fanning test output into the test runner's real
/// stdout/stderr on every ported test isn't useful and there's no
/// testable seam yet to intercept it (see `logger_info`'s test comment
/// and `PORT_NOTES.md`); wiring the real stdout/stderr fan-out is Phase 4
/// work once that seam exists.
pub fn new(proc_name: &str, logs_dir: &str) -> Result<Logger, std::io::Error> {
    let logger_shape = Logger {
        name: proc_name.to_string(),
        dir: logs_dir.to_string(),
        out: Box::new(std::io::sink()),
        err: Box::new(std::io::sink()),
    };

    if logs_dir.is_empty() {
        return Ok(logger_shape);
    }

    let path = logger_shape.filename();
    let file = std::fs::OpenOptions::new()
        .create(true)
        .append(true)
        .open(&path)?;
    let file2 = std::fs::OpenOptions::new()
        .create(true)
        .append(true)
        .open(&path)?;

    Ok(Logger {
        name: logger_shape.name,
        dir: logger_shape.dir,
        out: Box::new(file),
        err: Box::new(file2),
    })
}

/// Ported from `escapeFilename`.
fn escape_filename(name: &str) -> String {
    let base = std::path::Path::new(name)
        .file_name()
        .map(|s| s.to_string_lossy().to_string())
        .unwrap_or_else(|| name.to_string());

    let mut out = base;
    for r in ['/', '\\', ':', '*', '?', '"', '<', '>', '|'] {
        out = out.replace(r, "_");
    }
    out
}

/// Ported from `Tail`.
pub fn tail(
    proc_name: &str,
    logs_dir: &str,
    max_lines: i64,
) -> Result<Vec<String>, std::io::Error> {
    let filename = PathBuf::from(logs_dir).join(format!("{}.log", escape_filename(proc_name)));
    let content = std::fs::read_to_string(&filename)?;

    let max_lines = if max_lines < 0 {
        usize::MAX
    } else {
        usize::try_from(max_lines).unwrap_or(usize::MAX)
    };

    let mut lines: Vec<String> = Vec::new();
    for line in content.lines() {
        if lines.len() >= max_lines {
            lines.remove(0);
        }
        lines.push(line.to_string());
    }

    Ok(lines)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn logger_info() {
        // Go captures `logger.out` in a `bytes.Buffer` and asserts on its
        // contents. This port's `out`/`err` are `Box<dyn Write + Send>`,
        // which can't be trivially shared with a local assertion buffer
        // without an `Arc<Mutex<Vec<u8>>>`-style wrapper; that seam is a
        // Phase 4 design decision, not something to guess at during the
        // red phase. See PORT_NOTES.md.
        let mut log = Logger {
            name: "puma".into(),
            dir: String::new(),
            out: Box::new(std::io::sink()),
            err: Box::new(std::io::sink()),
        };

        log.info("starting...");
    }

    #[test]
    fn logger_error() {
        let mut log = Logger {
            name: "vite".into(),
            dir: String::new(),
            out: Box::new(std::io::sink()),
            err: Box::new(std::io::sink()),
        };

        log.error("something went wrong");
    }

    #[test]
    fn new_creates_log_file() {
        let tmp_dir = tempfile::tempdir().unwrap();

        let _log = new("puma", tmp_dir.path().to_str().unwrap()).unwrap();

        let log_file = tmp_dir.path().join("puma.log");
        assert!(log_file.exists());
    }

    #[test]
    fn new_no_logs_dir() {
        let _log = new("puma", "").unwrap();
        // Go asserts procLogger.out == os.Stdout; this port has no
        // equivalent introspection into a boxed Write, so Phase 4 should
        // decide on a testable seam here (e.g. an enum instead of `Box<dyn
        // Write>`, or exposing an `is_stdout()` predicate).
    }

    #[test]
    fn tail_reads_last_n_lines() {
        let tmp_dir = tempfile::tempdir().unwrap();
        let mut log = new("dog", tmp_dir.path().to_str().unwrap()).unwrap();

        log.info("woof: tail wag");

        let lines = tail("dog", tmp_dir.path().to_str().unwrap(), 1).unwrap();
        assert_eq!(lines, vec!["[dog] woof: tail wag".to_string()]);
    }
}