aconfig: support custom `dump format` specs
Teach `dump --format=<arg>` to format the output according to a
user-defined format string. The format string now accepts these
arguments:
- "protobuf": output all data as binary protobuf (as before)
- "textproto": output all data as text protobuf (as before)
- any other string: format according to the format spec, see below
Custom format spec: placeholders, enclosed in { and } and named after
the fields of ProtoParsedFlag, will be replaced by the actual values.
All other text is output verbatim. As an example:
- "{name}={state}" -> "enabled_ro=ENABLED"
Some fields support an alternative formatting via {<field>:<format>}. As
an example:
- "{name}={state:bool}" -> "enabled_ro=true"
Note that the text replacement does not support escaping { and }. This
means there is no way to print the string "{name}" without expanding it
to the actual flag's name. If needed this feature can be introduced in a
later CL.
For backwards compatibility, the following format strings have special
meaning and will produce an output identically to what it was before
this change:
- "text"
- "verbose"
- "bool"
A follow-up CL will add a new `dump --filter=` argument to limit which
parsed flags are included in the output.
Test: atest
Bug: b/315487153
Change-Id: If7c14b5fb3e7b41ea962425078bd04b4996318f4
diff --git a/tools/aconfig/src/commands.rs b/tools/aconfig/src/commands.rs
index 50049d5..7ae1219 100644
--- a/tools/aconfig/src/commands.rs
+++ b/tools/aconfig/src/commands.rs
@@ -23,12 +23,12 @@
use crate::codegen::cpp::generate_cpp_code;
use crate::codegen::java::generate_java_code;
use crate::codegen::rust::generate_rust_code;
-use crate::storage::generate_storage_files;
-
+use crate::dump::DumpFormat;
use crate::protos::{
ParsedFlagExt, ProtoFlagMetadata, ProtoFlagPermission, ProtoFlagState, ProtoParsedFlag,
ProtoParsedFlags, ProtoTracepoint,
};
+use crate::storage::generate_storage_files;
pub struct Input {
pub source: String,
@@ -279,15 +279,6 @@
Ok(output)
}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, ValueEnum)]
-pub enum DumpFormat {
- Text,
- Verbose,
- Protobuf,
- Textproto,
- Bool,
-}
-
pub fn dump_parsed_flags(
mut input: Vec<Input>,
format: DumpFormat,
@@ -297,55 +288,7 @@
input.iter_mut().map(|i| i.try_parse_flags()).collect();
let parsed_flags: ProtoParsedFlags =
crate::protos::parsed_flags::merge(individually_parsed_flags?, dedup)?;
-
- let mut output = Vec::new();
- match format {
- DumpFormat::Text => {
- for parsed_flag in parsed_flags.parsed_flag.into_iter() {
- let line = format!(
- "{} [{}]: {:?} + {:?}\n",
- parsed_flag.fully_qualified_name(),
- parsed_flag.container(),
- parsed_flag.permission(),
- parsed_flag.state()
- );
- output.extend_from_slice(line.as_bytes());
- }
- }
- DumpFormat::Verbose => {
- for parsed_flag in parsed_flags.parsed_flag.into_iter() {
- let sources: Vec<_> =
- parsed_flag.trace.iter().map(|tracepoint| tracepoint.source()).collect();
- let line = format!(
- "{} [{}]: {:?} + {:?} ({})\n",
- parsed_flag.fully_qualified_name(),
- parsed_flag.container(),
- parsed_flag.permission(),
- parsed_flag.state(),
- sources.join(", ")
- );
- output.extend_from_slice(line.as_bytes());
- }
- }
- DumpFormat::Protobuf => {
- parsed_flags.write_to_vec(&mut output)?;
- }
- DumpFormat::Textproto => {
- let s = protobuf::text_format::print_to_string_pretty(&parsed_flags);
- output.extend_from_slice(s.as_bytes());
- }
- DumpFormat::Bool => {
- for parsed_flag in parsed_flags.parsed_flag.into_iter() {
- let line = format!(
- "{}={:?}\n",
- parsed_flag.fully_qualified_name(),
- parsed_flag.state() == ProtoFlagState::ENABLED
- );
- output.extend_from_slice(line.as_bytes());
- }
- }
- }
- Ok(output)
+ crate::dump::dump_parsed_flags(parsed_flags.parsed_flag.into_iter(), format)
}
fn find_unique_package(parsed_flags: &[ProtoParsedFlag]) -> Option<&str> {
@@ -622,36 +565,16 @@
}
#[test]
- fn test_dump_text_format() {
+ fn test_dump() {
let input = parse_test_flags_as_input();
- let bytes = dump_parsed_flags(vec![input], DumpFormat::Text, false).unwrap();
- let text = std::str::from_utf8(&bytes).unwrap();
- assert!(
- text.contains("com.android.aconfig.test.disabled_ro [system]: READ_ONLY + DISABLED")
- );
- }
-
- #[test]
- fn test_dump_protobuf_format() {
- let expected = protobuf::text_format::parse_from_str::<ProtoParsedFlags>(
- crate::test::TEST_FLAGS_TEXTPROTO,
+ let bytes = dump_parsed_flags(
+ vec![input],
+ DumpFormat::Custom("{fully_qualified_name}".to_string()),
+ false,
)
- .unwrap()
- .write_to_bytes()
.unwrap();
-
- let input = parse_test_flags_as_input();
- let actual = dump_parsed_flags(vec![input], DumpFormat::Protobuf, false).unwrap();
-
- assert_eq!(expected, actual);
- }
-
- #[test]
- fn test_dump_textproto_format() {
- let input = parse_test_flags_as_input();
- let bytes = dump_parsed_flags(vec![input], DumpFormat::Textproto, false).unwrap();
let text = std::str::from_utf8(&bytes).unwrap();
- assert_eq!(crate::test::TEST_FLAGS_TEXTPROTO.trim(), text.trim());
+ assert!(text.contains("com.android.aconfig.test.disabled_ro"));
}
#[test]
diff --git a/tools/aconfig/src/dump.rs b/tools/aconfig/src/dump.rs
new file mode 100644
index 0000000..410c392
--- /dev/null
+++ b/tools/aconfig/src/dump.rs
@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use crate::protos::{ParsedFlagExt, ProtoFlagMetadata, ProtoFlagState, ProtoTracepoint};
+use crate::protos::{ProtoParsedFlag, ProtoParsedFlags};
+use anyhow::Result;
+use protobuf::Message;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DumpFormat {
+ Protobuf,
+ Textproto,
+ Custom(String),
+}
+
+impl TryFrom<&str> for DumpFormat {
+ type Error = anyhow::Error;
+
+ fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
+ match value {
+ // protobuf formats
+ "protobuf" => Ok(Self::Protobuf),
+ "textproto" => Ok(Self::Textproto),
+
+ // old formats now implemented as aliases to custom format
+ "text" => Ok(Self::Custom(
+ "{fully_qualified_name} [{container}]: {permission} + {state}".to_owned(),
+ )),
+ "verbose" => Ok(Self::Custom(
+ "{fully_qualified_name} [{container}]: {permission} + {state} ({trace:paths})"
+ .to_owned(),
+ )),
+ "bool" => Ok(Self::Custom("{fully_qualified_name}={state:bool}".to_owned())),
+
+ // custom format
+ _ => Ok(Self::Custom(value.to_owned())),
+ }
+ }
+}
+
+pub fn dump_parsed_flags<I>(parsed_flags_iter: I, format: DumpFormat) -> Result<Vec<u8>>
+where
+ I: Iterator<Item = ProtoParsedFlag>,
+{
+ let mut output = Vec::new();
+ match format {
+ DumpFormat::Protobuf => {
+ let parsed_flags =
+ ProtoParsedFlags { parsed_flag: parsed_flags_iter.collect(), ..Default::default() };
+ parsed_flags.write_to_vec(&mut output)?;
+ }
+ DumpFormat::Textproto => {
+ let parsed_flags =
+ ProtoParsedFlags { parsed_flag: parsed_flags_iter.collect(), ..Default::default() };
+ let s = protobuf::text_format::print_to_string_pretty(&parsed_flags);
+ output.extend_from_slice(s.as_bytes());
+ }
+ DumpFormat::Custom(format) => {
+ for flag in parsed_flags_iter {
+ dump_custom_format(&flag, &format, &mut output);
+ }
+ }
+ }
+ Ok(output)
+}
+
+fn dump_custom_format(flag: &ProtoParsedFlag, format: &str, output: &mut Vec<u8>) {
+ fn format_trace(trace: &[ProtoTracepoint]) -> String {
+ trace
+ .iter()
+ .map(|tracepoint| {
+ format!(
+ "{}: {:?} + {:?}",
+ tracepoint.source(),
+ tracepoint.permission(),
+ tracepoint.state()
+ )
+ })
+ .collect::<Vec<_>>()
+ .join(", ")
+ }
+
+ fn format_trace_paths(trace: &[ProtoTracepoint]) -> String {
+ trace.iter().map(|tracepoint| tracepoint.source()).collect::<Vec<_>>().join(", ")
+ }
+
+ fn format_metadata(metadata: &ProtoFlagMetadata) -> String {
+ format!("{:?}", metadata.purpose())
+ }
+
+ let mut str = format
+ // ProtoParsedFlag fields
+ .replace("{package}", flag.package())
+ .replace("{name}", flag.name())
+ .replace("{namespace}", flag.namespace())
+ .replace("{description}", flag.description())
+ .replace("{bug}", &flag.bug.join(", "))
+ .replace("{state}", &format!("{:?}", flag.state()))
+ .replace("{state:bool}", &format!("{}", flag.state() == ProtoFlagState::ENABLED))
+ .replace("{permission}", &format!("{:?}", flag.permission()))
+ .replace("{trace}", &format_trace(&flag.trace))
+ .replace("{trace:paths}", &format_trace_paths(&flag.trace))
+ .replace("{is_fixed_read_only}", &format!("{}", flag.is_fixed_read_only()))
+ .replace("{is_exported}", &format!("{}", flag.is_exported()))
+ .replace("{container}", flag.container())
+ .replace("{metadata}", &format_metadata(&flag.metadata))
+ // ParsedFlagExt functions
+ .replace("{fully_qualified_name}", &flag.fully_qualified_name());
+ str.push('\n');
+ output.extend_from_slice(str.as_bytes());
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::protos::ProtoParsedFlags;
+ use crate::test::parse_test_flags;
+ use protobuf::Message;
+
+ fn parse_enabled_ro_flag() -> ProtoParsedFlag {
+ parse_test_flags().parsed_flag.into_iter().find(|pf| pf.name() == "enabled_ro").unwrap()
+ }
+
+ #[test]
+ fn test_dumpformat_from_str() {
+ // supported format types
+ assert_eq!(DumpFormat::try_from("protobuf").unwrap(), DumpFormat::Protobuf);
+ assert_eq!(DumpFormat::try_from("textproto").unwrap(), DumpFormat::Textproto);
+ assert_eq!(
+ DumpFormat::try_from("foobar").unwrap(),
+ DumpFormat::Custom("foobar".to_owned())
+ );
+ }
+
+ #[test]
+ fn test_dump_parsed_flags_protobuf_format() {
+ let expected = protobuf::text_format::parse_from_str::<ProtoParsedFlags>(
+ crate::test::TEST_FLAGS_TEXTPROTO,
+ )
+ .unwrap()
+ .write_to_bytes()
+ .unwrap();
+ let parsed_flags = parse_test_flags();
+ let actual =
+ dump_parsed_flags(parsed_flags.parsed_flag.into_iter(), DumpFormat::Protobuf).unwrap();
+ assert_eq!(expected, actual);
+ }
+
+ #[test]
+ fn test_dump_parsed_flags_textproto_format() {
+ let parsed_flags = parse_test_flags();
+ let bytes =
+ dump_parsed_flags(parsed_flags.parsed_flag.into_iter(), DumpFormat::Textproto).unwrap();
+ let text = std::str::from_utf8(&bytes).unwrap();
+ assert_eq!(crate::test::TEST_FLAGS_TEXTPROTO.trim(), text.trim());
+ }
+
+ #[test]
+ fn test_dump_parsed_flags_custom_format() {
+ macro_rules! assert_dump_parsed_flags_custom_format_contains {
+ ($format:expr, $expected:expr) => {
+ let parsed_flags = parse_test_flags();
+ let bytes = dump_parsed_flags(
+ parsed_flags.parsed_flag.into_iter(),
+ $format.try_into().unwrap(),
+ )
+ .unwrap();
+ let text = std::str::from_utf8(&bytes).unwrap();
+ assert!(text.contains($expected));
+ };
+ }
+
+ // custom format
+ assert_dump_parsed_flags_custom_format_contains!(
+ "{fully_qualified_name}={permission} + {state}",
+ "com.android.aconfig.test.enabled_ro=READ_ONLY + ENABLED"
+ );
+
+ // aliases
+ assert_dump_parsed_flags_custom_format_contains!(
+ "text",
+ "com.android.aconfig.test.enabled_ro [system]: READ_ONLY + ENABLED"
+ );
+ assert_dump_parsed_flags_custom_format_contains!(
+ "verbose",
+ "com.android.aconfig.test.enabled_ro [system]: READ_ONLY + ENABLED (tests/test.aconfig, tests/first.values, tests/second.values)"
+ );
+ assert_dump_parsed_flags_custom_format_contains!(
+ "bool",
+ "com.android.aconfig.test.enabled_ro=true"
+ );
+ }
+
+ #[test]
+ fn test_dump_custom_format() {
+ macro_rules! assert_custom_format {
+ ($format:expr, $expected:expr) => {
+ let flag = parse_enabled_ro_flag();
+ let mut bytes = vec![];
+ dump_custom_format(&flag, $format, &mut bytes);
+ let text = std::str::from_utf8(&bytes).unwrap();
+ assert_eq!(text, $expected);
+ };
+ }
+
+ assert_custom_format!("{package}", "com.android.aconfig.test\n");
+ assert_custom_format!("{name}", "enabled_ro\n");
+ assert_custom_format!("{namespace}", "aconfig_test\n");
+ assert_custom_format!("{description}", "This flag is ENABLED + READ_ONLY\n");
+ assert_custom_format!("{bug}", "abc\n");
+ assert_custom_format!("{state}", "ENABLED\n");
+ assert_custom_format!("{state:bool}", "true\n");
+ assert_custom_format!("{permission}", "READ_ONLY\n");
+ assert_custom_format!("{trace}", "tests/test.aconfig: READ_WRITE + DISABLED, tests/first.values: READ_WRITE + DISABLED, tests/second.values: READ_ONLY + ENABLED\n");
+ assert_custom_format!(
+ "{trace:paths}",
+ "tests/test.aconfig, tests/first.values, tests/second.values\n"
+ );
+ assert_custom_format!("{is_fixed_read_only}", "false\n");
+ assert_custom_format!("{is_exported}", "false\n");
+ assert_custom_format!("{container}", "system\n");
+ assert_custom_format!("{metadata}", "PURPOSE_BUGFIX\n");
+
+ assert_custom_format!("name={name}|state={state}", "name=enabled_ro|state=ENABLED\n");
+ assert_custom_format!("{state}{state}{state}", "ENABLEDENABLEDENABLED\n");
+ }
+}
diff --git a/tools/aconfig/src/main.rs b/tools/aconfig/src/main.rs
index 63a50c8..08e8b97 100644
--- a/tools/aconfig/src/main.rs
+++ b/tools/aconfig/src/main.rs
@@ -26,13 +26,16 @@
mod codegen;
mod commands;
+mod dump;
mod protos;
mod storage;
+use dump::DumpFormat;
+
#[cfg(test)]
mod test;
-use commands::{CodegenMode, DumpFormat, Input, OutputFile};
+use commands::{CodegenMode, Input, OutputFile};
fn cli() -> Command {
Command::new("aconfig")
@@ -103,7 +106,7 @@
.arg(
Arg::new("format")
.long("format")
- .value_parser(EnumValueParser::<commands::DumpFormat>::new())
+ .value_parser(|s: &str| DumpFormat::try_from(s))
.default_value("text"),
)
.arg(Arg::new("dedup").long("dedup").num_args(0).action(ArgAction::SetTrue))
@@ -250,7 +253,7 @@
let format = get_required_arg::<DumpFormat>(sub_matches, "format")
.context("failed to dump previously parsed flags")?;
let dedup = get_required_arg::<bool>(sub_matches, "dedup")?;
- let output = commands::dump_parsed_flags(input, *format, *dedup)?;
+ let output = commands::dump_parsed_flags(input, format.clone(), *dedup)?;
let path = get_required_arg::<String>(sub_matches, "out")?;
write_output_to_file_or_stdout(path, &output)?;
}