#![allow(dead_code)]
use std::io::{BufRead, BufReader, Read, Write};
use std::net::TcpStream;
use std::path::{Path, PathBuf};
use std::process::{Child, Command, Stdio};
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
use std::sync::mpsc;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
pub const SETTLE: Duration = Duration::from_millis(700);
pub const TIMEOUT: Duration = Duration::from_secs(5);
pub const PAGE: &str = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
pub struct TempDir {
path: PathBuf,
}
impl TempDir {
pub fn new(name: &str) -> TempDir {
static NEXT: AtomicU32 = AtomicU32::new(0);
let unique = NEXT.fetch_add(1, Ordering::Relaxed);
let path = std::env::temp_dir().join(format!(
"servio-test-{}-{name}-{unique}",
std::process::id()
));
let _ = std::fs::remove_dir_all(&path);
std::fs::create_dir_all(&path).expect("could not create the test directory");
TempDir { path }
}
pub fn path(&self) -> &Path {
&self.path
}
pub fn join(&self, relative: &str) -> PathBuf {
self.path.join(relative)
}
pub fn write(&self, relative: &str, contents: &str) {
let file = self.join(relative);
if let Some(parent) = file.parent() {
std::fs::create_dir_all(parent).expect("could not create a parent directory");
}
std::fs::write(file, contents).expect("could not write the test file");
}
pub fn remove_all(&self) {
std::fs::remove_dir_all(&self.path).expect("could not remove the test directory");
}
pub fn create(&self) {
std::fs::create_dir_all(&self.path).expect("could not create the test directory");
}
}
impl Drop for TempDir {
fn drop(&mut self) {
if std::fs::remove_dir_all(&self.path).is_err() {
open_again(&self.path);
let _ = std::fs::remove_dir_all(&self.path);
}
}
}
#[cfg(unix)]
fn open_again(path: &Path) {
use std::os::unix::fs::PermissionsExt;
let _ = std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755));
let Ok(entries) = std::fs::read_dir(path) else {
return;
};
for entry in entries.flatten() {
let is_directory = entry.file_type().is_ok_and(|kind| kind.is_dir());
if is_directory {
open_again(&entry.path());
}
}
}
#[cfg(not(unix))]
fn open_again(_path: &Path) {}
pub struct Server {
child: Child,
pub port: u16,
log: Arc<Mutex<Vec<String>>>,
}
impl Server {
pub fn start(dir: &Path, args: &[&str]) -> Server {
Server::spawn(dir, &["--port", "0"], args, &[])
}
pub fn start_in(dir: &Path, args: &[&str], env: &[(&str, &str)]) -> Server {
Server::spawn(dir, &["--port", "0"], args, env)
}
pub fn start_choosing_a_port(dir: &Path) -> Server {
Server::spawn(dir, &[], &[], &[])
}
fn spawn(dir: &Path, port: &[&str], args: &[&str], env: &[(&str, &str)]) -> Server {
let mut child = Command::new(env!("CARGO_BIN_EXE_servio"))
.arg("--dir")
.arg(dir)
.args(port)
.args(args)
.envs(env.iter().copied())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("could not start servio");
let log = Arc::new(Mutex::new(Vec::new()));
let (found_port, port) = mpsc::channel();
let stdout = child.stdout.take().expect("no stdout");
collect(stdout, Arc::clone(&log), Some(found_port));
let stderr = child.stderr.take().expect("no stderr");
collect(stderr, Arc::clone(&log), None);
let Ok(port) = port.recv_timeout(TIMEOUT) else {
let stopped = match child.try_wait() {
Ok(Some(status)) => format!("it stopped with {status}"),
_ => "it is still running".to_string(),
};
panic!(
"servio never said which port it was listening on, {stopped}:\n{}",
log.lock().unwrap().join("\n")
);
};
Server { child, port, log }
}
pub fn lines(&self) -> Vec<String> {
self.log.lock().unwrap().clone()
}
pub fn count(&self, needle: &str) -> usize {
self.lines()
.iter()
.filter(|line| line.contains(needle))
.count()
}
pub fn said(&self, needle: &str) -> bool {
self.count(needle) > 0
}
pub fn open_browser(&self) -> Browser<'_> {
Browser::open(self)
}
pub fn wait_for(&self, needle: &str) {
self.wait_until(|| self.said(needle), needle);
}
pub fn wait_for_count(&self, needle: &str, wanted: usize) {
self.wait_until(
|| self.count(needle) >= wanted,
&format!("{needle} {wanted} time(s)"),
);
}
fn wait_until(&self, done: impl Fn() -> bool, wanted: &str) {
let deadline = Instant::now() + TIMEOUT;
while Instant::now() < deadline {
if done() {
return;
}
std::thread::sleep(Duration::from_millis(20));
}
panic!("waited for {wanted}:\n{}", self.lines().join("\n"));
}
pub fn settle(&self) {
std::thread::sleep(SETTLE);
}
}
impl Drop for Server {
fn drop(&mut self) {
let _ = self.child.kill();
let _ = self.child.wait();
}
}
fn collect(
stream: impl Read + Send + 'static,
log: Arc<Mutex<Vec<String>>>,
found_port: Option<mpsc::Sender<u16>>,
) {
std::thread::spawn(move || {
for line in BufReader::new(stream).lines().map_while(Result::ok) {
let port = found_port.as_ref().zip(port_in(&line));
log.lock().unwrap().push(line);
if let Some((sender, port)) = port {
let _ = sender.send(port);
}
}
});
}
fn port_in(line: &str) -> Option<u16> {
let (label, address) = line.split_once(':')?;
if !label.contains("Open") {
return None;
}
address.trim().rsplit(':').next()?.trim().parse().ok()
}
pub struct Response {
pub status: u16,
pub headers: Vec<(String, String)>,
pub body: Vec<u8>,
}
impl Response {
pub fn header(&self, name: &str) -> Option<&str> {
self.headers
.iter()
.find(|(header, _)| header.eq_ignore_ascii_case(name))
.map(|(_, value)| value.as_str())
}
pub fn text(&self) -> String {
String::from_utf8_lossy(&self.body).into_owned()
}
}
pub fn get(port: u16, path: &str) -> Response {
request(port, "GET", path, &[])
}
pub fn get_page(port: u16, path: &str) -> Response {
request(port, "GET", path, &[("Accept", PAGE)])
}
pub fn request(port: u16, method: &str, path: &str, headers: &[(&str, &str)]) -> Response {
let mut socket = TcpStream::connect(("127.0.0.1", port)).expect("could not connect");
socket.set_read_timeout(Some(TIMEOUT)).unwrap();
let mut lines = format!("{method} {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n");
for (header, value) in headers {
lines.push_str(&format!("{header}: {value}\r\n"));
}
lines.push_str("\r\n");
socket.write_all(lines.as_bytes()).expect("could not send");
let mut raw = Vec::new();
socket.read_to_end(&mut raw).expect("could not read");
parse(&raw)
}
const EVENT_STREAM: &[u8] =
b"GET /_tower-livereload/event-stream HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n";
pub struct Browser<'a> {
server: &'a Server,
seen: Arc<Seen>,
listener: Option<std::thread::JoinHandle<()>>,
}
#[derive(Default)]
struct Seen {
refreshes: AtomicUsize,
listening: AtomicBool,
closed: AtomicBool,
}
impl<'a> Browser<'a> {
fn open(server: &'a Server) -> Browser<'a> {
let seen = Arc::new(Seen::default());
let port = server.port;
let listener = std::thread::spawn({
let seen = Arc::clone(&seen);
move || listen(port, &seen)
});
let browser = Browser {
server,
seen,
listener: Some(listener),
};
server.wait_until(
|| browser.listening(),
"the browser to listen for refreshes",
);
browser
}
pub fn refreshes(&self) -> usize {
self.seen.refreshes.load(Ordering::SeqCst)
}
fn listening(&self) -> bool {
self.seen.listening.load(Ordering::SeqCst)
}
pub fn wait_for_refreshes(&self, wanted: usize) {
self.server.wait_until(
|| self.refreshes() >= wanted && self.listening(),
&format!("{wanted} refresh(es)"),
);
}
pub fn expect_no_refresh(&self) {
self.expect_no_refresh_within(SETTLE);
}
pub fn expect_no_refresh_within(&self, patience: Duration) {
std::thread::sleep(patience);
assert_eq!(
self.refreshes(),
0,
"nothing should have refreshed:\n{}",
self.server.lines().join("\n")
);
assert!(
self.listening(),
"the browser stopped hearing from the server:\n{}",
self.server.lines().join("\n")
);
}
}
impl Drop for Browser<'_> {
fn drop(&mut self) {
self.seen.closed.store(true, Ordering::SeqCst);
if let Some(listener) = self.listener.take() {
let _ = listener.join();
}
}
}
fn listen(port: u16, seen: &Seen) {
while !seen.closed.load(Ordering::SeqCst) {
let Ok(mut socket) = TcpStream::connect(("127.0.0.1", port)) else {
std::thread::sleep(Duration::from_millis(20));
continue;
};
let _ = socket.set_read_timeout(Some(Duration::from_millis(100)));
if socket.write_all(EVENT_STREAM).is_err() {
continue;
}
let mut received = Vec::new();
let mut chunk = [0; 512];
while !seen.closed.load(Ordering::SeqCst) {
match socket.read(&mut chunk) {
Ok(0) => break,
Ok(read) => received.extend_from_slice(&chunk[..read]),
Err(error) if would_block(&error) => continue,
Err(_) => break,
}
let events = String::from_utf8_lossy(&received);
if events.contains("event: reload") {
seen.listening.store(false, Ordering::SeqCst);
seen.refreshes.fetch_add(1, Ordering::SeqCst);
break;
}
if events.contains("event: init") {
seen.listening.store(true, Ordering::SeqCst);
}
}
seen.listening.store(false, Ordering::SeqCst);
}
}
fn would_block(error: &std::io::Error) -> bool {
matches!(
error.kind(),
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
)
}
fn parse(raw: &[u8]) -> Response {
let split = find(raw, b"\r\n\r\n").expect("no end of headers");
let head = String::from_utf8_lossy(&raw[..split]);
let mut lines = head.lines();
let status = lines
.next()
.and_then(|line| line.split_whitespace().nth(1))
.and_then(|code| code.parse().ok())
.expect("no status");
let headers: Vec<(String, String)> = lines
.filter_map(|line| line.split_once(':'))
.map(|(header, value)| (header.trim().to_string(), value.trim().to_string()))
.collect();
let body = &raw[split + 4..];
let chunked = headers.iter().any(|(header, value)| {
header.eq_ignore_ascii_case("transfer-encoding") && value.contains("chunked")
});
Response {
status,
headers,
body: if chunked {
dechunk(body)
} else {
body.to_vec()
},
}
}
fn dechunk(body: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut rest = body;
while let Some(end_of_size) = find(rest, b"\r\n") {
let size = String::from_utf8_lossy(&rest[..end_of_size]);
let size = size.split(';').next().unwrap_or_default().trim();
let Ok(size) = usize::from_str_radix(size, 16) else {
break;
};
let start = end_of_size + 2;
let Some(chunk) = rest.get(start..start + size) else {
break; };
if size == 0 {
break;
}
out.extend_from_slice(chunk);
rest = rest.get(start + size + 2..).unwrap_or_default();
}
out
}
fn find(haystack: &[u8], needle: &[u8]) -> Option<usize> {
haystack
.windows(needle.len())
.position(|window| window == needle)
}