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

Commit 56146b0e authored by Dennis Shen's avatar Dennis Shen Committed by Automerger Merge Worker
Browse files

Merge "aconfig: create one file at each create-storage command invocation" into main am: 1ef90586 

Original change: https://android-review.googlesource.com/c/platform/build/+/2918566



Change-Id: I77caeba57c683c80d40c35d739c55c26eff3b34f
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 88c1294f 1ef90586

tools/aconfig/src/commands.rs

+4 −3
Original line number Diff line number Diff line
@@ -30,7 +30,8 @@ use crate::protos::{ 
    ParsedFlagExt, ProtoFlagMetadata, ProtoFlagPermission, ProtoFlagState, ProtoParsedFlag,

    ProtoParsedFlags, ProtoTracepoint,

};

use crate::storage::generate_storage_files;

use crate::storage::generate_storage_file;

use crate::storage::StorageFileSelection;



pub struct Input {

    pub source: String,
@@ -223,7 +224,7 @@ pub fn create_rust_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<Ou 
    generate_rust_code(&package, modified_parsed_flags.into_iter(), codegen_mode)

}



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

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

    let parsed_flags_vec: Vec<ProtoParsedFlags> = caches

        .into_iter()

        .map(|mut input| input.try_parse_flags())
@@ -231,7 +232,7 @@ pub fn create_storage(caches: Vec<Input>, container: &str) -> Result<Vec<OutputF 
        .into_iter()

        .filter(|pfs| find_unique_container(pfs) == Some(container))

        .collect();

    generate_storage_files(container, parsed_flags_vec.iter())

    generate_storage_file(container, parsed_flags_vec.iter(), file)

}



pub fn create_device_config_defaults(mut input: Input) -> Result<Vec<u8>> {

tools/aconfig/src/main.rs

+11 −5
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ mod storage; 


use codegen::CodegenMode;

use dump::DumpFormat;

use storage::StorageFileSelection;



#[cfg(test)]

mod test;
@@ -135,6 +136,11 @@ fn cli() -> Command { 
                        .required(true)

                        .help("The target container for the generated storage file."),

                )

                .arg(

                    Arg::new("file")

                        .long("file")

                        .value_parser(|s: &str| StorageFileSelection::try_from(s)),

                )

                .arg(Arg::new("cache").long("cache").action(ArgAction::Append).required(true))

                .arg(Arg::new("out").long("out").required(true)),

        )
@@ -278,14 +284,14 @@ fn main() -> Result<()> { 
            write_output_to_file_or_stdout(path, &output)?;

        }

        Some(("create-storage", sub_matches)) => {

            let file = get_required_arg::<StorageFileSelection>(sub_matches, "file")

                .context("Invalid storage file selection")?;

            let cache = open_zero_or_more_files(sub_matches, "cache")?;

            let container = get_required_arg::<String>(sub_matches, "container")?;

            let dir = PathBuf::from(get_required_arg::<String>(sub_matches, "out")?);

            let generated_files = commands::create_storage(cache, container)

            let path = get_required_arg::<String>(sub_matches, "out")?;

            let output = commands::create_storage(cache, container, file)

                .context("failed to create storage files")?;

            generated_files

                .iter()

                .try_for_each(|file| write_output_file_realtive_to_dir(&dir, file))?;

            write_output_to_file_or_stdout(path, &output)?;

        }

        _ => unreachable!(),

    }

tools/aconfig/src/storage/mod.rs

+37 −23
Original line number Diff line number Diff line
@@ -21,14 +21,32 @@ pub mod package_table; 
use anyhow::{anyhow, Result};

use std::collections::{hash_map::DefaultHasher, HashMap, HashSet};

use std::hash::{Hash, Hasher};

use std::path::PathBuf;



use crate::commands::OutputFile;

use crate::protos::{ProtoParsedFlag, ProtoParsedFlags};

use crate::storage::{

    flag_table::FlagTable, flag_value::FlagValueList, package_table::PackageTable,

};



#[derive(Clone, Debug, PartialEq, Eq)]

pub enum StorageFileSelection {

    PackageMap,

    FlagMap,

    FlagVal,

}



impl TryFrom<&str> for StorageFileSelection {

    type Error = anyhow::Error;



    fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {

        match value {

            "package_map" => Ok(Self::PackageMap),

            "flag_map" => Ok(Self::FlagMap),

            "flag_val" => Ok(Self::FlagVal),

            _ => Err(anyhow!("Invalid storage file to create")),

        }

    }

}



pub const FILE_VERSION: u32 = 1;



pub const HASH_PRIMES: [u32; 29] = [
@@ -110,34 +128,30 @@ where 
    packages

}



pub fn generate_storage_files<'a, I>(

pub fn generate_storage_file<'a, I>(

    container: &str,

    parsed_flags_vec_iter: I,

) -> Result<Vec<OutputFile>>

    file: &StorageFileSelection,

) -> Result<Vec<u8>>

where

    I: Iterator<Item = &'a ProtoParsedFlags>,

{

    let packages = group_flags_by_package(parsed_flags_vec_iter);



    // create and serialize package map

    match file {

        StorageFileSelection::PackageMap => {

            let package_table = PackageTable::new(container, &packages)?;

    let package_table_file_path = PathBuf::from("package.map");

    let package_table_file =

        OutputFile { contents: package_table.as_bytes(), path: package_table_file_path };



    // create and serialize flag map

            Ok(package_table.as_bytes())

        }

        StorageFileSelection::FlagMap => {

            let flag_table = FlagTable::new(container, &packages)?;

    let flag_table_file_path = PathBuf::from("flag.map");

    let flag_table_file =

        OutputFile { contents: flag_table.as_bytes(), path: flag_table_file_path };



    // create and serialize flag value

            Ok(flag_table.as_bytes())

        }

        StorageFileSelection::FlagVal => {

            let flag_value = FlagValueList::new(container, &packages)?;

    let flag_value_file_path = PathBuf::from("flag.val");

    let flag_value_file =

        OutputFile { contents: flag_value.as_bytes(), path: flag_value_file_path };



    Ok(vec![package_table_file, flag_table_file, flag_value_file])

            Ok(flag_value.as_bytes())

        }

    }

}



#[cfg(test)]