fix: hanging reboot

Signed-off-by: Jan Zachmann <50990105+JanZachmann@users.noreply.github.com>

Author: JanZachmann

src/main.rs

@@ -7,11 +7,11 @@ pub mod web_service;
 
 use env_logger::{Builder, Env, Target};
 use log::{error, info};
-use std::{env, io::Write, process};
+use std::{io::Write, process};
 use twin::Twin;
 
 #[tokio::main]
-async fn main() {
+async fn main() -> process::ExitCode {
     log_panics::init();
 
     let mut builder = if cfg!(debug_assertions) {
@@ -45,18 +45,10 @@ async fn main() {
     if let Err(e) = Twin::run().await {
         error!("application error: {e:#}");
 
-        process::exit(1);
+        return process::ExitCode::FAILURE;
     }
 
     info!("application shutdown");
 
-    // FIXME:
-    //   under some circumstances the app can hang at termination what can be
-    //   worked around by explicitly issuing exit here.
-    //   to ease further examination of that problem allow setting an
-    //   environment variable to skip the workaround.
-    if env::var("DONT_EXPLICITLY_EXIT_ON_TERMINATION").is_err() {
-        // ensure that we terminate here right now
-        process::exit(0);
-    }
+    process::ExitCode::SUCCESS
 }

src/systemd/mod.rs

@@ -18,13 +18,18 @@ pub fn sd_notify_ready() {
 }
 
 #[cfg(not(feature = "mock"))]
-pub async fn reboot() -> Result<()> {
+pub async fn reboot(reason: &str, extra_info: &str) -> Result<()> {
+    use crate::reboot_reason;
     use anyhow::Context;
     use log::{debug, error};
     use std::process::Command;
 
     info!("systemd::reboot");
 
+    reboot_reason::write_reboot_reason(reason, extra_info).context(format!(
+        "reboot: failed to write reason '{reason}' with info '{extra_info}'"
+    ))?;
+
     //journalctl seems not to have a dbus api
     match Command::new("sudo").args(["journalctl", "--sync"]).status() {
         Ok(status) if !status.success() => error!("reboot: failed to execute 'journalctl --sync'"),
@@ -44,9 +49,6 @@ pub async fn reboot() -> Result<()> {
         )
         .await
         .context("reboot: call_method() failed")?;
-
-    debug!("reboot: succeeded to call systemd reboot");
-
     Ok(())
 }
 
@@ -74,6 +76,6 @@ pub async fn wait_for_system_running() -> Result<()> {
 }
 
 #[cfg(feature = "mock")]
-pub async fn reboot() -> Result<()> {
+pub async fn reboot(_reason: &str, _extra_info: &str) -> Result<()> {
     Ok(())
 }

src/twin/factory_reset.rs

@@ -1,13 +1,13 @@
 use crate::{
     bootloader_env,
     common::from_json_file,
-    reboot_reason, systemd,
+    systemd,
     twin::{Feature, feature::*},
     web_service,
 };
 use anyhow::{Context, Result, bail};
 use azure_iot_sdk::client::IotMessage;
-use log::{debug, error, info, warn};
+use log::{debug, info, warn};
 use notify_debouncer_full::{Debouncer, NoCache, notify::*};
 use serde::{Deserialize, Serialize};
 use serde_json::{from_reader, json};
@@ -263,13 +263,7 @@ impl FactoryReset {
         }
 
         bootloader_env::set("factory-reset", &serde_json::to_string(&cmd)?)?;
-
-        if let Err(e) =
-            reboot_reason::write_reboot_reason("factory-reset", "initiated by portal or API")
-        {
-            error!("reset_to_factory_settings: failed to write reboot reason with {e:#}");
-        }
-        systemd::reboot().await?;
+        systemd::reboot("factory-reset", "initiated by portal or API").await?;
         Ok(None)
     }
 }

src/twin/feature/mod.rs

@@ -37,7 +37,7 @@ pub enum Command {
     ReloadNetwork,
     RunFirmwareUpdate(firmware_update::RunUpdateCommand),
     SetWaitOnlineTimeout(reboot::SetWaitOnlineTimeoutCommand),
-    ValidateUpdateAuthenticated(bool),
+    ValidateUpdate(bool),
     UserConsent(consent::UserConsentCommand),
 }
 
@@ -62,7 +62,7 @@ impl Command {
             ReloadNetwork => TypeId::of::<network::Network>(),
             RunFirmwareUpdate(_) => TypeId::of::<firmware_update::FirmwareUpdate>(),
             SetWaitOnlineTimeout(_) => TypeId::of::<reboot::Reboot>(),
-            ValidateUpdateAuthenticated(_) => TypeId::of::<firmware_update::FirmwareUpdate>(),
+            ValidateUpdate(_) => TypeId::of::<firmware_update::FirmwareUpdate>(),
             UserConsent(_) => TypeId::of::<consent::DeviceUpdateConsent>(),
         }
     }

src/twin/firmware_update/mod.rs

@@ -6,7 +6,7 @@ pub mod update_validation;
 use crate::{
     bootloader_env,
     common::{RootPartition, from_json_file, path_ends_with, to_json_file},
-    reboot_reason, systemd,
+    systemd,
     systemd::{unit::UnitAction, watchdog::WatchdogManager},
     twin::{
         Feature,
@@ -182,7 +182,7 @@ impl Feature for FirmwareUpdate {
         match cmd {
             Command::LoadFirmwareUpdate(cmd) => self.load(&cmd.update_file_path).await,
             Command::RunFirmwareUpdate(cmd) => self.run(cmd.validate_iothub_connection).await,
-            Command::ValidateUpdateAuthenticated(authenticated) => {
+            Command::ValidateUpdate(authenticated) => {
                 self.update_validation
                     .set_authenticated(*authenticated)
                     .await?;
@@ -197,11 +197,11 @@ impl FirmwareUpdate {
     const FIRMWARE_UPDATE_VERSION: u8 = 1;
     const ID: &'static str = "firmware_update";
 
-    pub fn new(update_validation: UpdateValidation) -> Self {
-        FirmwareUpdate {
+    pub async fn new() -> Result<Self> {
+        Ok(FirmwareUpdate {
             swu_file_path: None,
-            update_validation,
-        }
+            update_validation: UpdateValidation::new().await?,
+        })
     }
 
     async fn load<P>(&mut self, path: P) -> CommandResult
@@ -394,11 +394,7 @@ impl FirmwareUpdate {
             true,
         )?;
 
-        if let Err(e) = reboot_reason::write_reboot_reason("swupdate", "local update") {
-            error!("failed to write reboot reason: {e:#}");
-        }
-
-        systemd::reboot().await?;
+        systemd::reboot("swupdate", "local update").await?;
 
         info!("update succeeded");
 
@@ -480,8 +476,7 @@ mod tests {
         crate::common::set_env_var("UPDATE_FOLDER_PATH", update_folder);
         crate::common::set_env_var("DEVICE_UPDATE_PATH", du_config_file);
         crate::common::set_env_var("SW_VERSIONS_PATH", sw_versions_file);
-        let (tx_validated, mut _rx_validated) = tokio::sync::oneshot::channel();
-        let update_validation = UpdateValidation::new(tx_validated).await.unwrap();
+        let update_validation = UpdateValidation::new().await.unwrap();
 
         let mut firmware_update = FirmwareUpdate {
             swu_file_path: None,
@@ -505,8 +500,7 @@ mod tests {
         crate::common::set_env_var("UPDATE_FOLDER_PATH", update_folder);
         crate::common::set_env_var("DEVICE_UPDATE_PATH", du_config_file);
         crate::common::set_env_var("SW_VERSIONS_PATH", &sw_versions_file);
-        let (tx_validated, mut _rx_validated) = tokio::sync::oneshot::channel();
-        let update_validation = UpdateValidation::new(tx_validated).await.unwrap();
+        let update_validation = UpdateValidation::new().await.unwrap();
 
         let mut firmware_update = FirmwareUpdate {
             swu_file_path: None,
@@ -553,8 +547,7 @@ mod tests {
         crate::common::set_env_var("UPDATE_FOLDER_PATH", update_folder);
         crate::common::set_env_var("DEVICE_UPDATE_PATH", &du_config_file);
         crate::common::set_env_var("SW_VERSIONS_PATH", sw_versions_file);
-        let (tx_validated, mut _rx_validated) = tokio::sync::oneshot::channel();
-        let update_validation = UpdateValidation::new(tx_validated).await.unwrap();
+        let update_validation = UpdateValidation::new().await.unwrap();
 
         let mut firmware_update = FirmwareUpdate {
             swu_file_path: None,