Add initial HostApp model

This also extracts the hostapp information from the target state and
converts it to a target hostapp.

Change-type: patch

Author: pipex

helios-api/src/lib.rs

@@ -34,7 +34,7 @@ use helios_util::types::Uuid;
 // However that means that if at some point we want to support a new target state endpoint version,
 // the local API will change.
 // FIXME: define API specific input types and validations
-use helios_remote::types::AppTarget;
+use helios_remote::types::UserAppTarget as AppTarget;
 
 pub enum Listener {
     Tcp(TcpListener),

helios-integration-tests/src/lib.rs

@@ -121,8 +121,7 @@ mod tests {
                     }
                 }
             }
-        }
-        );
+        });
         let body = client
             .post(format!("{HELIOS_URL}/v3/device/apps/test-app"))
             .json(&target)

helios-remote-types/Cargo.toml

@@ -16,6 +16,7 @@ version.workspace = true
 helios-util = { path = "../helios-util", version = "0" }
 
 serde.workspace = true
+serde_json.workspace = true
 
 [dev-dependencies]
 serde_json.workspace = true

helios-remote-types/src/lib.rs

@@ -18,18 +18,155 @@ pub struct DeviceTarget {
     pub name: String,
 
     #[serde(default)]
-    pub apps: HashMap<Uuid, AppTarget>,
+    pub apps: AppTargetMap,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct AppTargetMap(HashMap<Uuid, AppTarget>);
+
+impl Deref for AppTargetMap {
+    type Target = HashMap<Uuid, AppTarget>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for AppTargetMap {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl IntoIterator for AppTargetMap {
+    type Item = (Uuid, AppTarget);
+    type IntoIter = std::collections::hash_map::IntoIter<Uuid, AppTarget>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+impl<'de> Deserialize<'de> for AppTargetMap {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize, Clone, Debug)]
+        struct RemoteAppTarget {
+            pub id: u32,
+            pub name: String,
+            #[serde(default)]
+            pub is_host: bool,
+            #[serde(default)]
+            pub releases: ReleaseTargetMap,
+        }
+
+        let mut apps: HashMap<Uuid, RemoteAppTarget> = HashMap::deserialize(deserializer)?;
+
+        // validate that there is only one hostapp, and it has the appropriate metadata
+        let hostapps: HashMap<Uuid, RemoteAppTarget> = apps
+            .iter()
+            .filter(|(_, app)| app.is_host)
+            .map(|(uuid, app)| (uuid.clone(), app.clone()))
+            .collect();
+
+        if hostapps.len() > 1 {
+            return Err(serde::de::Error::custom(
+                "only one target hostapp is allowed",
+            ));
+        }
+
+        if let Some((uuid, app)) = hostapps.into_iter().last() {
+            if app.releases.is_empty() {
+                return Err(serde::de::Error::custom(
+                    "the hostapp must have at least one target release",
+                ));
+            }
+
+            let release = app.releases.values().last().unwrap();
+            let hostapp = release.services.values().find(|svc| {
+                svc.labels
+                    .get("io.balena.image.class")
+                    .map(|value| value == "hostapp")
+                    .is_some()
+            });
+
+            if hostapp.is_none_or(|svc| {
+                !svc.labels
+                    .contains_key("io.balena.private.hostapp.board-rev")
+            }) {
+                // The target OS may not have a board revision as it may be
+                // before v6.1.18. We ignore the hostapp in that case
+                apps.remove(&uuid);
+            }
+        }
+
+        let apps = apps
+            .into_iter()
+            .map(|(app_uuid, app)| {
+                let RemoteAppTarget {
+                    id,
+                    name,
+                    releases,
+                    is_host,
+                } = app;
+                if !is_host {
+                    (
+                        app_uuid,
+                        AppTarget::User(UserAppTarget { id, name, releases }),
+                    )
+                } else {
+                    // we have already validated that the release exists
+                    let (release_uuid, release) = releases.into_iter().last().unwrap();
+                    let mut service = release
+                        .services
+                        .into_values()
+                        .find(|s| {
+                            s.labels
+                                .get("io.balena.image.class")
+                                .map(|v| v == "hostapp")
+                                .is_some()
+                        })
+                        .unwrap();
+
+                    let board_rev = service
+                        .labels
+                        .remove("io.balena.private.hostapp.board-rev")
+                        .unwrap();
+
+                    (
+                        app_uuid,
+                        AppTarget::Host(HostAppTarget {
+                            release_uuid,
+                            image: service.image,
+                            board_rev,
+                        }),
+                    )
+                }
+            })
+            .collect();
+
+        Ok(AppTargetMap(apps))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum AppTarget {
+    User(UserAppTarget),
+    Host(HostAppTarget),
+}
+
+#[derive(Clone, Debug)]
+pub struct HostAppTarget {
+    pub release_uuid: Uuid,
+    pub image: ImageUri,
+    pub board_rev: String,
 }
 
 /// Target app as defined by the remote backend
 #[derive(Deserialize, Clone, Debug)]
-pub struct AppTarget {
+pub struct UserAppTarget {
     pub id: u32,
     pub name: String,
-
-    #[serde(default)]
-    pub is_host: bool,
-
     #[serde(default)]
     pub releases: ReleaseTargetMap,
 }
@@ -94,6 +231,9 @@ pub struct ReleaseTarget {
 pub struct ServiceTarget {
     pub id: u32,
     pub image: ImageUri,
+
+    #[serde(default)]
+    pub labels: HashMap<String, String>,
 }
 
 // FIXME: add remaining fields
@@ -139,4 +279,43 @@ mod tests {
         let release = serde_json::from_value::<ReleaseTargetMap>(json);
         assert!(release.is_err());
     }
+
+    #[test]
+    fn test_rejects_target_apps_with_more_than_one_hostapp() {
+        let json = json!({
+            "app-one": {
+                "id": 1,
+                "name": "ubuntu",
+                "is_host": true,
+            },
+            "app-two": {
+                "id": 2,
+                "name": "fedora",
+                "is_host": true,
+            }
+        });
+
+        let apps = serde_json::from_value::<AppTargetMap>(json);
+        assert!(apps.is_err_and(|e| e.to_string() == "only one target hostapp is allowed"));
+    }
+
+    #[test]
+    fn test_rejects_target_apps_with_no_releases() {
+        let json = json!({
+            "app-one": {
+                "id": 1,
+                "name": "ubuntu",
+                "is_host": true,
+                "releases": {}
+            },
+
+        });
+
+        let apps = serde_json::from_value::<AppTargetMap>(json);
+        assert!(
+            apps.is_err_and(
+                |e| e.to_string() == "the hostapp must have at least one target release"
+            )
+        );
+    }
 }

helios-state/src/models/app.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 use crate::common_types::Uuid;
-use crate::remote_types::AppTarget as RemoteAppTarget;
+use crate::remote_types::UserAppTarget as RemoteAppTarget;
 
 use super::release::Release;
 

helios-state/src/models/device.rs

@@ -5,9 +5,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::common_types::{ImageUri, OperatingSystem, Uuid};
 use crate::oci::RegistryAuth;
-use crate::remote_types::DeviceTarget as RemoteDeviceTarget;
+use crate::remote_types::{AppTarget as RemoteAppTarget, DeviceTarget as RemoteDeviceTarget};
 
 use super::app::App;
+use super::hostapp::HostApp;
 use super::image::Image;
 
 pub type RegistryAuthSet = HashSet<RegistryAuth>;
@@ -41,6 +42,11 @@ pub struct Device {
     #[serde(default)]
     pub apps: BTreeMap<Uuid, App>,
 
+    /// The hostapp configuration
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    pub hostapp: Option<HostApp>,
+
     #[serde(default)]
     pub needs_cleanup: bool,
 }
@@ -54,6 +60,7 @@ impl Device {
             auths: RegistryAuthSet::new(),
             images: BTreeMap::new(),
             apps: BTreeMap::new(),
+            hostapp: None,
             needs_cleanup: false,
         }
     }
@@ -64,12 +71,14 @@ impl From<Device> for DeviceTarget {
         let Device {
             name,
             apps,
+            hostapp,
             needs_cleanup,
             ..
         } = device;
         Self {
             name,
             apps,
+            hostapp,
             needs_cleanup,
         }
     }
@@ -79,22 +88,32 @@ impl From<RemoteDeviceTarget> for DeviceTarget {
     fn from(tgt: RemoteDeviceTarget) -> Self {
         let RemoteDeviceTarget { name, apps, .. } = tgt;
 
-        // This makes user app support optional while the feature is being developed
-        let apps = if cfg!(feature = "userapps") {
-            apps.into_iter()
-                // filter host apps for now
-                .filter(|(_, app)| !app.is_host)
-                .map(|(uuid, app)| (uuid, app.into()))
-                .collect()
-        } else {
-            BTreeMap::new()
-        };
+        let mut userapps = BTreeMap::new();
+        let mut hostapps = Vec::new();
+        for (app_uuid, app) in apps {
+            match app {
+                // Read the hostapp info if it exists and the feature is enabled
+                RemoteAppTarget::Host(hostapp) => {
+                    if cfg!(feature = "balenahup") {
+                        hostapps.push((app_uuid, hostapp).into());
+                    }
+                }
+                // Read the userapp info if it exists and the feature is enabled
+                RemoteAppTarget::User(userapp) => {
+                    if cfg!(feature = "userapps") {
+                        userapps.insert(app_uuid, userapp.into());
+                    }
+                }
+            };
+        }
 
-        // TODO: process the hostapp target separately
+        // Get only the first hostapp if any
+        let hostapp = hostapps.pop();
 
         Self {
             name: Some(name),
-            apps,
+            apps: userapps,
+            hostapp,
             needs_cleanup: false,
         }
     }

helios-state/src/models/hostapp.rs

@@ -0,0 +1,52 @@
+use mahler::State;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use crate::common_types::{ImageUri, Uuid};
+use crate::remote_types::HostAppTarget as RemoteHostAppTarget;
+
+#[derive(State, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct HostApp {
+    /// The host app uuid
+    ///
+    /// The value will not be available on first boot (it's not provided by the host OS)
+    /// so it will be read from local storage
+    pub app_uuid: Uuid,
+
+    /// The host app release
+    ///
+    /// The value will not be available on first boot (it's not provided by the host OS)
+    /// so it will be read from local storage
+    pub release_uuid: Uuid,
+
+    /// The host app image
+    ///
+    /// This is needed for reporting and will be stored on local storage
+    pub image: ImageUri,
+
+    /// The board revision
+    ///
+    /// This is used for comparing with the target hostapp as the image digest cannot be used
+    pub board_rev: String,
+}
+
+#[derive(Error, Debug)]
+#[error("invalid hostapp: ${0}")]
+pub struct InvalidHostApp(&'static str);
+
+impl From<(Uuid, RemoteHostAppTarget)> for HostAppTarget {
+    fn from((app_uuid, app): (Uuid, RemoteHostAppTarget)) -> Self {
+        let RemoteHostAppTarget {
+            release_uuid,
+            image,
+            board_rev,
+        } = app;
+
+        HostAppTarget {
+            app_uuid,
+            release_uuid,
+            image,
+            board_rev,
+        }
+    }
+}