Running actix-web from tauri async runtime

[joepio]

Hi guys! Have been using tauri for just a day, and have already made a lot of progress. Absolutely amazing tool, thanks so much to everyone who contributed!

However, I now feel kind of stuck. I'm trying to run a Rust server powered by actix from a tauri application. The problem is there are two async runtimes, and I think they might be incompatible. Every time I try to run async code, it simply does not execute.

My actix server is exported from a Library through a serve function, which internally looks a bit like this:

  actix_web::App::new()
      .bind_rustls(&endpoint, https_config)
      .expect(&*format!("Cannot bind to endpoint {}", &endpoint))
      .run()
      .await?;
Ok(())

I first tried calling my async serve function from inside a tauri spawn:

  tauri::async_runtime::spawn(async {
    atomic_server_lib::serve::serve(&config_clone)
      .await
      .expect("could not start server");
  });

But std::rc::Rc<[std::boxed::Box<(dyn actix_web::data::DataFactory + 'static)>]> cannot be sent between threads safely

So I tried blocking it, which works!

  tauri::async_runtime::block_on(async move {
    atomic_server_lib::serve::serve(&config_clone).await.unwrap();
  });

But of course, this blocks... So tauri doesn't even start!

I also tried using the actix runtime in tauri main.rs:

#[actix_rt::main]
async fn main() {
  actix_rt::spawn(async move {
    println!("This will not print");
  });

But now whatever is inside spawn will never even run.
Same happens when I use actix_rt like this:

  let system = actix_rt::System::new("atomic-server");
  actix_rt::spawn(async move {
    println!("I'm printing just fine")
  });
  system.run().unwrap();

Which does run, but after calling system.run(), nothing happens, as it's a blocking function that loops forever, of course. Perhaps if I could call system.run() from within the tauri runtime, things could work...

  tauri::async_runtime::spawn(async move {
    let _r = system.run();
  });

... but I can't call that function in a tauri::async_runtime::spawn block.

I'm running the latest beta's of actix_web, which (if I understand correctly) should support Tokio runtimes.

Actix versions:

actix-cors = "0.6.0-beta.4"
actix-files = "0.6.0-beta.9"
actix-web-actors = "4.0.0-beta.7"
actix-web = "4.0.0-beta.12"

Here's my project (Atomic-server) branch's main.rs and my internal issue.

Any help / thoughts would be appreciated!

[FabianLars]

Hmm, i think the easiest (might not be the best way lol) would be to create an actix runtime on a seperate std thread. so in your specific case you'd end up with something like this:

fn main() {
  let ctx = tauri::generate_context!();

  let config: atomic_server_lib::config::Config = atomic_server_lib::config::init()
    .map_err(|e| format!("Initialization failed: {}", e))
    .expect("failed init config");
  let config_clone = config.clone();

  std::thread::spawn(move || {
    let rt = actix_rt::Runtime::new().unwrap();
    rt.block_on(atomic_server_lib::serve::serve(&config_clone));
  });

  tauri::Builder::default()
    .menu(crate::menu::build(&ctx))
    .on_menu_event(crate::menu::handle)
    .system_tray(crate::system_tray::build())
    .on_system_tray_event(move |e, h| {
      let cfg = config.clone();
      crate::system_tray::handle(e, h, &cfg)
    })
    .run(ctx)
    .expect("Tauri Error.");
}

Edit: Should work the same with let rt = actix::System::new();. I don't know the differences 🤷

Alternatively you could do something like this. I think we need the actix beta versions for this to work, didn't even test the stable versions tho.

#[tokio::main]
async fn main() {
  tokio::task::spawn_blocking(move || {
    let rt = tokio::runtime::Handle::current();
    rt.block_on(async {
      let local = tokio::task::LocalSet::new();
      local
        .run_until(atomic_server_lib::serve::serve(&config_clone))
        .await;
    });
  });
}

Not only does this look kinda ugly, it probably can cause problems with tauri running inside an async main function.
But we can make it even uglier (but more compatible without the async main) by making it use tauri::async_runtime again:

fn main() {
  tauri::async_runtime::spawn(async move {
    let rt = tokio::runtime::Handle::current();
    let rt_ = rt.clone();
    rt.spawn_blocking(move || {
      rt_.block_on(async {
        let local = tokio::task::LocalSet::new();
        local
          .run_until(atomic_server_lib::serve::serve(&config_clone))
          .await;
      })
    });
  });
}

[joepio]

Thanks for helping out again, @FabianLars!

Running it like this:

  tauri::async_runtime::spawn(async move {
    let mut rt = actix_rt::System::new("tauri-server");
    let serv = atomic_server_lib::serve::serve(config_clone);
    rt.block_on(serv);
  });

Results in this:

thread 'tokio-runtime-worker' panicked at '`spawn_local` called from outside of a `task::LocalSet`

If I try the second suggestion:

  tokio::task::spawn_blocking(move || {
    let rt = tokio::runtime::Handle::current();
    rt.block_on(async {
      let local = tokio::task::LocalSet::new();
      local
        .run_until(atomic_server_lib::serve::serve(config_clone))
        .await
        .unwrap()
    })
  });

I get:

thread 'main' panicked at 'there is no reactor running, must be called from the context of a Tokio 1.x runtime',

Which seems to be caused by version mismatches of tokio. So I ran cargo tree -d | grep tokio, searched the cargo.lock files and tried to get rid of older versions, but the error remains.

Thanks again for your time!

[FabianLars]

@joepio i tested all the snippets in your repo before adding them here and all of them worked.

thread 'tokio-runtime-worker' panicked at 'spawn_local called from outside of a task::LocalSet

Which of my examples is this snippet modeled after? Doesn't seem to resemble any of them 🤔

thread 'main' panicked at 'there is no reactor running, must be called from the context of a Tokio 1.x runtime',

This example only works in a tokio::main annotated async fn (or the block_on alternative to this)

Edit: Also this one is weird to me:

actix_rt::System::new("tauri-server");

The new function doesn't accept a string anymore since actix_rt v2 (released almost a year ago)

[joepio]

Just tried the first snippet again, and it works!

Not sure what I did wrong the first time... Sorry.

I'm very grateful!