dbus: rauc: reload rauc daemon when required

This uses the existing systemd DBus API integration to trigger a daemon
restart (there is no support to just reload the config as of now) and
keep track of the following state changes.

Signed-off-by: Leonard Göhrs <l.goehrs@pengutronix.de>

Author: hnez

src/dbus.rs

@@ -89,11 +89,13 @@ impl DbusSession {
 
         let conn = Arc::new(tacd.serve(conn_builder).build().await?);
 
+        let systemd = Systemd::new(bb, wtb, &conn).await?;
+
         Ok(Self {
             hostname: Hostname::new(bb, wtb, &conn)?,
             network: Network::new(bb, wtb, &conn, led_dut, led_uplink)?,
-            rauc: Rauc::new(bb, wtb, &conn)?,
-            systemd: Systemd::new(bb, wtb, &conn).await?,
+            rauc: Rauc::new(bb, wtb, &conn, systemd.rauc.clone())?,
+            systemd,
         })
     }
 }

src/dbus/rauc.rs

@@ -21,9 +21,10 @@ use anyhow::Result;
 use async_std::stream::StreamExt;
 use async_std::sync::Arc;
 use futures_util::FutureExt;
-use log::warn;
+use log::{info, warn};
 use serde::{Deserialize, Serialize};
 
+use super::systemd::{Service, ServiceAction};
 use super::Connection;
 use crate::broker::{BrokerBuilder, Topic};
 use crate::watched_tasks::WatchedTasksBuilder;
@@ -188,6 +189,7 @@ async fn channel_list_update_task(
     reload: Arc<Topic<bool>>,
     enable_polling: Arc<Topic<bool>>,
     channels: Arc<Topic<Channels>>,
+    rauc_service: Service,
 ) -> Result<()> {
     let (reload_stream, _) = reload.subscribe_unbounded();
     let (mut enable_polling_stream, _) = enable_polling.subscribe_unbounded();
@@ -215,9 +217,43 @@ async fn channel_list_update_task(
             }
         };
 
-        update_system_conf(new_channels.primary(), enable_polling)?;
+        let should_reload = update_system_conf(new_channels.primary(), enable_polling)?;
 
         channels.set(new_channels);
+
+        if should_reload {
+            info!("New RAUC config written. Triggering daemon restart.");
+
+            let (mut status, status_subscription) =
+                rauc_service.status.clone().subscribe_unbounded();
+            rauc_service.action.set(ServiceAction::Restart);
+
+            info!("Waiting for daemon to go down");
+
+            while let Some(ev) = status.next().await {
+                info!("Current status: {} ({})", ev.active_state, ev.sub_state);
+
+                if ev.active_state != "active" {
+                    break;
+                }
+            }
+
+            info!("Waiting for daemon to come up again");
+
+            while let Some(ev) = status.next().await {
+                info!("Current status: {} ({})", ev.active_state, ev.sub_state);
+
+                if ev.active_state == "active" {
+                    break;
+                }
+            }
+
+            info!("Done");
+
+            status_subscription.unsubscribe();
+        } else {
+            info!("Config is up to date. Will not reload.");
+        }
     }
 }
 
@@ -249,6 +285,7 @@ impl Rauc {
         bb: &mut BrokerBuilder,
         wtb: &mut WatchedTasksBuilder,
         _conn: &Arc<Connection>,
+        rauc_service: Service,
     ) -> Result<Self> {
         let inst = Self::setup_topics(bb);
 
@@ -263,6 +300,7 @@ impl Rauc {
                 inst.reload.clone(),
                 inst.enable_polling.clone(),
                 inst.channels.clone(),
+                rauc_service,
             ),
         )?;
 
@@ -274,6 +312,7 @@ impl Rauc {
         bb: &mut BrokerBuilder,
         wtb: &mut WatchedTasksBuilder,
         conn: &Arc<Connection>,
+        rauc_service: Service,
     ) -> Result<Self> {
         let inst = Self::setup_topics(bb);
 
@@ -469,6 +508,7 @@ impl Rauc {
                 inst.reload.clone(),
                 inst.enable_polling.clone(),
                 inst.channels.clone(),
+                rauc_service,
             ),
         )?;
 

src/dbus/systemd.rs

@@ -66,7 +66,6 @@ pub struct Systemd {
     pub labgrid: Service,
     #[allow(dead_code)]
     pub iobus: Service,
-    #[allow(dead_code)]
     pub rauc: Service,
 }