Prepare for clap 4.
Bug: 260823636
Test: atest vm.test encryptedstore.test apkdmverity.test open_then_run.test ZipFuseTest
Change-Id: Iba2c4c317e7e42fc99362caf41ab083b4fc4a8db
diff --git a/TEST_MAPPING b/TEST_MAPPING
index c37fd19..4f879b4 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -43,6 +43,9 @@
"path": "packages/modules/Virtualization/avmd"
},
{
+ "path": "packages/modules/Virtualization/encryptedstore"
+ },
+ {
"path": "packages/modules/Virtualization/virtualizationservice"
},
{
diff --git a/apkdmverity/src/main.rs b/apkdmverity/src/main.rs
index 6e12e38..50b6069 100644
--- a/apkdmverity/src/main.rs
+++ b/apkdmverity/src/main.rs
@@ -23,7 +23,7 @@
use anyhow::{bail, Context, Result};
use apkverify::{HashAlgorithm, V4Signature};
-use clap::{App, Arg};
+use clap::{arg, Arg, ArgAction, Command};
use dm::loopdevice;
use dm::util;
use dm::verity::{DmVerityHashAlgorithm, DmVerityTargetBuilder};
@@ -34,22 +34,12 @@
use std::path::{Path, PathBuf};
fn main() -> Result<()> {
- let matches = App::new("apkdmverity")
- .about("Creates a dm-verity block device out of APK signed with APK signature scheme V4.")
- .arg(Arg::from_usage(
- "--apk... <apk_path> <idsig_path> <name> <root_hash> \
- 'Input APK file, idsig file, name of the block device, and root hash. \
- The APK file must be signed using the APK signature scheme 4. The \
- block device is created at \"/dev/mapper/<name>\".' root_hash is \
- optional; idsig file's root hash will be used if specified as \"none\"."
- ))
- .arg(Arg::with_name("verbose").short('v').long("verbose").help("Shows verbose output"))
- .get_matches();
+ let matches = clap_command().get_matches();
- let apks = matches.values_of("apk").unwrap();
+ let apks = matches.get_many::<String>("apk").unwrap();
assert!(apks.len() % 4 == 0);
- let verbose = matches.is_present("verbose");
+ let verbose = matches.get_flag("verbose");
for (apk, idsig, name, roothash) in apks.tuples() {
let roothash = if roothash != "none" {
@@ -68,6 +58,28 @@
Ok(())
}
+fn clap_command() -> Command {
+ Command::new("apkdmverity")
+ .about("Creates a dm-verity block device out of APK signed with APK signature scheme V4.")
+ .arg(
+ arg!(--apk ...
+ "Input APK file, idsig file, name of the block device, and root hash. \
+ The APK file must be signed using the APK signature scheme 4. The \
+ block device is created at \"/dev/mapper/<name>\".' root_hash is \
+ optional; idsig file's root hash will be used if specified as \"none\"."
+ )
+ .action(ArgAction::Append)
+ .value_names(&["apk_path", "idsig_path", "name", "root_hash"]),
+ )
+ .arg(
+ Arg::new("verbose")
+ .short('v')
+ .long("verbose")
+ .action(ArgAction::SetTrue)
+ .help("Shows verbose output"),
+ )
+}
+
struct VerityResult {
data_device: PathBuf,
hash_device: PathBuf,
@@ -380,4 +392,10 @@
},
);
}
+
+ #[test]
+ fn verify_command() {
+ // Check that the command parsing has been configured in a valid way.
+ clap_command().debug_assert();
+ }
}
diff --git a/authfs/TEST_MAPPING b/authfs/TEST_MAPPING
index ab6111b..5e144c7 100644
--- a/authfs/TEST_MAPPING
+++ b/authfs/TEST_MAPPING
@@ -4,6 +4,9 @@
"name": "authfs_device_test_src_lib"
},
{
+ "name": "open_then_run.test"
+ },
+ {
"name": "AuthFsHostTest"
}
],
diff --git a/authfs/tests/common/Android.bp b/authfs/tests/common/Android.bp
index ec426c7..01ebcfd 100644
--- a/authfs/tests/common/Android.bp
+++ b/authfs/tests/common/Android.bp
@@ -31,3 +31,19 @@
test_suites: ["general-tests"],
test_harness: false,
}
+
+rust_test {
+ name: "open_then_run.test",
+ crate_name: "open_then_run",
+ srcs: ["src/open_then_run.rs"],
+ edition: "2021",
+ rustlibs: [
+ "libandroid_logger",
+ "libanyhow",
+ "libclap",
+ "libcommand_fds",
+ "liblibc",
+ "liblog_rust",
+ ],
+ test_suites: ["general-tests"],
+}
diff --git a/authfs/tests/common/src/open_then_run.rs b/authfs/tests/common/src/open_then_run.rs
index 110d838..6d828e4 100644
--- a/authfs/tests/common/src/open_then_run.rs
+++ b/authfs/tests/common/src/open_then_run.rs
@@ -19,7 +19,7 @@
//! specified numbers in the child process.
use anyhow::{bail, Context, Result};
-use clap::{App, Arg, Values};
+use clap::{parser::ValuesRef, Arg, ArgAction};
use command_fds::{CommandFdExt, FdMapping};
use log::{debug, error};
use std::fs::OpenOptions;
@@ -51,7 +51,7 @@
}
fn parse_and_create_file_mapping<F>(
- values: Option<Values<'_>>,
+ values: Option<ValuesRef<'_, String>>,
opener: F,
) -> Result<Vec<OwnedFdMapping>>
where
@@ -75,35 +75,35 @@
}
}
-fn parse_args() -> Result<Args> {
- #[rustfmt::skip]
- let matches = App::new("open_then_run")
- .arg(Arg::with_name("open-ro")
+#[rustfmt::skip]
+fn args_command() -> clap::Command {
+ clap::Command::new("open_then_run")
+ .arg(Arg::new("open-ro")
.long("open-ro")
.value_name("FD:PATH")
.help("Open <PATH> read-only to pass as fd <FD>")
- .multiple(true)
- .number_of_values(1))
- .arg(Arg::with_name("open-rw")
+ .action(ArgAction::Append))
+ .arg(Arg::new("open-rw")
.long("open-rw")
.value_name("FD:PATH")
.help("Open/create <PATH> read-write to pass as fd <FD>")
- .multiple(true)
- .number_of_values(1))
- .arg(Arg::with_name("open-dir")
+ .action(ArgAction::Append))
+ .arg(Arg::new("open-dir")
.long("open-dir")
.value_name("FD:DIR")
.help("Open <DIR> to pass as fd <FD>")
- .multiple(true)
- .number_of_values(1))
- .arg(Arg::with_name("args")
+ .action(ArgAction::Append))
+ .arg(Arg::new("args")
.help("Command line to execute with pre-opened FD inherited")
.last(true)
.required(true)
- .multiple(true))
- .get_matches();
+ .num_args(0..))
+}
- let ro_file_fds = parse_and_create_file_mapping(matches.values_of("open-ro"), |path| {
+fn parse_args() -> Result<Args> {
+ let matches = args_command().get_matches();
+
+ let ro_file_fds = parse_and_create_file_mapping(matches.get_many("open-ro"), |path| {
Ok(OwnedFd::from(
OpenOptions::new()
.read(true)
@@ -112,7 +112,7 @@
))
})?;
- let rw_file_fds = parse_and_create_file_mapping(matches.values_of("open-rw"), |path| {
+ let rw_file_fds = parse_and_create_file_mapping(matches.get_many("open-rw"), |path| {
Ok(OwnedFd::from(
OpenOptions::new()
.read(true)
@@ -123,7 +123,7 @@
))
})?;
- let dir_fds = parse_and_create_file_mapping(matches.values_of("open-dir"), |path| {
+ let dir_fds = parse_and_create_file_mapping(matches.get_many("open-dir"), |path| {
Ok(OwnedFd::from(
OpenOptions::new()
.custom_flags(libc::O_DIRECTORY)
@@ -133,7 +133,8 @@
))
})?;
- let cmdline_args: Vec<_> = matches.values_of("args").unwrap().map(|s| s.to_string()).collect();
+ let cmdline_args: Vec<_> =
+ matches.get_many::<String>("args").unwrap().map(|s| s.to_string()).collect();
Ok(Args { ro_file_fds, rw_file_fds, dir_fds, cmdline_args })
}
@@ -168,3 +169,14 @@
std::process::exit(1);
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn verify_command() {
+ // Check that the command parsing has been configured in a valid way.
+ args_command().debug_assert();
+ }
+}
diff --git a/avmd/Android.bp b/avmd/Android.bp
index 0b87a7b..e5e0553 100644
--- a/avmd/Android.bp
+++ b/avmd/Android.bp
@@ -20,8 +20,8 @@
defaults: ["libavmd_defaults"],
}
-rust_binary {
- name: "avmdtool",
+rust_defaults {
+ name: "avmdtool.defaults",
srcs: ["src/main.rs"],
host_supported: true,
prefer_rlib: true,
@@ -37,6 +37,17 @@
],
}
+rust_binary {
+ name: "avmdtool",
+ defaults: ["avmdtool.defaults"],
+}
+
+rust_test {
+ name: "avmdtool.test",
+ defaults: ["avmdtool.defaults"],
+ test_suites: ["general-tests"],
+}
+
rust_test {
name: "avmdtool_tests",
srcs: ["tests/*_test.rs"],
diff --git a/avmd/TEST_MAPPING b/avmd/TEST_MAPPING
index ea58edb..892eb2c 100644
--- a/avmd/TEST_MAPPING
+++ b/avmd/TEST_MAPPING
@@ -1,7 +1,10 @@
{
- "avf-presubmit" : [
+ "avf-presubmit": [
{
- "name" : "avmdtool_tests"
+ "name": "avmdtool.test"
+ },
+ {
+ "name": "avmdtool_tests"
}
]
}
diff --git a/avmd/src/main.rs b/avmd/src/main.rs
index fc18225..740e9aa 100644
--- a/avmd/src/main.rs
+++ b/avmd/src/main.rs
@@ -18,9 +18,13 @@
use apexutil::get_payload_vbmeta_image_hash;
use apkverify::get_apk_digest;
use avmd::{ApkDescriptor, Avmd, Descriptor, ResourceIdentifier, VbMetaDescriptor};
-use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
+use clap::{
+ builder::ValueParser,
+ parser::{Indices, ValuesRef},
+ Arg, ArgAction, ArgMatches, Command,
+};
use serde::ser::Serialize;
-use std::fs::File;
+use std::{fs::File, path::PathBuf};
use vbmeta::VbMetaImage;
fn get_vbmeta_image_hash(file: &str) -> Result<Vec<u8>> {
@@ -31,13 +35,13 @@
/// Iterate over a set of argument values, that could be empty or come in
/// (<index>, <namespace>, <name>, <file>) tuple.
struct NamespaceNameFileIterator<'a> {
- indices: Option<clap::Indices<'a>>,
- values: Option<clap::Values<'a>>,
+ indices: Option<Indices<'a>>,
+ values: Option<ValuesRef<'a, String>>,
}
impl<'a> NamespaceNameFileIterator<'a> {
fn new(args: &'a ArgMatches, name: &'a str) -> Self {
- NamespaceNameFileIterator { indices: args.indices_of(name), values: args.values_of(name) }
+ NamespaceNameFileIterator { indices: args.indices_of(name), values: args.get_many(name) }
}
}
@@ -100,54 +104,58 @@
.packed_format()
.legacy_enums(),
)?;
- std::fs::write(args.value_of("file").unwrap(), &bytes)?;
+ std::fs::write(args.get_one::<PathBuf>("file").unwrap(), &bytes)?;
Ok(())
}
fn dump(args: &ArgMatches) -> Result<()> {
- let file = std::fs::read(args.value_of("file").unwrap())?;
+ let file = std::fs::read(args.get_one::<PathBuf>("file").unwrap())?;
let avmd: Avmd = serde_cbor::from_slice(&file)?;
println!("{}", avmd);
Ok(())
}
-fn main() -> Result<()> {
+fn clap_command() -> Command {
let namespace_name_file = ["namespace", "name", "file"];
- let app = App::new("avmdtool")
- .setting(AppSettings::SubcommandRequiredElseHelp)
+
+ Command::new("avmdtool")
+ .subcommand_required(true)
+ .arg_required_else_help(true)
.subcommand(
- SubCommand::with_name("create")
- .setting(AppSettings::ArgRequiredElseHelp)
- .arg(Arg::with_name("file").required(true).takes_value(true))
+ Command::new("create")
+ .arg_required_else_help(true)
+ .arg(Arg::new("file").value_parser(ValueParser::path_buf()).required(true))
.arg(
- Arg::with_name("vbmeta")
+ Arg::new("vbmeta")
.long("vbmeta")
- .takes_value(true)
.value_names(&namespace_name_file)
- .multiple(true),
+ .num_args(3)
+ .action(ArgAction::Append),
)
.arg(
- Arg::with_name("apk")
+ Arg::new("apk")
.long("apk")
- .takes_value(true)
.value_names(&namespace_name_file)
- .multiple(true),
+ .num_args(3)
+ .action(ArgAction::Append),
)
.arg(
- Arg::with_name("apex-payload")
+ Arg::new("apex-payload")
.long("apex-payload")
- .takes_value(true)
.value_names(&namespace_name_file)
- .multiple(true),
+ .num_args(3)
+ .action(ArgAction::Append),
),
)
.subcommand(
- SubCommand::with_name("dump")
- .setting(AppSettings::ArgRequiredElseHelp)
- .arg(Arg::with_name("file").required(true).takes_value(true)),
- );
+ Command::new("dump")
+ .arg_required_else_help(true)
+ .arg(Arg::new("file").value_parser(ValueParser::path_buf()).required(true)),
+ )
+}
- let args = app.get_matches();
+fn main() -> Result<()> {
+ let args = clap_command().get_matches();
match args.subcommand() {
Some(("create", sub_args)) => create(sub_args)?,
Some(("dump", sub_args)) => dump(sub_args)?,
@@ -155,3 +163,14 @@
}
Ok(())
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn verify_command() {
+ // Check that the command parsing has been configured in a valid way.
+ clap_command().debug_assert();
+ }
+}
diff --git a/encryptedstore/Android.bp b/encryptedstore/Android.bp
index 13ef1b9..94ebcfc 100644
--- a/encryptedstore/Android.bp
+++ b/encryptedstore/Android.bp
@@ -29,3 +29,9 @@
defaults: ["encryptedstore.defaults"],
bootstrap: true,
}
+
+rust_test {
+ name: "encryptedstore.test",
+ defaults: ["encryptedstore.defaults"],
+ test_suites: ["general-tests"],
+}
diff --git a/encryptedstore/TEST_MAPPING b/encryptedstore/TEST_MAPPING
new file mode 100644
index 0000000..a9e1d87
--- /dev/null
+++ b/encryptedstore/TEST_MAPPING
@@ -0,0 +1,7 @@
+{
+ "avf-presubmit": [
+ {
+ "name": "encryptedstore.test"
+ }
+ ]
+}
diff --git a/encryptedstore/src/main.rs b/encryptedstore/src/main.rs
index 7140ae2..888485b 100644
--- a/encryptedstore/src/main.rs
+++ b/encryptedstore/src/main.rs
@@ -19,9 +19,8 @@
//! It uses dm_rust lib.
use anyhow::{ensure, Context, Result};
-use clap::{arg, App};
-use dm::crypt::CipherType;
-use dm::util;
+use clap::arg;
+use dm::{crypt::CipherType, util};
use log::info;
use std::ffi::CString;
use std::fs::{create_dir_all, OpenOptions};
@@ -42,18 +41,11 @@
);
info!("Starting encryptedstore binary");
- let matches = App::new("encryptedstore")
- .args(&[
- arg!(--blkdevice <FILE> "the block device backing the encrypted storage")
- .required(true),
- arg!(--key <KEY> "key (in hex) equivalent to 32 bytes)").required(true),
- arg!(--mountpoint <MOUNTPOINT> "mount point for the storage").required(true),
- ])
- .get_matches();
+ let matches = clap_command().get_matches();
- let blkdevice = Path::new(matches.value_of("blkdevice").unwrap());
- let key = matches.value_of("key").unwrap();
- let mountpoint = Path::new(matches.value_of("mountpoint").unwrap());
+ let blkdevice = Path::new(matches.get_one::<String>("blkdevice").unwrap());
+ let key = matches.get_one::<String>("key").unwrap();
+ let mountpoint = Path::new(matches.get_one::<String>("mountpoint").unwrap());
encryptedstore_init(blkdevice, key, mountpoint).context(format!(
"Unable to initialize encryptedstore on {:?} & mount at {:?}",
blkdevice, mountpoint
@@ -61,6 +53,14 @@
Ok(())
}
+fn clap_command() -> clap::Command {
+ clap::Command::new("encryptedstore").args(&[
+ arg!(--blkdevice <FILE> "the block device backing the encrypted storage").required(true),
+ arg!(--key <KEY> "key (in hex) equivalent to 32 bytes)").required(true),
+ arg!(--mountpoint <MOUNTPOINT> "mount point for the storage").required(true),
+ ])
+}
+
fn encryptedstore_init(blkdevice: &Path, key: &str, mountpoint: &Path) -> Result<()> {
ensure!(
std::fs::metadata(&blkdevice)
@@ -160,3 +160,14 @@
Ok(())
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn verify_command() {
+ // Check that the command parsing has been configured in a valid way.
+ clap_command().debug_assert();
+ }
+}
diff --git a/vm/TEST_MAPPING b/vm/TEST_MAPPING
index a8d1fa6..485c3af 100644
--- a/vm/TEST_MAPPING
+++ b/vm/TEST_MAPPING
@@ -1,7 +1,7 @@
{
- "avf-presubmit" : [
+ "avf-presubmit": [
{
- "name" : "vm.test"
+ "name": "vm.test"
}
]
}
diff --git a/vm/src/main.rs b/vm/src/main.rs
index 9fa805e..b364275 100644
--- a/vm/src/main.rs
+++ b/vm/src/main.rs
@@ -387,10 +387,11 @@
#[cfg(test)]
mod tests {
use super::*;
- use clap::IntoApp;
+ use clap::CommandFactory;
#[test]
fn verify_app() {
- Opt::into_app().debug_assert();
+ // Check that the command parsing has been configured in a valid way.
+ Opt::command().debug_assert();
}
}
diff --git a/zipfuse/src/main.rs b/zipfuse/src/main.rs
index 365d236..5e9e160 100644
--- a/zipfuse/src/main.rs
+++ b/zipfuse/src/main.rs
@@ -21,7 +21,7 @@
mod inode;
use anyhow::{Context as AnyhowContext, Result};
-use clap::{App, Arg};
+use clap::{builder::ValueParser, Arg, ArgAction, Command};
use fuse::filesystem::*;
use fuse::mount::*;
use rustutils::system_properties;
@@ -34,65 +34,58 @@
use std::mem::size_of;
use std::os::unix::io::AsRawFd;
use std::path::Path;
+use std::path::PathBuf;
use std::sync::Mutex;
use crate::inode::{DirectoryEntry, Inode, InodeData, InodeKind, InodeTable};
fn main() -> Result<()> {
- let matches = App::new("zipfuse")
+ let matches = clap_command().get_matches();
+
+ let zip_file = matches.get_one::<PathBuf>("ZIPFILE").unwrap();
+ let mount_point = matches.get_one::<PathBuf>("MOUNTPOINT").unwrap();
+ let options = matches.get_one::<String>("options");
+ let noexec = matches.get_flag("noexec");
+ let ready_prop = matches.get_one::<String>("readyprop");
+ let uid: u32 = matches.get_one::<String>("uid").map_or(0, |s| s.parse().unwrap());
+ let gid: u32 = matches.get_one::<String>("gid").map_or(0, |s| s.parse().unwrap());
+ run_fuse(zip_file, mount_point, options, noexec, ready_prop, uid, gid)?;
+
+ Ok(())
+}
+
+fn clap_command() -> Command {
+ Command::new("zipfuse")
.arg(
- Arg::with_name("options")
+ Arg::new("options")
.short('o')
- .takes_value(true)
.required(false)
.help("Comma separated list of mount options"),
)
.arg(
- Arg::with_name("noexec")
+ Arg::new("noexec")
.long("noexec")
- .takes_value(false)
+ .action(ArgAction::SetTrue)
.help("Disallow the execution of binary files"),
)
.arg(
- Arg::with_name("readyprop")
+ Arg::new("readyprop")
.short('p')
- .takes_value(true)
.help("Specify a property to be set when mount is ready"),
)
- .arg(
- Arg::with_name("uid")
- .short('u')
- .takes_value(true)
- .help("numeric UID who's the owner of the files"),
- )
- .arg(
- Arg::with_name("gid")
- .short('g')
- .takes_value(true)
- .help("numeric GID who's the group of the files"),
- )
- .arg(Arg::with_name("ZIPFILE").required(true))
- .arg(Arg::with_name("MOUNTPOINT").required(true))
- .get_matches();
-
- let zip_file = matches.value_of("ZIPFILE").unwrap().as_ref();
- let mount_point = matches.value_of("MOUNTPOINT").unwrap().as_ref();
- let options = matches.value_of("options");
- let noexec = matches.is_present("noexec");
- let ready_prop = matches.value_of("readyprop");
- let uid: u32 = matches.value_of("uid").map_or(0, |s| s.parse().unwrap());
- let gid: u32 = matches.value_of("gid").map_or(0, |s| s.parse().unwrap());
- run_fuse(zip_file, mount_point, options, noexec, ready_prop, uid, gid)?;
- Ok(())
+ .arg(Arg::new("uid").short('u').help("numeric UID who's the owner of the files"))
+ .arg(Arg::new("gid").short('g').help("numeric GID who's the group of the files"))
+ .arg(Arg::new("ZIPFILE").value_parser(ValueParser::path_buf()).required(true))
+ .arg(Arg::new("MOUNTPOINT").value_parser(ValueParser::path_buf()).required(true))
}
/// Runs a fuse filesystem by mounting `zip_file` on `mount_point`.
pub fn run_fuse(
zip_file: &Path,
mount_point: &Path,
- extra_options: Option<&str>,
+ extra_options: Option<&String>,
noexec: bool,
- ready_prop: Option<&str>,
+ ready_prop: Option<&String>,
uid: u32,
gid: u32,
) -> Result<()> {
@@ -471,11 +464,11 @@
#[cfg(test)]
mod tests {
- use anyhow::{bail, Result};
+ use super::*;
+ use anyhow::bail;
use nix::sys::statfs::{statfs, FsType};
use std::collections::BTreeSet;
use std::fs;
- use std::fs::File;
use std::io::Write;
use std::os::unix::fs::MetadataExt;
use std::path::{Path, PathBuf};
@@ -873,4 +866,10 @@
// Start zipfuse over to the loop device (not the zip file)
run_fuse_and_check_test_zip(&test_dir.path(), &ld.path().unwrap());
}
+
+ #[test]
+ fn verify_command() {
+ // Check that the command parsing has been configured in a valid way.
+ clap_command().debug_assert();
+ }
}