tokio::select! blocks when using tokio::io::Lines::next_line()

[acheronfail]

I've just encountered this, and I'm not sure if it's a bug, or if it's some API I've misunderstood...

Basically, I have two futures I'm trying to run at the same time, and I want to get the first one that errors (and cancel all the rest). I'm trying to do this with tokio::select!, but it seems that when one future returns, tokio::select! will block until tokio::io::Lines::next_line()'s await has completed.

According to its documentation, tokio::io::Lines::next_line() is meant to be "cancel safe", so I thought that this wouldn't happen?

I've pushed a small reproducible repo here: https://github.com/acheronfail/tokio-select-example

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let result = tokio::select! {
        err = stdin_lines() => err,
        err = error() => err,
    };

    match result {
        Ok(_) => unreachable!(),
        Err(e) => println!("error: {}", e),
    }
}

async fn stdin_lines() -> Result<std::convert::Infallible, Box<dyn std::error::Error>> {
    use tokio::io::AsyncBufReadExt;

    let stdin = tokio::io::BufReader::new(tokio::io::stdin());
    let mut lines = stdin.lines();
    loop {
        let _ = lines.next_line().await?.unwrap();
    }
}

async fn error() -> Result<std::convert::Infallible, Box<dyn std::error::Error>> {
    println!("erroring in 1 second...");
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    println!("erroring now");
    Err("boom".into())
}

I run this example like this:

$ cargo build;
$ cat | (./target/debug/tokio-select-example; echo exited with: $?)

Wait for it to error, and you will observe that the program will not exit until two lines have been read.

What I expected

tokio::select! would return an err immediately on any future that returns an error, and any other futures used in it will be cancelled.

So, in this example, I expected:

$ cat | (./target/debug/tokio-select-example; echo exited with: $?)
erroring in 1 second...
erroring now
error: boom
exited with: 0    # <-- I expected the program to EXIT
$

What I'm seeing

tokio::select! does not return until tokio::io::Lines::next_line() has completed.

$ cat | (./target/debug/tokio-select-example; echo exited with: $?)
erroring in 1 second...
erroring now
error: boom
asdf 				# <-- the program hangs until a new line is entered
exited with: 0
$

[Darksonn]

When you return from main, Tokio will attempt to kill and then wait for background tasks before it exits. However, the background task that reads from stdin is impossible to kill, so Tokio is forced to wait until it returns normally.

I recommend following the recommendation from the documentation:

This handle is best used for non-interactive uses, such as when a file is piped into the application. For technical reasons, stdin is implemented by using an ordinary blocking read on a separate thread, and it is impossible to cancel that read. This can make shutdown of the runtime hang until the user presses enter.

For interactive uses, it is recommended to spawn a thread dedicated to user input and use blocking IO directly in that thread.

from the documentation

[acheronfail]

Ohhh I actually DID read that, but disregarded it since I thought my use-case wasn't an "interactive" one (it's reading events send over STDIN as JSON lines). But actually, now that you bring it up, it kinda is in a sense.

That makes heaps of sense now, thanks for helping me to see it!!