all lists on lists.proxmox.com
 help / color / mirror / Atom feed
From: Filip Schauer <f.schauer@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [PATCH proxmox 09/26] oci: add a registry client
Date: Thu, 12 Nov 2026 15:10:36 +0100	[thread overview]
Message-ID: <20261112141109.137298-10-f.schauer@proxmox.com> (raw)
In-Reply-To: <20261112141109.137298-1-f.schauer@proxmox.com>

The client code is inspired by
https://github.com/oras-project/rust-oci-client

Signed-off-by: Filip Schauer <f.schauer@proxmox.com>
---
 proxmox-oci/Cargo.toml     |   7 +
 proxmox-oci/debian/control |  16 +
 proxmox-oci/src/client.rs  | 612 +++++++++++++++++++++++++++++++++++++
 proxmox-oci/src/digest.rs  |  19 ++
 proxmox-oci/src/lib.rs     |   2 +
 5 files changed, 656 insertions(+)
 create mode 100644 proxmox-oci/src/client.rs

diff --git a/proxmox-oci/Cargo.toml b/proxmox-oci/Cargo.toml
index 08c47db5..45248658 100644
--- a/proxmox-oci/Cargo.toml
+++ b/proxmox-oci/Cargo.toml
@@ -13,12 +13,19 @@ rust-version.workspace = true
 
 [dependencies]
 flate2.workspace = true
+http.workspace = true
+http-auth = { version = "0.1", default-features = false }
 oci-spec = "0.8.3"
+serde.workspace = true
+serde_json.workspace = true
 sha2 = "0.10"
 tar.workspace = true
 thiserror = "1"
+url.workspace = true
 zstd.workspace = true
 
+proxmox-base64.workspace = true
+proxmox-http = { workspace = true, features = [ "client-sync" ] }
 proxmox-io.workspace = true
 
 [dev-dependencies]
diff --git a/proxmox-oci/debian/control b/proxmox-oci/debian/control
index a742b948..9ec73059 100644
--- a/proxmox-oci/debian/control
+++ b/proxmox-oci/debian/control
@@ -7,11 +7,19 @@ Build-Depends-Arch: cargo:native <!nocheck>,
  rustc:native (>= 1.88) <!nocheck>,
  libstd-rust-dev <!nocheck>,
  librust-flate2-1+default-dev <!nocheck>,
+ librust-http-1+default-dev <!nocheck>,
+ librust-http-auth-0.1-dev <!nocheck>,
  librust-oci-spec-0.8+default-dev (>= 0.8.3-~~) <!nocheck>,
+ librust-proxmox-base64-1+default-dev <!nocheck>,
+ librust-proxmox-http-1+client-sync-dev (>= 1.0.5-~~) <!nocheck>,
+ librust-proxmox-http-1+default-dev (>= 1.0.5-~~) <!nocheck>,
  librust-proxmox-io-1+default-dev (>= 1.2.1-~~) <!nocheck>,
+ librust-serde-1+default-dev <!nocheck>,
+ librust-serde-json-1+default-dev <!nocheck>,
  librust-sha2-0.10+default-dev <!nocheck>,
  librust-tar-0.4+default-dev <!nocheck>,
  librust-thiserror-1+default-dev <!nocheck>,
+ librust-url-2+default-dev (>= 2.2-~~) <!nocheck>,
  librust-zstd-0.13+default-dev <!nocheck>
 Maintainer: Proxmox Support Team <support@proxmox.com>
 Standards-Version: 4.7.2
@@ -26,11 +34,19 @@ Multi-Arch: same
 Depends:
  ${misc:Depends},
  librust-flate2-1+default-dev,
+ librust-http-1+default-dev,
+ librust-http-auth-0.1-dev,
  librust-oci-spec-0.8+default-dev (>= 0.8.3-~~),
+ librust-proxmox-base64-1+default-dev,
+ librust-proxmox-http-1+client-sync-dev (>= 1.0.5-~~),
+ librust-proxmox-http-1+default-dev (>= 1.0.5-~~),
  librust-proxmox-io-1+default-dev (>= 1.2.1-~~),
+ librust-serde-1+default-dev,
+ librust-serde-json-1+default-dev,
  librust-sha2-0.10+default-dev,
  librust-tar-0.4+default-dev,
  librust-thiserror-1+default-dev,
+ librust-url-2+default-dev (>= 2.2-~~),
  librust-zstd-0.13+default-dev
 Provides:
  librust-proxmox-oci+default-dev (= ${binary:Version}),
diff --git a/proxmox-oci/src/client.rs b/proxmox-oci/src/client.rs
new file mode 100644
index 00000000..c6d15cbc
--- /dev/null
+++ b/proxmox-oci/src/client.rs
@@ -0,0 +1,612 @@
+use std::collections::HashMap;
+use std::io::{self, Cursor, Read, Write};
+use std::str::FromStr;
+use std::time::{Duration, Instant};
+
+use http::HeaderValue;
+use http::uri::Scheme;
+use http::{HeaderMap, StatusCode};
+use http_auth::{ChallengeParser, ChallengeRef};
+use oci_spec::OciSpecError;
+use oci_spec::distribution::{ErrorResponse, Reference, TagList};
+use oci_spec::image::{
+    Arch, Descriptor, Digest, ImageConfiguration, ImageIndex, ImageManifest, MediaType, Os,
+};
+use proxmox_http::client::sync;
+use proxmox_http::{HttpClient, HttpOptions, ProxyConfig};
+use serde::Deserialize;
+use thiserror::Error;
+use url::Url;
+
+use crate::digest::{DigestError, VerifyingReader, verify_digest};
+
+// Inspired by https://github.com/oras-project/rust-oci-client
+
+#[derive(Deserialize)]
+pub enum RegistryAuth {
+    /// Access the registry anonymously
+    Anonymous,
+    /// Access the registry using HTTP Basic authentication
+    Basic(String, String),
+    /// Access the registry using Bearer token authentication
+    Bearer(String),
+}
+
+struct BearerChallenge {
+    realm: Url,
+    service: Option<String>,
+}
+
+impl TryFrom<&HeaderValue> for BearerChallenge {
+    type Error = String;
+
+    fn try_from(value: &HeaderValue) -> Result<Self, Self::Error> {
+        let header = value
+            .to_str()
+            .map_err(|e| format!("cannot convert header value to string: {e:?}"))?;
+        ChallengeParser::new(header)
+            .filter_map(Result::ok)
+            .find_map(|c| BearerChallenge::try_from(&c).ok())
+            .ok_or_else(|| "Cannot find Bearer challenge".to_string())
+    }
+}
+
+impl TryFrom<&ChallengeRef<'_>> for BearerChallenge {
+    type Error = String;
+
+    fn try_from(value: &ChallengeRef<'_>) -> Result<Self, Self::Error> {
+        if !value.scheme.eq_ignore_ascii_case("Bearer") {
+            return Err(format!(
+                "BearerChallenge doesn't support challenge scheme {:?}",
+                value.scheme
+            ));
+        }
+
+        let mut realm = None;
+        let mut service = None;
+
+        for (k, v) in &value.params {
+            if k.eq_ignore_ascii_case("realm") {
+                realm = Some(Url::parse(&v.to_unescaped()).map_err(|err| err.to_string())?);
+            }
+            if k.eq_ignore_ascii_case("service") {
+                service = Some(v.to_unescaped());
+            }
+        }
+
+        if let Some(realm) = realm {
+            Ok(BearerChallenge { realm, service })
+        } else {
+            Err("missing required parameter realm".to_string())
+        }
+    }
+}
+
+enum RegistryTokenType {
+    Bearer(String),
+    Basic(String, String),
+}
+
+struct TokenCacheValue {
+    token: RegistryTokenType,
+    expiration: Option<Instant>,
+}
+
+struct TokenCache(HashMap<Reference, TokenCacheValue>);
+
+impl TokenCache {
+    fn new() -> Self {
+        Self(HashMap::new())
+    }
+
+    fn insert(&mut self, reference: Reference, token: RegistryTokenType) {
+        let expiration = match token {
+            RegistryTokenType::Basic(_, _) => None,
+            RegistryTokenType::Bearer(_) => Instant::now().checked_add(Duration::from_secs(60)),
+        };
+        self.0
+            .insert(reference, TokenCacheValue { token, expiration });
+    }
+
+    fn get(&self, reference: &Reference) -> Option<&RegistryTokenType> {
+        let TokenCacheValue { token, expiration } = self.0.get(reference)?;
+        expiration
+            .is_none_or(|t| t > Instant::now())
+            .then_some(token)
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum OciClientError {
+    #[error("Authentication failure: {0}")]
+    AuthenticationFailure(String),
+    #[error(transparent)]
+    Digest(#[from] DigestError),
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    #[error("No image manifest found in image index for the requested platform")]
+    NoMatchingManifest,
+    #[error("Registry error: url {url}, envelope: {envelope}")]
+    Registry {
+        /// List of errors returned by the OCI registry
+        envelope: ErrorResponse,
+        /// Request URL
+        url: Url,
+    },
+    #[error("Transport error: {0}")]
+    Transport(String),
+    #[error("Server error: url {url}, code: {code}, message: {message}")]
+    Server {
+        code: http::StatusCode,
+        url: Url,
+        message: String,
+    },
+    #[error("OCI distribution spec violation: {0}")]
+    SpecViolation(String),
+    #[error("Not authorized: url {url}")]
+    Unauthorized { url: Url },
+    #[error(transparent)]
+    UrlParse(#[from] url::ParseError),
+    #[error(transparent)]
+    OciSpec(#[from] OciSpecError),
+}
+
+pub struct DigestedImageManifest {
+    pub manifest: ImageManifest,
+    pub raw: Vec<u8>,
+    pub digest: Digest,
+}
+
+pub struct DigestedImageConfig {
+    pub config: ImageConfiguration,
+    pub raw: Vec<u8>,
+    pub digest: Digest,
+}
+
+pub struct ImageMetadata {
+    pub manifest: DigestedImageManifest,
+    pub config: DigestedImageConfig,
+}
+
+struct OciResponse {
+    status: StatusCode,
+    headers: HeaderMap,
+    url: Url,
+    body: Box<dyn Read>,
+}
+
+impl OciResponse {
+    fn into_body(self) -> Box<dyn Read> {
+        self.body
+    }
+
+    fn read_to_end(mut self) -> Result<Vec<u8>, OciClientError> {
+        let mut buf = Vec::new();
+        self.body.read_to_end(&mut buf)?;
+        Ok(buf)
+    }
+
+    fn read_to_string(mut self) -> Result<String, OciClientError> {
+        let mut s = String::new();
+        self.body.read_to_string(&mut s)?;
+        Ok(s)
+    }
+}
+
+struct OciRequest {
+    url: Url,
+    headers: Vec<(String, String)>,
+    query_params: Vec<(String, String)>,
+}
+
+impl OciRequest {
+    fn new(url: Url) -> Self {
+        Self {
+            url,
+            headers: Vec::new(),
+            query_params: Vec::new(),
+        }
+    }
+
+    fn header(mut self, name: &str, value: &str) -> Self {
+        self.headers.push((name.to_string(), value.to_string()));
+        self
+    }
+
+    fn query(mut self, key: &str, value: &str) -> Self {
+        self.query_params.push((key.to_string(), value.to_string()));
+        self
+    }
+
+    fn with_accept(mut self, accept: &[&str]) -> Self {
+        self.headers.push(("Accept".to_string(), accept.join(", ")));
+        self
+    }
+
+    fn with_auth(mut self, token: &RegistryTokenType) -> Self {
+        let value = match token {
+            RegistryTokenType::Bearer(token) => format!("Bearer {token}"),
+            RegistryTokenType::Basic(username, password) => {
+                let creds = proxmox_base64::encode(format!("{username}:{password}"));
+                format!("Basic {creds}")
+            }
+        };
+        self.headers.push(("Authorization".to_string(), value));
+        self
+    }
+
+    fn build_url(&self) -> Url {
+        let mut url = self.url.clone();
+
+        for (k, v) in &self.query_params {
+            url.query_pairs_mut().append_pair(k, v);
+        }
+
+        url
+    }
+}
+
+pub struct ClientConfig {
+    pub protocol: Scheme,
+    pub timeout: Option<Duration>,
+    pub proxy_config: Option<ProxyConfig>,
+}
+
+impl Default for ClientConfig {
+    fn default() -> Self {
+        Self {
+            protocol: Scheme::HTTPS,
+            timeout: Some(Duration::from_secs(20)),
+            proxy_config: None,
+        }
+    }
+}
+
+pub struct Client {
+    protocol: Scheme,
+    auth: RegistryAuth,
+    tokens: TokenCache,
+    http_client: sync::Client,
+}
+
+impl Client {
+    pub fn new(config: ClientConfig, auth: RegistryAuth) -> Self {
+        let options = HttpOptions {
+            proxy_config: config.proxy_config,
+            ..Default::default()
+        };
+
+        let http_client = if let Some(timeout) = config.timeout {
+            sync::Client::new_with_timeout(options, timeout)
+        } else {
+            sync::Client::new(options)
+        }
+        .with_http_status_as_error(false);
+
+        Self {
+            tokens: TokenCache::new(),
+            protocol: config.protocol,
+            auth,
+            http_client,
+        }
+    }
+
+    fn get_auth_token(
+        &mut self,
+        reference: &Reference,
+    ) -> Result<Option<&RegistryTokenType>, OciClientError> {
+        if self.tokens.get(reference).is_none() {
+            match self.authenticate(reference, &self.auth)? {
+                Some(token) => self.tokens.insert(reference.clone(), token),
+                None => return Ok(None),
+            };
+        }
+
+        Ok(self.tokens.get(reference))
+    }
+
+    fn authenticate(
+        &self,
+        image: &Reference,
+        authentication: &RegistryAuth,
+    ) -> Result<Option<RegistryTokenType>, OciClientError> {
+        if let RegistryAuth::Bearer(token) = authentication {
+            return Ok(Some(RegistryTokenType::Bearer(token.clone())));
+        }
+
+        let url = Url::parse(&format!(
+            "{}://{}/v2/",
+            self.protocol,
+            image.resolve_registry()
+        ))?;
+        let req = OciRequest::new(url);
+        let res = self.send(req)?;
+        let dist_hdr = match res.headers.get(http::header::WWW_AUTHENTICATE) {
+            Some(h) => h,
+            None => return Ok(None),
+        };
+
+        let challenge = match BearerChallenge::try_from(dist_hdr) {
+            Ok(c) => c,
+            Err(_) => {
+                if let RegistryAuth::Basic(username, password) = authentication {
+                    return Ok(Some(RegistryTokenType::Basic(
+                        username.to_string(),
+                        password.to_string(),
+                    )));
+                }
+                return Ok(None);
+            }
+        };
+
+        let mut auth_req = OciRequest::new(challenge.realm)
+            .query("scope", &format!("repository:{}:pull", image.repository()));
+
+        if let Some(s) = challenge.service {
+            auth_req = auth_req.query("service", &s);
+        }
+
+        if let RegistryAuth::Basic(username, password) = authentication {
+            let creds = proxmox_base64::encode(format!("{username}:{password}"));
+            auth_req = auth_req.header("Authorization", &format!("Basic {creds}"));
+        }
+
+        let auth_res = self.send(auth_req)?;
+        let status = auth_res.status;
+        let text = auth_res.read_to_string()?;
+
+        if status != StatusCode::OK {
+            return Err(OciClientError::AuthenticationFailure(text));
+        }
+
+        serde_json::from_str::<serde_json::Value>(&text)
+            .ok()
+            .as_ref()
+            .and_then(|j| j["token"].as_str().or(j["access_token"].as_str()))
+            .map(|t| Some(RegistryTokenType::Bearer(t.into())))
+            .ok_or_else(|| {
+                OciClientError::AuthenticationFailure("Invalid response or missing token".into())
+            })
+    }
+
+    pub fn list_tags(
+        &mut self,
+        image: &Reference,
+        n: Option<usize>,
+        last: Option<&str>,
+    ) -> Result<TagList, OciClientError> {
+        let url = self.to_v2_url(image, "tags/list")?;
+        let mut req = OciRequest::new(url.clone());
+        if let Some(num) = n {
+            req = req.query("n", &num.to_string());
+        }
+        if let Some(l) = last {
+            req = req.query("last", l);
+        }
+
+        if let Some(auth_token) = self.get_auth_token(image)? {
+            req = req.with_auth(auth_token);
+        }
+        let res = self.send(req)?;
+        let status = res.status;
+        let body = res.read_to_end()?;
+        validate_registry_response(status, &body, &url)?;
+        Ok(serde_json::from_slice(&body).map_err(OciSpecError::SerDe)?)
+    }
+
+    pub fn pull_image_manifest(
+        &mut self,
+        image: &Reference,
+        os: Option<&Os>,
+        arch: Option<&Arch>,
+    ) -> Result<DigestedImageManifest, OciClientError> {
+        let (body, digest, media_type) = self.pull_manifest_raw(
+            image,
+            &[
+                MediaType::ImageManifest.as_ref(),
+                MediaType::ImageIndex.as_ref(),
+            ],
+        )?;
+
+        if matches!(media_type, MediaType::ImageIndex) {
+            let index = ImageIndex::from_reader(Cursor::new(&body))?;
+
+            let manifest_digest = index
+                .manifests()
+                .iter()
+                .find(|m| {
+                    m.platform().as_ref().is_none_or(|p| {
+                        arch.is_none_or(|a| p.architecture() == a) && os.is_none_or(|o| p.os() == o)
+                    })
+                })
+                .map(|m| m.digest().clone())
+                .ok_or(OciClientError::NoMatchingManifest)?;
+
+            let manifest_reference = image.clone_with_digest(manifest_digest.to_string());
+            let (manifest_raw, manifest_digest, _) =
+                self.pull_manifest_raw(&manifest_reference, &[MediaType::ImageManifest.as_ref()])?;
+            let manifest = ImageManifest::from_reader(Cursor::new(&manifest_raw))?;
+
+            Ok(DigestedImageManifest {
+                manifest,
+                raw: manifest_raw,
+                digest: manifest_digest,
+            })
+        } else {
+            let manifest = ImageManifest::from_reader(Cursor::new(&body))?;
+            Ok(DigestedImageManifest {
+                manifest,
+                raw: body,
+                digest,
+            })
+        }
+    }
+
+    pub fn pull_manifest_raw(
+        &mut self,
+        image: &Reference,
+        accepted_media_types: &[&str],
+    ) -> Result<(Vec<u8>, Digest, MediaType), OciClientError> {
+        let url = self.to_v2_url(
+            image,
+            &format!(
+                "manifests/{}",
+                image.digest().or_else(|| image.tag()).unwrap_or("latest")
+            ),
+        )?;
+
+        let mut req = OciRequest::new(url).with_accept(accepted_media_types);
+        if let Some(auth_token) = self.get_auth_token(image)? {
+            req = req.with_auth(auth_token);
+        }
+        let res = self.send(req)?;
+
+        let status = res.status;
+        let url = res.url.clone();
+        let headers = res.headers.clone();
+        let body = res.read_to_end()?;
+        validate_registry_response(status, &body, &url)?;
+
+        let expected_digest = image.digest().map(Digest::from_str).transpose()?;
+        let digest = verify_digest(&body, expected_digest)?;
+
+        let Some(media_type) = headers
+            .get(http::header::CONTENT_TYPE)
+            .and_then(|v| v.to_str().ok())
+            .map(MediaType::from)
+        else {
+            return Err(OciClientError::SpecViolation("Missing Content-Type".into()));
+        };
+
+        Ok((body, digest, media_type))
+    }
+
+    pub fn pull_image_manifest_and_config(
+        &mut self,
+        image: &Reference,
+        os: Option<&Os>,
+        arch: Option<&Arch>,
+    ) -> Result<ImageMetadata, OciClientError> {
+        let digested_manifest = self.pull_image_manifest(image, os, arch)?;
+
+        let config_descriptor = digested_manifest.manifest.config();
+        let mut config_bytes = Vec::new();
+        self.pull_blob(image, config_descriptor, &mut config_bytes)?;
+
+        let config = ImageConfiguration::from_reader(Cursor::new(&config_bytes))?;
+        let digested_config = DigestedImageConfig {
+            config,
+            raw: config_bytes,
+            digest: config_descriptor.digest().clone(),
+        };
+
+        Ok(ImageMetadata {
+            manifest: digested_manifest,
+            config: digested_config,
+        })
+    }
+
+    pub fn pull_blob<W: Write>(
+        &mut self,
+        image: &Reference,
+        layer: &Descriptor,
+        out: &mut W,
+    ) -> Result<(), OciClientError> {
+        let mut reader = self.pull_blob_reader(image, layer)?;
+        io::copy(&mut reader, out).map_err(|err| {
+            err.downcast::<DigestError>()
+                .map(OciClientError::Digest)
+                .unwrap_or_else(OciClientError::Io)
+        })?;
+        out.flush()?;
+
+        Ok(())
+    }
+
+    pub fn pull_blob_reader(
+        &mut self,
+        image: &Reference,
+        layer: &Descriptor,
+    ) -> Result<VerifyingReader<Box<dyn Read>>, OciClientError> {
+        let url = self.to_v2_url(image, &format!("blobs/{}", layer.digest()))?;
+
+        let mut request = OciRequest::new(url);
+        if let Some(auth_token) = self.get_auth_token(image)? {
+            request = request.with_auth(auth_token);
+        }
+
+        let response = self.send(request)?;
+        let status = response.status;
+        let url = response.url.clone();
+
+        if !status.is_success() {
+            let body = response.read_to_end()?;
+            return Err(validate_registry_response(status, &body, &url)
+                .expect_err("non-success status code must produce error"));
+        }
+
+        Ok(VerifyingReader::new(
+            response.into_body(),
+            layer.digest().clone(),
+        )?)
+    }
+
+    fn to_v2_url(&self, reference: &Reference, suffix: &str) -> Result<Url, url::ParseError> {
+        Url::parse(&format!(
+            "{}://{}/v2/{}/{suffix}",
+            self.protocol,
+            reference.resolve_registry(),
+            reference.repository(),
+        ))
+    }
+
+    fn send(&self, req: OciRequest) -> Result<OciResponse, OciClientError> {
+        let url = req.build_url();
+
+        let headers = req.headers.into_iter().collect();
+
+        let res = self
+            .http_client
+            .get(url.as_str(), Some(&headers))
+            .map_err(|e| OciClientError::Transport(e.to_string()))?;
+
+        let (parts, body) = res.into_parts();
+
+        Ok(OciResponse {
+            status: parts.status,
+            headers: parts.headers,
+            url,
+            body,
+        })
+    }
+}
+
+fn validate_registry_response(
+    status: StatusCode,
+    body: &[u8],
+    url: &Url,
+) -> Result<(), OciClientError> {
+    match status {
+        StatusCode::OK => Ok(()),
+        StatusCode::UNAUTHORIZED => Err(OciClientError::Unauthorized { url: url.clone() }),
+        s if s.is_success() => Err(OciClientError::SpecViolation(format!(
+            "Expected HTTP Status 200 OK, got {status} instead"
+        ))),
+        s if s.is_client_error() => match serde_json::from_slice::<ErrorResponse>(body) {
+            Ok(envelope) => Err(OciClientError::Registry {
+                envelope,
+                url: url.clone(),
+            }),
+            Err(_) => Err(OciClientError::Server {
+                code: s,
+                url: url.clone(),
+                message: String::from_utf8_lossy(body).into_owned(),
+            }),
+        },
+        s => Err(OciClientError::Server {
+            code: s,
+            url: url.clone(),
+            message: String::from_utf8_lossy(body).into_owned(),
+        }),
+    }
+}
diff --git a/proxmox-oci/src/digest.rs b/proxmox-oci/src/digest.rs
index b2170b87..af264f06 100644
--- a/proxmox-oci/src/digest.rs
+++ b/proxmox-oci/src/digest.rs
@@ -43,6 +43,25 @@ impl Digester {
     }
 }
 
+pub fn verify_digest(body: &[u8], expected_digest: Option<Digest>) -> Result<Digest, DigestError> {
+    let algorithm = expected_digest
+        .as_ref()
+        .map(|d| d.algorithm())
+        .unwrap_or(&DigestAlgorithm::Sha256);
+
+    let mut digester = Digester::new(algorithm)?;
+    digester.update(body);
+    let actual = digester.finalize();
+
+    if let Some(expected) = expected_digest
+        && actual != expected
+    {
+        return Err(DigestError::Mismatch { expected, actual });
+    }
+
+    Ok(actual)
+}
+
 pub struct VerifyingReader<R: Read> {
     inner: R,
     digester: Digester,
diff --git a/proxmox-oci/src/lib.rs b/proxmox-oci/src/lib.rs
index fcb81b03..274563f4 100644
--- a/proxmox-oci/src/lib.rs
+++ b/proxmox-oci/src/lib.rs
@@ -3,6 +3,8 @@ use std::path::Path;
 pub use oci_spec::image::{Arch, Config, Os};
 use thiserror::Error;
 
+pub mod client;
+
 mod digest;
 
 mod extract;
-- 
2.47.3





  parent reply	other threads:[~2026-11-12 14:13 UTC|newest]

Thread overview: 27+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-12 14:10 [PATCH container/manager/proxmox{,-perl-rs}/storage 00/26] oci: add native registry client and prepare for OverlayFS Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox-perl-rs 01/26] pve-rs: oci: update doc comment of parse_and_extract_image Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 02/26] oci: rename error when no manifest can be selected Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 03/26] oci: add `os` parameter to parse_and_extract_image Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox-perl-rs 04/26] pve-rs: " Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 05/26] oci: add a digest helper module Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 06/26] oci: reduce redundant layer decompression during extraction Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 07/26] oci: factor out parsing and extraction into modules Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 08/26] oci: explicitly set mtime of directories when extracting layer Filip Schauer
2026-11-12 14:10 ` Filip Schauer [this message]
2026-11-12 14:10 ` [PATCH proxmox 10/26] oci: add a public list_repository_tags function Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox-perl-rs 11/26] pve-rs: oci: expose list_repository_tags Filip Schauer
2026-11-12 14:10 ` [PATCH manager 12/26] use proxmox-oci instead of skopeo for listing tags from OCI registries Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 13/26] oci: rename parse_and_extract_image to be tar-specific Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox-perl-rs 14/26] pve-rs: " Filip Schauer
2026-11-12 14:10 ` [PATCH container 15/26] oci create: " Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 16/26] oci: rename ProxmoxOciError to ParseAndExtractTarError Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 17/26] oci: add a public pull_image_as_tar function Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox-perl-rs 18/26] pve-rs: oci: expose pull_image_as_tar Filip Schauer
2026-11-12 14:10 ` [PATCH storage 19/26] use proxmox-oci instead of skopeo for pulling from OCI registries Filip Schauer
2026-11-12 14:10 ` [PATCH storage 20/26] api: oci image pull: fix temp file cleanup on task stop Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 21/26] oci: add a public pull_image_to_oci_storage function Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox-perl-rs 22/26] pve-rs: oci: expose pull_image_to_oci_storage Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 23/26] fix #7058: oci: add compatibility for Docker Image Manifest V2 Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 24/26] oci: include media type in ParseError::WrongMediaType Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox 25/26] oci: add public functions for removing OCI images Filip Schauer
2026-11-12 14:10 ` [PATCH proxmox-perl-rs 26/26] pve-rs: oci: expose " Filip Schauer

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261112141109.137298-10-f.schauer@proxmox.com \
    --to=f.schauer@proxmox.com \
    --cc=pve-devel@lists.proxmox.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.
Service provided by Proxmox Server Solutions GmbH | Privacy | Legal