Cancel request and depended spawned tasks for streamed data

[liketoeatcheese]

Hi,

First of all, thank you for your great work!

I'm trying to do data streaming from certain sources, and I can't really figure out how I could cancel whatever was spawned inside that streams the data inside of an Actix request. In the example below, when I make a request to:
curl http://localhost:8080/hey

I would receive a continuous stream of:

event: hey_event
data: helloworld

The "loop" will be printed on the server's console every second. Even when I cancel the stream on the curl terminal, the "loop" will still be printed to the console.

Steps to reproduce

[package]
name = "actix_tokio_cancel"
version = "0.1.0"
edition = "2021"

[dependencies]
actix-web = { version = "4.6.0", features = ["rustls-0_22"] }
tokio = { version = "1.37.0", features = ["full"] }
tokio-stream = "0.1.15"
actix-web-lab = "0.20.2"

use std::time::Duration;

use actix_web::{web, App, HttpServer, Responder};
use actix_web_lab::sse::{self, Event};
use tokio::io;
use tokio_stream::wrappers::ReceiverStream;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().route("/hey", web::get().to(manual_hello)))
        .bind(("127.0.0.1", 8080))?
        .run()
        .await
}

pub async fn manual_hello() -> impl Responder {
    let (stream_tx, stream_rx) = tokio::sync::mpsc::channel::<Result<Event, io::Error>>(100);
    let stream = ReceiverStream::new(stream_rx);
    tokio::spawn(async move {
        loop {
            println!("looping");
            let event = sse::Data::new("hellowolrd").event(format!("hey_event"));
            if stream_tx
                .send(Ok::<_, io::Error>(sse::Event::Data(event)))
                .await
                .is_err()
            {
                break;
            }

            tokio::time::sleep(Duration::from_secs(1)).await;
        }
    });

    sse::Sse::from_stream(stream)
}

Expected behaviour

The infinite loop will stop

[robjtede]

My reproduction of this using your code always results in the stream exiting after a few seconds. I suspect it has something to do with leftover TCP connections at the OS level keeping the HTTP server alive for a while. For me, at least, on macOS, this seems to resolve itself. Maybe you're seeing infinite looping on Linux?

A somewhat more reliable test I've found is to use cURL's --max-time flag, which seems to shut down the TCP connection in a cleaner way, such that the next loop iteration more often exits out.

See that it prints "closing connection" whereas just ctrl-c is a more forceful shutdown that is likely to leave OS resources hanging.

[liketoeatcheese]

Probably! I found a workaround to handle those cases with sending occasional heart beat to the client. If events can't be sent means that the stream channel is closed and I just cancel the loop with named loop.

But thanks for getting back to me