Add Bicep extension to enable passing bicep file directly to dsc

Author: SteveL-MSFT

build.ps1

@@ -40,6 +40,7 @@ if ($GetPackageVersion) {
 $filesForWindowsPackage = @(
     'appx.dsc.extension.json',
     'appx-discover.ps1',
+    'bicep.dsc.extension.json',
     'dsc.exe',
     'dsc_default.settings.json',
     'dsc.settings.json',
@@ -75,6 +76,7 @@ $filesForWindowsPackage = @(
 )
 
 $filesForLinuxPackage = @(
+    'bicep.dsc.extension.json',
     'dsc',
     'dsc_default.settings.json',
     'dsc.settings.json'
@@ -99,6 +101,7 @@ $filesForLinuxPackage = @(
 )
 
 $filesForMacPackage = @(
+    'bicep.dsc.extension.json',
     'dsc',
     'dsc_default.settings.json',
     'dsc.settings.json'
@@ -305,6 +308,7 @@ if (!$SkipBuild) {
         "dsc_lib",
         "dsc",
         "dscecho",
+        "extensions/bicep",
         "osinfo",
         "powershell-adapter",
         'resources/PSScript',
@@ -313,8 +317,7 @@ if (!$SkipBuild) {
         "sshdconfig",
         "tools/dsctest",
         "tools/test_group_resource",
-        "y2j",
-        "."
+        "y2j"
     )
     $pedantic_unclean_projects = @()
     $clippy_unclean_projects = @("tree-sitter-dscexpression", "tree-sitter-ssh-server-config")

dsc/Cargo.lock

@@ -0,0 +1,11 @@
+// This is a very simple example Bicep file for testing
+
+targetScope = 'desiredStateConfiguration'
+
+// use workaround where Bicep currently requires version in date format
+resource echo 'Microsoft.DSC.Debug/Echo@2025-01-01' = {
+  name: 'exampleEcho'
+  properties: {
+    output: 'Hello, world!'
+  }
+}

dsc/examples/hello_world.dsc.bicep

@@ -480,7 +480,7 @@ pub fn validate_config(config: &Configuration, progress_format: ProgressFormat)
     let schema = serde_json::to_value(get_schema(SchemaType::Configuration))?;
     let config_value = serde_json::to_value(config)?;
     validate_json("Configuration", &schema, &config_value)?;
-    let mut dsc = DscManager::new()?;
+    let mut dsc = DscManager::new();
 
     // then validate each resource
     let Some(resources) = config_value["resources"].as_array() else {
@@ -551,13 +551,7 @@ pub fn validate_config(config: &Configuration, progress_format: ProgressFormat)
 }
 
 pub fn extension(subcommand: &ExtensionSubCommand, progress_format: ProgressFormat) {
-    let mut dsc = match DscManager::new() {
-        Ok(dsc) => dsc,
-        Err(err) => {
-            error!("Error: {err}");
-            exit(EXIT_DSC_ERROR);
-        }
-    };
+    let mut dsc = DscManager::new();
 
     match subcommand {
         ExtensionSubCommand::List{extension_name, output_format} => {
@@ -577,13 +571,7 @@ pub fn function(subcommand: &FunctionSubCommand) {
 
 #[allow(clippy::too_many_lines)]
 pub fn resource(subcommand: &ResourceSubCommand, progress_format: ProgressFormat) {
-    let mut dsc = match DscManager::new() {
-        Ok(dsc) => dsc,
-        Err(err) => {
-            error!("Error: {err}");
-            exit(EXIT_DSC_ERROR);
-        }
-    };
+    let mut dsc = DscManager::new();
 
     match subcommand {
         ResourceSubCommand::List { resource_name, adapter_name, description, tags, output_format } => {

dsc/src/subcommand.rs

@@ -3,9 +3,6 @@
 
 use crate::args::{SchemaType, OutputFormat, TraceFormat};
 use crate::resolve::Include;
-use dsc_lib::configure::config_result::ResourceTestResult;
-use dsc_lib::extensions::discover::DiscoverResult;
-use dsc_lib::extensions::extension_manifest::ExtensionManifest;
 use dsc_lib::{
     configure::{
         config_doc::{
@@ -16,22 +13,33 @@ use dsc_lib::{
         config_result::{
             ConfigurationGetResult,
             ConfigurationSetResult,
-            ConfigurationTestResult
-        }
+            ConfigurationTestResult,
+            ResourceTestResult,
+        },
     },
+    discovery::Discovery,
     dscerror::DscError,
     dscresources::{
         command_resource::TraceLevel,
-        dscresource::DscResource, invoke_result::{
+        dscresource::DscResource,
+        invoke_result::{
             GetResult,
             SetResult,
             TestResult,
             ResolveResult,
-        }, resource_manifest::ResourceManifest
+        },
+        resource_manifest::ResourceManifest
+    },
+    extensions::{
+        discover::DiscoverResult,
+        dscextension::Capability,
+        extension_manifest::ExtensionManifest,
     },
     functions::FunctionDefinition,
-    util::parse_input_to_json,
-    util::get_setting,
+    util::{
+        get_setting,
+        parse_input_to_json,
+    },
 };
 use jsonschema::Validator;
 use path_absolutize::Absolutize;
@@ -487,6 +495,14 @@ pub fn get_input(input: Option<&String>, file: Option<&String>, parameters_from_
                 }
             }
         } else {
+            // see if an extension should handle this file
+            let mut discovery = Discovery::new();
+            for extension in discovery.get_extensions(&Capability::Import) {
+                let Ok(content) = extension.import(path) else {
+                    continue;
+                };
+                return content;
+            }
             match std::fs::read_to_string(path) {
                 Ok(input) => {
                     // check if it contains UTF-8 BOM and remove it

dsc/src/util.rs

@@ -21,6 +21,7 @@ indicatif = "0.18"
 jsonschema = { version = "0.30", default-features = false }
 linked-hash-map = "0.5"
 num-traits = "0.2"
+path-absolutize = { version = "3.1" }
 regex = "1.11"
 rt-format = "0.3"
 rust-i18n = { version = "3.1" }

dsc_lib/Cargo.lock

@@ -96,6 +96,8 @@ extensionResourceFound = "Extension found resource '%{resource}'"
 callingExtension = "Calling extension '%{extension}' to discover resources"
 extensionFoundResources = "Extension '%{extension}' found %{count} resources"
 invalidManifestVersion = "Manifest '%{path}' has invalid version: %{err}"
+importExtensionsEmpty = "Import extension '%{extension}' has no import extensions defined"
+importNotSupported = "Import is not supported by extension '%{extension}' for file '%{file}'"
 
 [dscresources.commandResource]
 invokeGet = "Invoking get for '%{resource}'"
@@ -183,6 +185,7 @@ secretExtensionReturnedInvalidJson = "Extension '%{extension}' returned invalid
 extensionReturnedSecret = "Extension '%{extension}' returned secret"
 extensionReturnedNoSecret = "Extension '%{extension}' did not return a secret"
 secretNoResults = "Extension '%{extension}' returned no output"
+importingFile = "Importing file '%{file}' with extension '%{extension}'"
 
 [extensions.extension_manifest]
 extensionManifestSchemaTitle = "Extension manifest schema URI"

dsc_lib/Cargo.toml

@@ -266,7 +266,7 @@ impl Configurator {
     ///
     /// This function will return an error if the configuration is invalid or the underlying discovery fails.
     pub fn new(json: &str, progress_format: ProgressFormat) -> Result<Configurator, DscError> {
-        let discovery = Discovery::new()?;
+        let discovery = Discovery::new();
         let mut config = Configurator {
             json: json.to_owned(),
             config: Configuration::new(),

dsc_lib/locales/en-us.toml

@@ -726,12 +726,25 @@ fn load_extension_manifest(path: &Path, manifest: &ExtensionManifest) -> Result<
         verify_executable(&manifest.r#type, "secret", &secret.executable);
         capabilities.push(dscextension::Capability::Secret);
     }
+    let import_extensions = if let Some(import) = &manifest.import {
+        verify_executable(&manifest.r#type, "import", &import.executable);
+        capabilities.push(dscextension::Capability::Import);
+        if import.extensions.is_empty() {
+            warn!("{}", t!("discovery.commandDiscovery.importExtensionsEmpty", extension = manifest.r#type));
+            None
+        } else {
+            Some(import.extensions.clone())
+        }
+    } else {
+        None
+    };
 
     let extension = DscExtension {
         type_name: manifest.r#type.clone(),
         description: manifest.description.clone(),
         version: manifest.version.clone(),
         capabilities,
+        import_extensions,
         path: path.to_str().unwrap().to_string(),
         directory: path.parent().unwrap().to_str().unwrap().to_string(),
         manifest: serde_json::to_value(manifest)?,