Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dc689f8f authored by Dennis Shen's avatar Dennis Shen
Browse files

Use new storage for exported mode codegen 

1, update aconfig cache update modifier to override storage backend to
ACONFIGD, so that when creating codegen context struct in java.rs,
use_device_config will be strictly false.

2, update the ensure! statement in feature impl template file selection
that it must not use device config for exported mode. As 1 should have
guaranteed this.

Bug: b/406508083
Test: atest -c
Change-Id: Iea770b5a32be49b22ca19f0f9f5930baf3f9699c
parent 51e69bb3

tools/aconfig/aconfig/src/codegen/java.rs

+1 −1
Original line number Diff line number Diff line
@@ -267,7 +267,7 @@ fn add_feature_flags_impl_template(context: &Context, template: &mut TinyTemplat 
        true => {

            ensure!(

                !context.use_device_config,

                "using device config in exported mode is currently not supported"

                "All exported mode codegen should rely on new storage for safety"

            );

            template.add_template(

                "FeatureFlagsImpl.java",

tools/aconfig/aconfig/src/commands.rs

+37 −7
Original line number Diff line number Diff line
@@ -461,16 +461,22 @@ pub fn modify_parsed_flags_based_on_mode( 
    parsed_flags: ProtoParsedFlags,

    codegen_mode: CodegenMode,

) -> Result<Vec<ProtoParsedFlag>> {

    fn exported_mode_flag_modifier(mut parsed_flag: ProtoParsedFlag) -> ProtoParsedFlag {

    fn exported_mode_flag_modifier(mut parsed_flag: ProtoParsedFlag) -> Result<ProtoParsedFlag> {

        parsed_flag.set_state(ProtoFlagState::DISABLED);

        parsed_flag.set_permission(ProtoFlagPermission::READ_WRITE);

        parsed_flag.set_is_fixed_read_only(false);

        parsed_flag

        let m = parsed_flag.metadata.as_mut().ok_or(anyhow!("missing metadata"))?;

        m.set_storage(ProtoFlagStorageBackend::ACONFIGD);

        Ok(parsed_flag)

    }



    fn force_read_only_mode_flag_modifier(mut parsed_flag: ProtoParsedFlag) -> ProtoParsedFlag {

    fn force_read_only_mode_flag_modifier(

        mut parsed_flag: ProtoParsedFlag,

    ) -> Result<ProtoParsedFlag> {

        parsed_flag.set_permission(ProtoFlagPermission::READ_ONLY);

        parsed_flag

        let m = parsed_flag.metadata.as_mut().ok_or(anyhow!("missing metadata"))?;

        m.set_storage(ProtoFlagStorageBackend::NONE);

        Ok(parsed_flag)

    }



    let modified_parsed_flags: Vec<_> = match codegen_mode {
@@ -479,13 +485,13 @@ pub fn modify_parsed_flags_based_on_mode( 
            .into_iter()

            .filter(|pf| pf.is_exported())

            .map(exported_mode_flag_modifier)

            .collect(),

            .collect::<Result<Vec<_>>>()?,

        CodegenMode::ForceReadOnly => parsed_flags

            .parsed_flag

            .into_iter()

            .filter(|pf| !pf.is_exported())

            .map(force_read_only_mode_flag_modifier)

            .collect(),

            .collect::<Result<Vec<_>>>()?,

        CodegenMode::Production | CodegenMode::Test => {

            parsed_flags.parsed_flag.into_iter().collect()

        }
@@ -1261,13 +1267,19 @@ mod tests { 


    #[test]

    fn test_modify_parsed_flags_based_on_mode_exported() {

        let parsed_flags = crate::test::parse_test_flags();

        let mut parsed_flags = crate::test::parse_test_flags();



        let pf = parsed_flags.parsed_flag.iter_mut().find(|pf| pf.is_exported()).unwrap();

        let m = pf.metadata.as_mut().unwrap();

        m.set_storage(ProtoFlagStorageBackend::DEVICE_CONFIG);



        let p_parsed_flags =

            modify_parsed_flags_based_on_mode(parsed_flags, CodegenMode::Exported).unwrap();

        assert_eq!(3, p_parsed_flags.len());

        for flag in p_parsed_flags.iter() {

            assert_eq!(ProtoFlagState::DISABLED, flag.state());

            assert_eq!(ProtoFlagPermission::READ_WRITE, flag.permission());

            assert_eq!(ProtoFlagStorageBackend::ACONFIGD, flag.metadata.storage());

            assert!(!flag.is_fixed_read_only());

            assert!(flag.is_exported());

        }
@@ -1279,6 +1291,24 @@ mod tests { 
        assert_eq!("exported library contains no exported flags", format!("{:?}", error));

    }



    #[test]

    fn test_modify_parsed_flags_based_on_mode_forcereadonly() {

        let mut parsed_flags = crate::test::parse_test_flags();



        let pf = parsed_flags.parsed_flag.iter_mut().find(|pf| !pf.is_exported()).unwrap();

        let m = pf.metadata.as_mut().unwrap();

        m.set_storage(ProtoFlagStorageBackend::DEVICE_CONFIG);



        let p_parsed_flags =

            modify_parsed_flags_based_on_mode(parsed_flags, CodegenMode::ForceReadOnly).unwrap();

        assert_eq!(6, p_parsed_flags.len());

        for flag in p_parsed_flags.iter() {

            assert_eq!(ProtoFlagPermission::READ_ONLY, flag.permission());

            assert_eq!(ProtoFlagStorageBackend::NONE, flag.metadata.storage());

            assert!(!flag.is_exported());

        }

    }



    #[test]

    fn test_assign_flag_ids() {

        let mut parsed_flags = crate::test::parse_test_flags();