mitosis-db 0.1.0

Copy-on-write Postgres clones for AI agent tasks on macOS APFS
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

use crate::error::{ErrorCode, MitosisError, Result};
use std::collections::HashSet;
use std::net::TcpListener;
use std::ops::RangeInclusive;

/// Lowest port in `range` that is not leased, not skipped, and binds on 127.0.0.1 right now.
pub fn pick_port(
    range: RangeInclusive<u16>,
    leased: &HashSet<u16>,
    skip: &HashSet<u16>,
) -> Result<u16> {
    let (lo, hi) = (*range.start(), *range.end());
    range
        .filter(|p| !leased.contains(p) && !skip.contains(p))
        .find(|p| TcpListener::bind(("127.0.0.1", *p)).is_ok())
        .ok_or_else(|| {
            MitosisError::new(
                ErrorCode::PortsExhausted,
                format!("no free port in {lo}-{hi}"),
            )
            .with_hint("destroy unused clones, or widen the port range")
        })
}

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

    #[test]
    fn skips_busy_port_and_exhausts() {
        let busy = TcpListener::bind("127.0.0.1:0").unwrap();
        let p = busy.local_addr().unwrap().port();
        assert_ne!(
            pick_port(p..=p.saturating_add(5), &HashSet::new(), &HashSet::new()).unwrap(),
            p
        );
        assert_eq!(
            pick_port(p..=p, &HashSet::new(), &HashSet::new())
                .unwrap_err()
                .code,
            ErrorCode::PortsExhausted
        );
    }

    #[test]
    fn honours_leased_and_skip() {
        let p = TcpListener::bind("127.0.0.1:0")
            .unwrap()
            .local_addr()
            .unwrap()
            .port();
        let leased: HashSet<u16> = [p].into();
        assert_eq!(
            pick_port(p..=p, &leased, &HashSet::new()).unwrap_err().code,
            ErrorCode::PortsExhausted
        );
        assert_eq!(
            pick_port(p..=p, &HashSet::new(), &leased).unwrap_err().code,
            ErrorCode::PortsExhausted
        );
    }
}