Rust: Tokio + Warp run in background

Question

Rust newbie here since I recently started working on it. I'm trying get a rest api working and the following code works completely fine for me.

MyRest.rs

pub struct RestBro;

impl RestBro {

    pub async fn run_bro() {
        let routes_post = warp::post()
            .and(warp::path!("v1" / "homie").and_then(my_function));

        warp::serve(routes)
            .run(([127, 0, 0, 1], 3003))
            .await;    
    }

}

main.rs

#[tokio::main]
async fn main() {
    let rb = RestBro;
    rb.run_bro().await;
}

Now the thing is that I don't want my main to be an async and I just can't figure out how to run that run_bro() function indefinitely like its happening above. I've tried block_on and that just blocks and waits for run_bro to interrupt which is expected and when I tried spawn it just runs through and exits. The documentation on Tokio confused me and that's why I'm looking for some help here.

block_on

fn main() {
    let async_block = async {
        let rb = RestBro;
        rb.run_bro().await;
    };
    let tr = tokio::runtime::Runtime::new().unwrap();
    tr.block_on(async_block);
    println!("Everything working good!");
}

spawn

fn main() {
    let tr = tokio::runtime::Runtime::new().unwrap();
    tr.spawn(async {
        let rb = RestBro;
        rb.run_bro().await;
    });
    println!("Everything working good!");
}

To be clear, my question is how can I call asynchronous run_bro() function and await from a synchronous main? Thanks in advance!!

This (https://blog.joco.dev/posts/warp_auth_server_tutorial) help you ? — Zeppi, Sep 18 '21 at 07:27
I updated my post with a question which is more clear. Basically how can I call asynchronous run_bro() function and await from a synchronous main? — M. Ather Khan, Sep 18 '21 at 07:45
Because other that main function will be starting other services and doing some other operations unrelated to warp. Also since main is async I'll have to have all other functions async. — M. Ather Khan, Sep 18 '21 at 16:42

score 1 · Answer 1 · edited Jan 24 '22 at 21:16

To be clear, my question is how can I call asynchronous run_bro() function and await from a synchronous main?

I do not understand why you'd want to wrap server in spawn. In your code, it's not working because your main program closes and the spawn closes with it.

fn main() {
    let tr = tokio::runtime::Runtime::new().unwrap();
    tr.spawn(async {
        let rb = RestBro;
        rb.run_bro().await;
    });
    println!("Everything working good!");
}

If you change it to this it'll work for five seconds.

use std::{thread, time};

fn main() {
    let tr = tokio::runtime::Runtime::new().unwrap();
    tr.spawn(async {
        let rb = RestBro;
        rb.run_bro().await;
    });
    println!("Everything working good!");
    thread::sleep(time::Duration::from_secs(5));
}

Or indefinitely:

fn main() {
    let tr = tokio::runtime::Runtime::new().unwrap();
    tr.spawn(async {
        let rb = RestBro;
        rb.run_bro().await;
    });
    println!("Everything working good!");
    tr.join().unwrap();
}

Rust: Tokio + Warp run in background

1 Answers1