Merge pull request #6 from calvinrp/updated-warg

updated Warg and refactored

.gitignore

@@ -1,2 +1,4 @@
 target/
 Cargo.lock
+
+*.swp

crates/wasm-pkg-loader/Cargo.toml

@@ -27,6 +27,7 @@ tokio = { version = "1.35.1", features = ["rt", "macros"] }
 tokio-util = { version = "0.7.10", features = ["io"] }
 toml = "0.8.8"
 tracing = "0.1.40"
-tracing-subscriber = "0.3.18"
-warg-client = "=0.4.1"
-warg-protocol = "=0.4.1"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+url = "2.5.0"
+warg-client = "0.6.0"
+warg-protocol = "0.6.0"

crates/wasm-pkg-loader/src/config.rs

@@ -28,23 +28,27 @@ impl ClientConfig {
 
     pub fn merge_config(&mut self, other: ClientConfig) -> &mut Self {
         if let Some(default_registry) = other.default_registry {
-            self.default_registry(default_registry);
+            self.set_default_registry(default_registry);
         }
         for (namespace, registry) in other.namespace_registries {
-            self.namespace_registry(namespace, registry);
+            self.set_namespace_registry(namespace, registry);
         }
         for (registry, config) in other.registry_configs {
             self.registry_configs.insert(registry, config);
         }
         self
     }
 
-    pub fn default_registry(&mut self, registry: impl Into<String>) -> &mut Self {
+    pub fn set_default_registry(&mut self, registry: impl Into<String>) -> &mut Self {
         self.default_registry = Some(registry.into());
         self
     }
 
-    pub fn namespace_registry(
+    pub fn default_registry(&self) -> Option<&str> {
+        self.default_registry.as_deref()
+    }
+
+    pub fn set_namespace_registry(
         &mut self,
         namespace: impl Into<String>,
         registry: impl Into<String>,
@@ -54,7 +58,7 @@ impl ClientConfig {
         self
     }
 
-    pub fn local_registry_config(
+    pub fn set_local_registry_config(
         &mut self,
         registry: impl Into<String>,
         root: impl Into<PathBuf>,
@@ -66,7 +70,7 @@ impl ClientConfig {
         self
     }
 
-    pub fn oci_registry_config(
+    pub fn set_oci_registry_config(
         &mut self,
         registry: impl Into<String>,
         client_config: Option<OciClientConfig>,
@@ -88,14 +92,14 @@ impl ClientConfig {
         Ok(self)
     }
 
-    pub fn warg_registry_config(
+    pub fn set_warg_registry_config(
         &mut self,
         registry: impl Into<String>,
         client_config: Option<warg_client::Config>,
         auth_token: Option<impl Into<SecretString>>,
     ) -> Result<&mut Self, Error> {
         let cfg = RegistryConfig::Warg(WargConfig {
-            client_config: client_config.unwrap_or_default(),
+            client_config,
             auth_token: auth_token.map(Into::into),
         });
         self.registry_configs.insert(registry.into(), cfg);

crates/wasm-pkg-loader/src/config/toml.rs

@@ -118,8 +118,8 @@ impl TryFrom<TomlRegistryConfig> for super::RegistryConfig {
                 config_file,
             } => {
                 let client_config = match config_file {
-                    Some(path) => warg_client::Config::from_file(path)?,
-                    None => warg_client::Config::from_default_file()?.unwrap_or_default(),
+                    Some(path) => Some(warg_client::Config::from_file(path)?),
+                    None => Some(warg_client::Config::from_default_file()?.unwrap_or_default()),
                 };
                 Self::Warg(WargConfig {
                     auth_token,

crates/wasm-pkg-loader/src/lib.rs

@@ -15,7 +15,7 @@ use source::{
     local::LocalSource,
     oci::{OciConfig, OciSource},
     warg::{WargConfig, WargSource},
-    PackageSource,
+    PackageSource, VersionInfo,
 };
 
 /// Re-exported to ease configuration.
@@ -54,7 +54,10 @@ impl Client {
     }
 
     /// Returns a list of all package [`Version`]s available for the given package.
-    pub async fn list_all_versions(&mut self, package: &PackageRef) -> Result<Vec<Version>, Error> {
+    pub async fn list_all_versions(
+        &mut self,
+        package: &PackageRef,
+    ) -> Result<Vec<VersionInfo>, Error> {
         let source = self.resolve_source(package).await?;
         source.list_all_versions(package).await
     }
@@ -103,36 +106,34 @@ impl Client {
             let source: Box<dyn PackageSource> = match registry_config {
                 config::RegistryConfig::Local(config) => Box::new(LocalSource::new(config)),
                 config::RegistryConfig::Oci(config) => {
-                    Box::new(self.build_oci_client(&registry, config).await?)
+                    Box::new(self.build_oci_client(&registry, registry_meta, config)?)
                 }
                 config::RegistryConfig::Warg(config) => {
-                    Box::new(self.build_warg_client(&registry, config).await?)
+                    Box::new(self.build_warg_client(&registry, registry_meta, config)?)
                 }
             };
             self.sources.insert(registry.clone(), source);
         }
         Ok(self.sources.get_mut(&registry).unwrap().as_mut())
     }
 
-    async fn build_oci_client(
+    fn build_oci_client(
         &mut self,
         registry: &str,
+        registry_meta: RegistryMeta,
         config: OciConfig,
     ) -> Result<OciSource, Error> {
         tracing::debug!("Building new OCI client for {registry:?}");
-        // Check registry metadata for OCI registry override
-        let registry_meta = RegistryMeta::fetch_or_default(registry).await;
         OciSource::new(registry.to_string(), config, registry_meta)
     }
 
-    async fn build_warg_client(
+    fn build_warg_client(
         &mut self,
         registry: &str,
+        registry_meta: RegistryMeta,
         config: WargConfig,
     ) -> Result<WargSource, Error> {
         tracing::debug!("Building new Warg client for {registry:?}");
-        // Check registry metadata for OCI registry override
-        let registry_meta = RegistryMeta::fetch_or_default(registry).await;
         WargSource::new(registry.to_string(), config, registry_meta)
     }
 }
@@ -164,6 +165,12 @@ pub enum Error {
     RegistryMeta(#[source] anyhow::Error),
     #[error("invalid version: {0}")]
     VersionError(#[from] semver::Error),
+    #[error("version not found: {0}")]
+    VersionNotFound(Version),
+    #[error("version yanked: {0}")]
+    VersionYanked(Version),
     #[error("Warg error: {0}")]
     WargError(#[from] warg_client::ClientError),
+    #[error("Warg error: {0}")]
+    WargAnyhowError(#[from] anyhow::Error),
 }

crates/wasm-pkg-loader/src/main.rs

@@ -7,7 +7,9 @@ use wasm_pkg_loader::{Client, ClientConfig, PackageRef, Release, Version};
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> anyhow::Result<()> {
-    tracing_subscriber::fmt::init();
+    tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .init();
 
     let mut args = std::env::args();
     let arg0 = args.next().unwrap_or_else(|| "wasm-pkg-loader".into());
@@ -21,7 +23,7 @@ async fn main() -> anyhow::Result<()> {
 
     let client = {
         let mut config = ClientConfig::default();
-        config.namespace_registry("wasi", "bytecodealliance.org");
+        config.set_namespace_registry("wasi", "bytecodealliance.org");
         if let Some(file_config) = ClientConfig::from_default_file()? {
             config.merge_config(file_config);
         }
@@ -65,7 +67,11 @@ async fn show_package_info(
         println!("Package: {package}");
         println!("Versions:");
         for ver in versions {
-            println!("  {ver}");
+            println!(
+                "  {ver}{yanked}",
+                ver = ver.version,
+                yanked = if ver.yanked { " - Yanked" } else { "" }
+            );
         }
     }
     Ok(())
@@ -86,6 +92,7 @@ async fn fetch_package_content(
                 .with_context(|| format!("error listing {package} releases"))?;
             versions
                 .into_iter()
+                .map(|v| v.version)
                 .max()
                 .with_context(|| format!("no releases found for {package}"))?
         }

crates/wasm-pkg-loader/src/source.rs

@@ -2,16 +2,47 @@ use async_trait::async_trait;
 use bytes::Bytes;
 use futures_util::{stream::BoxStream, StreamExt};
 use semver::Version;
+use std::cmp::Ordering;
 
 use crate::{Error, PackageRef, Release};
 
 pub mod local;
 pub mod oci;
 pub mod warg;
 
+#[derive(Clone, Debug, Eq)]
+pub struct VersionInfo {
+    pub version: Version,
+    pub yanked: bool,
+}
+
+impl Ord for VersionInfo {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.version.cmp(&other.version)
+    }
+}
+
+impl PartialOrd for VersionInfo {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.version.cmp(&other.version))
+    }
+}
+
+impl PartialEq for VersionInfo {
+    fn eq(&self, other: &Self) -> bool {
+        self.version == other.version
+    }
+}
+
+impl std::fmt::Display for VersionInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{version}", version = self.version)
+    }
+}
+
 #[async_trait]
 pub trait PackageSource: Send {
-    async fn list_all_versions(&mut self, package: &PackageRef) -> Result<Vec<Version>, Error>;
+    async fn list_all_versions(&mut self, package: &PackageRef) -> Result<Vec<VersionInfo>, Error>;
 
     async fn get_release(
         &mut self,

crates/wasm-pkg-loader/src/source/local.rs

@@ -6,7 +6,10 @@ use futures_util::{stream::BoxStream, StreamExt, TryStreamExt};
 use semver::Version;
 use tokio_util::io::ReaderStream;
 
-use crate::{source::PackageSource, ContentDigest, Error, PackageRef, Release};
+use crate::{
+    source::{PackageSource, VersionInfo},
+    ContentDigest, Error, PackageRef, Release,
+};
 
 #[derive(Clone, Debug)]
 pub struct LocalConfig {
@@ -38,7 +41,7 @@ impl LocalSource {
 
 #[async_trait]
 impl PackageSource for LocalSource {
-    async fn list_all_versions(&mut self, package: &PackageRef) -> Result<Vec<Version>, Error> {
+    async fn list_all_versions(&mut self, package: &PackageRef) -> Result<Vec<VersionInfo>, Error> {
         let mut versions = vec![];
         let package_dir = self.package_dir(package);
         tracing::debug!("Reading versions from {package_dir:?}");
@@ -57,7 +60,10 @@ impl PackageSource for LocalSource {
                 tracing::warn!("invalid package file name at {path:?}");
                 continue;
             };
-            versions.push(version);
+            versions.push(VersionInfo {
+                version,
+                yanked: false,
+            });
         }
         Ok(versions)
     }

crates/wasm-pkg-loader/src/source/oci.rs

@@ -9,7 +9,10 @@ use secrecy::ExposeSecret;
 use semver::Version;
 
 use crate::{
-    config::BasicCredentials, meta::RegistryMeta, source::PackageSource, Error, PackageRef, Release,
+    config::BasicCredentials,
+    meta::RegistryMeta,
+    source::{PackageSource, VersionInfo},
+    Error, PackageRef, Release,
 };
 
 const WASM_LAYER_MEDIA_TYPES: &[&str] = &[
@@ -154,7 +157,7 @@ impl OciSource {
 
 #[async_trait]
 impl PackageSource for OciSource {
-    async fn list_all_versions(&mut self, package: &PackageRef) -> Result<Vec<Version>, Error> {
+    async fn list_all_versions(&mut self, package: &PackageRef) -> Result<Vec<VersionInfo>, Error> {
         let reference = self.make_reference(package, None);
 
         tracing::debug!("Listing tags for OCI reference {reference:?}");
@@ -167,7 +170,10 @@ impl PackageSource for OciSource {
             .tags
             .iter()
             .flat_map(|tag| match Version::parse(tag) {
-                Ok(version) => Some(version),
+                Ok(version) => Some(VersionInfo {
+                    version,
+                    yanked: false,
+                }),
                 Err(err) => {
                     tracing::warn!("Ignoring invalid version tag {tag:?}: {err:?}");
                     None