Multiple errors getting printed when a single error occurs.

[MaximalCats]

Hello everyone,

Just wanted to know if anyone knows a way to disable this behaviour? I'm not completely sure whether this is a bug.

use http_body_util::Full;
use hyper::{body::{Bytes, Incoming}, server::conn::http1, service::service_fn, Request, Response};
use hyper_util::rt::TokioIo;
use log::error;
use std::{
    error::{self, Error}, net::{IpAddr, SocketAddr}, str::FromStr
};
use tokio::{fs::File, io::AsyncReadExt, net::TcpListener};
use yaml_rust::{Yaml, YamlLoader};

async fn test(req: Request<Incoming>) -> Result<Response<Full<Bytes>>, hyper::Error>{
    panic!("hello, i am an error beep boop")
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    pretty_env_logger::init();

    let addr = SocketAddr::new(
        IpAddr::from_str("127.0.0.1").unwrap(),
        8006 ,
    );

    let listener = TcpListener::bind(addr).await?;

    loop {
        let (stream, _) = listener.accept().await?;

        let io = TokioIo::new(stream);

        tokio::task::spawn(async move {
            if let Err(err) = http1::Builder::new().serve_connection(io, service_fn(test)).await {
                error!("Error while trying to serve connection: {}", err.source().unwrap())
            }
        });
    }
}

// Multiple errors seem to get printed here, even though there has only been a single request.

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

thread 'tokio-runtime-worker' panicked at src/main.rs:12:5:
hello, i am an error beep boop

Same also happens when I return any errors by passing it to Err(). I'm thinking it might have something to do with tokio?

Thanks!

[seanmonstar]

Are you certain there's no other connections or requests? hyper isn't doing anything extra here, it just calls your service function when a request is received.

[MaximalCats]

Seems like Librewolf/Firefox is making extra requests. Using curl does actually just print a single error.

[MaximalCats]

Probably not directly related to the discussion but: the only way to resolve this is probably by responding with an error page instead of just Err()'ing. Unfortunately this isn't possible in my scenario due to the fact that I make a HTTP request to an external server and send the resulting Response<Incoming> back directly to the client without modification.

The only theoretical solution I've come up with so far is by using/consuming the body, headers and what not to manually re-construct a Response<Full<Bytes>> and returning it instead, so I can safely return an error page as response in other places of my code, but this becomes very messy. There is also no way afaik to manually construct Incoming. Any suggestions on how I should handle this?

[seanmonstar]

You don't need to buffer the entire response body, you can allow it stream by picking a streaming implementation.

Also, returning an error means the connection (or HTTP/2 stream) must be closed abruptly. Almost always it's more appropriate to convert the error you saw into a response.

You have many options for streaming the body. You could use an enum like Either, where one variant is from the external server, and the other is your error message converted to a body. You could use BoxBody, and cast the different kinds into one. You could use some sort of Channel or othering streaming kind. There's several to pick from here: https://docs.rs/http-body-util/latest/http_body_util/