//! The single instance over real sockets: the token check of the //! rendezvous listener, stale rendezvous files, and forwarding a second //! start's path to the running instance. #![allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)] use std::io::{BufRead, BufReader, Write}; use std::net::TcpStream; use std::path::Path; use std::sync::Arc; use std::time::Duration; use lutra_control::client::{self, Client, Unavailable}; use lutra_control::rendezvous::{self, Instance}; use lutra_testkit::EngineBackend; use serde_json::{Value, json}; const TIMEOUT: Duration = Duration::from_secs(10); /// Starts a token listener for `backend` and writes its rendezvous file in /// `dir`, as the desktop's claim does. fn claim(dir: &Path, backend: Arc) -> Instance { let token = rendezvous::new_token().unwrap(); let server = lutra_control::start_with_token(0, backend, &token).unwrap(); let instance = Instance { port: server.local_addr().port(), token, pid: std::process::id(), version: "test".into(), }; rendezvous::write(dir, &instance).unwrap(); instance } /// Sends raw lines and reads one response line, or `None` at end of stream. fn exchange(port: u16, lines: &[Value]) -> Vec> { let stream = TcpStream::connect(("127.0.0.1", port)).unwrap(); stream.set_read_timeout(Some(TIMEOUT)).unwrap(); let mut writer = stream.try_clone().unwrap(); let mut reader = BufReader::new(stream); lines .iter() .map(|line| { if writer.write_all(format!("{line}\n").as_bytes()).is_err() { return None; } let mut text = String::new(); match reader.read_line(&mut text) { Ok(0) | Err(_) => None, Ok(_) => Some(serde_json::from_str(&text).unwrap()), } }) .collect() } #[test] fn the_rendezvous_listener_needs_the_token_first() { let dir = tempfile::tempdir().unwrap(); let instance = claim(dir.path(), Arc::new(EngineBackend::new())); let ping = json!({"id": 2, "method": "app.ping"}); let r = exchange(instance.port, &[ping.clone(), ping.clone()]); assert_eq!(r[0].as_ref().unwrap()["error"]["code"], "unauthorized"); assert!(r[1].is_none(), "the connection is closed"); let wrong = json!({"id": 1, "method": "app.auth", "params": {"token": "0".repeat(64)}}); let r = exchange(instance.port, &[wrong, ping.clone()]); assert_eq!(r[0].as_ref().unwrap()["error"]["code"], "unauthorized"); assert!(r[1].is_none()); let r = exchange(instance.port, &[json!("garbage"), ping.clone()]); assert_eq!(r[0].as_ref().unwrap()["error"]["code"], "unauthorized"); let right = json!({"id": 1, "method": "app.auth", "params": {"token": instance.token}}); let r = exchange(instance.port, &[right, ping]); assert_eq!(r[0].as_ref().unwrap()["result"]["authenticated"], true); assert_eq!(r[1].as_ref().unwrap()["result"]["pong"], true); } #[test] fn the_open_control_channel_still_needs_no_token() { let server = lutra_control::start(0, Arc::new(EngineBackend::new())).unwrap(); let mut client = Client::connect(server.local_addr().port(), TIMEOUT).unwrap(); assert_eq!( client.request("app.ping", Value::Null).unwrap()["pong"], true ); } #[test] fn stale_files_are_detected() { let dir = tempfile::tempdir().unwrap(); assert!(matches!( client::connect_live(dir.path(), TIMEOUT), Err(Unavailable::Missing) )); std::fs::write(rendezvous::path(dir.path()), "{").unwrap(); assert!(matches!( client::connect_live(dir.path(), TIMEOUT), Err(Unavailable::Stale(_)) )); let closed = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); let port = closed.local_addr().unwrap().port(); drop(closed); let dead = Instance { port, token: "t".into(), pid: 1, version: "old".into(), }; rendezvous::write(dir.path(), &dead).unwrap(); assert!(matches!( client::connect_live(dir.path(), TIMEOUT), Err(Unavailable::Stale(_)) )); let live = claim(dir.path(), Arc::new(EngineBackend::new())); let reused = Instance { token: "f".repeat(64), ..live.clone() }; rendezvous::write(dir.path(), &reused).unwrap(); assert!( matches!( client::connect_live(dir.path(), TIMEOUT), Err(Unavailable::Stale(_)) ), "a listener that refuses the token is not ours" ); rendezvous::write(dir.path(), &live).unwrap(); let (found, _) = client::connect_live(dir.path(), TIMEOUT).unwrap(); assert_eq!(found, live, "the stale file was replaced"); } #[test] fn a_second_start_forwards_folders_and_files() { let rv = tempfile::tempdir().unwrap(); let project = tempfile::tempdir().unwrap(); let other = tempfile::tempdir().unwrap(); let file = project.path().join("a.php"); std::fs::write(&file, "