spotlit 0.1.4

A cross-platform desktop wallpaper companion for Windows Spotlight and Bing wallpapers.
Documentation
use std::{fs::OpenOptions, path::Path, sync::Mutex};

use anyhow::Context;

const LOG_FILE_NAME: &str = "spotlit.log";
const LOG_BACKUP_FILE_NAME: &str = "spotlit.log.1";
const MAX_LOG_FILE_BYTES: u64 = 1024 * 1024;

pub(crate) fn init_tracing(log_dir: &Path) -> anyhow::Result<()> {
    std::fs::create_dir_all(log_dir).context("failed to create log directory")?;
    let log_path = log_dir.join(LOG_FILE_NAME);
    rotate_log_file(&log_path, MAX_LOG_FILE_BYTES).context("failed to rotate spotlit log file")?;

    let filter = tracing_subscriber::EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| "spotlit=info".into());
    let log_file = match OpenOptions::new().create(true).append(true).open(&log_path) {
        Ok(log_file) => log_file,
        Err(error) => {
            eprintln!(
                "spotlit: failed to open log file at {}; falling back to stderr: {error}",
                log_path.display()
            );
            tracing_subscriber::fmt()
                .with_env_filter(filter)
                .with_ansi(false)
                .with_writer(std::io::stderr)
                .try_init()
                .map_err(|error| {
                    anyhow::anyhow!("failed to install tracing subscriber: {error}")
                })?;
            return Ok(());
        }
    };

    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_ansi(false)
        .with_writer(Mutex::new(log_file))
        .try_init()
        .map_err(|error| anyhow::anyhow!("failed to install tracing subscriber: {error}"))?;
    Ok(())
}

fn rotate_log_file(log_path: &Path, max_bytes: u64) -> anyhow::Result<()> {
    let metadata = match std::fs::metadata(log_path) {
        Ok(metadata) => metadata,
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(()),
        Err(error) => return Err(error).context("failed to inspect current log file"),
    };

    if metadata.len() <= max_bytes {
        return Ok(());
    }

    let backup_path = log_path.with_file_name(LOG_BACKUP_FILE_NAME);
    match std::fs::remove_file(&backup_path) {
        Ok(()) => {}
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
        Err(error) => return Err(error).context("failed to remove old log backup"),
    }

    std::fs::rename(log_path, &backup_path).context("failed to rotate current log file")?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use std::{
        fs,
        ops::Deref,
        path::{Path, PathBuf},
        time::{SystemTime, UNIX_EPOCH},
    };

    use super::{LOG_BACKUP_FILE_NAME, LOG_FILE_NAME, rotate_log_file};

    #[test]
    fn rotates_log_file_when_it_exceeds_limit() -> anyhow::Result<()> {
        let root = temp_root("log-rotate");
        fs::create_dir_all(&root)?;
        let log_path = root.join(LOG_FILE_NAME);
        let backup_path = root.join(LOG_BACKUP_FILE_NAME);
        fs::write(&log_path, b"abcdef")?;

        rotate_log_file(&log_path, 5)?;

        assert!(!log_path.exists());
        assert_eq!(fs::read(&backup_path)?, b"abcdef");

        Ok(())
    }

    #[test]
    fn keeps_log_file_when_it_is_within_limit() -> anyhow::Result<()> {
        let root = temp_root("log-keep");
        fs::create_dir_all(&root)?;
        let log_path = root.join(LOG_FILE_NAME);
        fs::write(&log_path, b"abc")?;

        rotate_log_file(&log_path, 5)?;

        assert_eq!(fs::read(&log_path)?, b"abc");
        assert!(!root.join(LOG_BACKUP_FILE_NAME).exists());

        Ok(())
    }

    fn temp_root(name: &str) -> TempRoot {
        TempRoot::new(name)
    }

    struct TempRoot {
        path: PathBuf,
    }

    impl TempRoot {
        fn new(name: &str) -> Self {
            let nanos = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .map(|duration| duration.as_nanos())
                .unwrap_or(0);
            let path =
                std::env::temp_dir().join(format!("spotlit-{name}-{}-{nanos}", std::process::id()));
            let _ = fs::remove_dir_all(&path);
            Self { path }
        }
    }

    impl Deref for TempRoot {
        type Target = Path;

        fn deref(&self) -> &Self::Target {
            &self.path
        }
    }

    impl AsRef<Path> for TempRoot {
        fn as_ref(&self) -> &Path {
            &self.path
        }
    }

    impl Drop for TempRoot {
        fn drop(&mut self) {
            let _ = fs::remove_dir_all(&self.path);
        }
    }
}