wapm.io integration

cli/src/main.rs

@@ -14,6 +14,7 @@ use humansize::{format_size, BINARY};
 use owo_colors::OwoColorize;
 use prettytable::{row, Table};
 use tokio::runtime::Runtime;
+use utils::registry::{download_module, gen_manifest, PackageRegistry, PackageSpec};
 use utils::structs::Manifest;
 use uuid::Uuid;
 
@@ -70,6 +71,12 @@ pub enum Command {
     History,
     /// Liveness check: ping at least one node on the mesh.
     Ping,
+    /// Highly experimental: Pull a package from WAPM.io and store it in Serval Mesh
+    Pull {
+        /// The name of the software package, formatted as
+        /// [[protocol://]registry.tld/]author/packagename[@version][:module]
+        identifer: String,
+    },
 }
 
 static SERVAL_NODE_URL: Mutex<Option<String>> = Mutex::new(None);
@@ -289,6 +296,95 @@ fn blocking_maybe_discover_service_url(
     Ok(format!("http://{addr}:{port}"))
 }
 
+/// Pull a Wasm package from a package manager, generate its manifest, and store it.
+fn pull(identifer: String) -> Result<()> {
+    let pkg_spec = PackageSpec::try_from(identifer).unwrap();
+    log::debug!("{:#?}", pkg_spec);
+    println!(
+        "📦 Identified package {}",
+        pkg_spec.profile_url().bold().blue()
+    );
+    println!("🏷  Using module {}", pkg_spec.module.bold().blue());
+    if pkg_spec.is_binary_cached() {
+        println!(
+            "✅ Binary for {} ({}) available locally.",
+            pkg_spec.fq_name().bold().green(),
+            pkg_spec.fq_digest()
+        );
+        // Creating a temporary manifest file
+        let manifest_path = gen_manifest(&pkg_spec).unwrap();
+        // Handing over to existing storage logic
+        upload_manifest(manifest_path)?;
+    } else {
+        println!(
+            "⌛️ Binary for {} not available locally, downloading...",
+            pkg_spec.fq_name().blue()
+        );
+        let mod_dl = download_module(&pkg_spec);
+        match mod_dl {
+            // This means the download function did not break. It does not mean that
+            // the executable was downloaded successfully... check HTTP status code.
+            Ok(status_code) => {
+                if status_code.is_success() {
+                    println!(
+                        "✅ Downloaded {} ({}) successfully.",
+                        pkg_spec.fq_name().bold().green(),
+                        pkg_spec.fq_digest()
+                    );
+                    // Creating a temporary manifest file
+                    let manifest_path = gen_manifest(&pkg_spec).unwrap();
+                    // Handing over to existing storage logic
+                    upload_manifest(manifest_path)?;
+                } else if status_code.is_server_error() {
+                    println!("🛑 Server error: {}", status_code);
+                    println!("   There may be an issue with this package manager.");
+                } else if status_code.is_client_error() {
+                    println!("🛑 Client error: {}", status_code);
+                    println!("{:#?}", status_code);
+                    if status_code == 404 {
+                        println!("   Failed to download from {:?}", pkg_spec.download_urls());
+                    }
+                    println!();
+                    if pkg_spec.version == "latest" && pkg_spec.registry == PackageRegistry::Wapm {
+                        println!(
+                            "💡 Please note that wapm.io does not properly alias the `{}` version tag.",
+                            "latest".bold().yellow()
+                        );
+                        println!("   You might want to look up the package and explicitly provide its most recent version:");
+                        println!("   \t{}", pkg_spec.profile_url());
+                        println!();
+                    }
+                    // Currently, a 404 is very likely if a package only contains modules that have names other than
+                    // the package name (which the module name defaults to if not provided).
+                    // TODO: retrieve available modules and interactively ask which module should be downloaded
+                    // Quick fix is to point this out to the user:
+                    if pkg_spec.name == pkg_spec.module {
+                        println!(
+                            "💡 Please verify that this package actually contains a `{}` module",
+                            pkg_spec.module.bold().yellow()
+                        );
+                        println!("   by checking the MODULES section on its profile page:");
+                        println!("   \t{}", pkg_spec.profile_url());
+                        println!(
+                            "   If the module name differs from the package name, you need to provide it with"
+                        );
+                        println!(
+                            "   \tserval pull {}:{}",
+                            pkg_spec.profile_url(),
+                            "<module>".bold().yellow()
+                        );
+                    }
+                } else {
+                    println!("😵‍💫 Something else happened. Status: {:?}", status_code);
+                }
+            }
+            // Something went horribly wrong.
+            Err(err) => println!("{:#?}", err),
+        }
+    }
+    Ok(())
+}
+
 /// Parse command-line arguments and act.
 fn main() -> Result<()> {
     let args = Args::parse();
@@ -320,6 +416,7 @@ fn main() -> Result<()> {
         Command::Status { id } => status(id)?,
         Command::History => history()?,
         Command::Ping => ping()?,
+        Command::Pull { identifer } => pull(identifer)?,
     };
 
     Ok(())

utils/Cargo.toml

@@ -25,3 +25,5 @@ tokio = { workspace = true }
 toml = "0.7.0"
 uuid = { workspace = true }
 wasi-common = { workspace = true }
+regex = "1.7.1"
+sha256 = "1.1.2"

utils/src/errors.rs

@@ -70,6 +70,18 @@ pub enum ServalError {
     /// Translation for errors from ssri.
     #[error("ssri::Error: {0}")]
     SsriError(#[from] ssri::Error),
+
+    /// The Package Registry is unknown.
+    #[error("unknown package registry`{0}`")]
+    PackageRegistryUnknownError(String),
+
+    /// The Package Registry Manifest could not be constructed.
+    #[error("failed to parse registry manifest `{0}`")]
+    PackageRegistryManifestError(String),
+
+    /// The Package Registry Manifest could not be constructed.
+    #[error("failed to download module from registry: {0}")]
+    PackageRegistryDownloadError(String),
 }
 
 use axum::http::StatusCode;

utils/src/lib.rs

@@ -3,4 +3,5 @@ pub mod errors;
 pub mod futures;
 pub mod mdns;
 pub mod networking;
+pub mod registry;
 pub mod structs;