standby 0.2.0

//! Linux-specific timerfd implementation for nanosecond-precision timeouts.
//!
//! Uses Linux timerfd_create(2) syscall for event-driven timeout handling.
//! This provides nanosecond precision without polling overhead.
//!
//! # How it works
//!
//! 1. Create a timerfd with CLOCK_MONOTONIC for monotonic timing
//! 2. Create a pipe for the child process
//! 3. Use poll(2) to wait for either:
//!    - Child process exit (via SIGCHLD, detected via polling child)
//!    - Timer expiration (via timerfd read-ready)
//! 4. Return immediately when either event occurs
//!
//! This approach has near-zero latency (~1μs) compared to polling (~5ms).

use std::os::unix::io::AsRawFd;
use std::process::Child;
use std::time::Duration;

use crate::errors::{Result, StandbyError};

/// Wait for process with nanosecond-precision timeout using timerfd.
pub fn wait_with_timerfd_timeout(
    mut child: Child,
    timeout: Duration,
) -> Result<std::process::ExitStatus> {
    use nix::poll::{PollFd, PollFlags, poll};
    use nix::sys::timerfd::{ClockId, TimerFd, TimerSetTimeFlags};

    // Create timerfd with CLOCK_MONOTONIC (not affected by system clock adjustments)
    let tfd = TimerFd::new(ClockId::CLOCK_MONOTONIC, nix::fcntl::OFlag::O_NONBLOCK)
        .map_err(|e| StandbyError::ProcessError(format!("Failed to create timerfd: {}", e)))?;

    // Set the timer to expire after the specified timeout
    // Using OneShot so it only fires once
    tfd.set(
        nix::sys::timerfd::Expiration::OneShot(timeout),
        TimerSetTimeFlags::empty(),
    )
    .map_err(|e| StandbyError::ProcessError(format!("Failed to set timer: {}", e)))?;

    let child_fd = child.as_raw_fd();
    let tfd_fd = tfd.as_raw_fd();

    // Create poll file descriptors
    let mut fds = [
        PollFd::new(child_fd, PollFlags::empty()), // Child process: we'll poll with try_wait
        PollFd::new(tfd_fd, PollFlags::POLLIN),    // Timer: wait for read-ready
    ];

    loop {
        // Poll with short timeout to check both child and timer
        // We use 100ms interval to also poll the child process status
        let poll_timeout = std::time::Duration::from_millis(100);
        let poll_millis = poll_timeout.as_millis() as i32;

        match nix::poll::poll(&mut fds, poll_millis) {
            Ok(0) => {
                // Timeout on poll, check if child exited
                match child.try_wait() {
                    Ok(Some(status)) => return Ok(status),
                    Ok(None) => continue, // Child still running, loop again
                    Err(e) => {
                        return Err(StandbyError::ProcessError(format!(
                            "Failed to wait for process: {}",
                            e
                        )));
                    }
                }
            }
            Ok(_) => {
                // Poll events occurred
                // First check if timer fired (timerfd became readable)
                if fds[1].revents().contains(PollFlags::POLLIN) {
                    // Timer expired, timeout occurred
                    return Err(StandbyError::ProcessError("Process timeout".to_string()));
                }

                // Otherwise check child status
                match child.try_wait() {
                    Ok(Some(status)) => return Ok(status),
                    Ok(None) => continue, // Child still running despite poll
                    Err(e) => {
                        return Err(StandbyError::ProcessError(format!(
                            "Failed to wait for process: {}",
                            e
                        )));
                    }
                }
            }
            Err(e) => return Err(StandbyError::ProcessError(format!("Poll failed: {}", e))),
        }
    }
}

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

    #[test]
    fn test_timerfd_immediate_exit() {
        let child = std::process::Command::new("true")
            .spawn()
            .expect("failed to spawn");

        let result = wait_with_timerfd_timeout(child, Duration::from_secs(5));
        assert!(result.is_ok());
    }

    #[test]
    fn test_timerfd_timeout() {
        let child = std::process::Command::new("sleep")
            .arg("10")
            .spawn()
            .expect("failed to spawn");

        let result = wait_with_timerfd_timeout(child, Duration::from_millis(100));
        assert!(result.is_err());
    }
}