Function test_value

archive/registry/src/regconfighelper.rs:231–289

(config: &Registry)

}

fn test_value(config: &Registry) -> Result<String, RegistryError> {
    let mut reg_result: Registry = Registry { key_path: config.key_path.clone(), ..Default::default()};
    let mut in_desired_state = true;

    let reg_key = match RegistryKey::new(config.key_path.as_str()) {
        Ok(key) => {
            key
        },
        Err(NtStatusError { status: NtStatusErrorKind::ObjectNameNotFound, ..}) => {
            reg_result.key_path = String::new();
            reg_result.in_desired_state = Some(false);
            return Ok(reg_result.to_json());
        },
        Err(err) => {
            return Err(RegistryError::NtStatus(err));
        }
    };

    let value_name = config.value_name.as_ref().unwrap();
    let mut value_exists = false;
    let reg_value: RegistryValue = match reg_key.get_value(value_name) {
        Ok(value) => {
            value_exists = true;
            reg_result.value_name = Some(value.name.clone());
            reg_result.value_data = Some(convert_ntreg_data(&value.data)?);
            value
        },
        Err(NtStatusError { status: NtStatusErrorKind::ObjectNameNotFound, ..}) => {
            RegistryValue {
                key_path: config.key_path.clone(),
                name : String::new(),
                data : NtRegistryValueData::None,
            }
        },
        Err(err) => {
            return Err(RegistryError::NtStatus(err));
        }
    };

    match &config.exist {
        Some(true) | None => {
            if value_exists {
                in_desired_state = reg_values_are_eq(config, &reg_value)?;
            }
            else {
                in_desired_state = false;
            }
        },
        Some(false) => {
            if value_exists {
                in_desired_state = false;
            }
        }
    }

    reg_result.exist = Some(value_exists);
    reg_result.in_desired_state = Some(in_desired_state);
    Ok(reg_result.to_json())