Add args to enable passing input to resource export

Author: SteveL-MSFT

dsc/src/args.rs

@@ -213,6 +213,10 @@ pub enum ResourceSubCommand {
     Export {
         #[clap(short, long, help = t!("args.resource").to_string())]
         resource: String,
+        #[clap(short, long, help = t!("args.input").to_string(), conflicts_with = "file")]
+        input: Option<String>,
+        #[clap(short = 'f', long, help = t!("args.file").to_string(), conflicts_with = "input")]
+        file: Option<String>,
         #[clap(short = 'o', long, help = t!("args.outputFormat").to_string())]
         output_format: Option<OutputFormat>,
     },

dsc/src/resource_command.rs

@@ -259,8 +259,7 @@ pub fn schema(dsc: &DscManager, resource_type: &str, format: Option<&OutputForma
     }
 }
 
-pub fn export(dsc: &mut DscManager, resource_type: &str, format: Option<&OutputFormat>) {
-    let mut input = String::new();
+pub fn export(dsc: &mut DscManager, resource_type: &str, mut input: String, format: Option<&OutputFormat>) {
     let Some(dsc_resource) = get_resource(dsc, resource_type) else {
         error!("{}", DscError::ResourceNotFound(resource_type.to_string()).to_string());
         exit(EXIT_DSC_RESOURCE_NOT_FOUND);

dsc/src/subcommand.rs

@@ -545,9 +545,10 @@ pub fn resource(subcommand: &ResourceSubCommand, progress_format: ProgressFormat
             dsc.find_resources(&[resource.to_string()], progress_format);
             resource_command::schema(&dsc, resource, output_format.as_ref());
         },
-        ResourceSubCommand::Export { resource, output_format } => {
+        ResourceSubCommand::Export { resource, input, file, output_format } => {
             dsc.find_resources(&[resource.to_string()], progress_format);
-            resource_command::export(&mut dsc, resource, output_format.as_ref());
+            let parsed_input = get_input(input.as_ref(), file.as_ref());
+            resource_command::export(&mut dsc, resource, parsed_input, output_format.as_ref());
         },
         ResourceSubCommand::Get { resource, input, file: path, all, output_format } => {
             dsc.find_resources(&[resource.to_string()], progress_format);

dsc/tests/dsc_export.tests.ps1

@@ -88,6 +88,18 @@ Describe 'resource export tests' {
       $config_with_process_list.resources.count | Should -BeGreaterThan 1
     }
 
+    It 'Export can be called on resource with input' {
+        $out = '{"count":3}' | dsc resource export -r Test/Export -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.resources.count | Should -Be 3
+        $out.resources[0].type | Should -BeExactly 'Test/Export'
+        $out.resources[0].properties.count | Should -Be 0
+        $out.resources[1].type | Should -BeExactly 'Test/Export'
+        $out.resources[1].properties.count | Should -Be 1
+        $out.resources[2].type | Should -BeExactly 'Test/Export'
+        $out.resources[2].properties.count | Should -Be 2
+    }
+
     It 'Export can be called on a configuration with the use of --output-format as a subcommand' {
 
       $yaml = @'

tools/dsctest/dscexport.dsc.resource.json

@@ -0,0 +1,25 @@
+{
+    "$schema": "https://aka.ms/dsc/schemas/v3/bundled/resource/manifest.json",
+    "type": "Test/Export",
+    "version": "0.1.0",
+    "export": {
+        "executable": "dsctest",
+        "args": [
+            "export",
+            {
+                "jsonInputArg": "--input",
+                "mandatory": true
+            }
+        ]
+    },
+    "schema": {
+        "command": {
+            "executable": "dsctest",
+            "args": [
+                "schema",
+                "-s",
+                "export"
+            ]
+        }
+    }
+}

tools/dsctest/src/args.rs

@@ -8,6 +8,7 @@ pub enum Schemas {
     Delete,
     Exist,
     ExitCode,
+    Export,
     Sleep,
     Trace,
     WhatIf,
@@ -41,6 +42,12 @@ pub enum SubCommand {
         input: String,
     },
 
+    #[clap(name = "export", about = "Export instances")]
+    Export {
+        #[clap(name = "input", short, long, help = "The input to the export command as JSON")]
+        input: String,
+    },
+
     #[clap(name = "schema", about = "Get the JSON schema for a subcommand")]
     Schema {
         #[clap(name = "subcommand", short, long, help = "The subcommand to get the schema for")]

tools/dsctest/src/export.rs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Export {
+    /// Number of instances to return
+    pub count: u64,
+}

tools/dsctest/src/main.rs

@@ -5,6 +5,7 @@ mod args;
 mod delete;
 mod exist;
 mod exit_code;
+mod export;
 mod sleep;
 mod trace;
 mod whatif;
@@ -15,6 +16,7 @@ use schemars::schema_for;
 use crate::delete::Delete;
 use crate::exist::{Exist, State};
 use crate::exit_code::ExitCode;
+use crate::export::Export;
 use crate::sleep::Sleep;
 use crate::trace::Trace;
 use crate::whatif::WhatIf;
@@ -65,6 +67,22 @@ fn main() {
             }
             input
         },
+        SubCommand::Export { input } => {
+            let export = match serde_json::from_str::<Export>(&input) {
+                Ok(export) => export,
+                Err(err) => {
+                    eprintln!("Error JSON does not match schema: {err}");
+                    std::process::exit(1);
+                }
+            };
+            for i in 0..export.count {
+                let instance = Export {
+                    count: i
+                };
+                println!("{}", serde_json::to_string(&instance).unwrap());
+            }
+            String::new()
+        },
         SubCommand::Schema { subcommand } => {
             let schema = match subcommand {
                 Schemas::Delete => {
@@ -76,6 +94,9 @@ fn main() {
                 Schemas::ExitCode => {
                     schema_for!(ExitCode)
                 },
+                Schemas::Export => {
+                    schema_for!(Export)
+                },
                 Schemas::Sleep => {
                     schema_for!(Sleep)
                 },
@@ -120,5 +141,7 @@ fn main() {
         },
     };
 
-    println!("{json}");
+    if !json.is_empty() {
+        println!("{json}");
+    }
 }