Modify the original cargo toml

Author: shepmaster

orchestrator/src/coordinator.rs

@@ -50,17 +50,23 @@ impl<B> Coordinator<B>
 where
     B: Backend,
 {
-    pub fn new(backend: B) -> Result<Self, Error> {
+    pub async fn new(backend: B) -> Result<Self, Error> {
         let token = CancellationToken::new();
 
         let [stable, beta, nightly] =
             Channel::ALL.map(|channel| Container::new(channel, token.clone(), &backend));
 
+        let (stable, beta, nightly) = join!(stable, beta, nightly);
+
+        let stable = stable?;
+        let beta = beta?;
+        let nightly = nightly?;
+
         Ok(Self {
             backend,
-            stable: stable?,
-            beta: beta?,
-            nightly: nightly?,
+            stable,
+            beta,
+            nightly,
             token,
         })
     }
@@ -110,19 +116,24 @@ where
 }
 
 impl Coordinator<DockerBackend> {
-    pub fn new_docker() -> Result<Self, Error> {
-        Self::new(DockerBackend(()))
+    pub async fn new_docker() -> Result<Self, Error> {
+        Self::new(DockerBackend(())).await
     }
 }
 
 #[derive(Debug)]
 pub struct Container {
     task: JoinHandle<Result<()>>,
+    modify_cargo_toml: ModifyCargoToml,
     commander: Commander,
 }
 
 impl Container {
-    fn new(channel: Channel, token: CancellationToken, backend: &impl Backend) -> Result<Self> {
+    async fn new(
+        channel: Channel,
+        token: CancellationToken,
+        backend: &impl Backend,
+    ) -> Result<Self> {
         let (mut child, stdin, stdout) = backend.run_worker_in_background(channel)?;
         let IoQueue {
             mut tasks,
@@ -151,7 +162,15 @@ impl Container {
             id: Default::default(),
         };
 
-        Ok(Container { task, commander })
+        let modify_cargo_toml = ModifyCargoToml::new(commander.clone())
+            .await
+            .context(CouldNotLoadCargoTomlSnafu)?;
+
+        Ok(Container {
+            task,
+            modify_cargo_toml,
+            commander,
+        })
     }
 
     pub async fn compile(
@@ -195,7 +214,7 @@ impl Container {
         };
 
         let write_main = self.commander.one(write_main);
-        let modify_cargo_toml = modify_cargo_toml(&self.commander, &request);
+        let modify_cargo_toml = self.modify_cargo_toml.modify_for(&request);
 
         let (write_main, modify_cargo_toml) = join!(write_main, modify_cargo_toml);
 
@@ -257,8 +276,13 @@ impl Container {
     }
 
     pub async fn shutdown(self) -> Result<()> {
-        let Self { task, commander } = self;
+        let Self {
+            task,
+            modify_cargo_toml,
+            commander,
+        } = self;
         drop(commander);
+        drop(modify_cargo_toml);
         task.await.context(ContainerTaskPanickedSnafu)?
     }
 }
@@ -302,41 +326,61 @@ struct Commander {
     id: Arc<AtomicU64>,
 }
 
-// Consider making this into a top-level message to the worker to avoid the roundtrip.
-async fn modify_cargo_toml(
-    commander: &Commander,
-    request: &CompileRequest,
-) -> Result<(), ModifyCargoTomlError> {
-    use modify_cargo_toml_error::*;
+#[derive(Debug)]
+struct ModifyCargoToml {
+    commander: Commander,
+    cargo_toml: toml::Value,
+}
 
+impl ModifyCargoToml {
     const PATH: &str = "Cargo.toml";
 
-    let read_request = ReadFileRequest {
-        path: PATH.to_owned(),
-    };
-    let cargo_toml = commander
-        .one(read_request)
-        .await
-        .context(CouldNotReadSnafu)?;
+    async fn new(commander: Commander) -> Result<Self, ModifyCargoTomlError> {
+        let cargo_toml = Self::read(&commander).await?;
+        Ok(Self {
+            commander,
+            cargo_toml,
+        })
+    }
 
-    let cargo_toml = String::from_utf8(cargo_toml.0)?;
-    let cargo_toml = toml::from_str(&cargo_toml)?;
+    async fn modify_for(&self, request: &CompileRequest) -> Result<(), ModifyCargoTomlError> {
+        let cargo_toml = self.cargo_toml.clone();
+        let cargo_toml = request.modify_cargo_toml(cargo_toml);
+        Self::write(&self.commander, cargo_toml).await
+    }
+
+    async fn read(commander: &Commander) -> Result<toml::Value, ModifyCargoTomlError> {
+        use modify_cargo_toml_error::*;
 
-    let cargo_toml = request.modify_cargo_toml(cargo_toml);
+        let path = Self::PATH.to_owned();
+        let cargo_toml = commander
+            .one(ReadFileRequest { path })
+            .await
+            .context(CouldNotReadSnafu)?;
 
-    let cargo_toml = toml::to_string(&cargo_toml)?;
-    let cargo_toml = cargo_toml.into_bytes();
+        let cargo_toml = String::from_utf8(cargo_toml.0)?;
+        let cargo_toml = toml::from_str(&cargo_toml)?;
 
-    let write_request = WriteFileRequest {
-        path: PATH.to_owned(),
-        content: cargo_toml,
-    };
-    commander
-        .one(write_request)
-        .await
-        .context(CouldNotWriteSnafu)?;
+        Ok(cargo_toml)
+    }
+
+    async fn write(
+        commander: &Commander,
+        cargo_toml: toml::Value,
+    ) -> Result<(), ModifyCargoTomlError> {
+        use modify_cargo_toml_error::*;
+
+        let cargo_toml = toml::to_string(&cargo_toml)?;
+        let content = cargo_toml.into_bytes();
+
+        let path = Self::PATH.to_owned();
+        commander
+            .one(WriteFileRequest { path, content })
+            .await
+            .context(CouldNotWriteSnafu)?;
 
-    Ok(())
+        Ok(())
+    }
 }
 
 #[derive(Debug, Snafu)]
@@ -646,6 +690,9 @@ pub enum Error {
 
     #[snafu(display("Failed to send worker message through channel"))]
     UnableToSendWorkerMessage { source: mpsc::error::SendError<()> },
+
+    #[snafu(display("Unable to load original Cargo.toml"))]
+    CouldNotLoadCargoToml { source: ModifyCargoTomlError },
 }
 
 struct IoQueue {
@@ -779,9 +826,9 @@ mod tests {
         }
     }
 
-    fn new_coordinator() -> Result<Coordinator<impl Backend>> {
-        Coordinator::new(TestBackend::new())
-        //Coordinator::new_docker()
+    async fn new_coordinator() -> Result<Coordinator<impl Backend>> {
+        Coordinator::new(TestBackend::new()).await
+        //Coordinator::new_docker().await
     }
 
     fn new_compile_request() -> CompileRequest {
@@ -864,7 +911,7 @@ mod tests {
     #[tokio::test]
     #[snafu::report]
     async fn test_compile_response() -> Result<()> {
-        let coordinator = new_coordinator()?;
+        let coordinator = new_coordinator().await?;
 
         let response = coordinator
             .compile(new_compile_request())
@@ -884,7 +931,7 @@ mod tests {
     #[tokio::test]
     #[snafu::report]
     async fn test_compile_streaming() -> Result<()> {
-        let coordinator = new_coordinator()?;
+        let coordinator = new_coordinator().await?;
 
         let ActiveCompilation {
             task,
@@ -919,7 +966,7 @@ mod tests {
     #[snafu::report]
     async fn test_compile_edition() -> Result<()> {
         for edition in Edition::ALL {
-            let coordinator = new_coordinator()?;
+            let coordinator = new_coordinator().await?;
 
             let response = coordinator
                 .compile(new_compile_hir_request_for(edition))
@@ -941,7 +988,7 @@ mod tests {
     #[tokio::test]
     #[snafu::report]
     async fn test_compile_assembly() -> Result<()> {
-        let coordinator = new_coordinator()?;
+        let coordinator = new_coordinator().await?;
 
         let response = coordinator
             .compile(new_compile_assembly_request())
@@ -966,7 +1013,7 @@ mod tests {
     #[tokio::test]
     #[snafu::report]
     async fn test_compile_hir() -> Result<()> {
-        let coordinator = new_coordinator()?;
+        let coordinator = new_coordinator().await?;
 
         let response = coordinator
             .compile(new_compile_hir_request())
@@ -985,7 +1032,7 @@ mod tests {
     #[tokio::test]
     #[snafu::report]
     async fn test_compile_llvm_ir() -> Result<()> {
-        let coordinator = new_coordinator()?;
+        let coordinator = new_coordinator().await?;
 
         let response = coordinator
             .compile(new_compile_llvm_ir_request())
@@ -1005,7 +1052,7 @@ mod tests {
     #[snafu::report]
     async fn test_compile_wasm() -> Result<()> {
         // cargo-wasm only exists inside the container
-        let coordinator = Coordinator::new_docker()?;
+        let coordinator = Coordinator::new_docker().await?;
 
         let response = coordinator
             .compile(new_compile_wasm_request())

orchestrator/src/sandbox.rs

@@ -192,16 +192,10 @@ impl CompileRequest {
     pub(crate) fn modify_cargo_toml(&self, mut cargo_toml: toml::Value) -> toml::Value {
         cargo_toml = modify_cargo_toml::set_edition(cargo_toml, self.edition.to_cargo_toml_key());
 
-        // TODO: When we boot the container, grab information like
-        // `Cargo.toml` (and the `rustc` version, dependency
-        // versions?). Then we always start from that version.
-
-        // TODO: We need to undo these changes when switching back from a library
         if let Some(crate_type) = self.crate_type.to_library_cargo_toml_key() {
             cargo_toml = modify_cargo_toml::set_crate_type(cargo_toml, crate_type);
         }
 
-        // TODO: We need to undo these changes when switching back from Wasm
         if CompileTarget::Wasm == self.target {
             cargo_toml = modify_cargo_toml::remove_dependencies(cargo_toml);
             cargo_toml = modify_cargo_toml::set_release_lto(cargo_toml, true);