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::RegistryPackageSpec;
 use utils::structs::Manifest;
 use uuid::Uuid;
 
@@ -70,6 +71,11 @@ 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 author/packagename@version
+        identifer: String,
+    },
 }
 
 static SERVAL_NODE_URL: Mutex<Option<String>> = Mutex::new(None);
@@ -286,7 +292,19 @@ fn blocking_maybe_discover_service_url(
     };
 
     let port = info.get_port();
-    return Ok(format!("http://{addr}:{port}"));
+    Ok(format!("http://{addr}:{port}"))
+}
+
+fn pull(registry: &str, identifer: String) -> Result<()> {
+    let package_spec = RegistryPackageSpec::parse(registry, identifer).unwrap();
+    println!("{:#?}", package_spec);
+    let dl_url = package_spec.registry.baseurl_download.to_string();
+    println!("{dl_url}");
+
+    println!("{}", package_spec.fqtn());
+
+    println!("{}", package_spec.fqdn());
+    Ok(())
 }
 
 /// Parse command-line arguments and act.
@@ -320,6 +338,7 @@ fn main() -> Result<()> {
         Command::Status { id } => status(id)?,
         Command::History => history()?,
         Command::Ping => ping()?,
+        Command::Pull { identifer } => pull("wapm", identifer)?,
     };
 
     Ok(())

utils/src/errors.rs

@@ -70,6 +70,10 @@ pub enum ServalError {
     /// Translation for errors from ssri.
     #[error("ssri::Error: {0}")]
     SsriError(#[from] ssri::Error),
+
+    /// The Package Registry Manifest could not be constructed.
+    #[error("failed to parse registry manifest `{0}`")]
+    PackageRegistryManifestError(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;

utils/src/registry.rs

@@ -0,0 +1,101 @@
+use std::str::FromStr;
+
+use crate::errors::ServalError;
+
+/// Package registry information, used to download executables and construct the Manifest.
+#[derive(Debug, PartialEq)]
+pub struct Registry {
+    pub namespace: String,
+    pub baseurl_summary: &'static str,
+    pub baseurl_download: &'static str,
+}
+
+impl FromStr for Registry {
+    type Err = ();
+
+    fn from_str(input: &str) -> Result<Registry, Self::Err> {
+        if let "wapm" = input {
+            Ok(Registry {
+                namespace: String::from("io.wapm"),
+                baseurl_summary: "https://wapm.io/{author}/{name}@{version}",
+                baseurl_download: "https://registry-cdn.wapm.io/contents/{author}/{name}/{version}/target/wasm32-wasi/release/{name}.wasm",
+        })
+        } else {
+            Err(())
+        }
+    }
+}
+
+/// Specification for a registry package
+#[derive(Debug, PartialEq)]
+pub struct RegistryPackageSpec {
+    pub registry: Registry,
+    pub author: String,
+    pub package: String,
+    pub version: String,
+}
+
+impl RegistryPackageSpec {
+
+    /// Parses a registry package using a registry key and a package identifier
+    pub fn parse(registry: &str, identifer: String) -> Result<RegistryPackageSpec, ServalError> {
+        let registry_spec = Registry::from_str(registry).unwrap();
+        // Split the string by "/". We expect the provided identifier to be one of the following:
+        // - author/package/version
+        // - author/package@version
+        let pkg_author_spec: Vec<&str> = identifer.split('/').collect();
+        match pkg_author_spec.len() {
+            // we assume the provided format is author/package@version
+            2 => {
+                let author = pkg_author_spec[0].to_string();
+                // The string after the / should contain package@version
+                let pkg_version_spec: Vec<&str> = pkg_author_spec[1].split('@').collect();
+                match pkg_version_spec.len() {
+                    // we found a package and version
+                    2 => {
+                        let (name, version) = (
+                            pkg_version_spec[0].to_string(),
+                            pkg_version_spec[1].to_string(),
+                        );
+                        Ok(RegistryPackageSpec {
+                            registry: registry_spec,
+                            author,
+                            package: name,
+                            version,
+                        })
+                    }
+                    _ => Err(ServalError::PackageRegistryManifestError(String::from(
+                        "could not parse version.",
+                    ))),
+                }
+            }
+            // we assume the provided format is author/package/version
+            3 => {
+                let (author, name, version) = (
+                    pkg_author_spec[0].to_string(),
+                    pkg_author_spec[1].to_string(),
+                    pkg_author_spec[2].to_string(),
+                );
+                Ok(RegistryPackageSpec {
+                    registry: registry_spec,
+                    author,
+                    package: name,
+                    version,
+                })
+            }
+            // unclear format, we're erroring out
+            _ => Err(ServalError::PackageRegistryManifestError(String::from(
+                "could not parse package identifier.",
+            ))),
+        }
+    }
+
+    /// The fully-qualified task name of the package, composed of the registry
+    /// namespace, author, package name and version.
+    pub fn fqtn(self) -> String {
+        format!(
+            "{}.{}.{}@{}",
+            self.registry.namespace, self.author, self.package, self.version
+        )
+    }
+}