Binary patching rust hot-reloading, sub-second rebuilds, independent server/client hot-reload (#3797)

Enable runtime rust hot patching. * roll back wry to 0.45 * cleanup rustc * wip * wip: fix client/server * get the subsecond cli thing working again * back to list of builds but with accessors * migrate some methods to workspace, clean up impl a bit * pass mode through build context * use a build context, similar to cargo/rustc * merge BuildUpdate and HandleUpdate into BuilderUpdate * Move more resolution of args into runner * migrate some methods to runner * hoist out fullstack * fix build request resolver * yay request is cleaned up * fixup resolution a bit * spawn off the build! * re-wire android autodetection * re-wire android autodetection * wire back up a few more things * re-wire tooling verification * I think it's mostly in the right condition for regular app * add depinfo parser * yay okay works with regular apps again * full rebuilds are back * rewire file wtcher * wire patch! * yayyyyyy patching works and is really fast * yay android works * clean up stdout piping * yayyy memap on android so we don't need root * create a static wasm jump table * wip: global offset table for wasm * wip... thinking about making the patches relocatable * wip: customized relocation * YESSSSSS RELOCATABLE WASM * clean up impl a bit * lil bit more cleanup * lil bit more * lil bit more cleanup * lil bit more cleanup, support 32 bit platforms * sick, wasm is completely pic * hmmmm not quite working yet * woooo, patches loading from rust+wasm * integrated into the cli 😎 * condense a bit * cleaned up request a bit * bust fingerprints * Make the file diffing logic a bit more sensible * still working through a few issues, server launches but is acting weird * fix merge conflict * more merge issues * remove stuff we don't want anymore * revert name change * wip: server not working anymore :( * split apart "dioxus fullstack" into "dioxus server" and "dioxus web" * fixup a few more compile errors * grrr opening server * simultaneous frontend and backend patching * use rustc wrapper * wip: passing assets to jumptable * migrate project-like examples * patchy patchy server fns! * rollback some random changes * unwind the js files * rollback hash * no need for patch * more cleanups * lil bit more cleanup, remove some old cruft * allow patching when wasm webpage is closed * tiny bit more robust * lil bit of clean up * clean up ws code * bit more clean ups * condense * undo file moves * move back other project * move other project * migrate out harness and janky CLI * fix compile * anonymize some files, heavily document others * lots more documentation, for posterity! * ton more docs * clean up the cli a bit more * more ws cleanup * more cleanup * migrate build id to cli-config * add command file handling * random small cleanups * wip.... * wip.... * fix: use workspace for krate discovery * fix panic logging on serve by placing it *after* the logs * reorder logging to be sensible on success * bring back swc * ws cruft * small patches to relocs in loader * bump krates * hoist main funcs into the ifunc table, fixing wasm * fix tui output for long lines * add more linker logging * wow, incredible, we build fat binaries, holy heckkkkk * fix args for frontend/backend * small cleanups * properly send along build IDs to clients * fix workspace compiles * clean up jump table work a bit * clean up logging a bit * open existing * fixup some commands * open existing browser integration * wire up the new dx serve client/server syntax * fixup `dx run` command * bring back some old functionality * fix serverfn feature sets * remove toast animation and simplify its code a bit * less intrusive toast * dont change build status when patching on web * add proper cache busting to vcomponent * clean up the patch file a bit * more lints/checks cleaned up * go back to TargetArgs but a BuildTargets resolved struct * clean up more nits * use an atomicptr for jumptable * fix interaction with initial web load + suspense * don't run asset system on wasm/bindgen js in dev * reduce blast radius of PR * use profile to determine if we're in release * cleanup prod html template * cleanup profiles * fix feature resolution of fullstack * if fullstack is explicitly false, don't use it * light cleanups * drop carg config2 * pass along linker args properly * make workspace examples compile with dx again * fewer unwraps and better error loggign * bit more error handlign * small cleanup * drive-by cleanups * use queries instead of initialize for aslr stuff * fix hotpatch with higher opt level * fix aslr bug from multiple clients * fix merge conflict * fix typos * clippy * fix miscompile * fix doctest * properly rollback wry to 0.45 * fix markdown path issues, other test issues * fix test in router * fix release mode test * fix some more tests, clean up a few more items * use fnptr instead of typeid * clean up memozation via subsecond in core * use "main" as sentinel * fix imports and re-exports * get off __rust_alloc for aslr offset detection * wip * wip... fixing unoptimized web * hmmmm mmmm * close,ish, still missing the wasmbindgen dynaimc imports * aha! full wasm works now - disable externref when compilng patch modules - manually link wasm instrinsics - displace the __wbindgen_placeholder__ table with the synthesized wbg imports what an awful pain. There might be a few items missing, so will test against the docsite shortly * remove failing test * hmmmm things aren't perfect * from what I can tell, relocatable wasm just doesn't work with wasm-bindgen sad https://github.com/rustwasm/wasm-bindgen/issues/1420 * AI IS LITERALLY THE WORST * preserve wasm snippets across compiles * IT HOTPATCHES THE DOCSITE, WE ARE LIVING IN THE FUTURE * remove the macos cfg-out * fix: need to allocate 1 more page * fix url issue * properly span props * properly fill in extra symbols * light cleanups and good docs * delete cruft, better docs * More cleanups and simplifications * clippy, typos * remove harnesses * wasm-bindgen error logging * clean up deps * remove cruft * proper priv/pub * use ifuncs for all env imports * cruft * use par_iter, better output * implement a cache for the base module * delete custom sections * cache the main native module too * add par iter in a few more places * clippy, map ident * better logging and status bars * wip: some small windows support * wip more windowss * fix weird regression * implement windows jump table * small fixes for windows * better windows support * windows support pt2 * rust lld is not msvc * whole archive the rlibs * ignore windows and sys crates * logging * ohhhhhh, pop out dlls * dedupe * thANK GOD FAT LINKING WORKS ON WINDOWS * hoist caching * implement patch based on cache * fix location for pdb * pass data symbols, correct object * add all symbol for windows * add log * treat none rva as undefined * whoops * handle windows calling convention * dont use relocated arm64 stub windows * not all are text? * WINDOWS FUNCTION PATCHING WORKS but issue with statics? * use our own entry * handle windows imp symbols * add log * jump to the real symbol not the layout * whoops * hotpatching windows works completely holy heck yay * drop linker args crate * disable ssg playwright for now * light cleanups * some cleanups / preps: - bump to serverfn 0.8.2 - fix playwright test - fix clippy * use fix from #4042 * bring in other fix for liveview * hoist some configuration * use __aslr_reference instead of aslr_reference * add better errors to patcherror * fix android * panic if patching fails * clean up tomls * wip: fixing wasm compile for server * fullstack wasm again * fix cfg * fixup feature detection * fix issue with features * fix playwright! * add barebones template test harness * fix compatibility between the two hotreload engines * fix preldue of server * fix check for wasm-opt * small fixes
2025-05-06 23:08:59 -07:00
1 parent 71d85e6dd5
commit d976ca184a
@@ -0,0 +1,283 @@
+//! A launch function that creates an axum router for the LaunchBuilder
+
+use crate::{
+    collect_raw_server_fns, render_handler, server::DioxusRouterExt, RenderHandleState, SSRState,
+    ServeConfig, ServeConfigBuilder,
+};
+use axum::{
+    body::Body,
+    extract::{Request, State},
+    response::IntoResponse,
+    routing::IntoMakeService,
+};
+use dioxus_cli_config::base_path;
+use dioxus_devtools::DevserverMsg;
+use dioxus_lib::prelude::*;
+use futures_util::{stream::FusedStream, StreamExt};
+use hyper::body::Incoming;
+use hyper_util::server::conn::auto::Builder as HyperBuilder;
+use hyper_util::{
+    rt::{TokioExecutor, TokioIo},
+    service::TowerToHyperService,
+};
+use std::{any::Any, collections::HashMap, net::SocketAddr};
+use tokio::net::TcpStream;
+use tokio_util::task::LocalPoolHandle;
+use tower::Service;
+use tower::ServiceExt as _;
+
+type ContextList = Vec<Box<dyn Fn() -> Box<dyn Any> + Send + Sync>>;
+
+type BaseComp = fn() -> Element;
+
+/// Launch a fullstack app with the given root component, contexts, and config.
+#[allow(unused)]
+pub fn launch(root: BaseComp, contexts: ContextList, platform_config: Vec<Box<dyn Any>>) -> ! {
+    #[cfg(not(target_arch = "wasm32"))]
+    tokio::runtime::Runtime::new()
+        .unwrap()
+        .block_on(async move {
+            serve_server(root, contexts, platform_config).await;
+        });
+
+    unreachable!("Launching a fullstack app should never return")
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+async fn serve_server(
+    original_root: fn() -> Result<VNode, RenderError>,
+    contexts: Vec<Box<dyn Fn() -> Box<dyn Any> + Send + Sync>>,
+    platform_config: Vec<Box<dyn Any>>,
+) {
+    let (devtools_tx, mut devtools_rx) = futures_channel::mpsc::unbounded();
+
+    if let Some(endpoint) = dioxus_cli_config::devserver_ws_endpoint() {
+        dioxus_devtools::connect(endpoint, move |msg| {
+            _ = devtools_tx.unbounded_send(msg);
+        })
+    }
+
+    let platform_config = platform_config
+        .into_iter()
+        .find_map(|cfg| {
+            cfg.downcast::<ServeConfig>()
+                .map(|cfg| Result::Ok(*cfg))
+                .or_else(|cfg| {
+                    cfg.downcast::<ServeConfigBuilder>()
+                        .map(|builder| builder.build())
+                })
+                .ok()
+        })
+        .unwrap_or_else(ServeConfig::new);
+
+    // Extend the config's context providers with the context providers from the launch builder
+    let cfg = platform_config
+        .map(|mut cfg| {
+            let mut contexts = contexts;
+            let cfg_context_providers = cfg.context_providers.clone();
+            for i in 0..cfg_context_providers.len() {
+                contexts.push(Box::new({
+                    let cfg_context_providers = cfg_context_providers.clone();
+                    move || (cfg_context_providers[i])()
+                }));
+            }
+            cfg.context_providers = std::sync::Arc::new(contexts);
+            cfg
+        })
+        .unwrap();
+
+    // Get the address the server should run on. If the CLI is running, the CLI proxies fullstack into the main address
+    // and we use the generated address the CLI gives us
+    let address = dioxus_cli_config::fullstack_address_or_localhost();
+
+    // Create the router and register the server functions under the basepath.
+    let router = apply_base_path(
+        axum::Router::new().serve_dioxus_application(cfg.clone(), original_root),
+        original_root,
+        cfg.clone(),
+        base_path().map(|s| s.to_string()),
+    );
+
+    let task_pool = LocalPoolHandle::new(5);
+    let mut make_service = router.into_make_service();
+
+    let listener = tokio::net::TcpListener::bind(address).await.unwrap();
+
+    tracing::trace!("Listening on {address}");
+
+    enum Msg {
+        TcpStream(std::io::Result<(TcpStream, SocketAddr)>),
+        Devtools(DevserverMsg),
+    }
+
+    let (shutdown_tx, shutdown_rx) = tokio::sync::watch::channel(0);
+    let mut hr_idx = 0;
+
+    // Manually loop on accepting connections so we can also respond to devtools messages
+    loop {
+        let res = tokio::select! {
+            res = listener.accept() => Msg::TcpStream(res),
+            msg = devtools_rx.next(), if !devtools_rx.is_terminated() => {
+                if let Some(msg) = msg {
+                    Msg::Devtools(msg)
+                } else {
+                    continue;
+                }
+            }
+        };
+
+        match res {
+            // We need to delete our old router and build a new one
+            //
+            // one challenge is that the server functions are sitting in the dlopened lib and no longer
+            // accessible by us (the original process)
+            //
+            // We need to somehow get them out... ?
+            //
+            // for now we just support editing existing server functions
+            Msg::Devtools(devserver_msg) => {
+                match devserver_msg {
+                    DevserverMsg::HotReload(hot_reload_msg) => {
+                        if hot_reload_msg.for_build_id == Some(dioxus_cli_config::build_id()) {
+                            if let Some(table) = hot_reload_msg.jump_table {
+                                unsafe { dioxus_devtools::subsecond::apply_patch(table).unwrap() };
+
+                                let mut new_router = axum::Router::new().serve_static_assets();
+                                let new_cfg = ServeConfig::new().unwrap();
+
+                                let server_fn_iter = collect_raw_server_fns();
+
+                                // de-duplicate iteratively by preferring the most recent (first, since it's linked)
+                                let mut server_fn_map: HashMap<_, _> = HashMap::new();
+                                for f in server_fn_iter.into_iter().rev() {
+                                    server_fn_map.insert(f.path(), f);
+                                }
+
+                                for (_, fn_) in server_fn_map {
+                                    tracing::trace!(
+                                        "Registering server function: {:?} {:?}",
+                                        fn_.path(),
+                                        fn_.method()
+                                    );
+                                    new_router = crate::register_server_fn_on_router(
+                                        fn_,
+                                        new_router,
+                                        new_cfg.context_providers.clone(),
+                                    );
+                                }
+
+                                let hot_root = subsecond::HotFn::current(original_root);
+                                let new_root_addr = hot_root.ptr_address() as usize as *const ();
+                                let new_root = unsafe {
+                                    std::mem::transmute::<*const (), fn() -> Element>(new_root_addr)
+                                };
+
+                                crate::document::reset_renderer();
+
+                                let state = RenderHandleState::new(new_cfg.clone(), new_root)
+                                    .with_ssr_state(SSRState::new(&new_cfg));
+
+                                let fallback_handler =
+                                    axum::routing::get(render_handler).with_state(state);
+
+                                make_service = apply_base_path(
+                                    new_router.fallback(fallback_handler),
+                                    new_root,
+                                    new_cfg.clone(),
+                                    base_path().map(|s| s.to_string()),
+                                )
+                                .into_make_service();
+
+                                shutdown_tx.send_modify(|i| {
+                                    *i += 1;
+                                    hr_idx += 1;
+                                });
+                            }
+                        }
+                    }
+                    DevserverMsg::FullReloadStart => {}
+                    DevserverMsg::FullReloadFailed => {}
+                    DevserverMsg::FullReloadCommand => {}
+                    DevserverMsg::Shutdown => {}
+                    _ => {}
+                }
+            }
+            Msg::TcpStream(Ok((tcp_stream, _remote_addr))) => {
+                let this_hr_index = hr_idx;
+                let mut make_service = make_service.clone();
+                let mut shutdown_rx = shutdown_rx.clone();
+                task_pool.spawn_pinned(move || async move {
+                    let tcp_stream = TokioIo::new(tcp_stream);
+
+                    std::future::poll_fn(|cx| {
+                        <IntoMakeService<axum::Router> as tower::Service<Request>>::poll_ready(
+                            &mut make_service,
+                            cx,
+                        )
+                    })
+                    .await
+                    .unwrap_or_else(|err| match err {});
+
+                    let tower_service = make_service
+                        .call(())
+                        .await
+                        .unwrap_or_else(|err| match err {})
+                        .map_request(|req: Request<Incoming>| req.map(Body::new));
+
+                    // upgrades needed for websockets
+                    let builder = HyperBuilder::new(TokioExecutor::new());
+                    let connection = builder.serve_connection_with_upgrades(
+                        tcp_stream,
+                        TowerToHyperService::new(tower_service),
+                    );
+
+                    tokio::select! {
+                        res = connection => {
+                            if let Err(_err) = res {
+                                // This error only appears when the client doesn't send a request and
+                                // terminate the connection.
+                                //
+                                // If client sends one request then terminate connection whenever, it doesn't
+                                // appear.
+                            }
+                        }
+                        _res = shutdown_rx.wait_for(|i| *i == this_hr_index + 1) => {}
+                    }
+                });
+            }
+            Msg::TcpStream(Err(_)) => {}
+        }
+    }
+}
+
+fn apply_base_path(
+    mut router: axum::Router,
+    root: fn() -> Result<VNode, RenderError>,
+    cfg: ServeConfig,
+    base_path: Option<String>,
+) -> axum::Router {
+    if let Some(base_path) = base_path {
+        let base_path = base_path.trim_matches('/');
+        // If there is a base path, nest the router under it and serve the root route manually
+        // Nesting a route in axum only serves /base_path or /base_path/ not both
+        router = axum::Router::new().nest(&format!("/{base_path}/"), router);
+
+        async fn root_render_handler(
+            state: State<RenderHandleState>,
+            mut request: Request<Body>,
+        ) -> impl IntoResponse {
+            // The root of the base path always looks like the root from dioxus fullstack
+            *request.uri_mut() = "/".parse().unwrap();
+            render_handler(state, request).await
+        }
+
+        let ssr_state = SSRState::new(&cfg);
+        router = router.route(
+            &format!("/{base_path}"),
+            axum::routing::method_routing::get(root_render_handler)
+                .with_state(RenderHandleState::new(cfg, root).with_ssr_state(ssr_state)),
+        )
+    }
+
+    router
+}