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

Commit c54c841e authored by Dennis Shen's avatar Dennis Shen Committed by Gerrit Code Review
Browse files

Merge "aconfig: split aconfig_storage_file crate" into main

parents 040dc611 61d8c5a7

tools/aconfig/Cargo.toml

+1 −0
Original line number Diff line number Diff line
@@ -4,6 +4,7 @@ members = [ 
    "aconfig",

    "aconfig_protos",

    "aconfig_storage_file",

    "aconfig_storage_read_api",

    "aflags",

    "printflags"

]

tools/aconfig/TEST_MAPPING

+6 −2
Original line number Diff line number Diff line
@@ -69,13 +69,17 @@ 
    }

  ],

  "postsubmit": [

    {

      // aconfig_storage_read_api unit tests

      "name": "aconfig_storage_read_api.test"

    },

    {

      // aconfig_storage read api rust integration tests

      "name": "aconfig_storage.test.rust"

      "name": "aconfig_storage_read_api.test.rust"

    },

    {

      // aconfig_storage read api cpp integration tests

      "name": "aconfig_storage.test.cpp"

      "name": "aconfig_storage_read_api.test.cpp"

    },

    {

      // aflags CLI unit tests

tools/aconfig/aconfig_storage_file/Android.bp

+0 −89
Original line number Diff line number Diff line
@@ -9,12 +9,6 @@ rust_defaults { 
    srcs: ["src/lib.rs"],

    rustlibs: [

        "libanyhow",

        "libaconfig_storage_protos",

        "libonce_cell",

        "libprotobuf",

        "libtempfile",

        "libmemmap2",

        "libcxx",

        "libthiserror",

    ],

}
@@ -26,91 +20,8 @@ rust_library { 
    defaults: ["aconfig_storage_file.defaults"],

}



genrule {

    name: "ro.package.map",

    out: ["tests/tmp.ro.package.map"],

    srcs: ["tests/package.map"],

    cmd: "rm -f $(out);cp -f $(in) $(out);chmod -w $(out)",

}



genrule {

    name: "ro.flag.map",

    out: ["tests/tmp.ro.flag.map"],

    srcs: ["tests/flag.map"],

    cmd: "rm -f $(out);cp -f $(in) $(out);chmod -w $(out)",

}



genrule {

    name: "ro.flag.val",

    out: ["tests/tmp.ro.flag.val"],

    srcs: ["tests/flag.val"],

    cmd: "rm -f $(out);cp -f $(in) $(out);chmod -w $(out)",

}



rust_test_host {

    name: "aconfig_storage_file.test",

    test_suites: ["general-tests"],

    defaults: ["aconfig_storage_file.defaults"],

    data: [

        "tests/package.map",

        "tests/flag.map",

        "tests/flag.val",

    ],

}



rust_protobuf {

    name: "libaconfig_storage_protos",

    protos: ["protos/aconfig_storage_metadata.proto"],

    crate_name: "aconfig_storage_protos",

    source_stem: "aconfig_storage_protos",

    host_supported: true,

}



cc_library_static {

    name: "libaconfig_storage_protos_cc",

    proto: {

        export_proto_headers: true,

        type: "lite",

    },

    srcs: ["protos/aconfig_storage_metadata.proto"],

    apex_available: [

        "//apex_available:platform",

        "//apex_available:anyapex",

    ],

    host_supported: true,

}



genrule {

    name: "libcxx_aconfig_storage_bridge_code",

    tools: ["cxxbridge"],

    cmd: "$(location cxxbridge) $(in) > $(out)",

    srcs: ["src/lib.rs"],

    out: ["aconfig_storage/lib.rs.cc"],

}



genrule {

    name: "libcxx_aconfig_storage_bridge_header",

    tools: ["cxxbridge"],

    cmd: "$(location cxxbridge) $(in) --header > $(out)",

    srcs: ["src/lib.rs"],

    out: ["aconfig_storage/lib.rs.h"],

}



rust_ffi_static {

    name: "libaconfig_storage_cxx_bridge",

    crate_name: "aconfig_storage_cxx_bridge",

    host_supported: true,

    defaults: ["aconfig_storage_file.defaults"],

}



cc_library_static {

    name: "libaconfig_storage_cc",

    srcs: ["aconfig_storage.cpp"],

    generated_headers: [

        "cxx-bridge-header",

        "libcxx_aconfig_storage_bridge_header"

    ],

    generated_sources: ["libcxx_aconfig_storage_bridge_code"],

    whole_static_libs: ["libaconfig_storage_cxx_bridge"],

    export_include_dirs: ["include"],

}

tools/aconfig/aconfig_storage_file/src/flag_table.rs

+1 −88
Original line number Diff line number Diff line
@@ -17,10 +17,9 @@ 
//! flag table module defines the flag table file format and methods for serialization

//! and deserialization



use crate::AconfigStorageError::{self, BytesParseFail, HigherStorageFileVersion};

use crate::AconfigStorageError::{self, BytesParseFail};

use crate::{get_bucket_index, read_str_from_bytes, read_u16_from_bytes, read_u32_from_bytes};

use anyhow::anyhow;

pub type FlagOffset = u16;



/// Flag table header struct

#[derive(PartialEq, Debug)]
@@ -154,44 +153,6 @@ impl FlagTable { 
    }

}



/// Query flag within package offset

pub fn find_flag_offset(

    buf: &[u8],

    package_id: u32,

    flag: &str,

) -> Result<Option<FlagOffset>, AconfigStorageError> {

    let interpreted_header = FlagTableHeader::from_bytes(buf)?;

    if interpreted_header.version > crate::FILE_VERSION {

        return Err(HigherStorageFileVersion(anyhow!(

            "Cannot read storage file with a higher version of {} with lib version {}",

            interpreted_header.version,

            crate::FILE_VERSION

        )));

    }



    let num_buckets = (interpreted_header.node_offset - interpreted_header.bucket_offset) / 4;

    let bucket_index = FlagTableNode::find_bucket_index(package_id, flag, num_buckets);



    let mut pos = (interpreted_header.bucket_offset + 4 * bucket_index) as usize;

    let mut flag_node_offset = read_u32_from_bytes(buf, &mut pos)? as usize;

    if flag_node_offset < interpreted_header.node_offset as usize

        || flag_node_offset >= interpreted_header.file_size as usize

    {

        return Ok(None);

    }



    loop {

        let interpreted_node = FlagTableNode::from_bytes(&buf[flag_node_offset..])?;

        if interpreted_node.package_id == package_id && interpreted_node.flag_name == flag {

            return Ok(Some(interpreted_node.flag_id));

        }

        match interpreted_node.next_offset {

            Some(offset) => flag_node_offset = offset as usize,

            None => return Ok(None),

        }

    }

}



#[cfg(test)]

mod tests {

    use super::*;
@@ -270,52 +231,4 @@ mod tests { 
        assert!(reinterpreted_table.is_ok());

        assert_eq!(&flag_table, &reinterpreted_table.unwrap());

    }



    #[test]

    // this test point locks down table query

    fn test_flag_query() {

        let flag_table = create_test_flag_table().as_bytes();

        let baseline = vec![

            (0, "enabled_ro", 1u16),

            (0, "enabled_rw", 2u16),

            (1, "disabled_ro", 0u16),

            (2, "enabled_ro", 1u16),

            (1, "enabled_fixed_ro", 1u16),

            (1, "enabled_ro", 2u16),

            (2, "enabled_fixed_ro", 0u16),

            (0, "disabled_rw", 0u16),

        ];

        for (package_id, flag_name, expected_offset) in baseline.into_iter() {

            let flag_offset =

                find_flag_offset(&flag_table[..], package_id, flag_name).unwrap().unwrap();

            assert_eq!(flag_offset, expected_offset);

        }

    }



    #[test]

    // this test point locks down table query of a non exist flag

    fn test_not_existed_flag_query() {

        let flag_table = create_test_flag_table().as_bytes();

        let flag_offset = find_flag_offset(&flag_table[..], 1, "disabled_fixed_ro").unwrap();

        assert_eq!(flag_offset, None);

        let flag_offset = find_flag_offset(&flag_table[..], 2, "disabled_rw").unwrap();

        assert_eq!(flag_offset, None);

    }



    #[test]

    // this test point locks down query error when file has a higher version

    fn test_higher_version_storage_file() {

        let mut table = create_test_flag_table();

        table.header.version = crate::FILE_VERSION + 1;

        let flag_table = table.as_bytes();

        let error = find_flag_offset(&flag_table[..], 0, "enabled_ro").unwrap_err();

        assert_eq!(

            format!("{:?}", error),

            format!(

                "HigherStorageFileVersion(Cannot read storage file with a higher version of {} with lib version {})",

                crate::FILE_VERSION + 1,

                crate::FILE_VERSION

            )

        );

    }

}

tools/aconfig/aconfig_storage_file/src/flag_value.rs

+1 −66
Original line number Diff line number Diff line
@@ -17,9 +17,8 @@ 
//! flag value module defines the flag value file format and methods for serialization

//! and deserialization



use crate::AconfigStorageError::{self, HigherStorageFileVersion, InvalidStorageFileOffset};

use crate::AconfigStorageError;

use crate::{read_str_from_bytes, read_u32_from_bytes, read_u8_from_bytes};

use anyhow::anyhow;



/// Flag value header struct

#[derive(PartialEq, Debug)]
@@ -87,31 +86,6 @@ impl FlagValueList { 
    }

}



/// Query flag value

pub fn find_boolean_flag_value(buf: &[u8], flag_offset: u32) -> Result<bool, AconfigStorageError> {

    let interpreted_header = FlagValueHeader::from_bytes(buf)?;

    if interpreted_header.version > crate::FILE_VERSION {

        return Err(HigherStorageFileVersion(anyhow!(

            "Cannot read storage file with a higher version of {} with lib version {}",

            interpreted_header.version,

            crate::FILE_VERSION

        )));

    }



    let mut head = (interpreted_header.boolean_value_offset + flag_offset) as usize;



    // TODO: right now, there is only boolean flags, with more flag value types added

    // later, the end of boolean flag value section should be updated (b/322826265).

    if head >= interpreted_header.file_size as usize {

        return Err(InvalidStorageFileOffset(anyhow!(

            "Flag value offset goes beyond the end of the file."

        )));

    }



    let val = read_u8_from_bytes(buf, &mut head)?;

    Ok(val == 1)

}



#[cfg(test)]

mod tests {

    use super::*;
@@ -142,43 +116,4 @@ mod tests { 
        assert!(reinterpreted_value_list.is_ok());

        assert_eq!(&flag_value_list, &reinterpreted_value_list.unwrap());

    }



    #[test]

    // this test point locks down flag value query

    fn test_flag_value_query() {

        let flag_value_list = create_test_flag_value_list().as_bytes();

        let baseline: Vec<bool> = vec![false, true, false, false, true, true, false, true];

        for (offset, expected_value) in baseline.into_iter().enumerate() {

            let flag_value = find_boolean_flag_value(&flag_value_list[..], offset as u32).unwrap();

            assert_eq!(flag_value, expected_value);

        }

    }



    #[test]

    // this test point locks down query beyond the end of boolean section

    fn test_boolean_out_of_range() {

        let flag_value_list = create_test_flag_value_list().as_bytes();

        let error = find_boolean_flag_value(&flag_value_list[..], 8).unwrap_err();

        assert_eq!(

            format!("{:?}", error),

            "InvalidStorageFileOffset(Flag value offset goes beyond the end of the file.)"

        );

    }



    #[test]

    // this test point locks down query error when file has a higher version

    fn test_higher_version_storage_file() {

        let mut value_list = create_test_flag_value_list();

        value_list.header.version = crate::FILE_VERSION + 1;

        let flag_value = value_list.as_bytes();

        let error = find_boolean_flag_value(&flag_value[..], 4).unwrap_err();

        assert_eq!(

            format!("{:?}", error),

            format!(

                "HigherStorageFileVersion(Cannot read storage file with a higher version of {} with lib version {})",

                crate::FILE_VERSION + 1,

                crate::FILE_VERSION

            )

        );

    }

}