dbus: rauc: add Channels type to use instead of Vec<Channel>

This allows us to add methods like "get the primary channel",
that operates on all update channels at once, to this `Channels`
type later on.

Signed-off-by: Leonard Göhrs <[email protected]>

Author: hnez

src/dbus/rauc.rs

@@ -32,7 +32,7 @@ use crate::broker::{BrokerBuilder, Topic};
 use crate::watched_tasks::WatchedTasksBuilder;
 
 mod update_channels;
-pub use update_channels::Channel;
+pub use update_channels::{Channel, Channels};
 
 #[cfg(feature = "demo_mode")]
 mod demo_mode;
@@ -124,7 +124,7 @@ pub struct Rauc {
     pub primary: Arc<Topic<String>>,
     pub last_error: Arc<Topic<String>>,
     pub install: Arc<Topic<String>>,
-    pub channels: Arc<Topic<Vec<Channel>>>,
+    pub channels: Arc<Topic<Channels>>,
     pub reload: Arc<Topic<bool>>,
     pub should_reboot: Arc<Topic<bool>>,
     pub enable_polling: Arc<Topic<bool>>,
@@ -203,7 +203,7 @@ fn would_reboot_into_other_slot(slot_status: &SlotStatus, primary: Option<String
 async fn channel_polling_task(
     conn: Arc<Connection>,
     enable_polling: Arc<Topic<bool>>,
-    channels: Arc<Topic<Vec<Channel>>>,
+    channels: Arc<Topic<Channels>>,
     slot_status: Arc<Topic<Arc<SlotStatus>>>,
     name: String,
 ) {
@@ -213,7 +213,7 @@ async fn channel_polling_task(
 
     while let Some(mut channel) = channels
         .try_get()
-        .and_then(|chs| chs.into_iter().find(|ch| ch.name == name))
+        .and_then(|chs| chs.into_vec().into_iter().find(|ch| ch.name == name))
     {
         // Make sure update polling is enabled before doing anything,
         // as contacting the update server requires user consent.
@@ -271,7 +271,7 @@ async fn channel_list_update_task(
     conn: Arc<Connection>,
     mut reload_stream: Receiver<bool>,
     enable_polling: Arc<Topic<bool>>,
-    channels: Arc<Topic<Vec<Channel>>>,
+    channels: Arc<Topic<Channels>>,
     slot_status: Arc<Topic<Arc<SlotStatus>>>,
 ) -> Result<()> {
     let mut previous: Option<Instant> = None;
@@ -292,7 +292,7 @@ async fn channel_list_update_task(
         }
 
         // Read the list of available update channels
-        let new_channels = match Channel::from_directory(CHANNELS_DIR) {
+        let new_channels = match Channels::from_directory(CHANNELS_DIR) {
             Ok(chs) => chs,
             Err(e) => {
                 warn!("Failed to get list of update channels: {e}");

src/dbus/rauc/update_channels.rs

@@ -54,6 +54,9 @@ pub struct Channel {
     pub bundle: Option<UpstreamBundle>,
 }
 
+#[derive(Serialize, Deserialize, Clone, PartialEq)]
+pub struct Channels(Vec<Channel>);
+
 #[derive(Deserialize)]
 pub struct ChannelFile {
     pub name: String,
@@ -140,38 +143,6 @@ impl Channel {
         Ok(ch)
     }
 
-    pub(super) fn from_directory(dir: &str) -> Result<Vec<Self>> {
-        // Find all .yaml files in CHANNELS_DIR
-        let mut dir_entries: Vec<DirEntry> = read_dir(dir)?
-            .filter_map(|dir_entry| dir_entry.ok())
-            .filter(|dir_entry| {
-                dir_entry
-                    .file_name()
-                    .as_os_str()
-                    .as_bytes()
-                    .ends_with(b".yaml")
-            })
-            .collect();
-
-        // And sort them alphabetically, so that 01_stable.yaml takes precedence over
-        // 05_testing.yaml.
-        dir_entries.sort_by_key(|dir_entry| dir_entry.file_name());
-
-        let mut channels: Vec<Self> = Vec::new();
-
-        for dir_entry in dir_entries {
-            let channel = Self::from_file(&dir_entry.path())?;
-
-            if channels.iter().any(|ch| ch.name == channel.name) {
-                bail!("Encountered duplicate channel name \"{}\"", channel.name);
-            }
-
-            channels.push(channel);
-        }
-
-        Ok(channels)
-    }
-
     fn update_enabled(&mut self) {
         // Which channels are enabled is decided based on which RAUC certificates are enabled.
         let cert_file = self.name.clone() + ".cert.pem";
@@ -206,6 +177,52 @@ impl Channel {
     }
 }
 
+impl Channels {
+    pub(super) fn from_directory(dir: &str) -> Result<Self> {
+        // Find all .yaml files in CHANNELS_DIR
+        let mut dir_entries: Vec<DirEntry> = read_dir(dir)?
+            .filter_map(|dir_entry| dir_entry.ok())
+            .filter(|dir_entry| {
+                dir_entry
+                    .file_name()
+                    .as_os_str()
+                    .as_bytes()
+                    .ends_with(b".yaml")
+            })
+            .collect();
+
+        // And sort them alphabetically, so that 01_stable.yaml takes precedence over
+        // 05_testing.yaml.
+        dir_entries.sort_by_key(|dir_entry| dir_entry.file_name());
+
+        let mut channels: Vec<Channel> = Vec::new();
+
+        for dir_entry in dir_entries {
+            let channel = Channel::from_file(&dir_entry.path())?;
+
+            if channels.iter().any(|ch| ch.name == channel.name) {
+                bail!("Encountered duplicate channel name \"{}\"", channel.name);
+            }
+
+            channels.push(channel);
+        }
+
+        Ok(Self(channels))
+    }
+
+    pub fn into_vec(self) -> Vec<Channel> {
+        self.0
+    }
+
+    pub fn iter(&self) -> std::slice::Iter<Channel> {
+        self.0.iter()
+    }
+
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<Channel> {
+        self.0.iter_mut()
+    }
+}
+
 impl UpstreamBundle {
     fn new(compatible: String, version: String, slot_status: Option<&SlotStatus>) -> Self {
         let mut ub = Self {

src/motd.rs

@@ -207,6 +207,7 @@ pub fn run(
                 },
                 update = channels_events.recv().fuse() => {
                     motd.rauc_update_urls = update?
+                        .into_vec()
                         .into_iter()
                         .filter_map(|ch| {
                             ch.bundle

src/ui/screens/diagnostics.rs

@@ -130,7 +130,7 @@ fn diagnostic_text(ui: &Ui) -> Result<String, std::fmt::Error> {
     if let Some(channels) = ui.res.rauc.channels.try_get() {
         write!(&mut text, "chs: ")?;
 
-        for ch in channels {
+        for ch in channels.into_vec() {
             let en = if ch.enabled { "[x]" } else { "[ ]" };
             let name = ch.name;
 

src/ui/screens/update_available.rs

@@ -30,7 +30,7 @@ use super::{
     InputEvent, Screen, Ui,
 };
 use crate::broker::Topic;
-use crate::dbus::rauc::Channel;
+use crate::dbus::rauc::{Channel, Channels};
 use crate::watched_tasks::WatchedTasksBuilder;
 
 const SCREEN_TYPE: AlertScreen = AlertScreen::UpdateAvailable;
@@ -73,8 +73,9 @@ impl Selection {
         !self.channels.is_empty()
     }
 
-    fn update_channels(&self, channels: Vec<Channel>) -> Option<Self> {
+    fn update_channels(&self, channels: Channels) -> Option<Self> {
         let channels: Vec<Channel> = channels
+            .into_vec()
             .into_iter()
             .filter(|ch| {
                 ch.bundle
@@ -143,7 +144,7 @@ impl UpdateAvailableScreen {
     pub fn new(
         wtb: &mut WatchedTasksBuilder,
         alerts: &Arc<Topic<AlertList>>,
-        channels: &Arc<Topic<Vec<Channel>>>,
+        channels: &Arc<Topic<Channels>>,
     ) -> Result<Self> {
         let (mut channels_events, _) = channels.clone().subscribe_unbounded();
         let alerts = alerts.clone();