Method spawn

tests/all/cli_tests.rs:1548–1609

(cmd: &mut Command)

        }

        fn spawn(cmd: &mut Command) -> Result<WasmtimeServe> {
            cmd.arg("--shutdown-addr=127.0.0.1:0");
            cmd.stdin(Stdio::null());
            cmd.stdout(Stdio::piped());
            cmd.stderr(Stdio::piped());
            let mut child = cmd.spawn()?;

            // Read the first few lines of stderr which will say which address
            // it's listening on. The first line is the shutdown line (with
            // `--shutdown-addr`) and the second is what `--addr` was bound to.
            // This is done to figure out what `:0` was bound to in the child
            // process.
            let mut line = String::new();
            let mut stderr = BufReader::new(child.stderr.take().unwrap());
            let mut read_addr_from_line = |prefix: &str| -> Result<SocketAddr> {
                stderr.read_line(&mut line)?;

                if !line.starts_with(prefix) {
                    bail!("input line `{line}` didn't start with `{prefix}`");
                }
                match line.find("127.0.0.1").and_then(|addr_start| {
                    let addr = &line[addr_start..];
                    let addr_end = addr.find("/")?;
                    addr[..addr_end].parse().ok()
                }) {
                    Some(addr) => {
                        line.truncate(0);
                        Ok(addr)
                    }
                    None => bail!("failed to address from: {line}"),
                }
            };
            let shutdown_addr = read_addr_from_line("Listening for shutdown");
            let addr = read_addr_from_line("Serving HTTP on");
            let (shutdown_addr, addr) = match (shutdown_addr, addr) {
                (Ok(a), Ok(b)) => (a, b),
                // If either failed kill the child and otherwise try to shepherd
                // along any contextual information we have.
                (Err(a), _) | (_, Err(a)) => {
                    child.kill()?;
                    child.wait()?;
                    stderr.read_to_string(&mut line)?;
                    return Err(a.context(line));
                }
            };
            let mut stdout = child.stdout.take().unwrap();
            Ok(WasmtimeServe {
                stdout: Some(thread::spawn(move || {
                    let mut dst = Vec::new();
                    stdout.read_to_end(&mut dst).map(|_| dst)
                })),

                stderr: Some(thread::spawn(move || {
                    let mut dst = Vec::new();
                    stderr.read_to_end(&mut dst).map(|_| dst)
                })),

                child: Some(child),