rename ManifestResource to ImportedManifest

SteveL-MSFT · SteveL-MSFT · commit 233c3f5d7777 · 2025-05-05T10:39:57.000-07:00
diff --git a/dsc/src/subcommand.rs b/dsc/src/subcommand.rs
@@ -17,7 +17,7 @@ use dsc_lib::{
         Configurator,
     },
     discovery::discovery_trait::DiscoveryKind,
-    discovery::command_discovery::ManifestResource,
+    discovery::command_discovery::ImportedManifest,
     dscerror::DscError,
     DscManager,
     dscresources::invoke_result::{
@@ -625,7 +625,7 @@ fn list_extensions(dsc: &mut DscManager, extension_name: Option<&String>, format
     }
     let mut include_separator = false;
     for manifest_resource in dsc.list_available(&DiscoveryKind::Extension, extension_name.unwrap_or(&String::from("*")), "", progress_format) {
-        if let ManifestResource::Extension(extension) = manifest_resource {
+        if let ImportedManifest::Extension(extension) = manifest_resource {
             let mut capabilities = "-".to_string();
             let capability_types = [
                 (ExtensionCapability::Discover, "d"),
@@ -683,7 +683,7 @@ fn list_resources(dsc: &mut DscManager, resource_name: Option<&String>, adapter_
     }
     let mut include_separator = false;
     for manifest_resource in dsc.list_available(&DiscoveryKind::Resource, resource_name.unwrap_or(&String::from("*")), adapter_name.unwrap_or(&String::new()), progress_format) {
-        if let ManifestResource::Resource(resource) = manifest_resource {
+        if let ImportedManifest::Resource(resource) = manifest_resource {
             let mut capabilities = "--------".to_string();
             let capability_types = [
                 (Capability::Get, "g"),
diff --git a/dsc_lib/src/discovery/command_discovery.rs b/dsc_lib/src/discovery/command_discovery.rs
@@ -31,7 +31,7 @@ const DSC_RESOURCE_EXTENSIONS: [&str; 3] = [".dsc.resource.json", ".dsc.resource
 const DSC_EXTENSION_EXTENSIONS: [&str; 3] = [".dsc.extension.json", ".dsc.extension.yaml", ".dsc.extension.yml"];
 
 #[derive(Clone)]
-pub enum ManifestResource {
+pub enum ImportedManifest {
     Resource(DscResource),
     Extension(DscExtension),
 }
@@ -246,7 +246,7 @@ impl ResourceDiscovery for CommandDiscovery {
                                 };
 
                                 match resource {
-                                    ManifestResource::Extension(extension) => {
+                                    ImportedManifest::Extension(extension) => {
                                         if regex.is_match(&extension.type_name) {
                                             trace!("{}", t!("discovery.commandDiscovery.extensionFound", extension = extension.type_name));
                                             // we only keep newest version of the extension so compare the version and only keep the newest
@@ -265,7 +265,7 @@ impl ResourceDiscovery for CommandDiscovery {
                                             }
                                         }
                                     },
-                                    ManifestResource::Resource(resource) => {
+                                    ImportedManifest::Resource(resource) => {
                                         if regex.is_match(&resource.type_name) {
                                             if let Some(ref manifest) = resource.manifest {
                                                 let manifest = import_manifest(manifest.clone())?;
@@ -423,19 +423,19 @@ impl ResourceDiscovery for CommandDiscovery {
         Ok(())
     }
 
-    fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str) -> Result<BTreeMap<String, Vec<ManifestResource>>, DscError> {
+    fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str) -> Result<BTreeMap<String, Vec<ImportedManifest>>, DscError> {
 
         trace!("Listing resources with type_name_filter '{type_name_filter}' and adapter_name_filter '{adapter_name_filter}'");
-        let mut resources = BTreeMap::<String, Vec<ManifestResource>>::new();
+        let mut resources = BTreeMap::<String, Vec<ImportedManifest>>::new();
 
         if *kind == DiscoveryKind::Resource {
             if adapter_name_filter.is_empty() {
                 self.discover(kind, type_name_filter)?;
                 for (resource_name, resources_vec) in &self.resources {
-                    resources.insert(resource_name.clone(), resources_vec.iter().map(|r| ManifestResource::Resource(r.clone())).collect());
+                    resources.insert(resource_name.clone(), resources_vec.iter().map(|r| ImportedManifest::Resource(r.clone())).collect());
                 }
                 for (adapter_name, adapter_vec) in &self.adapters {
-                    resources.insert(adapter_name.clone(), adapter_vec.iter().map(|r| ManifestResource::Resource(r.clone())).collect());
+                    resources.insert(adapter_name.clone(), adapter_vec.iter().map(|r| ImportedManifest::Resource(r.clone())).collect());
                 }
             } else {
                 self.discover(kind, "*")?;
@@ -445,13 +445,13 @@ impl ResourceDiscovery for CommandDiscovery {
                 add_resources_to_lookup_table(&self.adapted_resources);
 
                 for (adapted_name, adapted_vec) in &self.adapted_resources {
-                    resources.insert(adapted_name.clone(), adapted_vec.iter().map(|r| ManifestResource::Resource(r.clone())).collect());
+                    resources.insert(adapted_name.clone(), adapted_vec.iter().map(|r| ImportedManifest::Resource(r.clone())).collect());
                 }
             }
         } else {
             self.discover(kind, type_name_filter)?;
             for (extension_name, extension) in &self.extensions {
-                resources.insert(extension_name.clone(), vec![ManifestResource::Extension(extension.clone())]);
+                resources.insert(extension_name.clone(), vec![ImportedManifest::Extension(extension.clone())]);
             }
         }
 
@@ -595,12 +595,12 @@ fn insert_resource(resources: &mut BTreeMap<String, Vec<DscResource>>, resource:
 /// # Errors
 ///
 /// * Returns a `DscError` if the manifest could not be loaded or parsed.
-pub fn load_manifest(path: &Path) -> Result<ManifestResource, DscError> {
+pub fn load_manifest(path: &Path) -> Result<ImportedManifest, DscError> {
     let contents = fs::read_to_string(path)?;
     if path.extension() == Some(OsStr::new("json")) {
         if let Ok(manifest) = serde_json::from_str::<ExtensionManifest>(&contents) {
             let extension = load_extension_manifest(path, &manifest)?;
-            return Ok(ManifestResource::Extension(extension));
+            return Ok(ImportedManifest::Extension(extension));
         }
         let manifest = match serde_json::from_str::<ResourceManifest>(&contents) {
             Ok(manifest) => manifest,
@@ -609,12 +609,12 @@ pub fn load_manifest(path: &Path) -> Result<ManifestResource, DscError> {
             }
         };
         let resource = load_resource_manifest(path, &manifest)?;
-        return Ok(ManifestResource::Resource(resource));
+        return Ok(ImportedManifest::Resource(resource));
     }
 
     if let Ok(manifest) = serde_yaml::from_str::<ResourceManifest>(&contents) {
         let resource = load_resource_manifest(path, &manifest)?;
-        return Ok(ManifestResource::Resource(resource));
+        return Ok(ImportedManifest::Resource(resource));
     }
     let manifest = match serde_yaml::from_str::<ExtensionManifest>(&contents) {
         Ok(manifest) => manifest,
@@ -623,7 +623,7 @@ pub fn load_manifest(path: &Path) -> Result<ManifestResource, DscError> {
         }
     };
     let extension = load_extension_manifest(path, &manifest)?;
-    Ok(ManifestResource::Extension(extension))
+    Ok(ImportedManifest::Extension(extension))
 }
 
 fn load_resource_manifest(path: &Path, manifest: &ResourceManifest) -> Result<DscResource, DscError> {
diff --git a/dsc_lib/src/discovery/discovery_trait.rs b/dsc_lib/src/discovery/discovery_trait.rs
@@ -4,7 +4,7 @@
 use crate::{dscerror::DscError, dscresources::dscresource::DscResource};
 use std::collections::BTreeMap;
 
-use super::command_discovery::ManifestResource;
+use super::command_discovery::ImportedManifest;
 
 #[derive(PartialEq)]
 pub enum DiscoveryKind {
@@ -60,7 +60,7 @@ pub trait ResourceDiscovery {
     /// # Errors
     ///
     /// This function will return an error if the underlying discovery fails.
-    fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str) -> Result<BTreeMap<String, Vec<ManifestResource>>, DscError>;
+    fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str) -> Result<BTreeMap<String, Vec<ImportedManifest>>, DscError>;
 
     /// Find resources based on the required resource types.
     /// This is not applicable for extensions.
diff --git a/dsc_lib/src/discovery/mod.rs b/dsc_lib/src/discovery/mod.rs
@@ -8,7 +8,7 @@ use crate::discovery::discovery_trait::{DiscoveryKind, ResourceDiscovery};
 use crate::extensions::dscextension::DscExtension;
 use crate::{dscresources::dscresource::DscResource, dscerror::DscError, progress::ProgressFormat};
 use std::collections::BTreeMap;
-use command_discovery::ManifestResource;
+use command_discovery::ImportedManifest;
 use tracing::error;
 
 #[derive(Clone)]
@@ -42,12 +42,12 @@ impl Discovery {
     /// # Returns
     ///
     /// A vector of `DscResource` instances.
-    pub fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str, progress_format: ProgressFormat) -> Vec<ManifestResource> {
+    pub fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str, progress_format: ProgressFormat) -> Vec<ImportedManifest> {
         let discovery_types: Vec<Box<dyn ResourceDiscovery>> = vec![
             Box::new(command_discovery::CommandDiscovery::new(progress_format)),
         ];
 
-        let mut resources: Vec<ManifestResource> = Vec::new();
+        let mut resources: Vec<ImportedManifest> = Vec::new();
 
         for mut discovery_type in discovery_types {
 
diff --git a/dsc_lib/src/extensions/dscextension.rs b/dsc_lib/src/extensions/dscextension.rs
@@ -8,7 +8,7 @@ use schemars::JsonSchema;
 use std::{fmt::Display, path::Path};
 use tracing::info;
 
-use crate::{discovery::command_discovery::{load_manifest, ManifestResource}, dscerror::DscError, dscresources::{command_resource::{invoke_command, process_args}, dscresource::DscResource}};
+use crate::{discovery::command_discovery::{load_manifest, ImportedManifest}, dscerror::DscError, dscresources::{command_resource::{invoke_command, process_args}, dscresource::DscResource}};
 
 use super::{discover::DiscoverResult, extension_manifest::ExtensionManifest};
 
@@ -110,7 +110,7 @@ impl DscExtension {
                     }
                     let manifest_path = Path::new(&discover_result.resource_manifest_path);
                     // Currently we don't support extensions discovering other extensions
-                    if let ManifestResource::Resource(resource) = load_manifest(manifest_path)? {
+                    if let ImportedManifest::Resource(resource) = load_manifest(manifest_path)? {
                         resources.push(resource);
                     }
                 }
diff --git a/dsc_lib/src/lib.rs b/dsc_lib/src/lib.rs
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::discovery::command_discovery::ManifestResource;
+use crate::discovery::command_discovery::ImportedManifest;
 use crate::discovery::discovery_trait::DiscoveryKind;
 use crate::progress::ProgressFormat;
 
@@ -51,7 +51,7 @@ impl DscManager {
         self.discovery.find_resource(name)
     }
 
-    pub fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str, progress_format: ProgressFormat) -> Vec<ManifestResource> {
+    pub fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str, progress_format: ProgressFormat) -> Vec<ImportedManifest> {
         self.discovery.list_available(kind, type_name_filter, adapter_name_filter, progress_format)
     }
 

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ use schemars::JsonSchema;`
`8`	`8`	`use std::{fmt::Display, path::Path};`
`9`	`9`	`use tracing::info;`
`10`	`10`
`11`		`-use crate::{discovery::command_discovery::{load_manifest, ManifestResource}, dscerror::DscError, dscresources::{command_resource::{invoke_command, process_args}, dscresource::DscResource}};`
	`11`	`+use crate::{discovery::command_discovery::{load_manifest, ImportedManifest}, dscerror::DscError, dscresources::{command_resource::{invoke_command, process_args}, dscresource::DscResource}};`
`12`	`12`
`13`	`13`	`use super::{discover::DiscoverResult, extension_manifest::ExtensionManifest};`
`14`	`14`
`@@ -110,7 +110,7 @@ impl DscExtension {`
`110`	`110`	`}`
`111`	`111`	`let manifest_path = Path::new(&discover_result.resource_manifest_path);`
`112`	`112`	`// Currently we don't support extensions discovering other extensions`
`113`		`- if let ManifestResource::Resource(resource) = load_manifest(manifest_path)? {`
	`113`	`+ if let ImportedManifest::Resource(resource) = load_manifest(manifest_path)? {`
`114`	`114`	`resources.push(resource);`
`115`	`115`	`}`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`// Copyright (c) Microsoft Corporation.`
`2`	`2`	`// Licensed under the MIT License.`
`3`	`3`
`4`		`-use crate::discovery::command_discovery::ManifestResource;`
	`4`	`+use crate::discovery::command_discovery::ImportedManifest;`
`5`	`5`	`use crate::discovery::discovery_trait::DiscoveryKind;`
`6`	`6`	`use crate::progress::ProgressFormat;`
`7`	`7`
`@@ -51,7 +51,7 @@ impl DscManager {`
`51`	`51`	`self.discovery.find_resource(name)`
`52`	`52`	`}`
`53`	`53`
`54`		`- pub fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str, progress_format: ProgressFormat) -> Vec<ManifestResource> {`
	`54`	`+ pub fn list_available(&mut self, kind: &DiscoveryKind, type_name_filter: &str, adapter_name_filter: &str, progress_format: ProgressFormat) -> Vec<ImportedManifest> {`
`55`	`55`	`self.discovery.list_available(kind, type_name_filter, adapter_name_filter, progress_format)`
`56`	`56`	`}`
`57`	`57`