http server in tauri app

[aknuth]

Hi all,
I want to let my tauri app receive http REST requests (GET, PUT; POST). How can I implement this ? I can't see a JS API (even not on the examples sites - https://github.com/tauri-apps/tauri/tree/next/examples) which solves this ...
Any ideas?

[FabianLars]

You have to bundle a server yourself, either in rust or via a sidecar ( docs / example ).
Or if you already know a crazy way to host a server inside of a browser you probably can make that work too 🤷 (at least if i understood your usecase correctly)

[richardeschloss]

Fwiw, I found rocket to be the easiest solution. As somewhat of a Tauri newbie, I found it far easier than the sidecar example. I think others may find it useful if the rocket snippet were highlighted at the top in the "accepted answer".

[tom-haines]

As a postnote to this thread, I found it simpler to use Actix Web due to issues with Rocket asking for rust nightly features (under v0.4 at least).

#[get("/")]
async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello world!")
}

fn main() {
  tauri::Builder::default()
    .setup(|app| {
        tauri::async_runtime::spawn(
          HttpServer::new(|| {
              App::new()
                  .service(hello)
          })
              .bind(("127.0.0.1", 8080))?
              .run()
        );
        Ok(())
    })
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

[simonhyll]

Keep in mind that while you CAN make a server like this there's a fair number of security related aspects to be aware with this sort of approach. For example, you have to keep in mind that unless you yourself take some steps to prevent it, your API will be accessible to any other program on the users computer as well. And, if you select a port statically, what if that port is taken? You'll need to set it up to handle dynamic port assignment. And why are you really making the server? In most cases what you're getting is essentially the same thing as a Tauri command, just worse.

In short, I don't recommend starting a server in your Tauri app, unless you have a good grasp on related potential issues and have a plan for tackling them.

[tom-haines]

Agree @simonhyll as to being cautious, and that dynamic port allocation is a better tact to take.

There are some valid use cases for a local http api, such as an oAuth URL handler to securely convert/store a transient credential for example. Many apps (Google Drive etc) adopt this approach (a custom protocol handler is cleaner still as it removes the need for opening a port altogether, but I couldn't find any concrete examples of how to setup a url handler under tauri). Most IDP providers I've seen allow a wildcard for the port (wildcard permitted, for localhost only, using MS/Google IDPs for example).

For brevity, the example above is simply a hello world example.

[clytras]

@simonhyll one use cause for creating a server, is to create an HTTP proxy and bypass CORS restrictions inside Web Workers where neither IPC or Tauri HTTP client are available. See #3308.

[jovanlopez32]

Hello how I implement Rocket inside tauri

[bingryan]

I also have a similar QA: #6731

[tom-haines]

I was able to access via http in production mode on mac, using sample code above.

[snilan]

Hi I know this is an old thread, but I am able to run a web server through Actix Web but I want to trigger an event to the frontend when I get that request. Is this possible?

I am new to Rust and can't figure out how to get a proper reference to the app handle.

let app_handler = app.handle();
tauri::async_runtime::spawn(
          HttpServer::new(move || {
              App::new().route(
                     "/",
                     web::get().to(|| async {
                            app_handler.emit(
                                "hello",
                                Some(Payload {
                                    message: "Hello from Rust!".to_string(),
                                }),
                            );
                            HttpResponse::Ok().body("hello world!")
                        }),
                    )
                })
                .bind(("127.0.0.1", 8080))?
                .run(),
);

[FabianLars]

I would probably store it in a state: https://actix.rs/docs/application/#state 🤔

[mandaputtra]

did you managed to do it? @snilan. Im also having problem making it a global variables

// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
use actix_web::{get, App, HttpResponse, HttpServer, Responder};
use std::thread_local;
use tauri::{App as TauriApp, Manager};

thread_local! {
    static APP: Option<TauriApp> = None;
}

#[get("/")]
async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello world!")
}

#[get("/actions?<action>")]
async fn handle_actions(action: String) -> impl Responder {
    APP.with(|app| {
        if let Some(app) = app.as_ref() {
            match action.as_str() {
                "session_end" => {
                    app.get_window("main").unwrap().show().unwrap();
                    HttpResponse::Ok().body("Session ending, app shown")
                }
                "session_start" => {
                    app.get_window("main").unwrap().hide().unwrap();
                    HttpResponse::Ok().body("Session starting, app hidden")
                }
                _ => HttpResponse::Ok().body("Unknown action"),
            }
        } else {
            HttpResponse::InternalServerError().body("App instance not available")
        }
    })
}

fn main() {
    let app = tauri::Builder::default()
        .setup(|app| {
            *APP.with(|app| *app = Some(app));
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running Tauri application");

    tauri::async_runtime::spawn(
      HttpServer::new(|| App::new()
        .service(hello)
        .service(handle_actions))
        .bind(("127.0.0.1", 8080))?
        .run()
    );
}

It alwasys got error

mismatched types
expected struct `tauri::App`
found reference `&Option<tauri::App>`

[ImageDeeply]

@snilan @mandaputtra - any update? Are you using Tauri 1.x or 2.x beta?

Or, are there better ways to enable customers to send commands to my app and get back a response?

[mandaputtra]

https://stackoverflow.com/a/77936504/5672961

Here I solve it using this

[yuyang-ok]

I have been wonder this too

[mandaputtra]

Here use this as an example https://stackoverflow.com/a/77936504/5672961

[lcdss]

Creating a HTTP Server in a Tauri app is useful to share functionality with smartphones in your local network. Or is there any other way to call a Tauri command on a phone when the Tauri app is running on a computer in the same network?

[lcdss]

I ended up doing something like this (in case anyone wants to do the same) to start a web server and share the Tauri App Handle with Actix-web requests:

tauri::Builder::default()
        .setup(|app| {
            // Only start the server if we are in a desktop environment
            #[cfg(desktop)]
            {
                let app_handle = app.handle().clone();

                thread::spawn(|| {
                    server::init(app_handle).unwrap();
                });
            }

            Ok(())
        })

struct AppState {
    tauri: AppHandle,
}

#[actix_web::main]
pub async fn init(tauri: AppHandle) -> io::Result<()> {
    let app_data = web::Data::new(AppState { tauri });

    let http_server = HttpServer::new(move || {
        let cors = Cors::default()
            .allow_any_origin()
            .allow_any_method()
            .allow_any_header()
            .max_age(3600);

        App::new()
            .app_data(app_data.clone())
            .wrap(cors)
            .wrap(middleware::Logger::default())
            .service(handlers::system::state)
    })
    .bind(("0.0.0.0", 1111))
    .expect("failed to bind address")
    .run();

    println!("Server started at http://0.0.0.0:1111");

    http_server.await
}

#[post("/system/{action}")]
async fn state(
    (action, payload, data): (Path<String>, Json<StatePayload>, Data<AppState>),
) -> HttpResponse {
    let shell = data.tauri.shell();
    ...
}