//! Peer client against a local HTTP listener. //! //! The listener is not a full `slinuxm`; it only has to speak enough HTTP/1.1 //! to prove the real transport. Later cases in this file drive a second //! in-process server with fake sources. use std::time::Duration; use skyg_linux_tracker::peers::registry::ReqwestTransport; use skyg_linux_tracker::peers::transport::{PeerBody, PeerRequest, PeerTransport}; use skyg_linux_tracker::peers::types::{PeerConfig, PeerName, PeersConfig}; use skyg_linux_tracker::peers::PeerError; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::TcpListener; fn transport() -> ReqwestTransport { ReqwestTransport::new(&PeersConfig { enabled: true, max_response_bytes: 64, ..PeersConfig::default() }) .unwrap() } fn peer(port: u16, token: &std::path::Path) -> PeerConfig { PeerConfig { name: PeerName::parse("beta").unwrap(), url: url::Url::parse(&format!("http://127.0.0.1:{port}")).unwrap(), token_file: token.to_path_buf(), ca_file: None, allow_plain_http: false, enabled: true, } } fn token_file(contents: &str) -> std::path::PathBuf { use std::io::Write; use std::os::unix::fs::OpenOptionsExt; let path = std::env::temp_dir().join(format!( "slinuxm-peers-reg-{}-{}", std::process::id(), std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap() .as_nanos() )); std::fs::OpenOptions::new() .write(true) .create(true) .truncate(true) .mode(0o600) .open(&path) .unwrap() .write_all(contents.as_bytes()) .unwrap(); path } fn ping() -> PeerRequest { PeerRequest { path: "/api/v1/ping".into(), query: vec![], headers: vec![], accept: None, } } async fn read_head(sock: &mut tokio::net::TcpStream) -> String { let mut buf = Vec::new(); let mut tmp = [0u8; 512]; while !buf.windows(4).any(|w| w == b"\r\n\r\n") { let n = tokio::time::timeout(Duration::from_secs(2), sock.read(&mut tmp)) .await .unwrap() .unwrap(); if n == 0 { break; } buf.extend_from_slice(&tmp[..n]); } String::from_utf8_lossy(&buf).into_owned() } #[tokio::test] async fn client_get_is_capped_and_does_not_follow_redirects() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let token = token_file("fixture-token\n"); tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); let head = read_head(&mut sock).await; assert!(head.starts_with("GET /api/v1/ping HTTP/1.1")); assert!(head .to_ascii_lowercase() .contains("authorization: bearer fixture-token")); let body = "0123456789abcdef"; let resp = format!( "HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:1/nope\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len() ); let _ = sock.write_all(resp.as_bytes()).await; }); let resp = transport() .get(&peer(port, &token), ping(), Duration::from_secs(2)) .await .unwrap(); assert_eq!(resp.status, 302); match resp.body { PeerBody::Bytes(b) => assert_eq!(&b[..], b"0123456789abcdef"), PeerBody::Stream(_) => panic!("expected a buffered body"), } let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); let _ = read_head(&mut sock).await; let mut resp = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n".to_vec(); let chunk = vec![b'z'; 200]; resp.extend(format!("{:x}\r\n", chunk.len()).into_bytes()); resp.extend_from_slice(&chunk); resp.extend(b"\r\n0\r\n\r\n"); let _ = sock.write_all(&resp).await; }); let err = transport() .get(&peer(port, &token), ping(), Duration::from_secs(2)) .await .unwrap_err(); assert!(matches!(err, PeerError::Oversize), "{err:?}"); let _ = std::fs::remove_file(&token); }