passed coordinator tests with Docker

Author: adwinwhite

ui/src/coordinator.rs

@@ -11,28 +11,29 @@ use crate::{parse_channel, parse_crate_type, parse_edition, parse_mode, parse_ta
 
 use worker_message::{CoordinatorMessage, Job, JobReport, WorkerMessage};
 
+use lazy_static::lazy_static;
 use snafu::prelude::*;
 use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{ChildStdin, ChildStdout, Command};
 use tokio::sync::{mpsc, oneshot};
 use tokio::task::{JoinHandle, JoinSet};
-use lazy_static::lazy_static;
 
 pub type Container = (mpsc::Sender<String>, mpsc::Receiver<String>);
 
 lazy_static! {
-    pub(crate) static ref COORDINATOR: Arc<Mutex<Coordinator>> = Arc::new(Mutex::new(Coordinator::new()));
+    pub(crate) static ref COORDINATOR: Arc<Mutex<Coordinator>> =
+        Arc::new(Mutex::new(Coordinator::new()));
 }
 
 #[derive(Debug)]
 pub struct Coordinator {
-    free_containers: VecDeque<Container>
+    free_containers: VecDeque<Container>,
 }
 
 impl Coordinator {
     pub fn new() -> Self {
         Coordinator {
-            free_containers: VecDeque::new()
+            free_containers: VecDeque::new(),
         }
     }
 
@@ -47,7 +48,7 @@ impl Coordinator {
     pub fn recycle(&mut self, container: Container) -> bool {
         // Seems not rigorous.
         let closed = container.0.is_closed();
-        if !closed { 
+        if !closed {
             self.free_containers.push_back(container);
         }
 
@@ -56,7 +57,6 @@ impl Coordinator {
     }
 }
 
-
 #[derive(Debug, Snafu)]
 pub enum Error {
     #[snafu(display("Reached system process limit"))]
@@ -690,16 +690,16 @@ fn basic_secure_docker_command() -> Command {
     )
 }
 
-
 fn run_worker_in_background() -> Result<(ChildStdin, ChildStdout)> {
     // For local development.
-    // const WORKER_FILEPATH: &str = "../worker-message/target/debug/worker";
+    // const WORKER_FILEPATH: &str = "../worker-message/target/release/worker";
 
     // No need to track Child.
     // We know whether it exits via channels.
     // let mut child = Command::new(WORKER_FILEPATH)
     let mut child = basic_secure_docker_command()
         .arg("-i")
+        .args(["-a", "stdin", "-a", "stdout", "-a", "stderr"])
         .arg("adwinw/rust-playground-worker")
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
@@ -836,7 +836,7 @@ async fn pair_websocket_worker(
                         WorkerMessage::StdoutPacket(packet) => {
                             let Ok(_) = ws_sender.send(
                                 serde_json::to_string(&PlaygroundMessage::Stdout {packet}).context(PlaygroundMessageSerializationSnafu)?).await
-                                .context(UnableToSendPlaygroundMessageToWebSocketSnafu) 
+                                .context(UnableToSendPlaygroundMessageToWebSocketSnafu)
                             else {
                                 // TODO: log the failure.
                                 continue;
@@ -845,7 +845,7 @@ async fn pair_websocket_worker(
                         WorkerMessage::StderrPacket(packet) => {
                             let Ok(_) = ws_sender.send(
                                 serde_json::to_string(&PlaygroundMessage::Stderr {packet}).context(PlaygroundMessageSerializationSnafu)?).await
-                                .context(UnableToSendPlaygroundMessageToWebSocketSnafu) 
+                                .context(UnableToSendPlaygroundMessageToWebSocketSnafu)
                             else {
                                 // TODO: log the failure.
                                 continue;
@@ -854,7 +854,7 @@ async fn pair_websocket_worker(
                         WorkerMessage::StreamFailure => {
                             let Ok(_) = ws_sender.send(
                                 serde_json::to_string(&PlaygroundMessage::StreamFailure).context(PlaygroundMessageSerializationSnafu)?).await
-                                .context(UnableToSendPlaygroundMessageToWebSocketSnafu) 
+                                .context(UnableToSendPlaygroundMessageToWebSocketSnafu)
                             else {
                                 // TODO: log the failure.
                                 continue;
@@ -896,12 +896,11 @@ pub fn spawn_worker() -> Result<Container> {
 #[cfg(test)]
 mod tests {
 
-    use crate::coordinator::{PlaygroundMessage, WSMessage, WSRequest, WSResponse, spawn_worker};
+    use crate::coordinator::{spawn_worker, PlaygroundMessage, WSMessage, WSRequest, WSResponse};
     use std::sync::atomic::AtomicU64;
     use std::sync::Arc;
     use std::time::Duration;
 
-
     use serde_json::json;
     use tokio::time::error::Elapsed;
 
@@ -1023,7 +1022,7 @@ mod tests {
         let mut client = MockClient::new();
         let compile_resp = check_websocket_request_response(
             WSRequest::Compile(client.new_compile_request()),
-            5000,
+            15000,
         )
         .await
         .expect("Failed to receive response from coordinator in time");
@@ -1038,7 +1037,7 @@ mod tests {
     async fn format_request() {
         let mut client = MockClient::new();
         let compile_resp =
-            check_websocket_request_response(WSRequest::Format(client.new_format_request()), 5000)
+            check_websocket_request_response(WSRequest::Format(client.new_format_request()), 15000)
                 .await
                 .expect("Failed to receive response from coordinator in time");
         if let WSResponse::Format(resp) = compile_resp {
@@ -1064,7 +1063,7 @@ mod tests {
             .expect("Failed to send request to coordinator");
 
         let user_input = "Hello Playground!\n";
-        tokio::time::timeout(Duration::from_millis(5000), async move {
+        tokio::time::timeout(Duration::from_millis(15000), async move {
             // Check execute response and send user input.
             if let Some(msg) = client_receiver.recv().await {
                 let playground_msg = serde_json::from_str(&msg)
@@ -1091,7 +1090,7 @@ mod tests {
                     match playground_msg {
                         PlaygroundMessage::Stdout { packet } => {
                             assert!(
-                                packet == user_input,
+                                dbg!(packet) == dbg!(user_input),
                                 "Running program has incorrect standard output."
                             );
                             break
@@ -1124,7 +1123,7 @@ mod tests {
             )
             .await
             .expect("Failed to send request to coordinator");
-        tokio::time::timeout(Duration::from_millis(5000), async move {
+        tokio::time::timeout(Duration::from_millis(15000), async move {
             // Check format response and send compilation request.
             if let Some(msg) = client_receiver.recv().await {
                 let playground_msg = serde_json::from_str(&msg)
@@ -1190,7 +1189,7 @@ mod tests {
             .await
             .expect("Failed to send request to coordinator");
         let latest_seqno = 1;
-        tokio::time::timeout(Duration::from_millis(5000), async move {
+        tokio::time::timeout(Duration::from_millis(15000), async move {
             loop {
                 let server_msg = client_receiver.recv().await;
                 match server_msg {
@@ -1248,7 +1247,7 @@ mod tests {
             .await
             .expect("Failed to send request to coordinator");
         let latest_seqno = 1;
-        tokio::time::timeout(Duration::from_millis(5000), async move {
+        tokio::time::timeout(Duration::from_millis(15000), async move {
             loop {
                 let server_msg = client_receiver.recv().await;
                 match server_msg {

worker-message/.dockerignore

@@ -0,0 +1 @@
+target/

worker-message/src/worker.rs

@@ -310,7 +310,7 @@ async fn stream_stdio(
             let n = stderr_buf.read_line(&mut buffer).await?;
             if n != 0 {
                 coordinator_tx_err
-                    .send(WorkerMessage::StdoutPacket(buffer))
+                    .send(WorkerMessage::StderrPacket(buffer))
                     .await?;
             } else {
                 break;