smaller refactor

Author: jkelleyrtp

packages/cli/src/build/builder.rs

@@ -177,12 +177,17 @@ impl Builder {
         update
     }
 
-    pub(crate) fn patch_rebuild(&mut self, args: BuildArgs) {
+    pub(crate) fn patch_rebuild(&mut self, args: BuildArgs, direct_rustc: Vec<Vec<String>>) {
         // Abort all the ongoing builds, cleaning up any loose artifacts and waiting to cleanly exit
         self.abort_all();
 
         // And then start a new build, resetting our progress/stage to the beginning and replacing the old tokio task
-        let request = BuildRequest::new(self.krate.clone(), args, self.tx.clone(), BuildMode::Thin);
+        let request = BuildRequest::new(
+            self.krate.clone(),
+            args,
+            self.tx.clone(),
+            BuildMode::Thin { direct_rustc },
+        );
         self.request = request.clone();
         self.stage = BuildStage::Restarting;
 

packages/cli/src/build/bundle.rs

@@ -1,6 +1,6 @@
 use super::prerender::pre_render_static_routes;
 use super::templates::InfoPlistData;
-use crate::{BuildRequest, Platform, WasmOptConfig};
+use crate::{BuildMode, BuildRequest, Platform, WasmOptConfig};
 use crate::{Result, TraceSrc};
 use anyhow::Context;
 use dioxus_cli_opt::{process_file_to, AssetManifest};
@@ -282,27 +282,35 @@ impl AppBundle {
             server_assets: Default::default(),
         };
 
-        tracing::debug!("Assembling app bundle");
-
-        bundle.build.status_start_bundle();
-        bundle
-            .write_main_executable()
-            .await
-            .context("Failed to write main executable")?;
-        bundle.write_server_executable().await?;
-        bundle
-            .write_assets()
-            .await
-            .context("Failed to write assets")?;
-        bundle.write_metadata().await?;
-        bundle.optimize().await?;
-        bundle.pre_render_ssg_routes().await?;
-        bundle
-            .assemble()
-            .await
-            .context("Failed to assemble app bundle")?;
-
-        tracing::debug!("Bundle created at {}", bundle.build.root_dir().display());
+        match bundle.build.mode {
+            BuildMode::Base | BuildMode::Fat => {
+                tracing::debug!("Assembling app bundle");
+
+                bundle.build.status_start_bundle();
+                bundle
+                    .write_main_executable()
+                    .await
+                    .context("Failed to write main executable")?;
+                bundle.write_server_executable().await?;
+                bundle
+                    .write_assets()
+                    .await
+                    .context("Failed to write assets")?;
+                bundle.write_metadata().await?;
+                bundle.optimize().await?;
+                bundle.pre_render_ssg_routes().await?;
+                bundle
+                    .assemble()
+                    .await
+                    .context("Failed to assemble app bundle")?;
+
+                tracing::debug!("Bundle created at {}", bundle.build.root_dir().display());
+            }
+            BuildMode::Thin { .. } => {
+                tracing::debug!("Patching existing bundle");
+                bundle.write_patch().await?;
+            }
+        }
 
         Ok(bundle)
     }
@@ -533,6 +541,10 @@ impl AppBundle {
         Ok(())
     }
 
+    async fn write_patch(&self) -> Result<()> {
+        Ok(())
+    }
+
     /// The item that we'll try to run directly if we need to.
     ///
     /// todo(jon): we should name the app properly instead of making up the exe name. It's kinda okay for dev mode, but def not okay for prod

packages/cli/src/build/request.rs

@@ -43,7 +43,7 @@ pub enum BuildMode {
     Fat,
 
     /// A "thin" build generated with `rustc` directly and dx as a custom linker
-    Thin,
+    Thin { direct_rustc: Vec<Vec<String>> },
 }
 
 pub struct CargoBuildResult {
@@ -86,17 +86,7 @@ impl BuildRequest {
             false => (self.cargo_build().await?, self.build_server().await?),
         };
 
-        // let mut app_bundle = AppBundle::new {
-        //     app,
-        //     server,
-        //     build: self,
-        //     assets: Default::default(),
-        //     server_assets: Default::default(),
-        // };
-
-        // Ok(app_bundle)
-
-        todo!()
+        AppBundle::new(self, app, server).await
     }
 
     pub(crate) async fn build_server(&self) -> Result<Option<BuildArtifacts>> {
@@ -367,7 +357,7 @@ impl BuildRequest {
         }
 
         match self.mode {
-            BuildMode::Fat | BuildMode::Thin => cargo_args.push(format!(
+            BuildMode::Fat | BuildMode::Thin { .. } => cargo_args.push(format!(
                 "-Clinker={}",
                 dunce::canonicalize(std::env::current_exe().unwrap())
                     .unwrap()
@@ -586,7 +576,7 @@ impl BuildRequest {
                 }
                 .to_json(),
             )),
-            BuildMode::Thin => env_vars.push((
+            BuildMode::Thin { .. } => env_vars.push((
                 LinkAction::ENV_VAR_NAME,
                 LinkAction::ThinLink {
                     platform: self.build.platform(),

packages/cli/src/cli/run.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::{serve::ServeUpdate, BuildArgs, Builder, DioxusCrate, Platform, Result};
+use crate::{serve::HandleUpdate, BuildArgs, Builder, DioxusCrate, Platform, Result};
 
 /// Run the project with the given arguments
 #[derive(Clone, Debug, Parser)]
@@ -38,28 +38,18 @@ impl RunArgs {
         // Run the app, but mostly ignore all the other messages
         // They won't generally be emitted
         loop {
-            match runner.wait().await {
-                ServeUpdate::StderrReceived { platform, msg } => {
+            match runner.running.as_mut().unwrap().wait().await {
+                HandleUpdate::StderrReceived { platform, msg } => {
                     tracing::info!("[{platform}]: {msg}")
                 }
-                ServeUpdate::StdoutReceived { platform, msg } => {
+                HandleUpdate::StdoutReceived { platform, msg } => {
                     tracing::info!("[{platform}]: {msg}")
                 }
-                ServeUpdate::ProcessExited { platform, status } => {
+                HandleUpdate::ProcessExited { platform, status } => {
                     runner.cleanup().await;
                     tracing::info!("[{platform}]: process exited with status: {status:?}");
                     break;
                 }
-                ServeUpdate::BuildUpdate { .. } => {}
-                ServeUpdate::TracingLog { .. } => {}
-                ServeUpdate::Exit { .. } => break,
-                ServeUpdate::NewConnection => {}
-                ServeUpdate::WsMessage(_) => {}
-                ServeUpdate::FilesChanged { .. } => {}
-                ServeUpdate::RequestRebuild => {}
-                ServeUpdate::Redraw => {}
-                ServeUpdate::OpenApp => {}
-                ServeUpdate::ToggleShouldRebuild => {}
             }
         }
 

packages/cli/src/serve/handle.rs

@@ -1,10 +1,11 @@
 use crate::{AppBundle, DioxusCrate, Platform, Result};
 use anyhow::Context;
 use dioxus_cli_opt::process_file_to;
+use futures_util::future::OptionFuture;
 use std::{
     net::SocketAddr,
     path::{Path, PathBuf},
-    process::Stdio,
+    process::{ExitStatus, Stdio},
 };
 use tokio::{
     io::{AsyncBufReadExt, BufReader, Lines},
@@ -48,6 +49,25 @@ pub(crate) struct AppHandle {
     pub(crate) runtime_asst_dir: Option<PathBuf>,
 }
 
+pub enum HandleUpdate {
+    /// A running process has received a stdout.
+    /// May or may not be a complete line - do not treat it as a line. It will include a line if it is a complete line.
+    ///
+    /// We will poll lines and any content in a 50ms interval
+    StdoutReceived { platform: Platform, msg: String },
+
+    /// A running process has received a stderr.
+    /// May or may not be a complete line - do not treat it as a line. It will include a line if it is a complete line.
+    ///
+    /// We will poll lines and any content in a 50ms interval
+    StderrReceived { platform: Platform, msg: String },
+
+    ProcessExited {
+        platform: Platform,
+        status: ExitStatus,
+    },
+}
+
 impl AppHandle {
     pub async fn new(app: AppBundle) -> Result<Self> {
         Ok(AppHandle {
@@ -64,6 +84,44 @@ impl AppHandle {
         })
     }
 
+    pub(crate) async fn wait(&mut self) -> HandleUpdate {
+        let platform = self.app.build.build.platform();
+        use HandleUpdate::*;
+        tokio::select! {
+            Some(Ok(Some(msg))) = OptionFuture::from(self.app_stdout.as_mut().map(|f| f.next_line())) => {
+                StdoutReceived { platform, msg }
+            },
+            Some(Ok(Some(msg))) = OptionFuture::from(self.app_stderr.as_mut().map(|f| f.next_line())) => {
+                StderrReceived { platform, msg }
+            },
+            Some(status) = OptionFuture::from(self.app_child.as_mut().map(|f| f.wait())) => {
+                match status {
+                    Ok(status) => {
+                        self.app_child = None;
+                        ProcessExited { status, platform }
+                    },
+                    Err(_err) => todo!("handle error in process joining?"),
+                }
+            }
+            Some(Ok(Some(msg))) = OptionFuture::from(self.server_stdout.as_mut().map(|f| f.next_line())) => {
+                StdoutReceived { platform: Platform::Server, msg }
+            },
+            Some(Ok(Some(msg))) = OptionFuture::from(self.server_stderr.as_mut().map(|f| f.next_line())) => {
+                StderrReceived { platform: Platform::Server, msg }
+            },
+            Some(status) = OptionFuture::from(self.server_child.as_mut().map(|f| f.wait())) => {
+                match status {
+                    Ok(status) => {
+                        self.server_child = None;
+                        ProcessExited { status, platform }
+                    },
+                    Err(_err) => todo!("handle error in process joining?"),
+                }
+            }
+            else => futures_util::future::pending().await
+        }
+    }
+
     pub(crate) async fn open(
         &mut self,
         devserver_ip: SocketAddr,

packages/cli/src/serve/mod.rs

@@ -105,12 +105,17 @@ pub(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
                         devserver.send_hotreload(hr).await;
                     }
                     HotReloadKind::Patch => {
-                        builder.patch_rebuild(args.build_arguments.clone());
+                        if let Some(handle) = runner.running.as_ref() {
+                            builder.patch_rebuild(
+                                args.build_arguments.clone(),
+                                handle.app.app.direct_rustc.clone(),
+                            );
 
-                        runner.clear_hot_reload_changes();
-                        runner.clear_cached_rsx();
+                            runner.clear_hot_reload_changes();
+                            runner.clear_cached_rsx();
 
-                        devserver.start_patch().await
+                            devserver.start_patch().await
+                        }
                     }
                     HotReloadKind::Full {} => todo!(),
                 }
@@ -170,9 +175,8 @@ pub(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
                     }
 
                     BuildUpdate::BuildReady { bundle } if bundle.build.is_patch() => {
+                        runner.patch(&bundle).await?;
                         devserver.send_patch(bundle.app.exe.clone()).await;
-                        // if runner.patch(bundle).await.is_ok() {
-                        // }
                     }
 
                     BuildUpdate::BuildReady { bundle } => {
@@ -195,7 +199,7 @@ pub(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
             }
 
             // If the process exited *cleanly*, we can exit
-            ServeUpdate::ProcessExited { status, platform } => {
+            ServeUpdate::HandleUpdate(HandleUpdate::ProcessExited { status, platform }) => {
                 if !status.success() {
                     tracing::error!("Application [{platform}] exited with error: {status}");
                 } else {
@@ -207,11 +211,11 @@ pub(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
                 }
             }
 
-            ServeUpdate::StdoutReceived { platform, msg } => {
+            ServeUpdate::HandleUpdate(HandleUpdate::StdoutReceived { platform, msg }) => {
                 screen.push_stdio(platform, msg, tracing::Level::INFO);
             }
 
-            ServeUpdate::StderrReceived { platform, msg } => {
+            ServeUpdate::HandleUpdate(HandleUpdate::StderrReceived { platform, msg }) => {
                 screen.push_stdio(platform, msg, tracing::Level::ERROR);
             }
 

packages/cli/src/serve/runner.rs

@@ -20,6 +20,7 @@ use syn::spanned::Spanned;
 
 pub(crate) struct AppRunner {
     pub(crate) running: Option<AppHandle>,
+    pub(crate) app: Option<AppBundle>,
     pub(crate) krate: DioxusCrate,
     pub(crate) ignore: Gitignore,
     pub(crate) applied_hot_reload_message: HotReloadMsg,
@@ -45,6 +46,7 @@ impl AppRunner {
     pub(crate) fn start(krate: &DioxusCrate) -> Self {
         let mut runner = Self {
             running: Default::default(),
+            app: Default::default(),
             file_map: Default::default(),
             applied_hot_reload_message: Default::default(),
             ignore: krate.workspace_gitignore(),
@@ -72,39 +74,8 @@ impl AppRunner {
             return futures_util::future::pending().await;
         };
 
-        use ServeUpdate::*;
-        let platform = handle.app.build.build.platform();
         tokio::select! {
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.app_stdout.as_mut().map(|f| f.next_line())) => {
-                StdoutReceived { platform, msg }
-            },
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.app_stderr.as_mut().map(|f| f.next_line())) => {
-                StderrReceived { platform, msg }
-            },
-            Some(status) = OptionFuture::from(handle.app_child.as_mut().map(|f| f.wait())) => {
-                match status {
-                    Ok(status) => {
-                        handle.app_child = None;
-                        ProcessExited { status, platform }
-                    },
-                    Err(_err) => todo!("handle error in process joining?"),
-                }
-            }
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.server_stdout.as_mut().map(|f| f.next_line())) => {
-                StdoutReceived { platform: Platform::Server, msg }
-            },
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.server_stderr.as_mut().map(|f| f.next_line())) => {
-                StderrReceived { platform: Platform::Server, msg }
-            },
-            Some(status) = OptionFuture::from(handle.server_child.as_mut().map(|f| f.wait())) => {
-                match status {
-                    Ok(status) => {
-                        handle.server_child = None;
-                        ProcessExited { status, platform }
-                    },
-                    Err(_err) => todo!("handle error in process joining?"),
-                }
-            }
+            update = handle.wait() => ServeUpdate::HandleUpdate(update),
             else => futures_util::future::pending().await
         }
     }
@@ -456,7 +427,7 @@ impl AppRunner {
         _ = std::fs::create_dir_all(&cache_dir);
     }
 
-    pub async fn patch(&mut self, bundle: AppBundle) -> Result<()> {
+    pub async fn patch(&mut self, bundle: &AppBundle) -> Result<()> {
         let Some(running) = self.running.as_mut() else {
             return Ok(());
         };