devpane 0.3.0

A terminal-first multi-process workspace and development dashboard
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::io;
use std::net::{TcpListener, TcpStream};
use std::process::Command;
use std::thread;
use std::time::{Duration, Instant};

/// Check if a TCP port is currently in use on localhost.
pub fn is_port_in_use(port: u16) -> bool {
    if TcpListener::bind(("127.0.0.1", port)).is_err() {
        return true;
    }
    TcpStream::connect(("127.0.0.1", port)).is_ok()
}

/// Find PID(s) listening on a given TCP port.
pub fn find_pids_on_port(port: u16) -> Vec<u32> {
    #[cfg(unix)]
    {
        let output = Command::new("lsof")
            .args(["-ti", &format!("tcp:{}", port)])
            .output();

        if let Ok(out) = output {
            let s = String::from_utf8_lossy(&out.stdout);
            let mut pids = Vec::new();
            for line in s.lines() {
                if let Ok(pid) = line.trim().parse::<u32>() {
                    if pid > 0 && !pids.contains(&pid) {
                        pids.push(pid);
                    }
                }
            }
            return pids;
        }
    }

    #[cfg(windows)]
    {
        let output = Command::new("cmd")
            .args(["/C", &format!("netstat -ano | findstr :{}", port)])
            .output();

        if let Ok(out) = output {
            let s = String::from_utf8_lossy(&out.stdout);
            let mut pids = Vec::new();
            for line in s.lines() {
                if let Some(last_token) = line.split_whitespace().last() {
                    if let Ok(pid) = last_token.parse::<u32>() {
                        if pid > 0 && !pids.contains(&pid) {
                            pids.push(pid);
                        }
                    }
                }
            }
            return pids;
        }
    }

    Vec::new()
}

/// Kill conflicting processes occupying the port and wait for it to be freed.
pub fn free_port_if_occupied(port: u16) -> io::Result<Option<u32>> {
    if !is_port_in_use(port) {
        return Ok(None);
    }

    let pids = find_pids_on_port(port);
    let my_pid = std::process::id();

    for pid in &pids {
        if *pid == my_pid {
            continue;
        }
        println!("⚠️  Port {} is occupied by PID {}. Terminating conflicting process...", port, pid);
        let _ = crate::process::operations::stop_process(*pid);
    }

    // Wait up to 2 seconds for the port to become available
    let start = Instant::now();
    while start.elapsed() < Duration::from_secs(2) {
        if !is_port_in_use(port) {
            return Ok(pids.into_iter().next());
        }
        thread::sleep(Duration::from_millis(100));
    }

    Ok(pids.into_iter().next())
}

/// Wait until a TCP port or HTTP endpoint becomes healthy (reachable).
pub fn wait_for_health(
    port: Option<u16>,
    http_url: Option<&str>,
    timeout: Duration,
    interval: Duration,
) -> Result<(), String> {
    let start = Instant::now();

    while start.elapsed() < timeout {
        if let Some(p) = port {
            if TcpStream::connect(("127.0.0.1", p)).is_ok() {
                return Ok(());
            }
        }

        if let Some(url) = http_url {
            if let Some(p) = extract_port_from_url(url) {
                if TcpStream::connect(("127.0.0.1", p)).is_ok() {
                    return Ok(());
                }
            }
        }

        thread::sleep(interval);
    }

    Err(format!(
        "Health check timed out after {}s",
        timeout.as_secs()
    ))
}

fn extract_port_from_url(url: &str) -> Option<u16> {
    let stripped = url.trim_start_matches("http://").trim_start_matches("https://");
    let host_port = stripped.split('/').next()?;
    let port_str = host_port.split(':').nth(1)?;
    port_str.parse::<u16>().ok()
}