Upgrading from hyper v0 to hyper v1 still using the legacy::Client

[frederikhors]

I wrote a simple S3 client with axum v0.6 and hyper v0 using the hyper's (now deprecated/legacy Client).

I don't want to use reqwest or others because I need very simple and not complex features.

Now I need to update to axum v0.7 and hyper v1: I'm a bit lost.

This is the code that works with hyper v0 | The same on Rust Playground

This is the code that doesn't work with hyper v1 | The same on Rust Playground

Since I'm losing my mind, actually, I've already lost it, can you please help me understand how to change it for the new hyper version?

The most important thing for me is that the file is streamed and not copied into memory, both for uploading and downloading.

The code with both v0 (commented) and v1 (the second link above):

/*
[dependencies]
axum = { version = "0.7.4", default-features = false }
bytes = { version = "1.5.0", default-features = false }
tokio = { version = "1.0", features = ["full"] }
futures = { version = "0.3.30", default-features = false, features = ["std"] }
hyper = { version = "1.1.0", features = ["full"] }
hyper-tls = { version = "0.6.0", default-features = false }
hyper-util = { version = "0.1.2", features = [
    "client",
    "client-legacy",
    "http1",
    "http2",
] }
http-body-util = { version = "0.1.0", default-features = false }
tokio-util = { version = "0.7.10", default-features = false, features = [
    "compat",
    "io",
] }
*/

use futures::TryStreamExt;
use http_body_util::{combinators::BoxBody, BodyExt, BodyStream, Full, StreamBody};
use hyper::{
    body::{Frame, Incoming},
    header, Method,
};
use hyper_tls::HttpsConnector;
use hyper_util::{
    client::legacy::{self, connect::HttpConnector},
    rt::TokioExecutor,
};
use std::{error::Error, pin::Pin, time::Duration};
use tokio::io::AsyncRead;
use tokio_util::{
    bytes::Bytes,
    compat::FuturesAsyncReadCompatExt,
    io::{ReaderStream, StreamReader},
};

pub struct S3Client {
    credentials: String,
    hyper_client: legacy::Client<HttpsConnector<HttpConnector>, BoxBody<Bytes, std::io::Error>>,
}

impl S3Client {
    pub fn new(credentials: &str) -> Result<Self, Box<dyn Error>> {
        // With hyper v0
        // let hyper_client = hyper::Client::builder().build::<_, hyper::Body>(HttpsConnector::new());

        let hyper_client =
            legacy::Client::builder(TokioExecutor::new())
                .build::<_, BoxBody<Bytes, std::io::Error>>(HttpsConnector::new());

        Ok(Self {
            credentials: credentials.to_string(),
            hyper_client,
        })
    }

    pub async fn put_file(
        &self,
        size: i64,
        reader: Pin<Box<(dyn AsyncRead + Send + Sync)>>,
    ) -> Result<(), Box<dyn Error>> {
        self.hyper_client
            .request(
                hyper::Request::builder()
                    .method(Method::PUT)
                    .uri(&self.credentials)
                    .header(header::CONTENT_LENGTH, size)
                    // With hyper v0
                    // .body(hyper::Body::wrap_stream(ReaderStream::new(reader)))
                    .body(StreamBody::new(ReaderStream::new(reader).map_ok(Frame::data)).boxed())
                    .unwrap(),
            )
            .await?;

        Ok(())
    }

    pub async fn get_file(
        &self,
        id: &str,
    ) -> Result<Pin<Box<dyn AsyncRead + Send + Sync>>, Box<dyn Error>> {
        let response = self
            .hyper_client
            .get((format!("{}/{id}", self.credentials)).parse()?)
            .await?
            .into_body()
            // With hyper v0
            // .map_err(|e| futures::io::Error::new(futures::io::ErrorKind::Other, e))
            // .into_async_read()
            // .compat()
            ;

        let result = StreamReader::new(BodyStream::new(response));

        // With hyper v0
        // Ok(Box::pin(response))

        Ok(result)
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let s3_client = S3Client::new("something here")?;

    // I have a "request: axum::extract::Request," arg now in axum's v0.7 handler

    // let stream = request
    //     .into_body()
    //     .into_data_stream()
    //     .map_err(|err| io::Error::new(io::ErrorKind::Other, err));

    // s3_client
    //     .put_file(123, Box::pin(StreamReader::new(stream)))
    //     .await?;

    Ok(())
}

[dswij]

Can you help break down what issue you stumbled on?