Did I find a bug in Tokio?

[samvv]

Hi all,

I spent hours debugging a strange issue that occurs when using TcpStream::into_split() from Tokio. I'm not sure whether this is a bug or intended behavior, so that's why I'm asking here first.

I have the following simple code, which is part of a full working example:

async fn main() {
    let (mut reader, _writer) = TcpStream::connect((addr, port))
        .await
        .unwrap()
        .into_split();
    tokio::spawn(async move {
        loop {
            eprintln!("{}", reader.read_u8().await.unwrap());
        }
    });
}

In my head, I expect reader to be moved inside of the spawned task and continue its happy life inside the loop.

This is not what happens:

thread 'main' (441460) panicked at crates/bug/src/bin/server.rs:11:38:
called `Result::unwrap()` on an `Err` value: Os { code: 32, kind: BrokenPipe, message: "Broken pipe" }

From what I can tell, reader is destroyed, closing the TcpStream in the process.

To me, this is totally unexpected since the task should own reader until the task is finished.

Am I misunderstanding something?

[Darksonn]

What's happening is that you return from main, which kills the background task. This causes the server to print the error you saw as the client was closed by returning from main.

[samvv]

Im going to update the example and see if that fixes it.

[Darksonn]

No, returning from main results in all tasks being killed. This mirrors normal Rust where the same happens to background threads.

[samvv]

Thanks! That indeed seems to be the case. Does this also apply to returning from an async function? That would explain my real-world project issue.

[Darksonn]

No, not unless the method is annotated with #[tokio::main].

[samvv]

Thanks, Ill keep looking then.

[samvv]

Found the issue: I wasn't holding on to the OwnedWriteHalf. As soon as it dropped the connection was closed.