api adjustment

Author: bfjelds

crates/trident/src/cli.rs

@@ -178,9 +178,9 @@ pub enum Commands {
 
     /// Manually rollback to previous state
     Rollback {
-        /// Run a dry-run for rollback, return operation that would be performed
+        /// Check operation that would be performed
         #[arg(long)]
-        dry_run: bool,
+        check: bool,
 
         /// Invoke rollback only if next available rollback is runtime rollback
         #[arg(long, conflicts_with = "ab")]

crates/trident/src/lib.rs

@@ -737,7 +737,7 @@ impl Trident {
     pub fn rollback(
         &mut self,
         datastore: &mut DataStore,
-        dry_run: bool,
+        check: bool,
         invoke_if_next_is_runtime: bool,
         invoke_available_ab: bool,
         allowed_operations: Operations,
@@ -757,7 +757,7 @@ impl Trident {
         let rollback_result = self.execute_and_record_error(datastore, |datastore| {
             manual_rollback::execute_rollback(
                 datastore,
-                dry_run,
+                check,
                 invoke_if_next_is_runtime,
                 invoke_available_ab,
                 &allowed_operations,

crates/trident/src/main.rs

@@ -206,14 +206,14 @@ fn run_trident(
                     ),
                     Commands::Commit { .. } => trident.commit(&mut datastore),
                     Commands::Rollback {
-                        dry_run,
+                        check,
                         runtime,
                         ab,
                         ref allowed_operations,
                         ..
                     } => trident.rollback(
                         &mut datastore,
-                        dry_run,
+                        check,
                         runtime,
                         ab,
                         cli::to_operations(allowed_operations),

crates/trident/src/manual_rollback/mod.rs

@@ -85,7 +85,7 @@ pub fn get_rollback_info(datastore: &DataStore, kind: GetKind) -> Result<String,
 /// Handle manual rollback operations.
 pub fn execute_rollback(
     datastore: &mut DataStore,
-    dry_run: bool,
+    check: bool,
     invoke_if_next_is_runtime: bool,
     invoke_available_ab: bool,
     allowed_operations: &Operations,
@@ -105,13 +105,13 @@ pub fn execute_rollback(
         .structured(ServicingError::ManualRollback)
         .message("Failed to get available rollbacks")?;
 
-    let (rollback_index, dry_run_string) = get_requested_rollback_info(
+    let (rollback_index, check_string) = get_requested_rollback_info(
         &available_rollbacks,
         invoke_if_next_is_runtime,
         invoke_available_ab,
     )?;
-    if dry_run {
-        println!("{}", dry_run_string);
+    if check {
+        println!("{}", check_string);
         return Ok(ExitKind::Done);
     }
 
@@ -1041,31 +1041,31 @@ mod tests {
     }
 
     #[test]
-    fn test_dry_run() {
+    fn test_check() {
         let mut host_status_list = vec![
             inter(None, CI_FINAL, MIN),
             inter(None, CI_FINAL, MIN),
             prov(VOL_A, false, vec![], MIN),
         ];
         let context = create_rollback_context_for_testing(&host_status_list);
         // if nothing is requested and there are no rollbacks, none is returned
-        let (index, dry_run_string) =
+        let (index, check_string) =
             get_requested_rollback_info(&context.get_rollback_chain().unwrap(), false, false)
                 .unwrap();
         assert!(index.is_none());
-        assert_eq!(dry_run_string, "none");
+        assert_eq!(check_string, "none");
         // if both ab and runtime rollback is requested simultaneously, error is returned
-        let (index, dry_run_string) =
+        let (index, check_string) =
             get_requested_rollback_info(&context.get_rollback_chain().unwrap(), true, false)
                 .unwrap();
         assert!(index.is_none());
-        assert_eq!(dry_run_string, "none");
+        assert_eq!(check_string, "none");
         // if both ab and runtime rollback is requested simultaneously, error is returned
-        let (index, dry_run_string) =
+        let (index, check_string) =
             get_requested_rollback_info(&context.get_rollback_chain().unwrap(), false, true)
                 .unwrap();
         assert!(index.is_none());
-        assert_eq!(dry_run_string, "none");
+        assert_eq!(check_string, "none");
 
         // Add some operations to datastore
         host_status_list.push(inter(VOL_A, AB_STAGE, MIN));
@@ -1075,17 +1075,17 @@ mod tests {
         host_status_list.push(prov(VOL_B, false, vec![5, 2], MIN));
         let context = create_rollback_context_for_testing(&host_status_list);
         // if runtime rollback is requested and it is the next rollback, return the index of the runtime rollback and 'runtime'
-        let (index, dry_run_string) =
+        let (index, check_string) =
             get_requested_rollback_info(&context.get_rollback_chain().unwrap(), false, false)
                 .unwrap();
         assert_eq!(index, Some(0));
-        assert_eq!(dry_run_string, "runtime");
+        assert_eq!(check_string, "runtime");
         // if ab rollback is requested and it is not the next rollback, return the index of the ab rollback and 'ab'
-        let (index, dry_run_string) =
+        let (index, check_string) =
             get_requested_rollback_info(&context.get_rollback_chain().unwrap(), false, true)
                 .unwrap();
         assert_eq!(index, Some(1));
-        assert_eq!(dry_run_string, "ab");
+        assert_eq!(check_string, "ab");
         // if both ab and runtime rollback is requested simultaneously, error is returned
         assert!(
             get_requested_rollback_info(&context.get_rollback_chain().unwrap(), true, true)

docs/Reference/Trident-CLI.md

@@ -391,7 +391,8 @@ Argument summary:
 ```
 Arguments:
   [KIND]  What data to retrieve [default: status] [possible values:
-          configuration, status, last-error]
+          configuration, status, last-error, rollback-chain,
+          rollback-target]
 
 Options:
   -o, --outfile <OUTFILE>
@@ -413,6 +414,8 @@ Possible values:
 - `configuration`
 - `status`
 - `last-error`
+- `rollback-chain`
+- `rollback-target`
 
 Default: `status`
 
@@ -564,20 +567,20 @@ Argument summary:
 
 ```
 Options:
-      --runtime
-          Declare expectation that rollback undoes a runtime update
+      --check
+          Check operation that would be performed
   -v, --verbosity <VERBOSITY>
           Logging verbosity [OFF, ERROR, WARN, INFO, DEBUG, TRACE]
           [default: DEBUG]
+      --runtime
+          Invoke rollback only if next available rollback is runtime
+          rollback
       --ab
-          Declare expectation that rollback undoes an A/B update
+          Invoke available A/B rollback
       --allowed-operations [<ALLOWED_OPERATIONS>...]
           Comma-separated list of operations that Trident will be
           allowed to perform [default: stage,finalize] [possible
           values: stage, finalize]
-      --show <SHOW>
-          Show available rollback points [possible values: validation,
-          target, chain]
   -s, --status <STATUS>
           Path to save the resulting Host Status
   -e, --error <ERROR>
@@ -587,9 +590,14 @@ Options:
 
 ### Argument Details
 
+#### <span>--check &lt;CHECK&gt;</span>
+
+Check operation that would be performed
+
+
 #### <span>--runtime &lt;RUNTIME&gt;</span>
 
-Declare expectation that rollback undoes a runtime update
+Invoke rollback only if next available rollback is runtime rollback
 
 Conflicts with:
 
@@ -598,7 +606,7 @@ Conflicts with:
 
 #### <span>--ab &lt;AB&gt;</span>
 
-Declare expectation that rollback undoes an A/B update
+Invoke available A/B rollback
 
 Conflicts with:
 
@@ -617,17 +625,6 @@ Possible values:
 Default: `stage,finalize`
 
 
-#### <span>--show &lt;SHOW&gt;</span>
-
-Show available rollback points
-
-Possible values:
-
-- `validation`: Show the next available rollback type. 'ab' if an A/B update will be rolled back, 'runtime' if a runtime update will be rolled back, or 'none' if no rollback is possible 
-- `target`: Show the next available rollback Host Configuration 
-- `chain`: Show the full list of available rollbacks 
-
-
 #### <span>--status &lt;STATUS&gt;</span>
 
 Path to save the resulting Host Status

tools/storm/rollback/tests/rollback.go

@@ -491,24 +491,24 @@ func validateRollbacksAvailable(
 			}
 		}
 
-		rollbackShowValidationOutput, err := stormssh.SshCommand(vmConfig.VMConfig, vmIP, "sudo trident rollback --dry-run")
+		rollbackShowValidationOutput, err := stormssh.SshCommand(vmConfig.VMConfig, vmIP, "sudo trident rollback --check")
 		if err != nil {
-			return fmt.Errorf("'rollback --dry-run' failed to from VM: %v", err)
+			return fmt.Errorf("'rollback --check' failed to from VM: %v", err)
 		}
-		logrus.Tracef("Reported 'rollback --dry-run':\n%s", rollbackShowValidationOutput)
+		logrus.Tracef("Reported 'rollback --check':\n%s", rollbackShowValidationOutput)
 		if expectedAvailableRollbacks > 0 {
 			if expectedFirstRollbackNeedsReboot {
 				if strings.TrimSpace(rollbackShowValidationOutput) != "ab" {
-					return fmt.Errorf("expected 'ab' from 'rollback --dry-run', got: %s", rollbackShowValidationOutput)
+					return fmt.Errorf("expected 'ab' from 'rollback --check', got: %s", rollbackShowValidationOutput)
 				}
 			} else {
 				if strings.TrimSpace(rollbackShowValidationOutput) != "runtime" {
-					return fmt.Errorf("expected 'runtime' from 'rollback --dry-run', got: %s", rollbackShowValidationOutput)
+					return fmt.Errorf("expected 'runtime' from 'rollback --check', got: %s", rollbackShowValidationOutput)
 				}
 			}
 		} else {
 			if strings.TrimSpace(rollbackShowValidationOutput) != "none" {
-				return fmt.Errorf("expected 'none' from 'rollback --dry-run', got: %s", rollbackShowValidationOutput)
+				return fmt.Errorf("expected 'none' from 'rollback --check', got: %s", rollbackShowValidationOutput)
 			}
 		}