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

Commit 9fb58965 authored by Mårten Kongstad's avatar Mårten Kongstad
Browse files

aconfig: rename namespace -> package 

What used to be referred to as a namespace is now called a package.

This CL is a semantic change only.

Bug: 285000854
Test: m nothing
Test: atest aconfig.test
Change-Id: If3fca67c415af75b44f316e16666b97089407069
parent 2bb714ed

tools/aconfig/protos/aconfig.proto

+3 −3
Original line number Diff line number Diff line
@@ -40,12 +40,12 @@ message flag_declaration { 
};



message flag_declarations {

  required string namespace = 1;

  required string package = 1;

  repeated flag_declaration flag = 2;

};



message flag_value {

  required string namespace = 1;

  required string package = 1;

  required string name = 2;

  required flag_state state = 3;

  required flag_permission permission = 4;
@@ -65,7 +65,7 @@ message tracepoint { 
}



message parsed_flag {

  required string namespace = 1;

  required string package = 1;

  required string name = 2;

  required string description = 3;

  required flag_state state = 4;

tools/aconfig/src/aconfig.rs

+14 −14
Original line number Diff line number Diff line
@@ -109,7 +109,7 @@ impl TryFrom<ProtoFlagDeclaration> for FlagDeclaration { 


#[derive(Debug, PartialEq, Eq)]

pub struct FlagDeclarations {

    pub namespace: String,

    pub package: String,

    pub flags: Vec<FlagDeclaration>,

}
@@ -117,20 +117,20 @@ impl FlagDeclarations { 
    pub fn try_from_text_proto(text_proto: &str) -> Result<FlagDeclarations> {

        let proto: ProtoFlagDeclarations = crate::protos::try_from_text_proto(text_proto)

            .with_context(|| text_proto.to_owned())?;

        let Some(namespace) = proto.namespace else {

            bail!("missing 'namespace' field");

        let Some(package) = proto.package else {

            bail!("missing 'package' field");

        };

        let mut flags = vec![];

        for proto_flag in proto.flag.into_iter() {

            flags.push(proto_flag.try_into()?);

        }

        Ok(FlagDeclarations { namespace, flags })

        Ok(FlagDeclarations { package, flags })

    }

}



#[derive(Debug, PartialEq, Eq)]

pub struct FlagValue {

    pub namespace: String,

    pub package: String,

    pub name: String,

    pub state: FlagState,

    pub permission: Permission,
@@ -153,8 +153,8 @@ impl TryFrom<ProtoFlagValue> for FlagValue { 
    type Error = Error;



    fn try_from(proto: ProtoFlagValue) -> Result<Self, Self::Error> {

        let Some(namespace) = proto.namespace else {

            bail!("missing 'namespace' field");

        let Some(package) = proto.package else {

            bail!("missing 'package' field");

        };

        let Some(name) = proto.name else {

            bail!("missing 'name' field");
@@ -167,7 +167,7 @@ impl TryFrom<ProtoFlagValue> for FlagValue { 
            bail!("missing 'permission' field");

        };

        let permission = proto_permission.try_into()?;

        Ok(FlagValue { namespace, name, state, permission })

        Ok(FlagValue { package, name, state, permission })

    }

}
@@ -184,7 +184,7 @@ impl From<Cache> for ProtoParsedFlags { 
impl From<Item> for ProtoParsedFlag {

    fn from(item: Item) -> Self {

        let mut proto = crate::protos::ProtoParsedFlag::new();

        proto.set_namespace(item.namespace.to_owned());

        proto.set_package(item.package.to_owned());

        proto.set_name(item.name.clone());

        proto.set_description(item.description.clone());

        proto.set_state(item.state.into());
@@ -242,9 +242,9 @@ mod tests { 
    }



    #[test]

    fn test_namespace_try_from_text_proto() {

    fn test_package_try_from_text_proto() {

        let expected = FlagDeclarations {

            namespace: "ns".to_owned(),

            package: "ns".to_owned(),

            flags: vec![

                FlagDeclaration { name: "a".to_owned(), description: "A".to_owned() },

                FlagDeclaration { name: "b".to_owned(), description: "B".to_owned() },
@@ -252,7 +252,7 @@ mod tests { 
        };



        let s = r#"

        namespace: "ns"

        package: "ns"

        flag {

            name: "a"

            description: "A"
@@ -270,14 +270,14 @@ mod tests { 
    #[test]

    fn test_flag_declaration_try_from_text_proto_list() {

        let expected = FlagValue {

            namespace: "ns".to_owned(),

            package: "ns".to_owned(),

            name: "1234".to_owned(),

            state: FlagState::Enabled,

            permission: Permission::ReadOnly,

        };



        let s = r#"

        namespace: "ns"

        package: "ns"

        name: "1234"

        state: ENABLED

        permission: READ_ONLY

tools/aconfig/src/cache.rs

+27 −27
Original line number Diff line number Diff line
@@ -34,11 +34,11 @@ pub struct Tracepoint { 


#[derive(Serialize, Deserialize, Debug)]

pub struct Item {

    // TODO: duplicating the Cache.namespace as Item.namespace makes the internal representation

    // TODO: duplicating the Cache.package as Item.package makes the internal representation

    // closer to the proto message `parsed_flag`; hopefully this will enable us to replace the Item

    // struct and use a newtype instead once aconfig has matured. Until then, namespace should

    // struct and use a newtype instead once aconfig has matured. Until then, package should

    // really be a Cow<String>.

    pub namespace: String,

    pub package: String,

    pub name: String,

    pub description: String,

    pub state: FlagState,
@@ -48,7 +48,7 @@ pub struct Item { 


#[derive(Serialize, Deserialize, Debug)]

pub struct Cache {

    namespace: String,

    package: String,

    items: Vec<Item>,

}
@@ -96,9 +96,9 @@ impl Cache { 
        self.items.into_iter()

    }



    pub fn namespace(&self) -> &str {

        debug_assert!(!self.namespace.is_empty());

        &self.namespace

    pub fn package(&self) -> &str {

        debug_assert!(!self.package.is_empty());

        &self.package

    }

}
@@ -108,9 +108,9 @@ pub struct CacheBuilder { 
}



impl CacheBuilder {

    pub fn new(namespace: String) -> Result<CacheBuilder> {

        ensure!(codegen::is_valid_identifier(&namespace), "bad namespace");

        let cache = Cache { namespace, items: vec![] };

    pub fn new(package: String) -> Result<CacheBuilder> {

        ensure!(codegen::is_valid_identifier(&package), "bad package");

        let cache = Cache { package, items: vec![] };

        Ok(CacheBuilder { cache })

    }
@@ -128,7 +128,7 @@ impl CacheBuilder { 
            source

        );

        self.cache.items.push(Item {

            namespace: self.cache.namespace.clone(),

            package: self.cache.package.clone(),

            name: declaration.name.clone(),

            description: declaration.description,

            state: DEFAULT_FLAG_STATE,
@@ -147,18 +147,18 @@ impl CacheBuilder { 
        source: Source,

        value: FlagValue,

    ) -> Result<&mut CacheBuilder> {

        ensure!(codegen::is_valid_identifier(&value.namespace), "bad flag namespace");

        ensure!(codegen::is_valid_identifier(&value.package), "bad flag package");

        ensure!(codegen::is_valid_identifier(&value.name), "bad flag name");

        ensure!(

            value.namespace == self.cache.namespace,

            "failed to set values for flag {}/{} from {}: expected namespace {}",

            value.namespace,

            value.package == self.cache.package,

            "failed to set values for flag {}/{} from {}: expected package {}",

            value.package,

            value.name,

            source,

            self.cache.namespace

            self.cache.package

        );

        let Some(existing_item) = self.cache.items.iter_mut().find(|item| item.name == value.name) else {

            bail!("failed to set values for flag {}/{} from {}: flag not declared", value.namespace, value.name, source);

            bail!("failed to set values for flag {}/{} from {}: flag not declared", value.package, value.name, source);

        };

        existing_item.state = value.state;

        existing_item.permission = value.permission;
@@ -222,7 +222,7 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: "ns".to_string(),

                    package: "ns".to_string(),

                    name: "foo".to_string(),

                    state: FlagState::Enabled,

                    permission: Permission::ReadOnly,
@@ -245,7 +245,7 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: "ns".to_string(),

                    package: "ns".to_string(),

                    name: "foo".to_string(),

                    state: FlagState::Disabled,

                    permission: Permission::ReadOnly,
@@ -257,7 +257,7 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: "ns".to_string(),

                    package: "ns".to_string(),

                    name: "foo".to_string(),

                    state: FlagState::Enabled,

                    permission: Permission::ReadWrite,
@@ -265,19 +265,19 @@ mod tests { 
            )

            .unwrap();



        // different namespace -> no-op

        // different package -> no-op

        let error = builder

            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: "some_other_namespace".to_string(),

                    package: "some_other_package".to_string(),

                    name: "foo".to_string(),

                    state: FlagState::Enabled,

                    permission: Permission::ReadOnly,

                },

            )

            .unwrap_err();

        assert_eq!(&format!("{:?}", error), "failed to set values for flag some_other_namespace/foo from <memory>: expected namespace ns");

        assert_eq!(&format!("{:?}", error), "failed to set values for flag some_other_package/foo from <memory>: expected package ns");



        let cache = builder.build();

        let item = cache.iter().find(|&item| item.name == "foo").unwrap();
@@ -286,7 +286,7 @@ mod tests { 
    }



    #[test]

    fn test_reject_empty_cache_namespace() {

    fn test_reject_empty_cache_package() {

        CacheBuilder::new("".to_string()).unwrap_err();

    }
@@ -325,20 +325,20 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: "".to_string(),

                    package: "".to_string(),

                    name: "foo".to_string(),

                    state: FlagState::Enabled,

                    permission: Permission::ReadOnly,

                },

            )

            .unwrap_err();

        assert_eq!(&format!("{:?}", error), "bad flag namespace");

        assert_eq!(&format!("{:?}", error), "bad flag package");



        let error = builder

            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: "ns".to_string(),

                    package: "ns".to_string(),

                    name: "".to_string(),

                    state: FlagState::Enabled,

                    permission: Permission::ReadOnly,

tools/aconfig/src/codegen_cpp.rs

+23 −23
Original line number Diff line number Diff line
@@ -25,18 +25,18 @@ use crate::commands::OutputFile; 
pub fn generate_cpp_code(cache: &Cache) -> Result<OutputFile> {

    let class_elements: Vec<ClassElement> = cache.iter().map(create_class_element).collect();

    let readwrite = class_elements.iter().any(|item| item.readwrite);

    let namespace = cache.namespace().to_lowercase();

    let context = Context { namespace: namespace.clone(), readwrite, class_elements };

    let package = cache.package().to_lowercase();

    let context = Context { package: package.clone(), readwrite, class_elements };

    let mut template = TinyTemplate::new();

    template.add_template("cpp_code_gen", include_str!("../templates/cpp.template"))?;

    let contents = template.render("cpp_code_gen", &context)?;

    let path = ["aconfig", &(namespace + ".h")].iter().collect();

    let path = ["aconfig", &(package + ".h")].iter().collect();

    Ok(OutputFile { contents: contents.into(), path })

}



#[derive(Serialize)]

struct Context {

    pub namespace: String,

    pub package: String,

    pub readwrite: bool,

    pub class_elements: Vec<ClassElement>,

}
@@ -69,8 +69,8 @@ mod tests { 


    #[test]

    fn test_cpp_codegen_build_time_flag_only() {

        let namespace = "my_namespace";

        let mut builder = CacheBuilder::new(namespace.to_string()).unwrap();

        let package = "my_package";

        let mut builder = CacheBuilder::new(package.to_string()).unwrap();

        builder

            .add_flag_declaration(

                Source::File("aconfig_one.txt".to_string()),
@@ -83,7 +83,7 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: namespace.to_string(),

                    package: package.to_string(),

                    name: "my_flag_one".to_string(),

                    state: FlagState::Disabled,

                    permission: Permission::ReadOnly,
@@ -101,7 +101,7 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: namespace.to_string(),

                    package: package.to_string(),

                    name: "my_flag_two".to_string(),

                    state: FlagState::Enabled,

                    permission: Permission::ReadOnly,
@@ -109,11 +109,11 @@ mod tests { 
            )

            .unwrap();

        let cache = builder.build();

        let expect_content = r#"#ifndef my_namespace_HEADER_H

        #define my_namespace_HEADER_H

        #include "my_namespace.h"

        let expect_content = r#"#ifndef my_package_HEADER_H

        #define my_package_HEADER_H

        #include "my_package.h"



        namespace my_namespace {

        namespace my_package {



            class my_flag_one {

                public:
@@ -133,7 +133,7 @@ mod tests { 
        #endif

        "#;

        let file = generate_cpp_code(&cache).unwrap();

        assert_eq!("aconfig/my_namespace.h", file.path.to_str().unwrap());

        assert_eq!("aconfig/my_package.h", file.path.to_str().unwrap());

        assert_eq!(

            expect_content.replace(' ', ""),

            String::from_utf8(file.contents).unwrap().replace(' ', "")
@@ -142,8 +142,8 @@ mod tests { 


    #[test]

    fn test_cpp_codegen_runtime_flag() {

        let namespace = "my_namespace";

        let mut builder = CacheBuilder::new(namespace.to_string()).unwrap();

        let package = "my_package";

        let mut builder = CacheBuilder::new(package.to_string()).unwrap();

        builder

            .add_flag_declaration(

                Source::File("aconfig_one.txt".to_string()),
@@ -164,7 +164,7 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: namespace.to_string(),

                    package: package.to_string(),

                    name: "my_flag_two".to_string(),

                    state: FlagState::Enabled,

                    permission: Permission::ReadWrite,
@@ -172,20 +172,20 @@ mod tests { 
            )

            .unwrap();

        let cache = builder.build();

        let expect_content = r#"#ifndef my_namespace_HEADER_H

        #define my_namespace_HEADER_H

        #include "my_namespace.h"

        let expect_content = r#"#ifndef my_package_HEADER_H

        #define my_package_HEADER_H

        #include "my_package.h"



        #include <server_configurable_flags/get_flags.h>

        using namespace server_configurable_flags;



        namespace my_namespace {

        namespace my_package {



            class my_flag_one {

                public:

                    virtual const bool value() {

                        return GetServerConfigurableFlag(

                            "my_namespace",

                            "my_package",

                            "my_flag_one",

                            "false") == "true";

                    }
@@ -195,7 +195,7 @@ mod tests { 
                public:

                    virtual const bool value() {

                        return GetServerConfigurableFlag(

                            "my_namespace",

                            "my_package",

                            "my_flag_two",

                            "true") == "true";

                    }
@@ -205,7 +205,7 @@ mod tests { 
        #endif

        "#;

        let file = generate_cpp_code(&cache).unwrap();

        assert_eq!("aconfig/my_namespace.h", file.path.to_str().unwrap());

        assert_eq!("aconfig/my_package.h", file.path.to_str().unwrap());

        assert_eq!(

            expect_content.replace(' ', ""),

            String::from_utf8(file.contents).unwrap().replace(' ', "")

tools/aconfig/src/codegen_java.rs

+7 −7
Original line number Diff line number Diff line
@@ -26,12 +26,12 @@ use crate::commands::OutputFile; 
pub fn generate_java_code(cache: &Cache) -> Result<OutputFile> {

    let class_elements: Vec<ClassElement> = cache.iter().map(create_class_element).collect();

    let readwrite = class_elements.iter().any(|item| item.readwrite);

    let namespace = cache.namespace();

    let context = Context { namespace: namespace.to_string(), readwrite, class_elements };

    let package = cache.package();

    let context = Context { package: package.to_string(), readwrite, class_elements };

    let mut template = TinyTemplate::new();

    template.add_template("java_code_gen", include_str!("../templates/java.template"))?;

    let contents = template.render("java_code_gen", &context)?;

    let mut path: PathBuf = ["aconfig", namespace].iter().collect();

    let mut path: PathBuf = ["aconfig", package].iter().collect();

    // TODO: Allow customization of the java class name

    path.push("Flags.java");

    Ok(OutputFile { contents: contents.into(), path })
@@ -39,7 +39,7 @@ pub fn generate_java_code(cache: &Cache) -> Result<OutputFile> { 


#[derive(Serialize)]

struct Context {

    pub namespace: String,

    pub package: String,

    pub readwrite: bool,

    pub class_elements: Vec<ClassElement>,

}
@@ -76,8 +76,8 @@ mod tests { 


    #[test]

    fn test_generate_java_code() {

        let namespace = "example";

        let mut builder = CacheBuilder::new(namespace.to_string()).unwrap();

        let package = "example";

        let mut builder = CacheBuilder::new(package.to_string()).unwrap();

        builder

            .add_flag_declaration(

                Source::File("test.txt".to_string()),
@@ -98,7 +98,7 @@ mod tests { 
            .add_flag_value(

                Source::Memory,

                FlagValue {

                    namespace: namespace.to_string(),

                    package: package.to_string(),

                    name: "test".to_string(),

                    state: FlagState::Disabled,

                    permission: Permission::ReadOnly,