How to wire a global “graceful shutdown” in Dioxus Desktop 0.6 without startup crashes?

[Masorubka1]

Hi! I’m wiring a global graceful shutdown for a Dioxus Desktop (0.6.x) app:

• intercept window CloseRequested
• also handle Ctrl+C / SIGTERM
• show “shutting down…” in UI
• run async cleanup
• then exit the process

I use a Shutdown context with a CancellationToken and a Signal<bool> to flip the UI. However, the app panics on launch as soon as I keep use_context_provider(...) for this context (if I remove the provider, the app starts).

Environment: Dioxus 0.6.x, dioxus-desktop 0.6.x, tokio 1.40, macOS (Apple Silicon).

Minimal code (two files):

Cargo.toml

[dependencies]
dioxus = { version = "0.6", features = ["desktop"] }
dioxus-desktop = "0.6"
tokio = { version = "1.40", features = ["rt-multi-thread", "macros", "signal"] }
tokio-util = { version = "0.7", features = ["rt"] }

src/shutdown.rs

use dioxus::prelude::*;
use dioxus::desktop::use_wry_event_handler;
use dioxus::desktop::tao::event::{Event, WindowEvent};
use tokio_util::sync::CancellationToken;
use std::{future::Future, pin::Pin, time::Duration};

#[derive(Clone)]
pub struct Shutdown {
    pub token: CancellationToken,
    pub flag: Signal<bool>, // true -> show “shutting down…”
}

impl Shutdown {
    pub fn request(&self) {
        if !self.flag() {
            self.flag.set(true);
            self.token.cancel();
        }
    }
}

pub fn use_graceful_shutdown(
    cleanup: impl FnOnce() -> Pin<Box<dyn Future<Output = ()> + 'static>> + 'static,
) {
    let shutdown = use_context::<Shutdown>();

    // CloseRequested
    let sd_events = shutdown.clone();
    use_wry_event_handler(move |event, _| {
        if let Event::WindowEvent { event: WindowEvent::CloseRequested, .. } = event {
            sd_events.request();
        }
    });

    // Ctrl+C
    {
        let sd_ctrlc = shutdown.clone();
        spawn(async move {
            let _ = tokio::signal::ctrl_c().await;
            sd_ctrlc.request();
        });
    }

    // SIGTERM (Unix)
    #[cfg(unix)]
    {
        let sd_term = shutdown.clone();
        spawn(async move {
            use tokio::signal::unix::{signal, SignalKind};
            if let Ok(mut term) = signal(SignalKind::terminate()) {
                let _ = term.recv().await;
                sd_term.request();
            }
        });
    }

    // Wait -> cleanup -> exit
    let sd_wait = shutdown;
    spawn(async move {
        sd_wait.token.cancelled().await;
        tokio::time::sleep(Duration::from_millis(50)).await;
        cleanup().await;
        std::process::exit(0);
    });
}

src/main.rs

use dioxus::prelude::*;
use dioxus::desktop::{Config, WindowCloseBehaviour};
use tokio_util::sync::CancellationToken;

mod shutdown;
use shutdown::use_graceful_shutdown;

#[derive(Clone)]
struct Shutdown {
    token: CancellationToken,
    flag: Signal<bool>,
}

fn main() {
    let cfg = Config::new();
    dioxus::LaunchBuilder::new().with_cfg(cfg).launch(App);
}

fn App() -> Element {
    let shutting_down: Signal<bool> = use_signal(|| false);
    use_context_provider(|| Shutdown {
        token: CancellationToken::new(),
        flag: shutting_down.clone(),
    });

    use_graceful_shutdown(|| Box::pin(async {
        // do async cleanup here
    }));

    let shutdown = use_context::<Shutdown>();

    rsx! {
        div {
            button { onclick: move |_| shutdown.request(), "Quit gracefully" }
            (shutdown.flag().then_some(rsx!(p { "Shutting down…" })))
        }
    }
}

What happens

• With the provider present, the app panics right at launch (startup crash).
• Without the provider, it launches (but then I don’t have the shutdown context).

Questions

1. Is there a canonical pattern for a global shutdown context in Dioxus 0.6 Desktop?
2. Is anything wrong with calling use_context_provider exactly as above in the root App()?
3. Any caveats about Signal<bool> in contexts or about spawn being cancelled on unmount (use spawn_forever for cleanup?)

Thanks a lot for any pointers or a minimal sample!