Split Summary into two types

Author: Michael-F-Bryan

lib/wasi/src/runtime/package_loader/builtin_loader.rs

@@ -18,7 +18,7 @@ use crate::{
     http::{HttpClient, HttpRequest, HttpResponse, USER_AGENT},
     runtime::{
         package_loader::PackageLoader,
-        resolver::{Summary, WebcHash},
+        resolver::{DistributionInfo, Summary, WebcHash},
     },
 };
 
@@ -76,9 +76,9 @@ impl BuiltinLoader {
         Ok(None)
     }
 
-    async fn download(&self, summary: &Summary) -> Result<Bytes, Error> {
-        if summary.webc.scheme() == "file" {
-            if let Ok(path) = summary.webc.to_file_path() {
+    async fn download(&self, dist: &DistributionInfo) -> Result<Bytes, Error> {
+        if dist.webc.scheme() == "file" {
+            if let Ok(path) = dist.webc.to_file_path() {
                 // FIXME: This will block the thread
                 let bytes = std::fs::read(&path)
                     .with_context(|| format!("Unable to read \"{}\"", path.display()))?;
@@ -87,7 +87,7 @@ impl BuiltinLoader {
         }
 
         let request = HttpRequest {
-            url: summary.webc.to_string(),
+            url: dist.webc.to_string(),
             method: "GET".to_string(),
             headers: vec![
                 ("Accept".to_string(), "application/webc".to_string()),
@@ -117,17 +117,17 @@ impl BuiltinLoader {
     async fn save_and_load_as_mmapped(
         &self,
         webc: &[u8],
-        summary: &Summary,
+        dist: &DistributionInfo,
     ) -> Result<Container, Error> {
         // First, save it to disk
-        self.fs.save(webc, summary).await?;
+        self.fs.save(webc, dist).await?;
 
         // Now try to load it again. The resulting container should use
         // a memory-mapped file rather than an in-memory buffer.
-        match self.fs.lookup(&summary.webc_sha256).await? {
+        match self.fs.lookup(&dist.webc_sha256).await? {
             Some(container) => {
                 // we also want to make sure it's in the in-memory cache
-                self.in_memory.save(&container, summary.webc_sha256);
+                self.in_memory.save(&container, dist.webc_sha256);
 
                 Ok(container)
             }
@@ -144,20 +144,20 @@ impl BuiltinLoader {
 #[async_trait::async_trait]
 impl PackageLoader for BuiltinLoader {
     async fn load(&self, summary: &Summary) -> Result<Container, Error> {
-        if let Some(container) = self.get_cached(&summary.webc_sha256).await? {
+        if let Some(container) = self.get_cached(&summary.dist.webc_sha256).await? {
             return Ok(container);
         }
 
         // looks like we had a cache miss and need to download it manually
         let bytes = self
-            .download(summary)
+            .download(&summary.dist)
             .await
-            .with_context(|| format!("Unable to download \"{}\"", summary.webc))?;
+            .with_context(|| format!("Unable to download \"{}\"", summary.dist.webc))?;
 
         // We want to cache the container we downloaded, but we want to do it
         // in a smart way to keep memory usage down.
 
-        match self.save_and_load_as_mmapped(&bytes, summary).await {
+        match self.save_and_load_as_mmapped(&bytes, &summary.dist).await {
             Ok(container) => {
                 // The happy path - we've saved to both caches and loaded the
                 // container from disk (hopefully using mmap) so we're done.
@@ -166,17 +166,17 @@ impl PackageLoader for BuiltinLoader {
             Err(e) => {
                 tracing::warn!(
                     error=&*e,
-                    pkg.name=%summary.package_name,
-                    pkg.version=%summary.version,
-                    pkg.hash=?summary.webc_sha256,
-                    pkg.url=%summary.webc,
+                    pkg.name=%summary.pkg.name,
+                    pkg.version=%summary.pkg.version,
+                    pkg.hash=?summary.dist.webc_sha256,
+                    pkg.url=%summary.dist.webc,
                     "Unable to save the downloaded package to disk",
                 );
                 // The sad path - looks like we'll need to keep the whole thing
                 // in memory.
                 let container = Container::from_bytes(bytes)?;
                 // We still want to cache it, of course
-                self.in_memory.save(&container, summary.webc_sha256);
+                self.in_memory.save(&container, summary.dist.webc_sha256);
                 Ok(container)
             }
         }
@@ -221,8 +221,8 @@ impl FileSystemCache {
         }
     }
 
-    async fn save(&self, webc: &[u8], summary: &Summary) -> Result<(), Error> {
-        let path = self.path(&summary.webc_sha256);
+    async fn save(&self, webc: &[u8], dist: &DistributionInfo) -> Result<(), Error> {
+        let path = self.path(&dist.webc_sha256);
 
         let parent = path.parent().expect("Always within cache_dir");
 
@@ -273,7 +273,7 @@ mod tests {
 
     use crate::{
         http::{HttpRequest, HttpResponse},
-        runtime::resolver::{SourceId, SourceKind},
+        runtime::resolver::{PackageInfo, SourceId, SourceKind},
     };
 
     use super::*;
@@ -320,25 +320,29 @@ mod tests {
         }]));
         let loader = BuiltinLoader::new_with_client(temp.path(), client.clone());
         let summary = Summary {
-            package_name: "python/python".to_string(),
-            version: "0.1.0".parse().unwrap(),
-            webc: "https://wapm.io/python/python".parse().unwrap(),
-            webc_sha256: [0xaa; 32].into(),
-            dependencies: Vec::new(),
-            commands: Vec::new(),
-            source: SourceId::new(
-                SourceKind::Url,
-                "https://registry.wapm.io/graphql".parse().unwrap(),
-            ),
-            entrypoint: Some("asdf".to_string()),
+            pkg: PackageInfo {
+                name: "python/python".to_string(),
+                version: "0.1.0".parse().unwrap(),
+                dependencies: Vec::new(),
+                commands: Vec::new(),
+                entrypoint: Some("asdf".to_string()),
+            },
+            dist: DistributionInfo {
+                webc: "https://wapm.io/python/python".parse().unwrap(),
+                webc_sha256: [0xaa; 32].into(),
+                source: SourceId::new(
+                    SourceKind::Url,
+                    "https://registry.wapm.io/graphql".parse().unwrap(),
+                ),
+            },
         };
 
         let container = loader.load(&summary).await.unwrap();
 
         // A HTTP request was sent
         let requests = client.requests.lock().unwrap();
         let request = &requests[0];
-        assert_eq!(request.url, summary.webc.to_string());
+        assert_eq!(request.url, summary.dist.webc.to_string());
         assert_eq!(request.method, "GET");
         assert_eq!(
             request.headers,
@@ -351,11 +355,11 @@ mod tests {
         let manifest = container.manifest();
         assert_eq!(manifest.entrypoint.as_deref(), Some("python"));
         // it should have been automatically saved to disk
-        let path = loader.fs.path(&summary.webc_sha256);
+        let path = loader.fs.path(&summary.dist.webc_sha256);
         assert!(path.exists());
         assert_eq!(std::fs::read(&path).unwrap(), PYTHON);
         // and cached in memory for next time
         let in_memory = loader.in_memory.0.read().unwrap();
-        assert!(in_memory.contains_key(&summary.webc_sha256));
+        assert!(in_memory.contains_key(&summary.dist.webc_sha256));
     }
 }

lib/wasi/src/runtime/resolver/in_memory_source.rs

@@ -63,19 +63,14 @@ impl InMemorySource {
 
     /// Add a new [`Summary`] to the [`InMemorySource`].
     pub fn add(&mut self, summary: Summary) {
-        let summaries = self
-            .packages
-            .entry(summary.package_name.clone())
-            .or_default();
+        let summaries = self.packages.entry(summary.pkg.name.clone()).or_default();
         summaries.push(summary);
-        summaries.sort_by(|left, right| left.version.cmp(&right.version));
-        summaries.dedup_by(|left, right| left.version == right.version);
+        summaries.sort_by(|left, right| left.pkg.version.cmp(&right.pkg.version));
+        summaries.dedup_by(|left, right| left.pkg.version == right.pkg.version);
     }
 
     pub fn add_webc(&mut self, path: impl AsRef<Path>) -> Result<(), Error> {
-        let path = path.as_ref();
-
-        let summary = super::extract_summary_from_webc(path, self.id())?;
+        let summary = Summary::from_webc_file(path, self.id())?;
         self.add(summary);
 
         Ok(())
@@ -87,7 +82,7 @@ impl InMemorySource {
 
     pub fn get(&self, package_name: &str, version: &Version) -> Option<&Summary> {
         let summaries = self.packages.get(package_name)?;
-        summaries.iter().find(|s| s.version == *version)
+        summaries.iter().find(|s| s.pkg.version == *version)
     }
 }
 
@@ -105,7 +100,7 @@ impl Source for InMemorySource {
                 match self.packages.get(full_name) {
                     Some(summaries) => Ok(summaries
                         .iter()
-                        .filter(|summary| version.matches(&summary.version))
+                        .filter(|summary| version.matches(&summary.pkg.version))
                         .cloned()
                         .collect()),
                     None => Ok(Vec::new()),
@@ -120,7 +115,10 @@ impl Source for InMemorySource {
 mod tests {
     use tempfile::TempDir;
 
-    use crate::runtime::resolver::Dependency;
+    use crate::runtime::resolver::{
+        inputs::{DistributionInfo, PackageInfo},
+        Dependency,
+    };
 
     use super::*;
 
@@ -154,26 +152,30 @@ mod tests {
         assert_eq!(
             source.packages["sharrattj/bash"][0],
             Summary {
-                package_name: "sharrattj/bash".to_string(),
-                version: "1.0.12".parse().unwrap(),
-                webc: Url::from_file_path(bash.canonicalize().unwrap()).unwrap(),
-                webc_sha256: [
-                    7, 226, 190, 131, 173, 231, 130, 245, 207, 185, 51, 189, 86, 85, 222, 37, 27,
-                    163, 170, 27, 25, 24, 211, 136, 186, 233, 174, 119, 66, 15, 134, 9
-                ]
-                .into(),
-                dependencies: vec![Dependency {
-                    alias: "coreutils".to_string(),
-                    pkg: "sharrattj/coreutils@^1.0.11".parse().unwrap()
-                }],
-                commands: ["bash", "sh"]
-                    .iter()
-                    .map(|name| crate::runtime::resolver::Command {
-                        name: name.to_string()
-                    })
-                    .collect(),
-                entrypoint: None,
-                source: source.id()
+                pkg: PackageInfo {
+                    name: "sharrattj/bash".to_string(),
+                    version: "1.0.12".parse().unwrap(),
+                    dependencies: vec![Dependency {
+                        alias: "coreutils".to_string(),
+                        pkg: "sharrattj/coreutils@^1.0.11".parse().unwrap()
+                    }],
+                    commands: ["bash", "sh"]
+                        .iter()
+                        .map(|name| crate::runtime::resolver::Command {
+                            name: name.to_string()
+                        })
+                        .collect(),
+                    entrypoint: None,
+                },
+                dist: DistributionInfo {
+                    webc: Url::from_file_path(bash.canonicalize().unwrap()).unwrap(),
+                    webc_sha256: [
+                        7, 226, 190, 131, 173, 231, 130, 245, 207, 185, 51, 189, 86, 85, 222, 37,
+                        27, 163, 170, 27, 25, 24, 211, 136, 186, 233, 174, 119, 66, 15, 134, 9
+                    ]
+                    .into(),
+                    source: source.id()
+                },
             }
         );
     }

lib/wasi/src/runtime/resolver/inputs.rs

@@ -105,39 +105,51 @@ impl Dependency {
 /// [source]: crate::runtime::resolver::Source
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Summary {
+    pub pkg: PackageInfo,
+    pub dist: DistributionInfo,
+}
+
+impl Summary {
+    pub fn package_id(&self) -> PackageId {
+        PackageId {
+            package_name: self.pkg.name.clone(),
+            version: self.pkg.version.clone(),
+            source: self.dist.source.clone(),
+        }
+    }
+}
+
+/// Information about a package's contents.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PackageInfo {
     /// The package's full name (i.e. `wasmer/wapm2pirita`).
-    pub package_name: String,
+    pub name: String,
     /// The package version.
     pub version: Version,
-    /// A URL that can be used to download the `*.webc` file.
-    pub webc: Url,
-    /// A SHA-256 checksum for the `*.webc` file.
-    pub webc_sha256: WebcHash,
-    /// Any dependencies this package may have.
-    pub dependencies: Vec<Dependency>,
     /// Commands this package exposes to the outside world.
     pub commands: Vec<Command>,
     /// The name of a [`Command`] that should be used as this package's
     /// entrypoint.
     pub entrypoint: Option<String>,
+    /// Any dependencies this package may have.
+    pub dependencies: Vec<Dependency>,
+}
+
+/// Information used when retrieving a package.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DistributionInfo {
+    /// A URL that can be used to download the `*.webc` file.
+    pub webc: Url,
+    /// A SHA-256 checksum for the `*.webc` file.
+    pub webc_sha256: WebcHash,
     /// The [`Source`][source] this [`Summary`] came from.
     ///
     /// [source]: crate::runtime::resolver::Source
     pub source: SourceId,
 }
 
-impl Summary {
-    pub fn package_id(&self) -> PackageId {
-        PackageId {
-            package_name: self.package_name.clone(),
-            version: self.version.clone(),
-            source: self.source.clone(),
-        }
-    }
-}
-
 /// The SHA-256 hash of a `*.webc` file.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WebcHash([u8; 32]);
 
 impl WebcHash {

lib/wasi/src/runtime/resolver/mod.rs

@@ -10,7 +10,9 @@ mod wapm_source;
 
 pub use self::{
     in_memory_source::InMemorySource,
-    inputs::{Command, Dependency, PackageSpecifier, Summary, WebcHash},
+    inputs::{
+        Command, Dependency, DistributionInfo, PackageInfo, PackageSpecifier, Summary, WebcHash,
+    },
     multi_source_registry::MultiSourceRegistry,
     outputs::{
         DependencyGraph, FileSystemMapping, ItemLocation, PackageId, Resolution, ResolvedPackage,
@@ -20,5 +22,3 @@ pub use self::{
     source::{Source, SourceId, SourceKind},
     wapm_source::WapmSource,
 };
-
-pub(crate) use self::utils::{extract_summary_from_manifest, extract_summary_from_webc};

lib/wasi/src/runtime/resolver/registry.rs

@@ -17,7 +17,7 @@ pub trait Registry: Send + Sync + Debug {
         let candidates = self.query(pkg).await?;
         candidates
             .into_iter()
-            .max_by(|left, right| left.version.cmp(&right.version))
+            .max_by(|left, right| left.pkg.version.cmp(&right.pkg.version))
             .ok_or_else(|| Error::msg("Couldn't find a package version satisfying that constraint"))
     }
 }