6070696104

Committed 03 Sep 2023 05:09PM UTC coverage: 70.111% (-0.2%) from 70.34%

Build # 6070696104

Build Type

push

github

Committed by

ensc

Commit Message

test: add more tests

Run Details

9 of 9 new or added lines in 1 file covered. (100.0%)

1710 of 2439 relevant lines covered (70.11%)

382.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.46

/src/test/httpd.rs

use std::env;
use std::fs::File;
use std::io::Write;
use std::net::Ipv4Addr;
use std::os::fd::{AsRawFd, RawFd};
use std::os::unix::process::CommandExt;
use std::path::Path;
use std::process::{Command, Stdio, Child};
use std::time::Duration;

use tempfile::TempDir;

pub struct Server {
    process:        Option<Child>,
    _tmpdir:        TempDir,
    host:        String,
}

const LIGHTTP_PROG: &str = match option_env!("LIGHTTP_PROG") {
    Some(e)        => e,
    None        => "lighttpd",
};

// TODO: we have to set LISTEN_PID to the pid after 'fork()'.  But pre_exec()
// does not seem to support updating the environment.  Call 'lighttpd' through
// a wrapper
const LIGHTTP_WRAP: &str = r#"#!/bin/sh
export LISTEN_PID=$$
exec @LIGHTTP@ "$@"
"#;

const LIGHTTP_CONF: &str = r#"
var.conf_dir = "@TMPDIR@"
var.state_dir = "@TMPDIR@"
var.log_root = "@TMPDIR@"
var.cache_dur = "@TMPDIR@"
var.server_root = "@TMPDIR@"

server.document-root = "@DATADIR@"
server.use-ipv6 = "disable"

server.modules += ( "mod_deflate" )
deflate.allowed-encodings = ("brotli", "gzip", "deflate")

server.modules += ( "mod_expire" )

server.systemd-socket-activation = "enable"
"#;

impl Server {
    pub fn create(dir: &Path) -> Option<Self>
    {
        match cfg!(feature = "proxy") {
            true        => Some(Self::create_lighttpd(dir)),
            false        => None,
        }
    }

    unsafe fn remove_cloexec(fd: RawFd) -> nix::libc::c_int {
        use nix::libc as libc;
        use libc::FD_CLOEXEC;

        match libc::fcntl(fd, libc::F_GETFD) {
            e if e < 0                        => e,
            f if f & FD_CLOEXEC == 0        => 0,
            f                                => libc::fcntl(fd, libc::F_SETFD, f & !FD_CLOEXEC),
        }
    }

    unsafe fn dup_nocloexec(old_fd: RawFd, new_fd: RawFd) -> std::io::Result<()> {
        // TODO: this happens only occasionally and causes randomness in our
        // code coverage tests :(
        let rc = match old_fd == new_fd {
            false        => nix::libc::dup3(old_fd, new_fd, 0),
            true        => Self::remove_cloexec(old_fd),
        };

        if rc < 0 {
            return Err(std::io::Error::last_os_error());
        }

        Ok(())
    }

    fn create_lighttpd(dir: &Path) -> Self
    {
        let addr = std::net::SocketAddr::new(Ipv4Addr::LOCALHOST.into(), 0);
        let sock = std::net::TcpListener::bind(addr).unwrap();
        let host = format!("localhost:{}", sock.local_addr().unwrap().port());

        let tmpdir = TempDir::new().unwrap();

        let conf = tmpdir.path().join("httpd.conf");
        let prog = tmpdir.path().join("lighttp-wrap");

        File::create(&prog).unwrap()
            .write_all(LIGHTTP_WRAP
                       .replace("@LIGHTTP@", LIGHTTP_PROG)
                       .as_bytes())
            .unwrap();

        File::create(&conf).unwrap()
            .write_all(LIGHTTP_CONF
                       .replace("@TMPDIR@", tmpdir.path().to_str().unwrap())
                       .replace("@DATADIR@", dir.to_str().unwrap())
                       .as_bytes())
            .unwrap();

        let mut proc = Command::new("/bin/sh");

        proc
            .arg(prog)
            .arg("-D")
            .arg("-i30")
            .arg("-f")
            .arg(conf)
            .current_dir("/")
            .env("PATH",
                 "/sbin:/usr/sbin:/usr/local/sbin:".to_owned() + &env::var("PATH").unwrap_or("/bin".to_string()))
            .env("LISTEN_FDS", "1")
            .stdin(Stdio::null())
            .stdout(Stdio::inherit())
            .stderr(Stdio::inherit());

        let sock_fd = sock.as_raw_fd();

        unsafe {
            proc.pre_exec(move || {
                Self::dup_nocloexec(sock_fd, 3)
            })
        };

        let child = proc.spawn().unwrap();

        Self {
            process:        Some(child),
            _tmpdir:        tmpdir,
            host:        host,
        }
    }

    pub fn get_host(&self) -> Option<&str> {
        Some(&self.host)
    }

    pub fn wait_for_ready(&mut self) {
        std::thread::sleep(Duration::from_millis(500));

        match self.process.take() {
            None                => panic!("no process"),
            Some(mut proc)        => match proc.try_wait() {
                Ok(None)        => self.process = Some(proc),
                res                => panic!("lighttpd exited: {res:?}"),
            }
        }
    }
}

impl std::ops::Drop for Server {
    fn drop(&mut self) {
        if let Some(mut proc) = self.process.take() {
            let _ = proc.kill();
            let _ = proc.wait();
        }
    }
}

1	use std::env;
2	use std::fs::File;
3	use std::io::Write;
4	use std::net::Ipv4Addr;
5	use std::os::fd::{AsRawFd, RawFd};
6	use std::os::unix::process::CommandExt;
7	use std::path::Path;
8	use std::process::{Command, Stdio, Child};
9	use std::time::Duration;
10
11	use tempfile::TempDir;
12
13	pub struct Server {
14	process: Option<Child>,
15	_tmpdir: TempDir,
16	host: String,
17	}
18
19	const LIGHTTP_PROG: &str = match option_env!("LIGHTTP_PROG") {
20	Some(e) => e,
21	None => "lighttpd",
22	};
23
24	// TODO: we have to set LISTEN_PID to the pid after 'fork()'. But pre_exec()
25	// does not seem to support updating the environment. Call 'lighttpd' through
26	// a wrapper
27	const LIGHTTP_WRAP: &str = r#"#!/bin/sh
28	export LISTEN_PID=$$
29	exec @LIGHTTP@ "$@"
30	"#;
31
32	const LIGHTTP_CONF: &str = r#"
33	var.conf_dir = "@TMPDIR@"
34	var.state_dir = "@TMPDIR@"
35	var.log_root = "@TMPDIR@"
36	var.cache_dur = "@TMPDIR@"
37	var.server_root = "@TMPDIR@"
38
39	server.document-root = "@DATADIR@"
40	server.use-ipv6 = "disable"
41
42	server.modules += ( "mod_deflate" )
43	deflate.allowed-encodings = ("brotli", "gzip", "deflate")
44
45	server.modules += ( "mod_expire" )
46
47	server.systemd-socket-activation = "enable"
48	"#;
49
50	impl Server {
51	pub fn create(dir: &Path) -> Option<Self>	2✔
52	{
53	match cfg!(feature = "proxy") {	2✔
54	true => Some(Self::create_lighttpd(dir)),	2✔
55	false => None,	×
56	}
57	}	2✔
58
59	unsafe fn remove_cloexec(fd: RawFd) -> nix::libc::c_int {	×
60	use nix::libc as libc;
61	use libc::FD_CLOEXEC;
62
63	match libc::fcntl(fd, libc::F_GETFD) {	×
64	e if e < 0 => e,	×
65	f if f & FD_CLOEXEC == 0 => 0,	×
66	f => libc::fcntl(fd, libc::F_SETFD, f & !FD_CLOEXEC),	×
67	}
68	}	×
69
70	unsafe fn dup_nocloexec(old_fd: RawFd, new_fd: RawFd) -> std::io::Result<()> {	×
71	// TODO: this happens only occasionally and causes randomness in our
72	// code coverage tests :(
73	let rc = match old_fd == new_fd {	×
74	false => nix::libc::dup3(old_fd, new_fd, 0),	×
75	true => Self::remove_cloexec(old_fd),	×
76	};
77
78	if rc < 0 {	×
79	return Err(std::io::Error::last_os_error());	×
80	}
81
82	Ok(())	×
83	}	×
84
85	fn create_lighttpd(dir: &Path) -> Self	2✔
86	{
87	let addr = std::net::SocketAddr::new(Ipv4Addr::LOCALHOST.into(), 0);	2✔
88	let sock = std::net::TcpListener::bind(addr).unwrap();	2✔
89	let host = format!("localhost:{}", sock.local_addr().unwrap().port());	2✔
90
91	let tmpdir = TempDir::new().unwrap();	2✔
92
93	let conf = tmpdir.path().join("httpd.conf");	2✔
94	let prog = tmpdir.path().join("lighttp-wrap");	2✔
95
96	File::create(&prog).unwrap()	4✔
97	.write_all(LIGHTTP_WRAP	2✔
98	.replace("@LIGHTTP@", LIGHTTP_PROG)
99	.as_bytes())
100	.unwrap();	2✔
101
102	File::create(&conf).unwrap()	4✔
103	.write_all(LIGHTTP_CONF	4✔
104	.replace("@TMPDIR@", tmpdir.path().to_str().unwrap())	2✔
105	.replace("@DATADIR@", dir.to_str().unwrap())	2✔
106	.as_bytes())
107	.unwrap();	2✔
108
109	let mut proc = Command::new("/bin/sh");	2✔
110
111	proc	12✔
112	.arg(prog)	2✔
113	.arg("-D")
114	.arg("-i30")
115	.arg("-f")
116	.arg(conf)	2✔
117	.current_dir("/")
118	.env("PATH",
119	"/sbin:/usr/sbin:/usr/local/sbin:".to_owned() + &env::var("PATH").unwrap_or("/bin".to_string()))	2✔
120	.env("LISTEN_FDS", "1")
121	.stdin(Stdio::null())	2✔
122	.stdout(Stdio::inherit())	2✔
123	.stderr(Stdio::inherit());	4✔
124
125	let sock_fd = sock.as_raw_fd();	2✔
126
127	unsafe {
128	proc.pre_exec(move \|\| {	2✔
129	Self::dup_nocloexec(sock_fd, 3)	×
130	})	×
131	};
132
133	let child = proc.spawn().unwrap();	2✔
134
135	Self {	2✔
136	process: Some(child),	2✔
137	_tmpdir: tmpdir,	2✔
138	host: host,
139	}
140	}	2✔
141
142	pub fn get_host(&self) -> Option<&str> {	42✔
143	Some(&self.host)	42✔
144	}	42✔
145
146	pub fn wait_for_ready(&mut self) {	2✔
147	std::thread::sleep(Duration::from_millis(500));	2✔
148
149	match self.process.take() {	2✔
150	None => panic!("no process"),	×
151	Some(mut proc) => match proc.try_wait() {	2✔
152	Ok(None) => self.process = Some(proc),	2✔
153	res => panic!("lighttpd exited: {res:?}"),	×
154	}	2✔
155	}
156	}	2✔
157	}
158
159	impl std::ops::Drop for Server {
160	fn drop(&mut self) {	2✔
161	if let Some(mut proc) = self.process.take() {	2✔
162	let _ = proc.kill();	2✔
163	let _ = proc.wait();	2✔
164	}	2✔
165	}	2✔
166	}

ensc / r-tftpd / 6070696104

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous