wip

Author: jkelleyrtp

packages/cli/src/build/builder.rs

@@ -4,6 +4,8 @@ use crate::{
 };
 use std::time::{Duration, Instant};
 
+use super::BuildMode;
+
 /// The component of the serve engine that watches ongoing builds and manages their state, handle,
 /// and progress.
 ///
@@ -17,6 +19,7 @@ pub(crate) struct Builder {
     pub krate: DioxusCrate,
     pub request: BuildRequest,
     pub build: tokio::task::JoinHandle<Result<AppBundle>>,
+    pub bundle: tokio::task::JoinHandle<Result<AppBundle>>,
     pub tx: ProgressTx,
     pub rx: ProgressRx,
 
@@ -39,7 +42,7 @@ impl Builder {
     /// Create a new builder and immediately start a build
     pub(crate) fn start(krate: &DioxusCrate, args: BuildArgs) -> Result<Self> {
         let (tx, rx) = futures_channel::mpsc::unbounded();
-        let request = BuildRequest::new(krate.clone(), args, tx.clone(), None);
+        let request = BuildRequest::new(krate.clone(), args, tx.clone(), BuildMode::Fat);
 
         Ok(Self {
             krate: krate.clone(),
@@ -52,6 +55,7 @@ impl Builder {
 
                 request.build_all().await
             }),
+            bundle: tokio::spawn(async move { futures_util::future::pending().await }),
             tx,
             rx,
             compiled_crates: 0,
@@ -177,13 +181,26 @@ impl Builder {
         update
     }
 
+    pub(crate) fn patch_rebuild(&mut self, args: BuildArgs) {
+        // 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::Fat);
+        self.request = request.clone();
+        self.stage = BuildStage::Restarting;
+
+        // This build doesn't have any extra special logging - rebuilds would get pretty noisy
+        self.build = tokio::spawn(async move { request.build_all().await });
+    }
+
     /// Restart this builder with new build arguments.
     pub(crate) fn rebuild(&mut self, args: BuildArgs) {
         // 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(), None);
+        let request = BuildRequest::new(self.krate.clone(), args, self.tx.clone(), BuildMode::Fat);
         self.request = request.clone();
         self.stage = BuildStage::Restarting;
 

packages/cli/src/build/bundle.rs

@@ -90,14 +90,16 @@ use tokio::process::Command;
 pub(crate) struct AppBundle {
     pub(crate) build: BuildRequest,
     pub(crate) app: BuildArtifacts,
+    pub(crate) assets: AssetManifest,
     pub(crate) server: Option<BuildArtifacts>,
+    pub(crate) server_assets: Option<AssetManifest>,
 }
 
+/// The result of the `cargo rustc` including any additional metadata
 #[derive(Debug)]
 pub struct BuildArtifacts {
     pub(crate) exe: PathBuf,
     pub(crate) direct_rustc: Vec<Vec<String>>,
-    pub(crate) assets: AssetManifest,
     pub(crate) time_taken: Duration,
 }
 
@@ -265,7 +267,13 @@ impl AppBundle {
         app: BuildArtifacts,
         server: Option<BuildArtifacts>,
     ) -> Result<Self> {
-        let mut bundle = Self { app, server, build };
+        let mut bundle = Self {
+            app,
+            server,
+            build,
+            assets: Default::default(),
+            server_assets: Default::default(),
+        };
 
         tracing::debug!("Assembling app bundle");
 
@@ -292,6 +300,31 @@ impl AppBundle {
         Ok(bundle)
     }
 
+    /// Apply this build as a patch to the given bundle
+    pub(crate) async fn write_patch(&mut self, exe: &Path) -> Result<()> {
+        Ok(())
+    }
+
+    /// Traverse the target directory and collect all assets from the incremental cache
+    ///
+    /// This uses "known paths" that have stayed relatively stable during cargo's lifetime.
+    /// One day this system might break and we might need to go back to using the linker approach.
+    pub(crate) async fn collect_assets(&self, exe: &Path) -> Result<AssetManifest> {
+        tracing::debug!("Collecting assets ...");
+
+        if self.build.build.skip_assets {
+            return Ok(AssetManifest::default());
+        }
+
+        // walk every file in the incremental cache dir, reading and inserting items into the manifest.
+        let mut manifest = AssetManifest::default();
+
+        // And then add from the exe directly, just in case it's LTO compiled and has no incremental cache
+        _ = manifest.add_from_object_path(exe);
+
+        Ok(manifest)
+    }
+
     /// Take the output of rustc and make it into the main exe of the bundle
     ///
     /// For wasm, we'll want to run `wasm-bindgen` to make it a wasm binary along with some other optimizations
@@ -366,7 +399,6 @@ impl AppBundle {
         _ = tokio::fs::create_dir_all(&asset_dir).await;
         // Create a set of all the paths that new files will be bundled to
         let mut keep_bundled_output_paths: HashSet<_> = self
-            .app
             .assets
             .assets
             .values()
@@ -426,7 +458,7 @@ impl AppBundle {
         let mut assets_to_transfer = vec![];
 
         // Queue the bundled assets
-        for (asset, bundled) in &self.app.assets.assets {
+        for (asset, bundled) in &self.assets.assets {
             let from = asset.clone();
             let to = asset_dir.join(bundled.bundled_path());
 
@@ -720,7 +752,6 @@ impl AppBundle {
                 writeln!(
                     glue, "export const __wasm_split_load_chunk_{idx} = makeLoad(\"/assets/{url}\", [], fusedImports);",
                     url = self
-                        .app
                         .assets
                         .register_asset(&path, AssetOptions::Unknown)?.bundled_path(),
                 )?;
@@ -747,7 +778,6 @@ impl AppBundle {
 
                     // Again, register this wasm with the asset system
                     url = self
-                        .app
                         .assets
                         .register_asset(&path, AssetOptions::Unknown)?.bundled_path(),
 
@@ -789,12 +819,11 @@ impl AppBundle {
         }
 
         // Make sure to register the main wasm file with the asset system
-        self.app
-            .assets
+        self.assets
             .register_asset(&post_bindgen_wasm, AssetOptions::Unknown)?;
 
         // Register the main.js with the asset system so it bundles in the snippets and optimizes
-        self.app.assets.register_asset(
+        self.assets.register_asset(
             &self.build.wasm_bindgen_js_output_file(),
             AssetOptions::Js(JsAssetOptions::new().with_minify(true).with_preload(true)),
         )?;

packages/cli/src/build/patch.rs

@@ -31,6 +31,7 @@ pub struct PatchData {
 }
 
 pub async fn attempt_partial_link(
+    work_dir: PathBuf,
     old_cache: PathBuf,
     new_cache: PathBuf,
     proc_main_addr: u64,
@@ -44,7 +45,7 @@ pub async fn attempt_partial_link(
         .new
         .iter()
         .flat_map(|(_, f)| f.file.exports().unwrap())
-        .map(|e| e.name().to_utf8())
+        .map(|e| e.name())
         .collect::<HashSet<_>>();
 
     let mut adrp_imports = HashSet::new();
@@ -89,13 +90,13 @@ pub async fn attempt_partial_link(
             .unwrap();
 
         for i in f.file.imports().unwrap() {
-            if all_exports.contains(i.name().to_utf8()) {
-                adrp_imports.insert(i.name().to_utf8());
+            if all_exports.contains(i.name()) {
+                adrp_imports.insert(i.name());
             }
         }
 
         for e in f.file.exports().unwrap() {
-            satisfied_exports.insert(e.name().to_utf8());
+            satisfied_exports.insert(e.name());
         }
     }
 
@@ -106,7 +107,7 @@ pub async fn attempt_partial_link(
 
     // Assemble the stub
     let stub_data = make_stub_file(proc_main_addr, patch_target, adrp_imports);
-    let stub_file = workspace_dir().join("stub.o");
+    let stub_file = work_dir.join("stub.o");
     std::fs::write(&stub_file, stub_data).unwrap();
 
     let out = Command::new("cc")
@@ -126,7 +127,7 @@ pub async fn attempt_partial_link(
 
     let err = String::from_utf8_lossy(&out.stderr);
     println!("err: {err}");
-    std::fs::write(workspace_dir().join("link_errs_partial.txt"), &*err).unwrap();
+    std::fs::write(work_dir.join("link_errs_partial.txt"), &*err).unwrap();
 
     // // -O0 ? supposedly faster
     // // -reproducible - even better?
@@ -152,11 +153,13 @@ pub async fn attempt_partial_link(
     //     .await?;
 }
 
-fn system_cc(platform: Platform) -> &'static str {
+/// todo: detect if the user specified a custom linker
+fn system_linker(platform: Platform) -> &'static str {
     match platform {
+        // mac + linux use just CC unless the user is trying to use something like mold / lld
         Platform::MacOS => "cc",
-        Platform::Windows => "cc",
         Platform::Linux => "cc",
+        Platform::Windows => "cc",
         Platform::Ios => "cc",
         Platform::Android => "cc",
         Platform::Server => "cc",
@@ -618,33 +621,22 @@ fn compare_masked<'a>(
 
 fn symbol_name_of_relo<'a>(obj: &impl Object<'a>, target: RelocationTarget) -> Option<&'a str> {
     match target {
-        RelocationTarget::Symbol(symbol_index) => Some(
-            obj.symbol_by_index(symbol_index)
-                .unwrap()
-                .name_bytes()
-                .unwrap()
-                .to_utf8(),
-        ),
+        RelocationTarget::Symbol(symbol_index) => obj
+            .symbol_by_index(symbol_index)
+            .unwrap()
+            .name_bytes()
+            .ok()
+            .and_then(|s| std::str::from_utf8(s).ok()),
         RelocationTarget::Section(_) => None,
         RelocationTarget::Absolute => None,
         _ => None,
     }
 }
 
-trait ToUtf8<'a> {
-    fn to_utf8(&self) -> &'a str;
-}
-
-impl<'a> ToUtf8<'a> for &'a [u8] {
-    fn to_utf8(&self) -> &'a str {
-        std::str::from_utf8(self).unwrap()
-    }
-}
-
 fn make_stub_file(
     proc_main_addr: u64,
     patch_target: PathBuf,
-    adrp_imports: HashSet<&str>,
+    adrp_imports: HashSet<&[u8]>,
 ) -> Vec<u8> {
     let data = fs::read(&patch_target).unwrap();
     let old = File::parse(&data as &[u8]).unwrap();
@@ -654,7 +646,7 @@ fn make_stub_file(
         .symbols()
         .filter_map(|sym| {
             adrp_imports
-                .get(sym.name().ok()?)
+                .get(sym.name_bytes().ok()?)
                 .copied()
                 .map(|o| (o, sym.address() + aslr_offset))
         })
@@ -689,7 +681,7 @@ fn build_stub(
     format: BinaryFormat,
     architecture: Architecture,
     endian: Endianness,
-    adrp_imports: HashMap<&str, u64>,
+    adrp_imports: HashMap<&[u8], u64>,
 ) -> Result<Vec<u8>> {
     use object::{
         write::{Object, Symbol, SymbolSection},
@@ -745,7 +737,7 @@ fn build_stub(
         //       _$LT$generational_box..references..GenerationalRef$LT$R$GT$$u20$as$u20$core..fmt..Display$GT$::fmt::h455abb35572b9c11
         // let name = strip_mangled(name);
 
-        let name = if name.starts_with("_") {
+        let name = if name.starts_with(b"_") {
             &name[1..]
         } else {
             name