starling-devex 0.1.7

Starling: a local dev orchestrator with a central daemon, shared named-URL proxy, and a k9s-style TUI (a Rust port of Tilt + portless)
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

//! Client for talking to the Starling daemon over its Unix socket.

use std::path::PathBuf;
use std::process::Stdio;
use std::time::Duration;

use anyhow::{anyhow, Result};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::net::UnixStream;

use super::protocol::{socket_path, Request, Response};

#[derive(Clone)]
pub struct DaemonClient {
    sock: PathBuf,
}

impl DaemonClient {
    pub fn new() -> Self {
        DaemonClient {
            sock: socket_path(),
        }
    }

    /// Send one request and read one response (connection-per-request).
    pub async fn call(&self, req: &Request) -> Result<Response> {
        let stream = UnixStream::connect(&self.sock)
            .await
            .map_err(|e| anyhow!("connecting to daemon at {}: {e}", self.sock.display()))?;
        let (read_half, mut write_half) = stream.into_split();
        let mut line = serde_json::to_string(req)?;
        line.push('\n');
        write_half.write_all(line.as_bytes()).await?;
        write_half.flush().await?;

        let mut reader = BufReader::new(read_half);
        let mut resp = String::new();
        reader.read_line(&mut resp).await?;
        if resp.trim().is_empty() {
            return Err(anyhow!("empty response from daemon"));
        }
        Ok(serde_json::from_str(&resp)?)
    }

    pub async fn is_running(&self) -> bool {
        matches!(self.call(&Request::Ping).await, Ok(Response::Ok))
    }

    /// Ensure a daemon is running, spawning `starling daemon` (detached) if not.
    pub async fn ensure_running(&self, proxy_port: u16, tld: &str, tls: bool) -> Result<()> {
        self.ensure_running_with(proxy_port, tld, "127.0.0.1", tls, false)
            .await
    }

    /// Ensure a daemon is running, spawning `starling daemon` (detached) if not.
    pub async fn ensure_running_with(
        &self,
        proxy_port: u16,
        tld: &str,
        host: &str,
        tls: bool,
        lan: bool,
    ) -> Result<()> {
        if self.is_running().await {
            return Ok(());
        }
        let exe = std::env::current_exe()?;
        let log = super::protocol::log_path();
        if let Some(dir) = log.parent() {
            std::fs::create_dir_all(dir).ok();
        }
        let out = std::fs::OpenOptions::new()
            .create(true)
            .append(true)
            .open(&log)
            .ok();
        let mut cmd = std::process::Command::new(exe);
        cmd.arg("daemon")
            .arg("--proxy-port")
            .arg(proxy_port.to_string())
            .arg("--tld")
            .arg(tld)
            .arg("--host")
            .arg(host)
            .stdin(Stdio::null());
        if tls {
            cmd.arg("--tls");
        }
        if lan {
            cmd.arg("--lan");
        }
        if let Some(f) = out {
            let f2 = f.try_clone().ok();
            cmd.stdout(Stdio::from(f));
            if let Some(f2) = f2 {
                cmd.stderr(Stdio::from(f2));
            }
        }
        cmd.spawn()
            .map_err(|e| anyhow!("spawning daemon: {e}"))?;

        // Wait for the socket to come up.
        for _ in 0..40 {
            if self.is_running().await {
                return Ok(());
            }
            tokio::time::sleep(Duration::from_millis(50)).await;
        }
        Err(anyhow!("daemon did not start within 2s; see {}", log.display()))
    }
}