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

Commit e8a4ee72 authored by Zhi Dou's avatar Zhi Dou
Browse files

aconfig: add exported mode in rust codegen 

This commit adds exported mode to rust codegen.

When the codegen mode is exported
1. only flags with exported: true will be generated
2. the generated getter should be in a read_write format and with
   default value as false, regardless the original permission and state
   of the flag

This commit adds integration test for rust codegen exported mode.

Bug: 316357104
Test: atest aconfig.test aconfig.test_mode.test.rust aconfig.exported_mode.test.rust
Change-Id: Ib7dae666e13eb8898289b06d42a4f89326e175c4
parent b52465da

tools/aconfig/Android.bp

+18 −0
Original line number Diff line number Diff line
@@ -238,3 +238,21 @@ rust_test { 
    ],

    test_suites: ["general-tests"],

}



rust_aconfig_library {

    name: "libaconfig_test_rust_library_with_exported_mode",

    crate_name: "aconfig_test_rust_library",

    aconfig_declarations: "aconfig.test.flags",

    mode: "exported",

}



rust_test {

    name: "aconfig.exported_mode.test.rust",

    srcs: [

        "tests/aconfig_exported_mode_test.rs"

    ],

    rustlibs: [

        "libaconfig_test_rust_library_with_exported_mode",

    ],

    test_suites: ["general-tests"],

}

tools/aconfig/src/codegen/rust.rs

+78 −11
Original line number Diff line number Diff line
@@ -45,9 +45,7 @@ where 
        match codegen_mode {

            CodegenMode::Production => include_str!("../../templates/rust_prod.template"),

            CodegenMode::Test => include_str!("../../templates/rust_test.template"),

            CodegenMode::Exported => {

                todo!("exported mode not yet supported for rust, see b/313894653.")

            }

            CodegenMode::Exported => include_str!("../../templates/rust_exported.template"),

        },

    )?;

    let contents = template.render("rust_code_gen", &context)?;
@@ -487,15 +485,80 @@ pub fn set_enabled_rw(val: bool) { 
pub fn reset_flags() {

    PROVIDER.lock().unwrap().reset_flags()

}

"#;



    const EXPORTED_EXPECTED: &str = r#"

//! codegenerated rust flag lib



/// flag provider

pub struct FlagProvider;



lazy_static::lazy_static! {

    /// flag value cache for disabled_rw_exported

    static ref CACHED_disabled_rw_exported: bool = flags_rust::GetServerConfigurableFlag(

        "aconfig_flags.aconfig_test",

        "com.android.aconfig.test.disabled_rw_exported",

        "false") == "true";



    /// flag value cache for enabled_fixed_ro_exported

    static ref CACHED_enabled_fixed_ro_exported: bool = flags_rust::GetServerConfigurableFlag(

        "aconfig_flags.aconfig_test",

        "com.android.aconfig.test.enabled_fixed_ro_exported",

        "false") == "true";



    /// flag value cache for enabled_ro_exported

    static ref CACHED_enabled_ro_exported: bool = flags_rust::GetServerConfigurableFlag(

        "aconfig_flags.aconfig_test",

        "com.android.aconfig.test.enabled_ro_exported",

        "false") == "true";



}



impl FlagProvider {

    /// query flag disabled_rw_exported

    pub fn disabled_rw_exported(&self) -> bool {

        *CACHED_disabled_rw_exported

    }



    /// query flag enabled_fixed_ro_exported

    pub fn enabled_fixed_ro_exported(&self) -> bool {

        *CACHED_enabled_fixed_ro_exported

    }



    /// query flag enabled_ro_exported

    pub fn enabled_ro_exported(&self) -> bool {

        *CACHED_enabled_ro_exported

    }

}



/// flag provider

pub static PROVIDER: FlagProvider = FlagProvider;



/// query flag disabled_rw_exported

#[inline(always)]

pub fn disabled_rw_exported() -> bool {

    PROVIDER.disabled_rw_exported()

}



/// query flag enabled_fixed_ro_exported

#[inline(always)]

pub fn enabled_fixed_ro_exported() -> bool {

    PROVIDER.enabled_fixed_ro_exported()

}



/// query flag enabled_ro_exported

#[inline(always)]

pub fn enabled_ro_exported() -> bool {

    PROVIDER.enabled_ro_exported()

}

"#;



    fn test_generate_rust_code(mode: CodegenMode) {

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

        let generated = generate_rust_code(

            crate::test::TEST_PACKAGE,

            parsed_flags.parsed_flag.into_iter(),

            mode,

        )

        let modified_parsed_flags =

            crate::commands::modify_parsed_flags_based_on_mode(parsed_flags, mode);

        let generated =

            generate_rust_code(crate::test::TEST_PACKAGE, modified_parsed_flags.into_iter(), mode)

                .unwrap();

        assert_eq!("src/lib.rs", format!("{}", generated.path.display()));

        assert_eq!(
@@ -504,8 +567,7 @@ pub fn reset_flags() { 
                match mode {

                    CodegenMode::Production => PROD_EXPECTED,

                    CodegenMode::Test => TEST_EXPECTED,

                    CodegenMode::Exported =>

                        todo!("exported mode not yet supported for rust, see b/313894653."),

                    CodegenMode::Exported => EXPORTED_EXPECTED,

                },

                &String::from_utf8(generated.contents).unwrap()

            )
@@ -521,4 +583,9 @@ pub fn reset_flags() { 
    fn test_generate_rust_code_for_test() {

        test_generate_rust_code(CodegenMode::Test);

    }



    #[test]

    fn test_generate_rust_code_for_exported() {

        test_generate_rust_code(CodegenMode::Exported);

    }

}

tools/aconfig/src/commands.rs

+3 −3
Original line number Diff line number Diff line
@@ -217,12 +217,12 @@ pub fn create_cpp_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<Vec 


pub fn create_rust_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<OutputFile> {

    let parsed_flags = input.try_parse_flags()?;

    let filtered_parsed_flags = filter_parsed_flags(parsed_flags, codegen_mode);

    let Some(package) = find_unique_package(&filtered_parsed_flags) else {

    let modified_parsed_flags = modify_parsed_flags_based_on_mode(parsed_flags, codegen_mode);

    let Some(package) = find_unique_package(&modified_parsed_flags) else {

        bail!("no parsed flags, or the parsed flags use different packages");

    };

    let package = package.to_string();

    generate_rust_code(&package, filtered_parsed_flags.into_iter(), codegen_mode)

    generate_rust_code(&package, modified_parsed_flags.into_iter(), codegen_mode)

}



pub fn create_storage(caches: Vec<Input>, container: &str) -> Result<Vec<OutputFile>> {

tools/aconfig/templates/rust_exported.template

0 → 100644
+36 −0
Original line number Diff line number Diff line 
//! codegenerated rust flag lib



/// flag provider

pub struct FlagProvider;



lazy_static::lazy_static! \{

    {{ for flag in template_flags }}

    /// flag value cache for {flag.name}

    static ref CACHED_{flag.name}: bool = flags_rust::GetServerConfigurableFlag(

        "aconfig_flags.{flag.device_config_namespace}",

        "{flag.device_config_flag}",

        "false") == "true";

    {{ endfor }}

}



impl FlagProvider \{



    {{ for flag in template_flags }}

    /// query flag {flag.name}

    pub fn {flag.name}(&self) -> bool \{

        *CACHED_{flag.name}

    }

    {{ endfor }}



}



/// flag provider

pub static PROVIDER: FlagProvider = FlagProvider;



{{ for flag in template_flags }}

/// query flag {flag.name}

#[inline(always)]

pub fn {flag.name}() -> bool \{

    PROVIDER.{flag.name}()

}

{{ endfor }}

tools/aconfig/tests/aconfig_exported_mode_test.rs

0 → 100644
+7 −0
Original line number Diff line number Diff line 
#[cfg(not(feature = "cargo"))]

#[test]

fn test_flags() {

    assert!(!aconfig_test_rust_library::disabled_rw_exported());

    assert!(!aconfig_test_rust_library::enabled_fixed_ro_exported());

    assert!(!aconfig_test_rust_library::enabled_ro_exported());

}