Method pull_via_api

crates/lib/src/podman_client.rs:183–243

Pull using the libpod HTTP API (docker transport only).

(&self, image: &str)

    /// Pull using the libpod HTTP API (docker transport only).
    async fn pull_via_api(&self, image: &str) -> Result<()> {
        let stream = tokio::net::UnixStream::connect(&self.socket_path)
            .await
            .context("Connecting to podman API socket")?;
        let io = hyper_util::rt::TokioIo::new(stream);

        let (mut sender, conn) = hyper::client::conn::http1::handshake(io)
            .await
            .context("HTTP/1.1 handshake with podman")?;

        tokio::spawn(async move {
            if let Err(e) = conn.await {
                tracing::warn!("Podman HTTP connection error: {e}");
            }
        });

        let encoded_ref =
            percent_encoding::utf8_percent_encode(image, percent_encoding::NON_ALPHANUMERIC);
        let uri = format!(
            "/{LIBPOD_API_VERSION}/libpod/images/pull?reference={encoded_ref}&pullProgress=true&policy=always"
        );

        tracing::debug!("POST {uri}");
        let response = sender
            .send_request(
                hyper::Request::builder()
                    .method(hyper::Method::POST)
                    .uri(&uri)
                    .header(hyper::header::HOST, "d")
                    .body(http_body_util::Empty::<hyper::body::Bytes>::new())
                    .context("Building pull request")?,
            )
            .await
            .context("Sending pull request to podman")?;

        let status = response.status();
        if !status.is_success() {
            let body = response
                .into_body()
                .collect()
                .await
                .context("Reading error response body")?
                .to_bytes();
            anyhow::bail!(
                "Podman libpod pull failed with HTTP {status}: {}",
                String::from_utf8_lossy(&body)
            );
        }

        // Turn the HTTP body into an AsyncBufRead so we can use read_line().
        let body_stream =
            http_body_util::BodyStream::new(response.into_body()).filter_map(|r| async {
                match r {
                    Ok(frame) => frame.into_data().ok().map(|b| Ok::<_, std::io::Error>(b)),
                    Err(e) => Some(Err(std::io::Error::other(e))),
                }
            });
        let reader = tokio_util::io::StreamReader::new(body_stream);