teasr-core 0.21.0

Core orchestration and capture for teasr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use anyhow::{Context, Result};
use std::process::Command;
use std::time::{Duration, Instant};
use tracing::{debug, info};

use crate::types::ServerConfig;

/// A managed server process with proper cleanup.
pub struct ManagedServer {
    #[cfg(unix)]
    pgid: i32,
    #[cfg(windows)]
    child: std::process::Child,
}

impl ManagedServer {
    /// Spawn a dev server and wait until it's ready.
    pub async fn start(config: &ServerConfig) -> Result<Self> {
        info!("starting server: {}", config.command);

        #[cfg(unix)]
        let server = {
            use std::os::unix::process::CommandExt;

            let child = unsafe {
                Command::new("sh")
                    .arg("-c")
                    .arg(&config.command)
                    .pre_exec(|| {
                        // Create a new process group so we can kill all descendants
                        nix::unistd::setsid().ok();
                        Ok(())
                    })
                    .stdin(std::process::Stdio::null())
                    .stdout(std::process::Stdio::null())
                    .stderr(std::process::Stdio::null())
                    .spawn()
                    .context("failed to spawn server")?
            };

            let pgid = child.id() as i32;
            debug!("server started with pgid {pgid}");

            ManagedServer { pgid }
        };

        #[cfg(windows)]
        let server = {
            let child = Command::new("cmd")
                .arg("/c")
                .arg(&config.command)
                .stdin(std::process::Stdio::null())
                .stdout(std::process::Stdio::null())
                .stderr(std::process::Stdio::null())
                .spawn()
                .context("failed to spawn server")?;

            ManagedServer { child }
        };

        // Poll until server is ready
        let deadline = Instant::now() + Duration::from_millis(config.timeout);
        let client = reqwest::Client::builder()
            .timeout(Duration::from_secs(2))
            .build()?;

        loop {
            if Instant::now() > deadline {
                drop(server);
                anyhow::bail!(
                    "server failed to respond at {} within {}ms",
                    config.url,
                    config.timeout
                );
            }

            match client.get(&config.url).send().await {
                Ok(resp) if resp.status().is_success() || resp.status().is_redirection() => {
                    info!("server ready at {}", config.url);
                    break;
                }
                _ => {
                    tokio::time::sleep(Duration::from_millis(500)).await;
                }
            }
        }

        Ok(server)
    }
}

impl Drop for ManagedServer {
    fn drop(&mut self) {
        debug!("shutting down server");

        #[cfg(unix)]
        {
            // Kill the entire process group
            unsafe {
                libc::killpg(self.pgid, libc::SIGTERM);
            }
            // Give it a moment, then force kill
            std::thread::sleep(Duration::from_millis(200));
            unsafe {
                libc::killpg(self.pgid, libc::SIGKILL);
            }
        }

        #[cfg(windows)]
        {
            self.child.kill().ok();
        }
    }
}