#![allow(dead_code)]
use std::collections::HashSet;
use std::io::prelude::*;
use std::io::BufReader;
use std::net::{SocketAddr, TcpListener, TcpStream};
use std::path::PathBuf;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread;
pub struct Server {
messages: Option<Sender<Message>>,
addr: Addr,
thread: Option<thread::JoinHandle<()>>,
}
enum Message {
Read(String),
Write(String),
}
enum Addr {
Tcp(SocketAddr),
Unix(PathBuf),
}
fn run(stream: impl Read + Write, rx: &Receiver<Message>) {
let mut socket = BufReader::new(stream);
for msg in rx.iter() {
match msg {
Message::Read(ref expected) => {
let mut expected = &expected[..];
let mut expected_headers = HashSet::new();
while let Some(i) = expected.find('\n') {
let line = &expected[..i + 1];
expected = &expected[i + 1..];
expected_headers.insert(line);
if line == "\r\n" {
break;
}
}
let mut expected_len = None;
while !expected_headers.is_empty() {
let mut actual = String::new();
t!(socket.read_line(&mut actual));
if actual.starts_with("Content-Length") {
let len = actual.split(": ").nth(1).unwrap();
expected_len = len.trim().parse().ok();
}
if actual == "Proxy-Connection: Keep-Alive\r\n" {
continue;
}
if expected_headers.remove(&actual[..]) {
continue;
}
let mut found = None;
for header in expected_headers.iter() {
if lines_match(header, &actual) {
found = Some(*header);
break;
}
}
if let Some(found) = found {
expected_headers.remove(&found);
continue;
}
panic!(
"unexpected header: {:?} (remaining headers {:?})",
actual, expected_headers
);
}
for header in expected_headers {
panic!("expected header but not found: {:?}", header);
}
let mut line = String::new();
let mut socket = match expected_len {
Some(amt) => socket.by_ref().take(amt),
None => socket.by_ref().take(expected.len() as u64),
};
while socket.limit() > 0 {
line.truncate(0);
t!(socket.read_line(&mut line));
if line.is_empty() {
break;
}
if expected.is_empty() {
panic!("unexpected line: {:?}", line);
}
let i = expected.find('\n').unwrap_or(expected.len() - 1);
let expected_line = &expected[..i + 1];
expected = &expected[i + 1..];
if lines_match(expected_line, &line) {
continue;
}
panic!(
"lines didn't match:\n\
expected: {:?}\n\
actual: {:?}\n",
expected_line, line
)
}
if !expected.is_empty() {
println!("didn't get expected data: {:?}", expected);
}
}
Message::Write(ref to_write) => {
t!(socket.get_mut().write_all(to_write.as_bytes()));
return;
}
}
}
let mut dst = Vec::new();
t!(socket.read_to_end(&mut dst));
assert_eq!(dst.len(), 0);
}
fn lines_match(expected: &str, mut actual: &str) -> bool {
for (i, part) in expected.split("[..]").enumerate() {
match actual.find(part) {
Some(j) => {
if i == 0 && j != 0 {
return false;
}
actual = &actual[j + part.len()..];
}
None => return false,
}
}
actual.is_empty() || expected.ends_with("[..]")
}
impl Server {
pub fn new() -> Server {
let listener = t!(TcpListener::bind("127.0.0.1:0"));
let addr = t!(listener.local_addr());
let (tx, rx) = channel();
let thread = thread::spawn(move || run(listener.accept().unwrap().0, &rx));
Server {
messages: Some(tx),
addr: Addr::Tcp(addr),
thread: Some(thread),
}
}
#[cfg(not(windows))]
pub fn new_unix() -> Server {
use std::os::unix::net::UnixListener;
let path = "/tmp/easy_server.sock";
std::fs::remove_file(path).ok();
let listener = t!(UnixListener::bind(path));
let (tx, rx) = channel();
let thread = thread::spawn(move || run(listener.incoming().next().unwrap().unwrap(), &rx));
Server {
messages: Some(tx),
addr: Addr::Unix(path.into()),
thread: Some(thread),
}
}
pub fn receive(&self, msg: &str) {
self.msg(Message::Read(self.replace_port(msg)));
}
fn replace_port(&self, msg: &str) -> String {
match &self.addr {
Addr::Tcp(addr) => msg.replace("$PORT", &addr.port().to_string()),
Addr::Unix(_) => msg.to_string(),
}
}
pub fn send(&self, msg: &str) {
self.msg(Message::Write(self.replace_port(msg)));
}
fn msg(&self, msg: Message) {
t!(self.messages.as_ref().unwrap().send(msg));
}
pub fn addr(&self) -> &SocketAddr {
match &self.addr {
Addr::Tcp(addr) => addr,
Addr::Unix(_) => panic!("server is a UnixListener"),
}
}
#[cfg(not(windows))]
pub fn path(&self) -> &str {
match &self.addr {
Addr::Tcp(_) => panic!("server is a TcpListener"),
Addr::Unix(p) => p.as_os_str().to_str().unwrap(),
}
}
pub fn url(&self, path: &str) -> String {
match &self.addr {
Addr::Tcp(addr) => format!("http://{}{}", addr, path),
Addr::Unix(_) => format!("http://localhost{}", path),
}
}
}
impl Drop for Server {
fn drop(&mut self) {
match &self.addr {
Addr::Tcp(addr) => drop(TcpStream::connect(addr)),
Addr::Unix(p) => t!(std::fs::remove_file(p)),
}
drop(self.messages.take());
let res = self.thread.take().unwrap().join();
if !thread::panicking() {
t!(res);
} else if let Err(e) = res {
println!("child server thread also failed: {:?}", e);
}
}
}