Function invoke_get

lib/dsc-lib/src/dscresources/command_resource.rs:44–92

Invoke the get operation on a resource # Arguments `resource` - The resource manifest `filter` - The filter to apply to the resource in JSON # Errors Error returned if the resource does not successfully get the current state

(resource: &DscResource, filter: &str, target_resource: Option<&DscResource>)

///
/// Error returned if the resource does not successfully get the current state
pub fn invoke_get(resource: &DscResource, filter: &str, target_resource: Option<&DscResource>) -> Result<GetResult, DscError> {
    debug!("{}", t!("dscresources.commandResource.invokeGet", resource = &resource.type_name));
    let Some(manifest) = &resource.manifest else {
        return Err(DscError::MissingManifest(resource.type_name.to_string()));
    };
    let mut command_input = CommandInput { env: None, stdin: None };
    let Some(get) = &manifest.get else {
        return Err(DscError::NotImplemented("get".to_string()));
    };
    let resource_type = match target_resource {
        Some(r) => r.type_name.clone(),
        None => resource.type_name.clone(),
    };
    validate_security_context(&get.require_security_context, &resource_type, "get")?;
    let path = target_resource.map(|target_resource| target_resource.path.clone());
    let command_resource_info = CommandResourceInfo {
        type_name: resource_type.clone(),
        path,
    };
    let args = process_get_args(get.args.as_ref(), filter, &command_resource_info);
    if !filter.is_empty() {
        verify_json_from_manifest(resource, filter, target_resource)?;
        command_input = get_command_input(get.input.as_ref(), filter)?;
    }

    info!("{}", t!("dscresources.commandResource.invokeGetUsing", resource = &resource.type_name, executable = &get.executable));
    let (_exit_code, stdout, stderr) = invoke_command(&get.executable, args, command_input.stdin.as_deref(), Some(&resource.directory), command_input.env, manifest.exit_codes.as_ref())?;
    if resource.kind == Kind::Resource {
        debug!("{}", t!("dscresources.commandResource.verifyOutputUsing", resource = &resource.type_name, executable = &get.executable));
        verify_json_from_manifest(resource, &stdout, target_resource)?;
    }

    let result: GetResult = if let Ok(group_response) = serde_json::from_str::<Vec<ResourceGetResult>>(&stdout) {
        trace!("{}", t!("dscresources.commandResource.groupGetResponse", response = &group_response : {:?}));
        GetResult::Group(group_response)
    } else {
        let result: Value = match serde_json::from_str(&stdout) {
            Ok(r) => {r},
            Err(err) => {
                return Err(DscError::Operation(t!("dscresources.commandResource.failedParseJson", executable = &get.executable, stdout = stdout, stderr = stderr, err = err).to_string()))
            }
        };
        GetResult::Resource(ResourceGetResponse{
            actual_state: result,
        })
    };

    Ok(result)
}

/// Invoke the set operation on a resource
///