B: B1 real reqwest peer client with caps, timeouts and ring TLS

This commit is contained in:
ari committed 2026-10-19 20:55:25 -04:00
1 parent 58b41fa001
commit bd5b21bcc4
6 files changed
+1117

No files matched your search

+133
View File
@@ -0,0 +1,133 @@
//! 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);
}