src/server.rs

@@ -1,7 +1,7 @@
-use crate::server::utils::{get_free_port, wait_for_server};
+use crate::server::utils::{get_free_port, wait_for_port};
 use mktemp::Temp;
 use std::error::Error;
-use std::io::{self, Cursor, Read};
+use std::io::{Cursor, Read};
 use std::process::{Child, Stdio};
 use zip::ZipArchive;
 
@@ -48,15 +48,15 @@ impl EmbeddedServer {
         log::info!("Will execute file {}", server_file);
 
         // Start server
-        let mut child = std::process::Command::new("/usr/bin/python3")
+        let child = std::process::Command::new("/usr/bin/python3")
             .arg(server_file)
             .arg("-p")
             .arg(port.to_string())
             .stdout(Stdio::null())
-            .stderr(Stdio::piped())
+            .stderr(Stdio::null())
             .spawn()?;
 
-        wait_for_server(&mut child, port)?;
+        wait_for_port(port)?;
 
         Ok(Self {
             _srv_dir: dest,
@@ -78,9 +78,7 @@ impl Drop for EmbeddedServer {
 }
 
 mod utils {
-    use std::fmt::Write;
+    use std::io::ErrorKind;
-    use std::io::{BufRead, BufReader, ErrorKind};
-    use std::process::Child;
     use std::time::Duration;
 
     /// Get a free port
@@ -98,9 +96,8 @@ mod utils {
         Ok(port)
     }
 
-    pub fn wait_for_server(child: &mut Child, port: u16) -> std::io::Result<()> {
+    pub fn wait_for_port(port: u16) -> std::io::Result<()> {
         for _ in 0..50 {
-            check_server(child)?;
             if port_scanner::scan_port(port) {
                 return Ok(());
             }
@@ -112,32 +109,4 @@ mod utils {
             format!("Port {} did not open in time!", port),
         ))?
     }
-
-    fn check_server(child: &mut Child) -> Result<(), std::io::Error> {
-        match child.try_wait() {
-            Ok(None) => Ok(()), // Continue
-            Ok(Some(status)) => {
-                let mut err_msg = format!("grammalecte-server exit with `{status}`");
-
-                if let Some(err) = child.stderr.take() {
-                    writeln!(&mut err_msg, " :").unwrap();
-                    let err = BufReader::new(err);
-                    err.lines().for_each(|line| match line {
-                        Ok(line) => {
-                            writeln!(&mut err_msg, "\t{}", line).unwrap();
-                        }
-                        Err(err) => {
-                            writeln!(&mut err_msg, "__{err:?}").unwrap();
-                        }
-                    });
-                };
-
-                Err(std::io::Error::new(ErrorKind::Other, err_msg))
-            }
-            Err(err) => Err(std::io::Error::new(
-                ErrorKind::Other,
-                format!("Error append during check grammalecte-server status {err}"),
-            )),
-        }
-    }
 }