[wicket] mark skipped components as SKIPPED (#3717)

sunshowers · web-flow · commit a29f08ba1c0d · 2023-07-25T08:48:58.000-07:00
Just check that the "SpComponentUpdate" step was skipped. To test this, I had to add two facilities: 1. Detecting and storing the currently active slot in sp-sim. 2. New environment variables for simulating SP and RoT update results. Closes #3641.
diff --git a/openapi/wicketd.json b/openapi/wicketd.json
@@ -2527,6 +2527,24 @@
               }
             ]
           },
+          "test_simulate_rot_result": {
+            "nullable": true,
+            "description": "If passed in, simulates a result for the RoT update.\n\nThis is used for testing.",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/UpdateSimulatedResult"
+              }
+            ]
+          },
+          "test_simulate_sp_result": {
+            "nullable": true,
+            "description": "If passed in, simulates a result for the SP update.\n\nThis is used for testing.",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/UpdateSimulatedResult"
+              }
+            ]
+          },
           "test_step_seconds": {
             "nullable": true,
             "description": "If passed in, creates a test step that lasts these many seconds long.\n\nThis is used for testing.",
@@ -3990,6 +4008,16 @@
           }
         ]
       },
+      "UpdateSimulatedResult": {
+        "description": "A simulated result for a component update.\n\nUsed by [`StartUpdateOptions`].",
+        "type": "string",
+        "enum": [
+          "success",
+          "warning",
+          "skipped",
+          "failure"
+        ]
+      },
       "UpdateStepId": {
         "oneOf": [
           {
diff --git a/sp-sim/src/gimlet.rs b/sp-sim/src/gimlet.rs
@@ -4,6 +4,8 @@
 
 use crate::config::GimletConfig;
 use crate::config::SpComponentConfig;
+use crate::helpers::rot_slot_id_from_u16;
+use crate::helpers::rot_slot_id_to_u16;
 use crate::rot::RotSprocketExt;
 use crate::serial_number_padded;
 use crate::server;
@@ -494,6 +496,7 @@ struct Handler {
 
     attached_mgs: Arc<Mutex<Option<(SpComponent, SpPort, SocketAddrV6)>>>,
     incoming_serial_console: HashMap<SpComponent, UnboundedSender<Vec<u8>>>,
+    rot_active_slot: RotSlotId,
     power_state: PowerState,
     startup_options: StartupOptions,
     update_state: UpdateState,
@@ -527,6 +530,7 @@ impl Handler {
             serial_number,
             attached_mgs,
             incoming_serial_console,
+            rot_active_slot: RotSlotId::A,
             power_state: PowerState::A2,
             startup_options: StartupOptions::empty(),
             update_state: UpdateState::NotPrepared,
@@ -1107,12 +1111,18 @@ impl SpHandler for Handler {
         component: SpComponent,
     ) -> Result<u16, SpError> {
         warn!(
-            &self.log, "asked for component active slot (not supported for sim components)";
+            &self.log, "asked for component active slot";
             "sender" => %sender,
             "port" => ?port,
             "component" => ?component,
         );
-        Err(SpError::RequestUnsupportedForComponent)
+        if component == SpComponent::ROT {
+            Ok(rot_slot_id_to_u16(self.rot_active_slot))
+        } else {
+            // The real SP returns `RequestUnsupportedForComponent` for anything
+            // other than the RoT, including SP_ITSELF.
+            Err(SpError::RequestUnsupportedForComponent)
+        }
     }
 
     fn component_set_active_slot(
@@ -1124,14 +1134,21 @@ impl SpHandler for Handler {
         persist: bool,
     ) -> Result<(), SpError> {
         warn!(
-            &self.log, "asked to set component active slot (not supported for sim components)";
+            &self.log, "asked to set component active slot";
             "sender" => %sender,
             "port" => ?port,
             "component" => ?component,
             "slot" => slot,
             "persist" => persist,
         );
-        Err(SpError::RequestUnsupportedForComponent)
+        if component == SpComponent::ROT {
+            self.rot_active_slot = rot_slot_id_from_u16(slot)?;
+            Ok(())
+        } else {
+            // The real SP returns `RequestUnsupportedForComponent` for anything
+            // other than the RoT, including SP_ITSELF.
+            Err(SpError::RequestUnsupportedForComponent)
+        }
     }
 
     fn component_action(
diff --git a/sp-sim/src/helpers.rs b/sp-sim/src/helpers.rs
@@ -0,0 +1,20 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use gateway_messages::{RotSlotId, SpError};
+
+pub(crate) fn rot_slot_id_to_u16(slot_id: RotSlotId) -> u16 {
+    match slot_id {
+        RotSlotId::A => 0,
+        RotSlotId::B => 1,
+    }
+}
+
+pub(crate) fn rot_slot_id_from_u16(slot_id: u16) -> Result<RotSlotId, SpError> {
+    match slot_id {
+        0 => Ok(RotSlotId::A),
+        1 => Ok(RotSlotId::B),
+        _ => Err(SpError::InvalidSlotForComponent),
+    }
+}
diff --git a/sp-sim/src/lib.rs b/sp-sim/src/lib.rs
@@ -4,6 +4,7 @@
 
 pub mod config;
 mod gimlet;
+mod helpers;
 mod rot;
 mod server;
 mod sidecar;
diff --git a/sp-sim/src/sidecar.rs b/sp-sim/src/sidecar.rs
@@ -6,6 +6,8 @@ use crate::config::Config;
 use crate::config::SidecarConfig;
 use crate::config::SimulatedSpsConfig;
 use crate::config::SpComponentConfig;
+use crate::helpers::rot_slot_id_from_u16;
+use crate::helpers::rot_slot_id_to_u16;
 use crate::rot::RotSprocketExt;
 use crate::serial_number_padded;
 use crate::server;
@@ -297,6 +299,7 @@ struct Handler {
 
     serial_number: String,
     ignition: FakeIgnition,
+    rot_active_slot: RotSlotId,
     power_state: PowerState,
 }
 
@@ -326,6 +329,7 @@ impl Handler {
             leaked_component_description_strings,
             serial_number,
             ignition,
+            rot_active_slot: RotSlotId::A,
             power_state: PowerState::A2,
         }
     }
@@ -828,12 +832,18 @@ impl SpHandler for Handler {
         component: SpComponent,
     ) -> Result<u16, SpError> {
         warn!(
-            &self.log, "asked for component active slot (not supported for sim components)";
+            &self.log, "asked for component active slot";
             "sender" => %sender,
             "port" => ?port,
             "component" => ?component,
         );
-        Err(SpError::RequestUnsupportedForComponent)
+        if component == SpComponent::ROT {
+            Ok(rot_slot_id_to_u16(self.rot_active_slot))
+        } else {
+            // The real SP returns `RequestUnsupportedForComponent` for anything
+            // other than the RoT, including SP_ITSELF.
+            Err(SpError::RequestUnsupportedForComponent)
+        }
     }
 
     fn component_set_active_slot(
@@ -845,14 +855,21 @@ impl SpHandler for Handler {
         persist: bool,
     ) -> Result<(), SpError> {
         warn!(
-            &self.log, "asked to set component active slot (not supported for sim components)";
+            &self.log, "asked to set component active slot";
             "sender" => %sender,
             "port" => ?port,
             "component" => ?component,
             "slot" => slot,
             "persist" => persist,
         );
-        Err(SpError::RequestUnsupportedForComponent)
+        if component == SpComponent::ROT {
+            self.rot_active_slot = rot_slot_id_from_u16(slot)?;
+            Ok(())
+        } else {
+            // The real SP returns `RequestUnsupportedForComponent` for anything
+            // other than the RoT, including SP_ITSELF.
+            Err(SpError::RequestUnsupportedForComponent)
+        }
     }
 
     fn component_action(
diff --git a/update-engine/src/events.rs b/update-engine/src/events.rs
@@ -955,6 +955,23 @@ impl<S: StepSpec> StepOutcome<S> {
             }
         }
     }
+
+    /// Returns true if the step was successful, including success with
+    /// warning.
+    pub fn is_success_or_warning(&self) -> bool {
+        match self {
+            Self::Success { .. } | Self::Warning { .. } => true,
+            Self::Skipped { .. } => false,
+        }
+    }
+
+    /// Returns true if the step was skipped.
+    pub fn is_skipped(&self) -> bool {
+        match self {
+            Self::Skipped { .. } => true,
+            Self::Success { .. } | Self::Warning { .. } => false,
+        }
+    }
 }
 
 #[derive(Deserialize, Serialize, JsonSchema)]
diff --git a/wicket-common/src/update_events.rs b/wicket-common/src/update_events.rs
@@ -146,6 +146,8 @@ pub enum UpdateTerminalError {
         #[from]
         error: NestedEngineError<TestStepSpec>,
     },
+    #[error("simulated failure result")]
+    SimulatedFailure,
     #[error("error updating component")]
     ComponentNestedError {
         #[from]
diff --git a/wicket/README.md b/wicket/README.md
@@ -136,6 +136,34 @@ an appropriate value. For example:
 WICKET_UPDATE_TEST_STEP_SECONDS=15 cargo run --bin wicket
 ```
 
+## Adding simulated results to individual steps
+
+Some individual steps support having simulated results via environment variables.
+
+Environment variables supported are:
+
+* `WICKET_UPDATE_TEST_SIMULATE_ROT_RESULT`: Simulates a result for the "Updating RoT" step.
+* `WICKET_UPDATE_TEST_SIMULATE_SP_RESULT`: Simulates a result for the "Updating SP" step.
+
+The environment variable can be set to:
+
+* `success`: A success outcome.
+* `warning`: Success with warning.
+* `failure`: A failure.
+* `skipped`: A skipped outcome.
+
+### Example
+
+If wicket is invoked as:
+
+```
+WICKET_UPDATE_TEST_SIMULATE_ROT_RESULT=skipped cargo run --bin wicket
+```
+
+Then, while performing an update, the "Updating RoT" step will be simulated as skipped.
+
+![Screenshot showing that the "Updating RoT" step has a "skipped" status with a message saying "Simulated skipped result"](https://user-images.githubusercontent.com/180618/254689686-99259bc0-4e68-421d-98ca-362774eef155.png).
+
 ## Testing upload functionality
 
 Test upload functionality without setting up wicket as an SSH captive shell (see below for instructions). (This is the most common use case.)
diff --git a/wicket/src/runner.rs b/wicket/src/runner.rs
@@ -28,6 +28,7 @@ use tui::Terminal;
 use wicketd_client::types::AbortUpdateOptions;
 use wicketd_client::types::ClearUpdateStateOptions;
 use wicketd_client::types::StartUpdateOptions;
+use wicketd_client::types::UpdateSimulatedResult;
 use wicketd_client::types::UpdateTestError;
 
 use crate::events::EventReportMap;
@@ -191,9 +192,18 @@ impl RunnerCore {
                                 )
                             });
 
+                    let test_simulate_rot_result = get_update_simulated_result(
+                        "WICKET_UPDATE_TEST_SIMULATE_ROT_RESULT",
+                    )?;
+                    let test_simulate_sp_result = get_update_simulated_result(
+                        "WICKET_UPDATE_TEST_SIMULATE_SP_RESULT",
+                    )?;
+
                     let options = StartUpdateOptions {
                         test_error,
                         test_step_seconds,
+                        test_simulate_rot_result,
+                        test_simulate_sp_result,
                         skip_rot_version_check: self
                             .state
                             .force_update_state
@@ -307,6 +317,26 @@ fn get_update_test_error(
     Ok(test_error)
 }
 
+fn get_update_simulated_result(
+    env_var: &str,
+) -> Result<Option<UpdateSimulatedResult>, anyhow::Error> {
+    let result = match std::env::var(env_var) {
+        Ok(v) if v == "success" => Some(UpdateSimulatedResult::Success),
+        Ok(v) if v == "warning" => Some(UpdateSimulatedResult::Warning),
+        Ok(v) if v == "skipped" => Some(UpdateSimulatedResult::Skipped),
+        Ok(v) if v == "failure" => Some(UpdateSimulatedResult::Failure),
+        Ok(value) => {
+            bail!("unrecognized value for {env_var}: {value}");
+        }
+        Err(VarError::NotPresent) => None,
+        Err(VarError::NotUnicode(value)) => {
+            bail!("invalid Unicode for {env_var}: {}", value.to_string_lossy());
+        }
+    };
+
+    Ok(result)
+}
+
 /// The `Runner` owns the main UI thread, and starts a tokio runtime
 /// for interaction with downstream services.
 pub struct Runner {
diff --git a/wicket/src/state/update.rs b/wicket/src/state/update.rs
diff --git a/wicketd/src/http_entrypoints.rs b/wicketd/src/http_entrypoints.rs
diff --git a/wicketd/src/update_tracker.rs b/wicketd/src/update_tracker.rs

Original file line number	Diff line number	Diff line change
`@@ -955,6 +955,23 @@ impl<S: StepSpec> StepOutcome<S> {`
`955`	`955`	`}`
`956`	`956`	`}`
`957`	`957`	`}`
	`958`	`+`
	`959`	`+ /// Returns true if the step was successful, including success with`
	`960`	`+ /// warning.`
	`961`	`+ pub fn is_success_or_warning(&self) -> bool {`
	`962`	`+ match self {`
	`963`	`+ Self::Success { .. } \| Self::Warning { .. } => true,`
	`964`	`+ Self::Skipped { .. } => false,`
	`965`	`+ }`
	`966`	`+ }`
	`967`	`+`
	`968`	`+ /// Returns true if the step was skipped.`
	`969`	`+ pub fn is_skipped(&self) -> bool {`
	`970`	`+ match self {`
	`971`	`+ Self::Skipped { .. } => true,`
	`972`	`+ Self::Success { .. } \| Self::Warning { .. } => false,`
	`973`	`+ }`
	`974`	`+ }`
`958`	`975`	`}`
`959`	`976`
`960`	`977`	`#[derive(Deserialize, Serialize, JsonSchema)]`