How to use tokio's multi-threaded runtime?

[oleid]

Dear all,

I'm trying to use zenoh in the backend of a fullstack application using dioxus-0.7.
Zenoh apparently doesn't support tokio's current_thread scheduler:

https://gitlab.ingescape.com/third-party/zenoh/-/blob/1.2.0/commons/zenoh-runtime/src/lib.rs?ref_type=tags#L149

I've been trying to use something like this:

#[cfg(feature = "server")]
#[tokio::main]
async fn main() {
    // Start the server
    let address = dioxus::cli_config::fullstack_address_or_localhost();
    let router = axum::Router::new()
        // You can add a dioxus application to the router with the `serve_dioxus_application` method
        // This will add a fallback route to the router that will serve your component and server functions
        .serve_dioxus_application(dioxus_server::ServeConfig::new(), App);
    let router = router.into_make_service();
    let listener = tokio::net::TcpListener::bind(address).await.unwrap();

    tokio::spawn(async move {
        axum::serve(listener, router).await.unwrap();
    });

    dioxus::LaunchBuilder::server()
        .with_cfg(ServeConfig::default())
        .launch(App);
}

to start the server, but then tokio complains:

[dev] Application [server] exited with error: exit status: 101
[server] thread 'main' (21665) panicked at /home/leidinge/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.49.0/src/runtime/scheduler/multi_thread/mod.rs:88:9:
[server] Cannot start a runtime from within a runtime. This happens because a function (like `block_on`) attempted to block the current thread while the thread is being used to drive asynchronous tasks.
[server] note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Then I tried the following:

fn main() {
    #[cfg(feature = "web")]
    dioxus::launch(App);

    #[cfg(feature = "server")]
    {
        let middleware_runtime = tokio::runtime::Builder::new_multi_thread()
            .worker_threads(2)
            .thread_name("middleware-pool")
            .enable_all()
            .build()
            .expect("Failed to create middleware runtime");

        let dioxus_rt = tokio::runtime::Builder::new_current_thread()
            .thread_name("dioxus-pool")
            .enable_all()
            .build()
            .expect("Failed to create dioxus runtime");

        middleware_runtime.spawn(async move { api::server::init_server_background_task().await });

        dioxus_rt.block_on(async move {
            launch_server().await;
        });
    }
}

#[cfg(feature = "server")]
async fn launch_server() {
    use axum::routing::get;
    use axum::{
        body::Body,
        http::header,
        response::{IntoResponse, Response},
        Router,
    };
    use dioxus::prelude::*;
    use std::net::{IpAddr, Ipv4Addr, SocketAddr};

    let address = dioxus::cli_config::fullstack_address_or_localhost();

    let router = Router::new()
        .serve_dioxus_application(ServeConfig::default(), App);

    let listener = tokio::net::TcpListener::bind(address).await.unwrap();
    axum::serve(listener, router).await.unwrap();
}

The result is the same:

[dev] Application [server] exited with error: exit status: 101
[server] Cannot start a runtime from within a runtime. This happens because a function (like `block_on`) attempted to block the current thread while the thread is being used to drive asynchronous tasks.
[server] note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Is there any supported way to break the cycle?

[w1n5t0n99]

This worked for me

    #[cfg(feature = "server")]
    {
        tokio::runtime::Builder::new_multi_thread()
            .enable_all()
            .build()
            .unwrap()
            .block_on(async {
                axum::serve(listener, app).await;
            });
    }

    #[cfg(not(feature = "server"))]
    {
        // Standard client-side launch
        dioxus::launch(App);
    }
}

[oleid]

Thanks for testing this.
Apparently, my 2nd attempt was already working, but something else was wrong.
I re-created a minimal example and this works apparently fine. I created a demo-repo in case anyone needs do to something similar. C.f.

https://github.com/oleid/dioxus-zenoh/blob/main/src/main.rs