Function stream

opensuse-proxy-cache/src/main.rs:477–526

(
    state: Arc<AppState>,
    url: Url,
    metadata: bool,
    range: Option<(u64, Option<u64>)>,
    client_ip_addr: IpAddr,
)

#[instrument(skip_all)]
async fn stream(
    state: Arc<AppState>,
    url: Url,
    metadata: bool,
    range: Option<(u64, Option<u64>)>,
    client_ip_addr: IpAddr,
) -> Response {
    let send_headers = send_headers(range);

    let client_response = if metadata {
        info!("🍍  start stream -> HEAD {}", url.as_str());
        state.client.head(url).headers(send_headers).send().await
    } else {
        info!("🍍  start stream -> GET {}", url.as_str());
        state.client.get(url).headers(send_headers).send().await
    };

    // Handle this error properly. Shortcut return a 500?
    let client_response = match client_response {
        Ok(cr) => cr,
        Err(e) => {
            error!(?e, "Error handling client response");
            return (StatusCode::INTERNAL_SERVER_ERROR).into_response();
        }
    };

    let headers = filter_headers(client_response.headers(), metadata);

    // Filter the headers
    let status = client_response.status();

    if metadata {
        (status, headers).into_response()
    } else {
        // When streaming, even if a range was specified, the content-length
        // correctly represents the amount of content we are about to recieve.
        let cnt_amt = headers
            .get("content-length")
            .and_then(|hk| hk.to_str().ok().and_then(|i| usize::from_str(i).ok()))
            .unwrap_or(0);

        trace_client_req_size(state.daily_quota.as_ref(), client_ip_addr, cnt_amt).await;

        // let stream = client_response.bytes_stream();
        let buffered_client_stream = BufferedStream::new(client_response.bytes_stream());
        let body = Body::from_stream(buffered_client_stream);

        (status, headers, body).into_response()
    }
}

#[instrument(skip_all)]
async fn miss(