Make specifying an invalid unlock method a parser error

Because it would require implementing the ValueEnum trait for
UnlockMethod somewhere in stratisd rather than in stratis_min.rs, do
not attempt that approach at this time.

The gain is that the parser becomes responsible for useful things:
1. Listing the allowed options.
2. Exiting with error code 2 if the unlock_method option is used with an
   invalid unlock method value, rather than deferring the error until it
   is a runtime error.

Uses the trick explained here:
clap-rs/clap#4264

Signed-off-by: mulhern <[email protected]>

src/bin/stratis-min/stratis-min.rs

@@ -4,16 +4,17 @@
 
 use std::{error::Error, path::PathBuf};
 
-use clap::{Arg, ArgAction, ArgGroup, Command};
+use clap::{builder::PossibleValuesParser, Arg, ArgAction, ArgGroup, Command};
 use serde_json::{json, Map, Value};
+use strum::VariantNames;
 
 use stratisd::{
     engine::{
         EncryptionInfo, KeyDescription, Name, PoolIdentifier, PoolUuid, UnlockMethod,
         CLEVIS_TANG_TRUST_URL,
     },
     jsonrpc::client::{filesystem, key, pool, report},
-    stratis::{StratisError, VERSION},
+    stratis::VERSION,
 };
 
 fn parse_args() -> Command {
@@ -41,7 +42,12 @@ fn parse_args() -> Command {
                 Command::new("start")
                     .arg(Arg::new("id").required(true))
                     .arg(Arg::new("name").long("name").num_args(0))
-                    .arg(Arg::new("unlock_method").long("unlock-method").num_args(1))
+                    .arg(
+                        Arg::new("unlock_method")
+                            .long("unlock-method")
+                            .num_args(1)
+                            .value_parser(PossibleValuesParser::new(UnlockMethod::VARIANTS)),
+                    )
                     .arg(
                         Arg::new("prompt")
                             .long("prompt")
@@ -235,13 +241,9 @@ fn main() -> Result<(), String> {
                             .expect("required"),
                     )?)
                 };
-                let unlock_method =
-                    match args.get_one::<String>("unlock_method").map(|s| s.as_str()) {
-                        Some(um) => Some(UnlockMethod::try_from(um).map_err(|_| {
-                            StratisError::Msg(format!("{um} is an invalid unlock method"))
-                        })?),
-                        None => None,
-                    };
+                let unlock_method = args.get_one::<String>("unlock_method").map(|s| {
+                    UnlockMethod::try_from(s.as_str()).expect("parser ensures valid string value")
+                });
                 let prompt = args.get_flag("prompt");
                 pool::pool_start(id, unlock_method, prompt)?;
                 Ok(())

src/engine/types/mod.rs

@@ -16,7 +16,7 @@ use std::{
 use libudev::EventType;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use strum_macros::{self, EnumString, FromRepr};
+use strum_macros::{self, EnumString, FromRepr, VariantNames};
 use uuid::Uuid;
 
 pub use crate::engine::{
@@ -131,7 +131,7 @@ impl Display for StratisUuid {
 }
 
 /// Use Clevis or keyring to unlock LUKS volume.
-#[derive(Serialize, Deserialize, Clone, Copy, Eq, PartialEq, Debug, EnumString)]
+#[derive(Serialize, Deserialize, Clone, Copy, Eq, PartialEq, Debug, EnumString, VariantNames)]
 #[strum(serialize_all = "snake_case")]
 pub enum UnlockMethod {
     Clevis,

tests/stratis_min.rs

@@ -254,12 +254,7 @@ fn test_stratis_min_pool_start_invalid_unlock_method() {
         .arg("--name")
         .arg("pn")
         .arg("--unlock-method=bogus");
-    cmd.assert()
-        .failure()
-        .code(1)
-        .stderr(predicate::str::contains(
-            "bogus is an invalid unlock method",
-        ));
+    cmd.assert().failure().code(2);
 }
 
 #[test]