chore: cleaning up examples of is_some() + unwrap() (#362)

chet · web-flow · commit b40c0b190738 · 2026-02-23T07:11:31.000-08:00
diff --git a/crates/admin-cli/src/extension_service/cmds.rs b/crates/admin-cli/src/extension_service/cmds.rs
@@ -93,25 +93,24 @@ pub async fn handle_update(
 ) -> CarbideCliResult<()> {
     let is_json = output_format == OutputFormat::Json;
 
-    let credential =
-        if args.username.is_some() || args.password.is_some() || args.registry_url.is_some() {
-            if args.username.is_none() || args.password.is_none() || args.registry_url.is_none() {
-                return Err(CarbideCliError::GenericError(
-                    "All of username, password and registry URL are required to create credential"
-                        .to_string(),
-                ));
-            }
-
+    let credential = match (args.username, args.password, args.registry_url) {
+        (Some(username), Some(password), Some(registry_url)) => {
             Some(::rpc::forge::DpuExtensionServiceCredential {
-                registry_url: args.registry_url.unwrap(),
+                registry_url,
                 r#type: Some(Type::UsernamePassword(rpc::forge::UsernamePassword {
-                    username: args.username.unwrap(),
-                    password: args.password.unwrap(),
+                    username,
+                    password,
                 })),
             })
-        } else {
-            None
-        };
+        }
+        (None, None, None) => None,
+        _ => {
+            return Err(CarbideCliError::GenericError(
+                "All of username, password and registry URL are required to create credential"
+                    .to_string(),
+            ));
+        }
+    };
 
     let observability = if let Some(r) = args.observability {
         serde_json::from_str(&r)?
diff --git a/crates/agent/src/duppet/sync.rs b/crates/agent/src/duppet/sync.rs
@@ -315,11 +315,9 @@ pub fn maybe_update_file_permissions(
 ) -> io::Result<bool> {
     // If not configured to manage the mode,
     // just return nothing was changed.
-    if expected_mode.is_none() {
+    let Some(expected_mode) = expected_mode else {
         return Ok(false);
-    }
-
-    let expected_mode = expected_mode.unwrap();
+    };
     let file = File::open(path)?;
     let metadata = file.metadata()?;
     let mut perms = metadata.permissions();
diff --git a/crates/agent/src/ethernet_virtualization.rs b/crates/agent/src/ethernet_virtualization.rs
@@ -1420,10 +1420,13 @@ fn parse_fdb(fdb_json: &str) -> eyre::Result<HashMap<u32, Vec<Fdb>>> {
     let all_fdb: Vec<Fdb> = serde_json::from_str(fdb_json)?;
     let mut out: HashMap<u32, Vec<Fdb>> = HashMap::new();
     for fdb in all_fdb.into_iter() {
-        if fdb.vlan.is_none() || fdb.state == "permanent" {
+        let Some(vlan) = fdb.vlan else {
+            continue;
+        };
+        if fdb.state == "permanent" {
             continue;
         }
-        out.entry(fdb.vlan.unwrap())
+        out.entry(vlan)
             .and_modify(|v| v.push(fdb.clone()))
             .or_insert_with(|| vec![fdb]);
     }
diff --git a/crates/api-db/src/instance.rs b/crates/api-db/src/instance.rs
@@ -64,28 +64,37 @@ pub async fn find_ids(
     let mut builder = sqlx::QueryBuilder::new("SELECT id FROM instances WHERE TRUE "); // The TRUE will be optimized away.
 
     if let Some(label) = filter.label {
-        if label.key.is_empty() && label.value.is_some() {
-            builder.push(
-                " AND EXISTS (
+        match (label.key.is_empty(), label.value) {
+            // Label key is empty, label value is set.
+            (true, Some(value)) => {
+                builder.push(
+                    " AND EXISTS (
                         SELECT 1
                         FROM jsonb_each_text(labels) AS kv
                         WHERE kv.value = ",
-            );
-            builder.push_bind(label.value.unwrap());
-            builder.push(")");
-        } else if label.key.is_empty() && label.value.is_none() {
-            return Err(DatabaseError::InvalidArgument(
-                "finding instances based on label needs either key or a value.".to_string(),
-            ));
-        } else if !label.key.is_empty() && label.value.is_none() {
-            builder.push(" AND labels ->> ");
-            builder.push_bind(label.key);
-            builder.push(" IS NOT NULL");
-        } else if !label.key.is_empty() && label.value.is_some() {
-            builder.push(" AND labels ->> ");
-            builder.push_bind(label.key);
-            builder.push(" = ");
-            builder.push_bind(label.value.unwrap());
+                );
+                builder.push_bind(value);
+                builder.push(")");
+            }
+            // Label key is empty, label value is not set.
+            (true, None) => {
+                return Err(DatabaseError::InvalidArgument(
+                    "finding instances based on label needs either key or a value.".to_string(),
+                ));
+            }
+            // Label key is not empty, label value is not set.
+            (false, None) => {
+                builder.push(" AND labels ->> ");
+                builder.push_bind(label.key);
+                builder.push(" IS NOT NULL");
+            }
+            // Label key is not empty, label value is set.
+            (false, Some(value)) => {
+                builder.push(" AND labels ->> ");
+                builder.push_bind(label.key);
+                builder.push(" = ");
+                builder.push_bind(value);
+            }
         }
     }
 
diff --git a/crates/api-db/src/machine.rs b/crates/api-db/src/machine.rs
@@ -92,8 +92,7 @@ pub async fn get_or_create(
 ) -> DatabaseResult<Machine> {
     let existing_machine =
         find_one(&mut *txn, stable_machine_id, MachineSearchConfig::default()).await?;
-    if interface.machine_id.is_some() {
-        let machine_id = interface.machine_id.as_ref().unwrap();
+    if let Some(machine_id) = interface.machine_id.as_ref() {
         if machine_id != stable_machine_id {
             return Err(DatabaseError::internal(format!(
                 "Database inconsistency: MachineId {} on interface {} does not match stable machine ID {} which now uses this interface",
@@ -1628,10 +1627,9 @@ pub async fn apply_agent_upgrade_policy(
         None => Ok(false),
         Some(obs) => {
             let carbide_api_version = carbide_version::v!(build_version);
-            if obs.agent_version.is_none() {
+            let Some(agent_version) = obs.agent_version.clone() else {
                 return Ok(false);
-            }
-            let agent_version = obs.agent_version.as_ref().cloned().unwrap();
+            };
             let should_upgrade = policy.should_upgrade(&agent_version, carbide_api_version);
             if should_upgrade != machine.needs_agent_upgrade() {
                 set_dpu_agent_upgrade_requested(
diff --git a/crates/api-db/src/vpc.rs b/crates/api-db/src/vpc.rs
@@ -107,31 +107,40 @@ pub async fn find_ids(
         if has_filter {
             builder.push(" AND ");
         }
-        if label.key.is_empty() && label.value.is_some() {
-            builder.push(
-                " EXISTS (
+        match (label.key.is_empty(), label.value) {
+            // Label key is empty, label value is set.
+            (true, Some(value)) => {
+                builder.push(
+                    " EXISTS (
                         SELECT 1
                         FROM jsonb_each_text(labels) AS kv
                         WHERE kv.value = ",
-            );
-            builder.push_bind(label.value.unwrap());
-            builder.push(")");
-            has_filter = true;
-        } else if label.key.is_empty() && label.value.is_none() {
-            return Err(DatabaseError::InvalidArgument(
-                "finding VPCs based on label needs either key or a value.".to_string(),
-            ));
-        } else if !label.key.is_empty() && label.value.is_none() {
-            builder.push(" labels ->> ");
-            builder.push_bind(label.key);
-            builder.push(" IS NOT NULL");
-            has_filter = true;
-        } else if !label.key.is_empty() && label.value.is_some() {
-            builder.push(" labels ->> ");
-            builder.push_bind(label.key);
-            builder.push(" = ");
-            builder.push_bind(label.value.unwrap());
-            has_filter = true;
+                );
+                builder.push_bind(value);
+                builder.push(")");
+                has_filter = true;
+            }
+            // Label key is empty, label value is not set.
+            (true, None) => {
+                return Err(DatabaseError::InvalidArgument(
+                    "finding VPCs based on label needs either key or a value.".to_string(),
+                ));
+            }
+            // Label key is not empty, label value is not set.
+            (false, None) => {
+                builder.push(" labels ->> ");
+                builder.push_bind(label.key);
+                builder.push(" IS NOT NULL");
+                has_filter = true;
+            }
+            // Label key is not empty, label value is set.
+            (false, Some(value)) => {
+                builder.push(" labels ->> ");
+                builder.push_bind(label.key);
+                builder.push(" = ");
+                builder.push_bind(value);
+                has_filter = true;
+            }
         }
     }
     if has_filter {
diff --git a/crates/api/src/cfg/file.rs b/crates/api/src/cfg/file.rs
@@ -654,32 +654,27 @@ impl CarbideConfig {
     }
 
     pub fn is_dpa_enabled(&self) -> bool {
-        if self.dpa_config.is_none() {
+        let Some(conf) = &self.dpa_config else {
             return false;
-        }
-
-        let conf = self.dpa_config.clone().unwrap();
+        };
 
         conf.enabled
     }
 
     pub fn get_dpa_subnet_ip(&self) -> Result<Ipv4Addr, eyre::Report> {
-        if self.dpa_config.is_none() {
+        let Some(conf) = &self.dpa_config else {
             tracing::error!("get_dpa_subnet_ip: DPA config missing");
             return Err(eyre::eyre!("get_dpa_subnet_ip: DPA config missing"));
-        }
+        };
 
-        let conf = self.dpa_config.clone().unwrap();
         Ok(conf.subnet_ip)
     }
 
     pub fn get_dpa_subnet_mask(&self) -> Result<i32, eyre::Report> {
-        if self.dpa_config.is_none() {
+        let Some(conf) = &self.dpa_config else {
             tracing::error!("get_dpa_subnet_mask: DPA config missing");
             return Err(eyre::eyre!("get_dpa_subnet_mask: DPA config missing"));
-        }
-
-        let conf = self.dpa_config.clone().unwrap();
+        };
 
         Ok(conf.subnet_mask)
     }
diff --git a/crates/api/src/handlers/dpa.rs b/crates/api/src/handlers/dpa.rs
@@ -502,8 +502,8 @@ async fn process_mlx_observation(
             firmware_report: None,
         });
 
-        if obs.lock_status.is_some() {
-            let ls = match DpaLockMode::try_from(obs.lock_status.unwrap()) {
+        if let Some(lock_status) = obs.lock_status {
+            let ls = match DpaLockMode::try_from(lock_status) {
                 Ok(ls) => ls,
                 Err(e) => {
                     tracing::error!("process_mlx_observation Error from LockStatus::try_from {e}");
@@ -572,11 +572,9 @@ pub(crate) async fn publish_mlx_device_report(
         );
 
         // Without a machine_id, we can't create dpa interfaces
-        if report.machine_id.is_some() {
+        if let Some(machine_id) = report.machine_id {
             let mut spx_nics: i32 = 0;
 
-            let machine_id = report.machine_id.unwrap();
-
             // Go over each of the MlxDeviceInfo reports from the
             // MlxDeviceReport. Each MlxDeviceInfo corresponds to
             // an individual device reported by `mlxfwmanager`, with
@@ -587,8 +585,9 @@ pub(crate) async fn publish_mlx_device_report(
                 // Change this to base device detection using part numbers rather
                 // than device description.
                 // XXX TODO XXX
-                if device_info.device_description.is_some() && device_info.base_mac.is_some() {
-                    let descr = device_info.device_description.clone().unwrap();
+                if let (Some(descr), Some(mac_address)) =
+                    (device_info.device_description.clone(), device_info.base_mac)
+                {
                     if descr.contains("SuperNIC") {
                         spx_nics += 1;
 
@@ -597,7 +596,6 @@ pub(crate) async fn publish_mlx_device_report(
                         // the TODO(chet) below about create_internal behavior.
                         // I think we can refactor all of this so these hoops
                         // aren't needed.
-                        let mac_address = device_info.base_mac.unwrap();
                         let pci_name = device_info.pci_name.clone();
                         let device_type = device_info.device_type.clone();
                         let dpa_info = NewDpaInterface {
diff --git a/crates/measured-boot/src/site.rs b/crates/measured-boot/src/site.rs
@@ -180,11 +180,7 @@ impl MachineAttestationSummaryList {
                 .iter()
                 .map(|e| MachineAttestationSummaryPb {
                     machine_id: e.machine_id.to_string(),
-                    bundle_id: if e.bundle_id.is_none() {
-                        None
-                    } else {
-                        Some(e.bundle_id.unwrap())
-                    },
+                    bundle_id: e.bundle_id,
                     profile_name: e.profile_name.clone(),
                     ts: Some(e.ts.into()),
                 })
@@ -204,14 +200,13 @@ impl MachineAttestationSummaryList {
                 })?,
                 bundle_id: pb.bundle_id,
                 profile_name: pb.profile_name.clone(),
-                ts: if pb.ts.is_none() {
-                    chrono::DateTime::<Utc>::default()
-                } else {
-                    chrono::DateTime::<Utc>::try_from(pb.ts.unwrap()).map_err(|err| {
+                ts: match pb.ts {
+                    Some(ts) => chrono::DateTime::<Utc>::try_from(ts).map_err(|err| {
                         super::Error::RpcConversion(format!(
                             "Could not deserialize ListAttestationSummaryResponse(timestamp): {err}"
                         ))
-                    })?
+                    })?,
+                    None => chrono::DateTime::<Utc>::default(),
                 },
             });
         }
diff --git a/crates/scout/src/main.rs b/crates/scout/src/main.rs
@@ -441,11 +441,10 @@ async fn handle_mlxreport_action(
     machine_id: &MachineId,
     data: Option<ForgeAgentControlExtraInfo>,
 ) {
-    if data.is_none() {
+    let Some(ed) = data else {
         tracing::error!("handle_mlxreport_action Did not expect extra data to be empty");
         return;
-    }
-    let ed = data.unwrap();
+    };
 
     // The Extra data is an array of key value pairs.
     // The key is the pci_name of a DPA NIC.
diff --git a/crates/secrets/src/forge_vault.rs b/crates/secrets/src/forge_vault.rs
@@ -607,8 +607,8 @@ impl VaultTask<Certificate> for GetCertificateHelper {
             trust_domain, namespace, self.unique_identifier,
         );
 
-        let ttl = if self.ttl.is_some() {
-            self.ttl.clone().unwrap()
+        let ttl = if let Some(ttl) = self.ttl.clone() {
+            ttl
         } else {
             // this is to setup a baseline skew of between 60 - 100% of 30 days,
             // so that not all boxes will renew (or expire) at the same time.
diff --git a/crates/ssh-console/src/bmc/vendor.rs b/crates/ssh-console/src/bmc/vendor.rs
@@ -227,12 +227,11 @@ impl EscapeSequence {
     ) -> (Cow<'a, [u8]>, bool) {
         // Helper to lazily get &mut Vec<u8>
         fn get_buf<'b>(out: &'b mut Option<Vec<u8>>, input: &[u8], idx: usize) -> &'b mut Vec<u8> {
-            if out.is_none() {
+            out.get_or_insert_with(|| {
                 let mut v = Vec::with_capacity(input.len());
                 v.extend_from_slice(&input[..idx]);
-                *out = Some(v);
-            }
-            out.as_mut().unwrap()
+                v
+            })
         }
 
         match self {
