test(edge): end-to-end connection path over loopback
Drive a real TCP client through engine::listener and Gateway to a real upstream on 127.0.0.1, covering plain HTTP proxying, the PoW gate (coalesced nonce + request, wrong nonce dropped), the per-IP rate limit and the blacklist. Ports are ephemeral, every wait is bounded, and the accept loop is always stopped and awaited.
This commit is contained in:
parent
bcae8901c6
commit
ca7ce8c58e
2 changed files with 403 additions and 0 deletions
250
tests/edge_e2e/support.rs
Normal file
250
tests/edge_e2e/support.rs
Normal file
|
|
@ -0,0 +1,250 @@
|
|||
//! Shared loopback harness for `tests/edge_e2e.rs`; cargo does not build it as
|
||||
//! its own test binary because it lives in a subdirectory.
|
||||
|
||||
use rampart::config::Config;
|
||||
use rampart::engine::challenge::DifficultyAdjuster;
|
||||
use rampart::engine::listener;
|
||||
use rampart::engine::tunnel::Gateway;
|
||||
use rampart::filter::blacklist::Blacklist;
|
||||
use rampart::filter::rate_limit::RateLimiter;
|
||||
use rampart::protocol::ProtocolRegistry;
|
||||
use rampart::protocol::http::HttpProtocolHandler;
|
||||
use rampart::traffic::hook::TrafficHook;
|
||||
use rampart::traffic::reputation::IpReputation;
|
||||
use std::collections::HashSet;
|
||||
use std::io::ErrorKind;
|
||||
use std::net::{Ipv4Addr, SocketAddr};
|
||||
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
use tokio::net::TcpStream;
|
||||
use tokio::sync::watch;
|
||||
use tokio::task::JoinHandle;
|
||||
|
||||
pub const REQUEST: &[u8] = b"GET / HTTP/1.1\r\nHost: edge\r\n\r\n";
|
||||
pub const RESPONSE: &[u8] = b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK";
|
||||
pub const POW_DIFFICULTY: u8 = 2;
|
||||
/// Upper bound of every I/O wait, so a regression fails instead of hanging.
|
||||
pub const IO_BUDGET: Duration = Duration::from_secs(4);
|
||||
const READY_BUDGET: Duration = Duration::from_secs(2);
|
||||
const MAX_REPLY_BYTES: usize = 64 * 1024;
|
||||
|
||||
// --- upstream -------------------------------------------------------------
|
||||
|
||||
/// Real upstream: returns its address, an accept counter and the heads it saw.
|
||||
pub async fn start_upstream() -> (SocketAddr, Arc<AtomicUsize>, Arc<Mutex<Vec<Vec<u8>>>>) {
|
||||
let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
|
||||
.await
|
||||
.expect("bind upstream");
|
||||
let addr = listener.local_addr().expect("upstream address");
|
||||
let accepted = Arc::new(AtomicUsize::new(0));
|
||||
let requests = Arc::new(Mutex::new(Vec::new()));
|
||||
let (count, seen) = (Arc::clone(&accepted), Arc::clone(&requests));
|
||||
// Detached: the per-test runtime drops this server when the test ends.
|
||||
tokio::spawn(async move {
|
||||
while let Ok((mut stream, _)) = listener.accept().await {
|
||||
count.fetch_add(1, Ordering::SeqCst);
|
||||
let seen = Arc::clone(&seen);
|
||||
tokio::spawn(async move {
|
||||
let head = read_head(&mut stream).await;
|
||||
seen.lock().expect("requests lock").push(head);
|
||||
let _ = stream.write_all(RESPONSE).await;
|
||||
let _ = stream.shutdown().await;
|
||||
});
|
||||
}
|
||||
});
|
||||
(addr, accepted, requests)
|
||||
}
|
||||
|
||||
/// Reads until the request head ends (`\r\n\r\n`), the peer closes or a read fails.
|
||||
async fn read_head(stream: &mut TcpStream) -> Vec<u8> {
|
||||
let mut head = Vec::new();
|
||||
let mut buf = [0u8; 512];
|
||||
while head.len() < 4096 {
|
||||
match stream.read(&mut buf).await {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => {
|
||||
head.extend_from_slice(&buf[..n]);
|
||||
if head.windows(4).any(|w| w == b"\r\n\r\n".as_slice()) {
|
||||
break;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
head
|
||||
}
|
||||
|
||||
// --- edge -----------------------------------------------------------------
|
||||
|
||||
/// Production-shaped config from serde defaults, plus the per-test overrides.
|
||||
fn test_config(port: u16, upstream: SocketAddr) -> Config {
|
||||
let mut config = Config::default();
|
||||
config.bind.address = Ipv4Addr::LOCALHOST.to_string();
|
||||
config.bind.port = port;
|
||||
config.backend.upstreams = vec![upstream.to_string()];
|
||||
config.workers.count = 1;
|
||||
config.limits.handshake_timeout_secs = 2;
|
||||
config.limits.relay_idle_timeout_secs = 5;
|
||||
config.limits.max_connections_per_ip = 8;
|
||||
config.protocol.http.max_header_bytes = 4096;
|
||||
config.protocol.http.timeout_secs = 2;
|
||||
config
|
||||
}
|
||||
|
||||
/// Running accept loop plus the shared state a test may pre-seed.
|
||||
pub struct Edge {
|
||||
pub addr: SocketAddr,
|
||||
pub blacklist: Arc<Blacklist>,
|
||||
shutdown: watch::Sender<bool>,
|
||||
task: JoinHandle<anyhow::Result<()>>,
|
||||
}
|
||||
|
||||
impl Edge {
|
||||
/// Stops the accept loop and waits for it, so no task outlives the test.
|
||||
pub async fn stop(mut self) -> anyhow::Result<()> {
|
||||
let _ = self.shutdown.send(true);
|
||||
match tokio::time::timeout(IO_BUDGET, &mut self.task).await {
|
||||
Ok(result) => result?,
|
||||
Err(_) => anyhow::bail!("edge accept loop did not stop within {IO_BUDGET:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Edge {
|
||||
fn drop(&mut self) {
|
||||
// Panic path: still wake the accept loop instead of leaking it.
|
||||
let _ = self.shutdown.send(true);
|
||||
}
|
||||
}
|
||||
|
||||
/// Starts `listener::run`, retrying once if the throwaway port was stolen.
|
||||
///
|
||||
/// The port comes from binding `:0` and dropping the probe, so another process
|
||||
/// can claim it before the edge binds; `run` then fails immediately and a fresh
|
||||
/// port is used. The retry is bounded, never a loop.
|
||||
pub async fn start_edge(upstream: SocketAddr, tune: impl Fn(&mut Config)) -> anyhow::Result<Edge> {
|
||||
let mut last_error = anyhow::anyhow!("edge listener did not bind");
|
||||
for _ in 0..2 {
|
||||
let port = free_port()?;
|
||||
let mut config = test_config(port, upstream);
|
||||
tune(&mut config);
|
||||
let config = Arc::new(config);
|
||||
let (gateway, blacklist, hook) = build_gateway(&config);
|
||||
let (shutdown, shutdown_rx) = watch::channel(false);
|
||||
let task = tokio::spawn(listener::run(config, gateway, hook, shutdown_rx));
|
||||
let addr = SocketAddr::from((Ipv4Addr::LOCALHOST, port));
|
||||
if wait_until_bound(addr, &task).await {
|
||||
return Ok(Edge {
|
||||
addr,
|
||||
blacklist,
|
||||
shutdown,
|
||||
task,
|
||||
});
|
||||
}
|
||||
let _ = shutdown.send(true);
|
||||
if let Ok(Err(error)) = task.await {
|
||||
last_error = error;
|
||||
}
|
||||
}
|
||||
Err(last_error.context("edge listener failed to bind a loopback port after two attempts"))
|
||||
}
|
||||
|
||||
/// Binds `127.0.0.1:0`, reads the assigned port and releases it.
|
||||
fn free_port() -> anyhow::Result<u16> {
|
||||
let probe = std::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))?;
|
||||
let port = probe.local_addr()?.port();
|
||||
drop(probe);
|
||||
Ok(port)
|
||||
}
|
||||
|
||||
/// Waits until the edge owns `addr`. A second bind without `SO_REUSEPORT` fails
|
||||
/// with `EADDRINUSE` exactly then, so no throwaway connection spends a
|
||||
/// rate-limit token and pollutes the assertions.
|
||||
async fn wait_until_bound(addr: SocketAddr, task: &JoinHandle<anyhow::Result<()>>) -> bool {
|
||||
let deadline = Instant::now() + READY_BUDGET;
|
||||
while Instant::now() < deadline {
|
||||
if task.is_finished() {
|
||||
return false;
|
||||
}
|
||||
if std::net::TcpListener::bind(addr).is_err() {
|
||||
return true;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(2)).await;
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
/// Assembles the edge state as `app::runtime` does, minus XDP, Redis and the
|
||||
/// ClickHouse writer (all optional, all `None` here).
|
||||
fn build_gateway(config: &Arc<Config>) -> (Arc<Gateway>, Arc<Blacklist>, Arc<TrafficHook>) {
|
||||
let blacklist = Arc::new(Blacklist::new());
|
||||
let reputation = Arc::new(IpReputation::new());
|
||||
let mut registry = ProtocolRegistry::new();
|
||||
registry.register(Box::new(HttpProtocolHandler::new(
|
||||
&config.protocol.http,
|
||||
&config.backend.upstreams,
|
||||
)));
|
||||
let gateway = Gateway::new(
|
||||
Arc::clone(config),
|
||||
Arc::new(RateLimiter::new(
|
||||
config.limits.rate_limit_pps,
|
||||
config.limits.rate_limit_burst,
|
||||
)),
|
||||
Arc::clone(&blacklist),
|
||||
Arc::new(Mutex::new(DifficultyAdjuster::with_floor(config.pow.difficulty))),
|
||||
Arc::new(HashSet::new()),
|
||||
Arc::clone(&reputation),
|
||||
None,
|
||||
None,
|
||||
Arc::new(AtomicU64::new(0)),
|
||||
Arc::new(registry),
|
||||
None,
|
||||
);
|
||||
// Auto-ban stays at its default (disabled), so a drop cannot leak a ban into
|
||||
// a later assertion.
|
||||
let hook = Arc::new(TrafficHook::new(
|
||||
reputation,
|
||||
Arc::clone(&blacklist),
|
||||
config.detect.autoban.clone(),
|
||||
config.ban.ban_duration_secs,
|
||||
));
|
||||
(Arc::new(gateway), blacklist, hook)
|
||||
}
|
||||
|
||||
// --- client ---------------------------------------------------------------
|
||||
|
||||
/// Reads until the peer closes; a reset also means "closed, no extra data".
|
||||
pub async fn read_to_close(stream: &mut TcpStream) -> anyhow::Result<Vec<u8>> {
|
||||
let mut out = Vec::new();
|
||||
let mut buf = [0u8; 512];
|
||||
loop {
|
||||
match stream.read(&mut buf).await {
|
||||
Ok(0) => return Ok(out),
|
||||
Ok(n) => {
|
||||
out.extend_from_slice(&buf[..n]);
|
||||
if out.len() > MAX_REPLY_BYTES {
|
||||
anyhow::bail!("peer kept sending past {MAX_REPLY_BYTES} bytes");
|
||||
}
|
||||
},
|
||||
Err(error) if error.kind() == ErrorKind::ConnectionReset => return Ok(out),
|
||||
Err(error) => return Err(error.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `payload` on a fresh connection and returns everything until the close.
|
||||
pub async fn exchange(addr: SocketAddr, payload: &[u8]) -> anyhow::Result<Vec<u8>> {
|
||||
let mut client = TcpStream::connect(addr).await?;
|
||||
client.write_all(payload).await?;
|
||||
tokio::time::timeout(IO_BUDGET, read_to_close(&mut client)).await?
|
||||
}
|
||||
|
||||
/// Best-effort request on a fresh connection: a rejected peer may already be
|
||||
/// gone, so write errors are ignored. The reply is what the caller asserts on —
|
||||
/// a gate that let the request through would return the upstream response.
|
||||
pub async fn rejected_reply(addr: SocketAddr, payload: &[u8]) -> anyhow::Result<Vec<u8>> {
|
||||
let mut client = TcpStream::connect(addr).await?;
|
||||
let _ = client.write_all(payload).await;
|
||||
tokio::time::timeout(IO_BUDGET, read_to_close(&mut client)).await?
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue