Function check_security_context

lib/dsc-lib/src/configure/mod.rs:289–331

(metadata: Option<&Metadata>, directive_security_context: Option<&SecurityContextKind>)

}

fn check_security_context(metadata: Option<&Metadata>, directive_security_context: Option<&SecurityContextKind>) -> Result<(), DscError> {
    if metadata.is_none() && directive_security_context.is_none() {
        return Ok(());
    }

    let mut security_context_required: Option<&SecurityContextKind> = None;
    if let Some(metadata) = &metadata
        && let Some(microsoft_dsc) = &metadata.microsoft
        && let Some(required_security_context) = &microsoft_dsc.security_context {
            warn!("{}", t!("configure.mod.securityContextInMetadataDeprecated"));
            security_context_required = Some(required_security_context);
        }

    if let Some(directive_security_context) = directive_security_context {
        if let Some(security_context_required) = security_context_required
            && security_context_required != directive_security_context {
                return Err(DscError::SecurityContext(t!(
                    "configure.mod.conflictingSecurityContext",
                    metadata = security_context_required,
                    directive = directive_security_context
                ).to_string()));
            }
        security_context_required = Some(directive_security_context);
    }

    match security_context_required {
        Some(SecurityContextKind::Elevated) => {
            if get_security_context() != SecurityContext::Admin {
                return Err(DscError::SecurityContext(t!("configure.mod.elevationRequired").to_string()));
            }
        },
        Some(SecurityContextKind::Restricted) => {
            if get_security_context() != SecurityContext::User {
                return Err(DscError::SecurityContext(t!("configure.mod.restrictedRequired").to_string()));
            }
        },
        None | Some(SecurityContextKind::Current) => {
            // no check needed
        },
    }

    Ok(())
}

fn get_metadata_from_result(mut context: Option<&mut Context>, properties: &mut Value, metadata: &mut Metadata, execution_information: &mut ExecutionInformation) -> Result<(), DscError> {
    if let Some(restart_required) = properties.get("_restartRequired") {