Allow resolving from resolved schema using Manifest file.

crates/weaver_common/Cargo.toml

@@ -23,6 +23,7 @@ once_cell.workspace = true
 schemars.workspace = true
 ureq.workspace = true
 log.workspace = true
+url.workspace = true
 
 tempfile.workspace = true
 dirs = "6.0.0"

crates/weaver_common/src/lib.rs

@@ -17,6 +17,7 @@ use miette::Diagnostic;
 use paris::formatter::colorize_string;
 use serde::Serialize;
 use std::io::Write;
+use std::path::Path;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 
@@ -295,3 +296,36 @@ pub fn warn_flare<T: std::fmt::Display>(message: T) -> String {
 pub fn log_warn<T: std::fmt::Display>(message: T) {
     log::warn!("{}", warn_flare(message));
 }
+
+/// Types of path strings we can support.
+pub enum PathType {
+    /// A URL path, like http://server/
+    URL,
+    /// A relative path, like ../some-file
+    RelativePath,
+    /// An absolute path, like /my/file/location
+    AbsolutePath,
+    /// Weaver-special.  A reference to a file
+    /// in a git repo or other.
+    WeaverPath,
+}
+
+/// Returns the type of path we're dealing with.
+#[must_use]
+pub fn get_path_type(input: &str) -> PathType {
+    match url::Url::parse(input) {
+        Ok(_) => PathType::URL,
+        Err(url::ParseError::RelativeUrlWithoutBase) => {
+            let test_path = Path::new(input);
+            if test_path.is_absolute() {
+                PathType::AbsolutePath
+            } else {
+                PathType::RelativePath
+            }
+        }
+        // TODO - we can learn more from error, we may be able
+        // to determine if this is a git-relative path or
+        // in-archive file reference.
+        Err(_) => PathType::WeaverPath,
+    }
+}

crates/weaver_common/src/vdir.rs

@@ -130,6 +130,56 @@
     },
 }
 
+impl VirtualDirectoryPath {
+    /// Converts a virtual directory path by manipulating the "sub folder".
+    /// 
+    /// Returning an empty string means no sub_folder will be used in resulting path.
+    /// 
+    /// Sub folder will be modified as follows:
+    /// 
+    /// - LocalFolder: will see the entire path
+    /// - others: will see the path inside the archive or empty string if none.
+    pub fn map_sub_folder<F: FnOnce(String) -> String>(self, f: F) -> VirtualDirectoryPath {
+        match self {
+            LocalFolder { path } => LocalFolder { path: f(path) },
+            LocalArchive { path, sub_folder } => LocalArchive { 
+                path,
+                sub_folder: {
+                    let result = f(sub_folder.unwrap_or("".to_string()));
+                    if result.is_empty() {
+                        None
+                    } else {
+                        Some(result)
+                    }
+                }
+            },
+            RemoteArchive { url, sub_folder } => RemoteArchive { 
+                url,
+                sub_folder: {
+                    let result = f(sub_folder.unwrap_or("".to_string()));
+                    if result.is_empty() {
+                        None
+                    } else {
+                        Some(result)
+                    }
+                }
+            },
+            GitRepo { url, refspec, sub_folder } => GitRepo { 
+                url,
+                refspec,
+                sub_folder: {
+                    let result = f(sub_folder.unwrap_or("".to_string()));
+                    if result.is_empty() {
+                        None
+                    } else {
+                        Some(result)
+                    }
+                }
+            },
+        }
+    }
+}
+
 /// Enables parsing a [`VirtualDirectoryPath`] from a string representation.
 ///
 /// This implementation allows easy deserialization from strings (e.g. configuration files, command-line arguments).
@@ -686,10 +736,16 @@
 
     /// Returns the original string representation that was used to create this `VirtualDirectory`.
     #[must_use]
-    pub fn vdir_path(&self) -> &str {
+    pub fn vdir_path_str(&self) -> &str {
         &self.vdir_path
     }
 
+    /// Returns the original `VirtualDirectoryRef` that was used to create this `VirtualDirectory`.
+    #[must_use]
+    pub fn vdir_path(&self) -> VirtualDirectoryPath {
+        self.vdir_path_str().try_into().expect("VirtualDirectory should not have invalid `vdir_path`.")
+    }
+
     /// Creates and returns a new temporary directory within `.weaver/vdir_cache`.
     ///
     /// The created directory and its contents are automatically deleted when dropped.

crates/weaver_semconv/src/manifest.rs

@@ -68,7 +68,11 @@ pub struct RegistryManifest {
 pub struct Dependency {
     /// The name of the dependency.
     pub name: String,
-    /// The registry path of the dependency.
+    /// The path to the dependency.
+    ///
+    /// This can be either:
+    /// - A manifest of a published registry
+    /// - A directory containing the raw definition.
     pub registry_path: VirtualDirectoryPath,
 }
 

crates/weaver_semconv/src/registry_repo.rs

@@ -8,16 +8,19 @@ use std::sync::Arc;
 
 use crate::manifest::RegistryManifest;
 use crate::Error;
-use weaver_common::log_info;
 use weaver_common::vdir::{VirtualDirectory, VirtualDirectoryPath};
+use weaver_common::{get_path_type, log_info};
 
 /// The name of the registry manifest file.
 pub const REGISTRY_MANIFEST: &str = "registry_manifest.yaml";
 
 /// A semantic convention registry repository that can be:
-/// - A simple wrapper around a local directory
-/// - Initialized from a Git repository
-/// - Initialized from a Git archive
+/// - A definition repository, which is one of:
+///   - A simple wrapper around a local directory
+///   - Initialized from a Git repository
+///   - Initialized from a Git archive
+/// - A published repository, which is a manifest file
+///   that denotes where to find aspects of the registry.
 #[derive(Default, Debug, Clone)]
 pub struct RegistryRepo {
     // A unique identifier for the registry (e.g. main, baseline, etc.)
@@ -66,7 +69,7 @@ impl RegistryRepo {
     /// Returns the registry path textual representation.
     #[must_use]
     pub fn registry_path_repr(&self) -> &str {
-        self.registry.vdir_path()
+        self.registry.vdir_path_str()
     }
 
     /// Returns the registry manifest specified in the registry repo.
@@ -75,9 +78,37 @@ impl RegistryRepo {
         self.manifest.as_ref()
     }
 
+    /// Returns the resolved schema URL, if available in the manifest.
+    #[must_use]
+    pub fn resolved_schema_url(&self) -> Option<VirtualDirectoryPath> {
+        let manifest = self.manifest.as_ref()?;
+        let resolved_url: &str = manifest.resolved_schema_url.as_ref()?;
+        match get_path_type(resolved_url) {
+            weaver_common::PathType::RelativePath => {
+                let vdir_was_manifest_file = self.manifest_path()?.is_file();
+                Some(self.registry.vdir_path().map_sub_folder(|path| {
+                    if vdir_was_manifest_file {
+                        match Path::new(&path).parent() {
+                            Some(parent) => format!("{}", parent.join(resolved_url).display()),
+                            None => format!(""),
+                        }
+                    } else {
+                        format!("{}", Path::new(&path).join(resolved_url).display())
+                    }
+                }))
+            }
+            _ => resolved_url.try_into().ok(),
+        }
+    }
+
     /// Returns the path to the `registry_manifest.yaml` file (if any).
     #[must_use]
     pub fn manifest_path(&self) -> Option<PathBuf> {
+        // First check to see if we're pointing at a manifest.
+        if self.registry.path().is_file() {
+            // The VirtualDirectory *is* the registry.
+            return Some(self.registry.path().to_path_buf());
+        }
         let manifest_path = self.registry.path().join(REGISTRY_MANIFEST);
         if manifest_path.exists() {
             log_info(format!(
@@ -127,4 +158,43 @@ mod tests {
         // The local folder should not be deleted.
         assert!(repo_path.exists());
     }
+
+    #[test]
+    fn test_resolved_registry_path() {
+        // A RegistryRepo created from a local folder.
+        let registry_path = VirtualDirectoryPath::LocalFolder {
+            path: "tests/published_repository/resolved/1.0.0".to_owned(),
+        };
+        let repo =
+            RegistryRepo::try_new("main", &registry_path).expect("Failed to load test repository.");
+        let Some(manifest) = repo.manifest() else {
+            panic!("Did not resolve manifest for repo: {repo:?}");
+        };
+        assert_eq!(manifest.name, "resolved");
+
+        let Some(resolved_path) = repo.resolved_schema_url() else {
+            panic!(
+                "Should find a resolved schema path from manfiest in {}",
+                repo.registry_path_repr()
+            );
+        };
+        assert_eq!(
+            "tests/published_repository/resolved/resolved_1.0.0.yaml",
+            format!("{resolved_path}")
+        );
+
+        // Now make sure a different repository with full URL works too.
+        let registry_path = VirtualDirectoryPath::LocalFolder {
+            path: "tests/published_repository/resolved/2.0.0".to_owned(),
+        };
+        let repo =
+            RegistryRepo::try_new("main", &registry_path).expect("Failed to load test repository.");
+        let Some(resolved_path) = repo.resolved_schema_url() else {
+            panic!(
+                "Should find a resolved schema path from manfiest in {}",
+                repo.registry_path_repr()
+            );
+        };
+        assert_eq!("https://github.com/open-telemetry/weaver.git\\creates/weaver_semconv/tests/published_respository/resolved/resolved_2.0.0", format!("{resolved_path}"));
+    }
 }

crates/weaver_semconv/tests/published_repository/resolved/1.0.0

@@ -0,0 +1,7 @@
+file_format: manifest/2.0.0
+name: resolved
+description: Test repository that has been resolved.
+version: 1.0.0
+repository_url: https://github.com/open-telemetry/weaver.git
+stability: stable
+resolved_schema_url: resolved_1.0.0.yaml

crates/weaver_semconv/tests/published_repository/resolved/2.0.0

@@ -0,0 +1,7 @@
+file_format: manifest/2.0.0
+name: resolved
+description: Test repository that has been resolved.
+version: 2.0.0
+repository_url: https://github.com/open-telemetry/weaver.git
+stability: stable
+resolved_schema_url: https://github.com/open-telemetry/weaver.git\creates/weaver_semconv/tests/published_respository/resolved/resolved_2.0.0