Merge pull request #210 from mkatychev/feat/publish-dry-run

feat: added `--dry-run` to `wkg publish`

Author: lann

Cargo.lock

@@ -85,6 +85,9 @@ pub struct PublishOpts {
     pub package: Option<(PackageRef, Version)>,
     /// Override the registry to publish to.
     pub registry: Option<Registry>,
+    /// If true, resolve the package, version, and registry but do not call the
+    /// backend to publish.
+    pub dry_run: bool,
 }
 
 /// A read-only registry client.
@@ -181,8 +184,9 @@ impl Client {
         let source = self
             .resolve_source(&package, additional_options.registry)
             .await?;
+
         source
-            .publish(&package, &version, data)
+            .publish(&package, &version, data, additional_options.dry_run)
             .await
             .map(|_| (package, version))
     }

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

@@ -112,11 +112,15 @@ impl PackagePublisher for LocalBackend {
         package: &PackageRef,
         version: &Version,
         mut data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), Error> {
         let package_dir = self.package_dir(package);
         // Ensure the package directory exists.
         tokio::fs::create_dir_all(package_dir).await?;
         let path = self.version_path(package, version);
+        if dry_run {
+            return Ok(());
+        }
         let mut out = tokio::fs::File::create(path).await?;
         tokio::io::copy(&mut data, &mut out)
             .await

crates/wasm-pkg-client/src/local.rs

@@ -101,6 +101,13 @@ impl OciBackend {
                 Ok(auth)
             })
             .await
+            .map_err(|e| {
+                if let Error::RegistryError(anyhow_err) = e {
+                    Error::RegistryError(anyhow_err.context(reference.repository().to_owned()))
+                } else {
+                    e
+                }
+            })
             .cloned()
     }
 

crates/wasm-pkg-client/src/oci/mod.rs

@@ -15,6 +15,7 @@ impl PackagePublisher for OciBackend {
         package: &PackageRef,
         version: &Version,
         mut data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), crate::Error> {
         // NOTE(thomastaylor312): oci-client doesn't support publishing from a stream or reader, so
         // we have to read all the data in for now. Once we can address that upstream, we'll be able
@@ -64,10 +65,12 @@ impl PackagePublisher for OciBackend {
 
         let reference: Reference = self.make_reference(package, Some(version));
         let auth = self.auth(&reference, RegistryOperation::Push).await?;
-        self.client
-            .push(&reference, &auth, layer, config, Some(annotations))
-            .await
-            .map_err(crate::Error::RegistryError)?;
+        if !dry_run {
+            self.client
+                .push(&reference, &auth, layer, config, Some(annotations))
+                .await
+                .map_err(crate::Error::RegistryError)?;
+        }
         Ok(())
     }
 }

crates/wasm-pkg-client/src/oci/publisher.rs

@@ -10,5 +10,6 @@ pub trait PackagePublisher: Send + Sync {
         package: &PackageRef,
         version: &Version,
         data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), crate::Error>;
 }

crates/wasm-pkg-client/src/publisher.rs

@@ -18,6 +18,7 @@ impl PackagePublisher for WargBackend {
         package: &PackageRef,
         version: &Version,
         data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), crate::Error> {
         // store the Wasm in Warg cache, so that it is available to Warg client for uploading
         let content = self
@@ -37,6 +38,10 @@ impl PackagePublisher for WargBackend {
         // convert package name to Warg package name
         let name = super::package_ref_to_name(package)?;
 
+        if dry_run {
+            return Ok(());
+        }
+
         // start Warg publish, using the keyring to sign
         let version = version.clone();
         let info = PublishInfo {

crates/wasm-pkg-client/src/warg/publisher.rs

@@ -30,6 +30,7 @@ sha2 = { workspace = true }
 tokio = { workspace = true, optional = true, features = ["fs"] }
 toml = { workspace = true, optional = true }
 thiserror = { workspace = true }
+tracing.workspace = true
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt"] }

crates/wasm-pkg-common/Cargo.toml

@@ -118,6 +118,8 @@ impl Config {
             Some(path) => path,
             None => return Ok(None),
         };
+
+        tracing::debug!(path = %path.display(), "using global config");
         let contents = match tokio::fs::read_to_string(&path).await {
             Ok(contents) => contents,
             Err(err) if err.kind() == ErrorKind::NotFound => return Ok(None),

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

@@ -30,6 +30,7 @@ pub struct Config {
 impl Config {
     /// Loads a configuration file from the given path.
     pub async fn load_from_path(path: impl AsRef<Path>) -> Result<Config> {
+        tracing::info!(path = %path.as_ref().display(), "loading wkg config file");
         let contents = tokio::fs::read_to_string(path)
             .await
             .context("unable to load config from file")?;