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,440 @@
+use parking_lot::RwLock;
+use std::any::Any;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+type SendSyncAnyMap = std::collections::HashMap<std::any::TypeId, ContextType>;
+
+/// A shared context for server functions that contains information about the request and middleware state.
+///
+/// You should not construct this directly inside components or server functions. Instead use [`server_context()`] to get the server context from the current request.
+///
+/// # Example
+///
+/// ```rust, no_run
+/// # use dioxus::prelude::*;
+/// #[server]
+/// async fn read_headers() -> Result<(), ServerFnError> {
+///     let server_context = server_context();
+///     let headers: http::HeaderMap = server_context.extract().await?;
+///     println!("{:?}", headers);
+///     Ok(())
+/// }
+/// ```
+#[derive(Clone)]
+pub struct DioxusServerContext {
+    shared_context: Arc<RwLock<SendSyncAnyMap>>,
+    response_parts: Arc<RwLock<http::response::Parts>>,
+    pub(crate) parts: Arc<RwLock<http::request::Parts>>,
+    response_sent: Arc<std::sync::atomic::AtomicBool>,
+}
+
+enum ContextType {
+    Factory(Box<dyn Fn() -> Box<dyn Any> + Send + Sync>),
+    Value(Box<dyn Any + Send + Sync>),
+}
+
+impl ContextType {
+    fn downcast<T: Clone + 'static>(&self) -> Option<T> {
+        match self {
+            ContextType::Value(value) => value.downcast_ref::<T>().cloned(),
+            ContextType::Factory(factory) => factory().downcast::<T>().ok().map(|v| *v),
+        }
+    }
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for DioxusServerContext {
+    fn default() -> Self {
+        Self {
+            shared_context: Arc::new(RwLock::new(HashMap::new())),
+            response_parts: Arc::new(RwLock::new(
+                http::response::Response::new(()).into_parts().0,
+            )),
+            parts: Arc::new(RwLock::new(http::request::Request::new(()).into_parts().0)),
+            response_sent: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+        }
+    }
+}
+
+mod server_fn_impl {
+    use super::*;
+    use parking_lot::{RwLockReadGuard, RwLockWriteGuard};
+    use std::any::{Any, TypeId};
+
+    impl DioxusServerContext {
+        /// Create a new server context from a request
+        pub fn new(parts: http::request::Parts) -> Self {
+            Self {
+                parts: Arc::new(RwLock::new(parts)),
+                shared_context: Arc::new(RwLock::new(SendSyncAnyMap::new())),
+                response_parts: std::sync::Arc::new(RwLock::new(
+                    http::response::Response::new(()).into_parts().0,
+                )),
+                response_sent: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            }
+        }
+
+        /// Create a server context from a shared parts
+        #[allow(unused)]
+        pub(crate) fn from_shared_parts(parts: Arc<RwLock<http::request::Parts>>) -> Self {
+            Self {
+                parts,
+                shared_context: Arc::new(RwLock::new(SendSyncAnyMap::new())),
+                response_parts: std::sync::Arc::new(RwLock::new(
+                    http::response::Response::new(()).into_parts().0,
+                )),
+                response_sent: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            }
+        }
+
+        /// Clone a value from the shared server context. If you are using [`DioxusRouterExt`](crate::prelude::DioxusRouterExt), any values you insert into
+        /// the launch context will also be available in the server context.
+        ///
+        /// Example:
+        /// ```rust, no_run
+        /// use dioxus::prelude::*;
+        ///
+        /// LaunchBuilder::new()
+        ///     // You can provide context to your whole app (including server functions) with the `with_context` method on the launch builder
+        ///     .with_context(server_only! {
+        ///         1234567890u32
+        ///     })
+        ///     .launch(app);
+        ///
+        /// #[server]
+        /// async fn read_context() -> Result<u32, ServerFnError> {
+        ///     // You can extract values from the server context with the `extract` function
+        ///     let FromContext(value) = extract().await?;
+        ///     Ok(value)
+        /// }
+        ///
+        /// fn app() -> Element {
+        ///     let future = use_resource(read_context);
+        ///     rsx! {
+        ///         h1 { "{future:?}" }
+        ///     }
+        /// }
+        /// ```
+        pub fn get<T: Any + Send + Sync + Clone + 'static>(&self) -> Option<T> {
+            self.shared_context
+                .read()
+                .get(&TypeId::of::<T>())
+                .map(|v| v.downcast::<T>().unwrap())
+        }
+
+        /// Insert a value into the shared server context
+        pub fn insert<T: Any + Send + Sync + 'static>(&self, value: T) {
+            self.insert_any(Box::new(value));
+        }
+
+        /// Insert a boxed `Any` value into the shared server context
+        pub fn insert_any(&self, value: Box<dyn Any + Send + Sync + 'static>) {
+            self.shared_context
+                .write()
+                .insert((*value).type_id(), ContextType::Value(value));
+        }
+
+        /// Insert a factory that creates a non-sync value for the shared server context
+        pub fn insert_factory<F, T>(&self, value: F)
+        where
+            F: Fn() -> T + Send + Sync + 'static,
+            T: 'static,
+        {
+            self.shared_context.write().insert(
+                TypeId::of::<T>(),
+                ContextType::Factory(Box::new(move || Box::new(value()))),
+            );
+        }
+
+        /// Insert a boxed factory that creates a non-sync value for the shared server context
+        pub fn insert_boxed_factory(&self, value: Box<dyn Fn() -> Box<dyn Any> + Send + Sync>) {
+            self.shared_context
+                .write()
+                .insert((*value()).type_id(), ContextType::Factory(value));
+        }
+
+        /// Get the response parts from the server context
+        ///
+        #[doc = include_str!("../docs/request_origin.md")]
+        ///
+        /// # Example
+        ///
+        /// ```rust, no_run
+        /// # use dioxus::prelude::*;
+        /// #[server]
+        /// async fn set_headers() -> Result<(), ServerFnError> {
+        ///     let server_context = server_context();
+        ///     let response_parts = server_context.response_parts();
+        ///     let cookies = response_parts
+        ///         .headers
+        ///         .get("Cookie")
+        ///         .ok_or_else(|| ServerFnError::new("failed to find Cookie header in the response"))?;
+        ///     println!("{:?}", cookies);
+        ///     Ok(())
+        /// }
+        /// ```
+        pub fn response_parts(&self) -> RwLockReadGuard<'_, http::response::Parts> {
+            self.response_parts.read()
+        }
+
+        /// Get the response parts from the server context
+        ///
+        #[doc = include_str!("../docs/request_origin.md")]
+        ///
+        /// # Example
+        ///
+        /// ```rust, no_run
+        /// # use dioxus::prelude::*;
+        /// #[server]
+        /// async fn set_headers() -> Result<(), ServerFnError> {
+        ///     let server_context = server_context();
+        ///     server_context.response_parts_mut()
+        ///         .headers
+        ///         .insert("Cookie", http::HeaderValue::from_static("dioxus=fullstack"));
+        ///     Ok(())
+        /// }
+        /// ```
+        pub fn response_parts_mut(&self) -> RwLockWriteGuard<'_, http::response::Parts> {
+            if self
+                .response_sent
+                .load(std::sync::atomic::Ordering::Relaxed)
+            {
+                tracing::error!("Attempted to modify the request after the first frame of the response has already been sent. \
+                You can read the response, but modifying the response will not change the response that the client has already received. \
+                Try modifying the response before the suspense boundary above the router is resolved.");
+            }
+            self.response_parts.write()
+        }
+
+        /// Get the request parts
+        ///
+        #[doc = include_str!("../docs/request_origin.md")]
+        ///
+        /// # Example
+        ///
+        /// ```rust, no_run
+        /// # use dioxus::prelude::*;
+        /// #[server]
+        /// async fn read_headers() -> Result<(), ServerFnError> {
+        ///     let server_context = server_context();
+        ///     let request_parts = server_context.request_parts();
+        ///     let id: &i32 = request_parts
+        ///         .extensions
+        ///         .get()
+        ///         .ok_or_else(|| ServerFnError::new("failed to find i32 extension in the request"))?;
+        ///     println!("{:?}", id);
+        ///     Ok(())
+        /// }
+        /// ```
+        pub fn request_parts(&self) -> parking_lot::RwLockReadGuard<'_, http::request::Parts> {
+            self.parts.read()
+        }
+
+        /// Get the request parts mutably
+        ///
+        #[doc = include_str!("../docs/request_origin.md")]
+        ///
+        /// # Example
+        ///
+        /// ```rust, no_run
+        /// # use dioxus::prelude::*;
+        /// #[server]
+        /// async fn read_headers() -> Result<(), ServerFnError> {
+        ///     let server_context = server_context();
+        ///     let id: i32 = server_context.request_parts_mut()
+        ///         .extensions
+        ///         .remove()
+        ///         .ok_or_else(|| ServerFnError::new("failed to find i32 extension in the request"))?;
+        ///     println!("{:?}", id);
+        ///     Ok(())
+        /// }
+        /// ```
+        pub fn request_parts_mut(&self) -> parking_lot::RwLockWriteGuard<'_, http::request::Parts> {
+            self.parts.write()
+        }
+
+        /// Extract part of the request.
+        ///
+        #[doc = include_str!("../docs/request_origin.md")]
+        ///
+        /// # Example
+        ///
+        /// ```rust, no_run
+        /// # use dioxus::prelude::*;
+        /// #[server]
+        /// async fn read_headers() -> Result<(), ServerFnError> {
+        ///     let server_context = server_context();
+        ///     let headers: http::HeaderMap = server_context.extract().await?;
+        ///     println!("{:?}", headers);
+        ///     Ok(())
+        /// }
+        /// ```
+        pub async fn extract<M, T: FromServerContext<M>>(&self) -> Result<T, T::Rejection> {
+            T::from_request(self).await
+        }
+
+        /// Copy the response parts to a response and mark this server context as sent
+        pub(crate) fn send_response<B>(&self, response: &mut http::response::Response<B>) {
+            self.response_sent
+                .store(true, std::sync::atomic::Ordering::Relaxed);
+            let parts = self.response_parts.read();
+
+            let mut_headers = response.headers_mut();
+            for (key, value) in parts.headers.iter() {
+                mut_headers.insert(key, value.clone());
+            }
+            *response.status_mut() = parts.status;
+            *response.version_mut() = parts.version;
+            response.extensions_mut().extend(parts.extensions.clone());
+        }
+    }
+}
+
+#[test]
+fn server_context_as_any_map() {
+    let parts = http::Request::new(()).into_parts().0;
+    let server_context = DioxusServerContext::new(parts);
+    server_context.insert_boxed_factory(Box::new(|| Box::new(1234u32)));
+    assert_eq!(server_context.get::<u32>().unwrap(), 1234u32);
+}
+
+std::thread_local! {
+    pub(crate) static SERVER_CONTEXT: std::cell::RefCell<Box<DioxusServerContext>> = Default::default();
+}
+
+/// Get information about the current server request.
+///
+/// This function will only provide the current server context if it is called from a server function or on the server rendering a request.
+pub fn server_context() -> DioxusServerContext {
+    SERVER_CONTEXT.with(|ctx| *ctx.borrow().clone())
+}
+
+/// Extract some part from the current server request.
+///
+/// This function will only provide the current server context if it is called from a server function or on the server rendering a request.
+pub async fn extract<E: FromServerContext<I>, I>() -> Result<E, E::Rejection> {
+    E::from_request(&server_context()).await
+}
+
+/// Run a function inside of the server context.
+pub fn with_server_context<O>(context: DioxusServerContext, f: impl FnOnce() -> O) -> O {
+    // before polling the future, we need to set the context
+    let prev_context = SERVER_CONTEXT.with(|ctx| ctx.replace(Box::new(context)));
+    // poll the future, which may call server_context()
+    let result = f();
+    // after polling the future, we need to restore the context
+    SERVER_CONTEXT.with(|ctx| ctx.replace(prev_context));
+    result
+}
+
+/// A future that provides the server context to the inner future
+#[pin_project::pin_project]
+pub struct ProvideServerContext<F: std::future::Future> {
+    context: DioxusServerContext,
+    #[pin]
+    f: F,
+}
+
+impl<F: std::future::Future> ProvideServerContext<F> {
+    /// Create a new future that provides the server context to the inner future
+    pub fn new(f: F, context: DioxusServerContext) -> Self {
+        Self { f, context }
+    }
+}
+
+impl<F: std::future::Future> std::future::Future for ProvideServerContext<F> {
+    type Output = F::Output;
+
+    fn poll(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Self::Output> {
+        let this = self.project();
+        let context = this.context.clone();
+        with_server_context(context, || this.f.poll(cx))
+    }
+}
+
+/// A trait for extracting types from the server context
+#[async_trait::async_trait]
+pub trait FromServerContext<I = ()>: Sized {
+    /// The error type returned when extraction fails. This type must implement `std::error::Error`.
+    type Rejection;
+
+    /// Extract this type from the server context.
+    async fn from_request(req: &DioxusServerContext) -> Result<Self, Self::Rejection>;
+}
+
+/// A type was not found in the server context
+pub struct NotFoundInServerContext<T: 'static>(std::marker::PhantomData<T>);
+
+impl<T: 'static> std::fmt::Debug for NotFoundInServerContext<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let type_name = std::any::type_name::<T>();
+        write!(f, "`{type_name}` not found in server context")
+    }
+}
+
+impl<T: 'static> std::fmt::Display for NotFoundInServerContext<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let type_name = std::any::type_name::<T>();
+        write!(f, "`{type_name}` not found in server context")
+    }
+}
+
+impl<T: 'static> std::error::Error for NotFoundInServerContext<T> {}
+
+/// Extract a value from the server context provided through the launch builder context or [`DioxusServerContext::insert`]
+///
+/// Example:
+/// ```rust, no_run
+/// use dioxus::prelude::*;
+///
+/// dioxus::LaunchBuilder::new()
+///     // You can provide context to your whole app (including server functions) with the `with_context` method on the launch builder
+///     .with_context(server_only! {
+///         1234567890u32
+///     })
+///     .launch(app);
+///
+/// #[server]
+/// async fn read_context() -> Result<u32, ServerFnError> {
+///     // You can extract values from the server context with the `extract` function
+///     let FromContext(value) = extract().await?;
+///     Ok(value)
+/// }
+///
+/// fn app() -> Element {
+///     let future = use_resource(read_context);
+///     rsx! {
+///         h1 { "{future:?}" }
+///     }
+/// }
+/// ```
+pub struct FromContext<T: std::marker::Send + std::marker::Sync + Clone + 'static>(pub T);
+
+#[async_trait::async_trait]
+impl<T: Send + Sync + Clone + 'static> FromServerContext for FromContext<T> {
+    type Rejection = NotFoundInServerContext<T>;
+
+    async fn from_request(req: &DioxusServerContext) -> Result<Self, Self::Rejection> {
+        Ok(Self(req.get::<T>().ok_or({
+            NotFoundInServerContext::<T>(std::marker::PhantomData::<T>)
+        })?))
+    }
+}
+
+/// An adapter for axum extractors for the server context
+pub struct Axum;
+
+#[async_trait::async_trait]
+impl<I: axum::extract::FromRequestParts<()>> FromServerContext<Axum> for I {
+    type Rejection = I::Rejection;
+
+    #[allow(clippy::all)]
+    async fn from_request(req: &DioxusServerContext) -> Result<Self, Self::Rejection> {
+        let mut lock = req.request_parts_mut();
+        I::from_request_parts(&mut lock, &()).await
+    }
+}