Skip to main content

qualia_core_db/p2p/connectivity/
two_process.rs

1//! Two OS processes exchange an authenticated WSS datagram. Process evidence only.
2
3#![cfg(not(target_arch = "wasm32"))]
4
5use core::sync::atomic::{AtomicBool, Ordering};
6#[cfg(test)]
7use std::net::TcpListener;
8#[cfg(test)]
9use std::process::Command;
10#[cfg(test)]
11use std::time::Duration;
12
13use super::wss::ENV_CHILD;
14#[cfg(test)]
15use super::wss::{self, ENV_ADDR, ENV_SECRET};
16
17static DONE: AtomicBool = AtomicBool::new(false);
18
19/// `?::local_wss_two_process_executed`.
20pub fn local_wss_two_process_executed() -> bool {
21    DONE.load(Ordering::SeqCst) || std::env::var(ENV_CHILD).ok().as_deref() == Some("1")
22}
23
24#[cfg(test)]
25fn is_child() -> bool {
26    std::env::var(ENV_CHILD).ok().as_deref() == Some("1")
27}
28
29#[cfg(test)]
30fn child_main() -> Result<(), String> {
31    let addr = std::env::var(ENV_ADDR).map_err(|e| e.to_string())?;
32    let secret = std::env::var(ENV_SECRET).map_err(|e| e.to_string())?;
33    let sock: std::net::SocketAddr = addr
34        .parse()
35        .map_err(|e: std::net::AddrParseError| e.to_string())?;
36    let mut s = wss::dial(sock, secret.as_bytes()).map_err(|e| e.to_string())?;
37    let (_, _, got) = wss::recv_datagram(&mut s).map_err(|e| e.to_string())?;
38    if got != b"from-a" {
39        return Err("unexpected payload".into());
40    }
41    wss::send_datagram(&mut s, 1, 1, b"from-b", true).map_err(|e| e.to_string())?;
42    DONE.store(true, Ordering::SeqCst);
43    Ok(())
44}
45
46#[cfg(test)]
47fn parent_main() -> Result<(), String> {
48    let listener = TcpListener::bind("127.0.0.1:0").map_err(|e| e.to_string())?;
49    let addr = listener.local_addr().map_err(|e| e.to_string())?;
50    let secret = b"qdnf-wss-local-test-secret";
51    let hub = std::thread::spawn(move || wss::serve_pair(listener, secret));
52    let exe = std::env::current_exe().map_err(|e| e.to_string())?;
53    let test_name = std::thread::current()
54        .name()
55        .ok_or("missing test name")?
56        .to_owned();
57    let mut child = Command::new(&exe)
58        .args(["--exact", &test_name, "--nocapture", "--test-threads", "1"])
59        .env(ENV_CHILD, "1")
60        .env(ENV_ADDR, addr.to_string())
61        .env(ENV_SECRET, core::str::from_utf8(secret).unwrap())
62        .stdout(std::process::Stdio::inherit())
63        .stderr(std::process::Stdio::inherit())
64        .spawn()
65        .map_err(|e| e.to_string())?;
66    std::thread::sleep(Duration::from_millis(50));
67    let mut a = wss::dial(addr, secret).map_err(|e| e.to_string())?;
68    wss::send_datagram(&mut a, 1, 1, b"from-a", true).map_err(|e| e.to_string())?;
69    let (_, _, got) = wss::recv_datagram(&mut a).map_err(|e| e.to_string())?;
70    if got != b"from-b" {
71        let _ = child.kill();
72        return Err("parent did not receive from-b".into());
73    }
74    let status = child.wait().map_err(|e| e.to_string())?;
75    if !status.success() {
76        return Err("child failed".into());
77    }
78    let _ = hub.join();
79    DONE.store(true, Ordering::SeqCst);
80    Ok(())
81}
82
83#[cfg(test)]
84mod tests {
85    use super::*;
86
87    #[test]
88    fn two_process_authenticated_wss() {
89        if is_child() {
90            child_main().expect("wss child");
91            return;
92        }
93        parent_main().expect("wss parent");
94        assert!(local_wss_two_process_executed());
95    }
96}