Callback when service is ready to serve

[tisonkun]

I'd like to prompt users when the service is ready to accept requests, but fail to find a method for inserting such a logging point with tonic.

For example, how can I prompt "Server started" when tonic Server finished the internal tasks.

    async fn run(self) -> Result<()> {
        let addr = self.addr.parse()?;
        info!(message = "Starting server.", %addr);

        let transactor = engula_transactor::Server::new().into_service();
        let object_engine_master = object_engine_master::Server::new().into_service();
        let stream_engine_master = stream_engine_master::Server::new().into_service();
        tonic::transport::Server::builder()
            .add_service(transactor)
            .add_service(object_engine_master)
            .add_service(stream_engine_master)
            .serve(addr)
            .await?;
        Ok(())
    }

[tisonkun]

Also the health example doesn't show how to achieve this. It flips the status of a service every second. But in the real-world we may callback set_serving when the associated service actually started.

[tisonkun]

cc @davidpdrsn

[davidpdrsn]

Please don't @ping me. I get enough github notifications already.

When you call .server(addr).await the service is immediately ready. So I'd just do whatever necessary before calling that.

[tisonkun]

immediately ready

If the address already in use, when I know whether it can successfully start it's after calling .await. Of course I can handle Error later, but it may be too early to set the server state as Ready before calling .await.

[davidpdrsn]

If you wanna be really sure the port isn't already in use you can make a tokio::net::TcpListener and use Router::serve_with_incoming like shown here

tonic/tests/integration_tests/tests/timeout.rs

Lines 79 to 89 in 9ff4f7b

	let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
	let addr = listener.local_addr().unwrap();
	tokio::spawn(async move {
	Server::builder()
	.timeout(server_timeout)
	.add_service(svc)
	.serve_with_incoming(tokio_stream::wrappers::TcpListenerStream::new(listener))
	.await
	.unwrap();
	});

.

[Narayanbhat166]

I have a similar use case. I'm writing integration tests for my grpc service. I spin up the server ( in a separate tokio::spawn task ) in every test and I want to know once the server is started so that I can proceed with calling my server functions. I'm currently adding a timeout, is there any better alternative to achieve this?

tokio::spawn(async { start_server(true).await });

// Can this sleep time be avoided
tokio::time::sleep(std::time::Duration::from_secs(1)).await;

let config = utils::read_config::<ClientConfig>("config/client.toml", Some("BLAZER"));
let mut client = grpc_client::GrpcClient::connect(config.server_url.clone())
    .await
    .unwrap();

let ping_response = client.ping(PingRequest { user_id: None }).await.unwrap();

[andresmargalef]

The solution is this.
In your example the code must be something like this:

async fn start_server(
    flag:bool,
    listener:TcpListener,
) -> Result<(), tonic::transport::Error> {
    Server::builder()
        .add_service(SomeService::new())
        // add as a dev-dependency the crate `tokio-stream` with feature `net` enabled
        .serve_with_incoming(tokio_stream::wrappers::TcpListenerStream::new(listener)) 
        .await
}

// This line start listening before the spawn is executed so any other line after this will success trying to connect with the server.
let listener = tokio::net::TcpListener::bind("127.0.0.1:30000").await?;
tokio::spawn(async { start_server(true, listener).await });

// The next line is not needed anymore
// tokio::time::sleep(std::time::Duration::from_secs(1)).await;

let config = utils::read_config::<ClientConfig>("config/client.toml", Some("BLAZER"));
let mut client = grpc_client::GrpcClient::connect(config.server_url.clone())
    .await
    .unwrap();

let ping_response = client.ping(PingRequest { user_id: None }).await.unwrap();