fix compilation output filepath

Author: adwinwhite

playground-worker/src/lib.rs

@@ -4,9 +4,9 @@ use std::fs;
 use std::io::{Read, Write};
 use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::Path;
-use std::process::Child;
 use std::process::Command;
 use std::process::Stdio;
+use std::process::{Child, Output};
 use std::str::from_utf8;
 use std::{io, thread};
 use worker_message::{ExecuteOutput, Pid, Request, Response};
@@ -45,20 +45,36 @@ fn handle_socket(request_stream: UnixStream, stdio_stream: UnixStream) {
                 envs,
                 cwd,
             } => {
+                dbg!(&args);
                 let result = Command::new(cmd)
                     .args(args)
                     .envs(envs)
                     .current_dir(cwd)
                     .output();
-                let response = Response::ExecuteResult(
-                    result
-                        .map(|output| ExecuteOutput {
-                            status: output.status.code(),
-                            stderr: output.stderr,
-                            stdout: output.stdout,
-                        })
-                        .map_err(|e| e.to_string()),
-                );
+                let response = Response::ExecuteResult(match result {
+                    Ok(output) => {
+                        let Output {
+                            status,
+                            stderr,
+                            stdout,
+                        } = output;
+                        if status.success() {
+                            Ok(ExecuteOutput {
+                                status: status.code(),
+                                stderr,
+                                stdout,
+                            })
+                        } else {
+                            Err(format!(
+                                "exit_status: {:#?}, stderr: {}, stdout: {}",
+                                status.code(),
+                                std::str::from_utf8(&stderr).unwrap(),
+                                std::str::from_utf8(&stdout).unwrap()
+                            ))
+                        }
+                    }
+                    Err(err) => Err(err.to_string()),
+                });
                 bincode::serialize_into(&request_stream, &response).unwrap();
             }
             Request::StreamCommand {

ui/src/coordinator.rs

@@ -5,7 +5,9 @@ use std::os::unix::net::UnixStream;
 use bincode::{deserialize_from, serialize_into};
 use log::info;
 
-use crate::sandbox::{CrateType, Edition, ExecuteRequest, Mode, CompileRequest, CompileTarget, Channel};
+use crate::sandbox::{
+    Channel, CompileRequest, CompileTarget, CrateType, Edition, ExecuteRequest, Mode,
+};
 
 type JobBatch = Vec<worker_message::Request>;
 
@@ -35,16 +37,20 @@ fn compile_request_to_batch(req: CompileRequest) -> JobBatch {
         )
         .into(),
     });
-    let mut args = vec!["rustc"];
+    let mut args = if let Wasm = req.target {
+        vec!["wasm", "build"]
+    } else {
+        vec!["rustc"]
+    };
     if let Mode::Release = req.mode {
         args.push("--release");
     }
-    args.extend(&["--", "-o", "/tmp/playground/compilation"]);
+    let output_path: &str = "/tmp/playground/compilation";
     match req.target {
         Assembly(flavor, _, _) => {
             use crate::sandbox::AssemblyFlavor::*;
 
-            args.push("--emit=asm");
+            args.extend(&["--", "--emit", "asm=/tmp/playground/compilation"]);
 
             // Enable extra assembly comments for nightly builds
             if let Channel::Nightly = req.channel {
@@ -58,10 +64,10 @@ fn compile_request_to_batch(req: CompileRequest) -> JobBatch {
                 Intel => args.push("llvm-args=-x86-asm-syntax=intel"),
             }
         }
-        LlvmIr => args.push("--emit=llvm-ir"),
-        Mir => args.push("--emit=mir"),
-        Hir => args.push("-Zunpretty=hir"),
-        Wasm => { panic!("Wasm target not supported now"); }
+        LlvmIr => args.extend(&["--", "--emit", "llvm-ir=/tmp/playground/compilation"]),
+        Mir => args.extend(&["--", "--emit", "mir=/tmp/playground/compilation"]),
+        Hir => args.extend(&["--", "-Zunpretty=hir", "-o", output_path]),
+        Wasm => args.extend(&["-o", output_path]),
     }
     let mut envs = HashMap::new();
     if req.backtrace {
@@ -77,7 +83,7 @@ fn compile_request_to_batch(req: CompileRequest) -> JobBatch {
         cwd: "/tmp/playground".to_owned(),
     });
     batch.push(ReadFile {
-        path: "/tmp/playground/compilation".to_owned()
+        path: "/tmp/playground/compilation".to_owned(),
     });
     batch
 }
@@ -136,6 +142,7 @@ fn process_batch(stream: &mut UnixStream, batch: JobBatch) -> Option<worker_mess
     let mut response = None;
     for job in batch {
         let res = work(stream, job);
+        dbg!(&res);
         if !res.is_ok() {
             return Some(res);
         } else {
@@ -152,15 +159,17 @@ fn work(stream: &mut UnixStream, req: worker_message::Request) -> worker_message
 
 #[cfg(test)]
 mod tests {
+    use std::io::{Read, Write};
     use std::path::Path;
     use std::str::from_utf8;
     use std::time::SystemTime;
     use std::{fs, os::unix::net::UnixStream, thread, time::Duration};
-    use std::io::{Read, Write};
 
     use crate::{
-        coordinator::{execute_request_to_batch, compile_request_to_batch},
-        sandbox::{Channel, Edition, ExecuteRequest, Mode, CompileRequest, CompileTarget, CrateType},
+        coordinator::{compile_request_to_batch, execute_request_to_batch},
+        sandbox::{
+            Channel, CompileRequest, CompileTarget, CrateType, Edition, ExecuteRequest, Mode,
+        },
     };
     use playground_worker;
 
@@ -191,7 +200,11 @@ mod tests {
     }
 
     fn generate_temporary_socket() -> String {
-        let timestamp = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
+        let timestamp = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+            .to_string();
         format!("/tmp/playground_test_socket_{timestamp}")
     }
 
@@ -219,6 +232,7 @@ mod tests {
         let batch = compile_request_to_batch(request);
         let result = process_batch(&mut request_socket, batch).unwrap();
         println!("{result}");
+        assert!(result.is_ok());
     }
 
     #[test]
@@ -254,6 +268,7 @@ mod tests {
             }
         });
         println!("{result}");
+        assert!(result.is_ok());
         // handle.join().unwrap();
         thread::sleep(Duration::from_secs(1));
     }