Merge pull request #51 from balena-io/refactor-host-info

Refactor `Device` type and accept `os-version` via the CLI

Author: flowzone-app[bot]

Cargo.lock

@@ -17,7 +17,7 @@ axum = { version = "0.8.4", default-features = false, features = [
   "json",
   "query",
 ] }
-tokio = { version = "1.46.1", default-features = false, features = [
+tokio = { version = "1.47.1", default-features = false, features = [
   "rt-multi-thread",
   "macros",
   "time",
@@ -27,7 +27,7 @@ tower-http = { version = "0.6.6", default-features = false, features = [
   "trace",
 ] }
 tracing = "0.1.41"
-tracing-subscriber = { version = "0.3.19", features = [
+tracing-subscriber = { version = "0.3.20", features = [
   "env-filter",
   "fmt",
   "registry",
@@ -45,13 +45,13 @@ thiserror = "2"
 rand = "0.9.2"
 clap = { version = "4.5", features = ["derive", "env"] }
 dirs = "6.0.0"
-uuid = { version = "1.17", features = ["v4"] }
-mahler = { version = "0.19.5" }
-bollard = "0.19.1"
+uuid = { version = "1.18", features = ["v4"] }
+mahler = { version = "0.19.6" }
+bollard = "0.19.2"
 sha2 = { version = "0.10.9", default-features = false }
 fastrand = "2.3.0"
-futures-lite = { version = "2.6.0", default-features = false }
-regex = "1.10"
+futures-lite = { version = "2.6.1", default-features = false }
+regex = "1.11"
 
 [dev-dependencies]
 mockito = { version = "1.7", default-features = false }

Cargo.toml

@@ -31,7 +31,15 @@ unset HELIOS_REMOTE_MIN_INTERVAL_MS
 # - io.balena.features.balena-api: '1'
 
 # Read configuration from BALENA_* variables
-HELIOS_DEVICE_UUID="${BALENA_DEVICE_UUID}"
+# Ignore any credentials env vars and use BALENA_DEVICE_UUID by default
+HELIOS_UUID="${BALENA_DEVICE_UUID}"
+export HELIOS_UUID
+unset HELIOS_REMOTE_API_KEY
+
+if [ -n "${BALENA_HOST_OS_VERSION}" ]; then
+  HELIOS_OS_VERSION="${BALENA_HOST_OS_VERSION}"
+  export HELIOS_OS_VERSION
+fi
 
 # Run in unmanaged mode if the legacy Supervisor is unmanaged
 if [ -n "${BALENA_API_URL}" ] && [ -n "${BALENA_API_KEY}" ]; then
@@ -57,4 +65,4 @@ export XDG_STATE_HOME=/local
 rm /tmp/run/helios.sock 2>/dev/null || true
 
 # Start the new supervisor
-exec helios --uuid "${HELIOS_DEVICE_UUID}" --local-api-address /tmp/run/helios.sock
+exec helios --local-api-address /tmp/run/helios.sock

scripts/start.sh

@@ -235,8 +235,6 @@ async fn set_app_tgt_state(
 
 #[cfg(test)]
 mod tests {
-    use crate::state::models::Host;
-
     use super::*;
     use serde_json::json;
     use tokio::net::TcpListener;
@@ -253,14 +251,7 @@ mod tests {
             raw_target: None,
         });
         let (poll_request_tx, poll_rx) = watch::channel(PollRequest::default());
-        let device = Device::new(
-            Uuid::default(),
-            Some("generic-aarch64".into()),
-            Host {
-                os: "balenaOS 6.3.1".into(),
-                arch: "aarch64".into(),
-            },
-        );
+        let device = Device::new(Uuid::default(), "balenaOS 6.3.1".parse().ok());
         let local_state = LocalState {
             device,
             status: UpdateStatus::default(),

src/api.rs

@@ -3,7 +3,7 @@ use std::num::ParseIntError;
 use std::time::Duration;
 
 use crate::api::LocalAddress;
-use crate::types::{ApiKey, Uuid};
+use crate::types::{ApiKey, OperatingSystem, Uuid};
 use crate::util::http::Uri;
 
 fn parse_duration(s: &str) -> Result<Duration, ParseIntError> {
@@ -18,6 +18,10 @@ pub struct Cli {
     #[arg(env = "HELIOS_UUID", long = "uuid", value_name = "uuid")]
     pub uuid: Option<Uuid>,
 
+    /// Host OS name and version with metadata, eg. "balenaOS 6.5.39+rev1"
+    #[arg(env = "HELIOS_OS_VERSION", long = "os-version", value_name = "str")]
+    pub os: Option<OperatingSystem>,
+
     /// Local API listen address
     #[arg(
         env = "HELIOS_LOCAL_API_ADDRESS",

src/cli.rs

@@ -12,7 +12,6 @@ use tracing_subscriber::{
     util::SubscriberInitExt,
     EnvFilter,
 };
-use types::DeviceType;
 
 mod api;
 mod cli;
@@ -29,7 +28,7 @@ use crate::legacy::{LegacyConfig, ProxyConfig, ProxyState};
 use crate::remote::{
     provision, ProvisioningConfig, ProvisioningError, RemoteConfig, RequestConfig,
 };
-use crate::types::Uuid;
+use crate::types::{OperatingSystem, Uuid};
 
 fn initialize_tracing() {
     // Initialize tracing subscriber for human-readable logs
@@ -43,6 +42,7 @@ fn initialize_tracing() {
                     .add_directive("mahler::planner=warn".parse().unwrap())
                     .add_directive("mahler::worker=debug".parse().unwrap())
                     .add_directive("hyper=error".parse().unwrap())
+                    .add_directive("reqwest=debug".parse().unwrap())
                     .add_directive("bollard=error".parse().unwrap()),
             ),
         )
@@ -82,17 +82,18 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 .expect("not nil because legacy_api_endpoint isn't nil"),
         });
 
-    let (uuid, remote_config, device_type) = maybe_provision(&cli).await?;
+    let (uuid, remote_config) = maybe_provision(&cli).await?;
+    let os = cli.os.clone();
 
-    start_supervisor(uuid, device_type, api_config, remote_config, legacy_config).await?;
+    start_supervisor(uuid, os, api_config, remote_config, legacy_config).await?;
 
     Ok(())
 }
 
 #[instrument(name = "helios", skip_all, err)]
 async fn start_supervisor(
     uuid: Uuid,
-    device_type: Option<DeviceType>,
+    os: Option<OperatingSystem>,
     api_config: Option<ApiConfig>,
     remote_config: Option<RemoteConfig>,
     legacy_config: Option<LegacyConfig>,
@@ -107,7 +108,7 @@ async fn start_supervisor(
 
     // Load the initial state
     let docker = Docker::connect_with_defaults()?;
-    let initial_state = state::read(&docker, uuid.clone(), device_type).await?;
+    let initial_state = state::read(&docker, uuid.clone(), os).await?;
 
     let registry_auth = remote_config.clone().map(RegistryAuthClient::new);
 
@@ -227,9 +228,7 @@ where
 /// If `remote_config` is not nil, then we are registered with a remote.
 /// If `remote_config` is nil, then we aren't registered and need to provision.
 /// If `remote_config` is still nil after provisioning, then we'll run in "unmanaged" mode.
-async fn maybe_provision(
-    cli: &Cli,
-) -> Result<(Uuid, Option<RemoteConfig>, Option<DeviceType>), ProvisioningError> {
+async fn maybe_provision(cli: &Cli) -> Result<(Uuid, Option<RemoteConfig>), ProvisioningError> {
     // Load our provisioning config, if one exists
     let provisioning_config = config::get::<ProvisioningConfig>()?;
 
@@ -266,7 +265,7 @@ async fn maybe_provision(
             );
         }
 
-        Ok((uuid.clone(), Some(remote), None))
+        Ok((uuid.clone(), Some(remote)))
     }
     // Otherwise use an existing provisioning config, if available
     else if let Some(ref provisioning_config) = &provisioning_config {
@@ -291,7 +290,6 @@ async fn maybe_provision(
         }
 
         let uuid = &provisioning_config.uuid;
-        let device_type = provisioning_config.device_type.clone();
         let request_defaults = &provisioning_config.remote.request;
         let remote = RemoteConfig {
             request: RequestConfig {
@@ -311,7 +309,7 @@ async fn maybe_provision(
             ..provisioning_config.remote.clone()
         };
 
-        Ok((uuid.clone(), Some(remote), Some(device_type)))
+        Ok((uuid.clone(), Some(remote)))
     }
     // We have a provisioning key
     else if let Some(provisioning_key) = &cli.provisioning_key {
@@ -355,13 +353,13 @@ async fn maybe_provision(
             },
         };
 
-        let (uuid, remote, device_type) = provision(provisioning_key, &provisioning_config).await?;
+        let (uuid, remote, _) = provision(provisioning_key, &provisioning_config).await?;
 
-        Ok((uuid, Some(remote), Some(device_type)))
+        Ok((uuid, Some(remote)))
     }
     // We don't have a remote at all; run in "unmanaged" mode
     else {
         // Generate a UUID if none provided
-        Ok((cli.uuid.clone().unwrap_or_default(), None, None))
+        Ok((cli.uuid.clone().unwrap_or_default(), None))
     }
 }

src/main.rs

@@ -150,20 +150,13 @@ pub async fn start_report(config: RemoteConfig, mut state_rx: Receiver<LocalStat
 mod tests {
     use serde_json::json;
 
-    use crate::state::models::{Device, Host};
+    use crate::state::models::Device;
 
     use super::*;
 
     #[test]
     fn it_creates_a_device_report_from_a_device() {
-        let device = Device::new(
-            "test-uuid".into(),
-            Some("generic-aarch64".into()),
-            Host {
-                os: "balenaOS 5.3.1".into(),
-                arch: "aarch64".into(),
-            },
-        );
+        let device = Device::new("test-uuid".into(), "balenaOS 5.3.1".parse().ok());
 
         let report = Report::from(LocalState {
             status: crate::state::UpdateStatus::Done,

src/remote/report.rs

@@ -2,39 +2,14 @@ use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashSet};
 
 use crate::remote::RegistryAuth;
-use crate::types::{DeviceType, Uuid};
+use crate::types::{OperatingSystem, Uuid};
 use crate::util::docker::ImageUri;
 
 use super::app::{App, TargetAppMap};
 use super::image::Image;
 
 pub type DeviceConfig = BTreeMap<String, String>;
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Host {
-    pub os: String,
-    pub arch: String,
-}
-
-impl Default for Host {
-    fn default() -> Self {
-        // See list in https://doc.rust-lang.org/std/env/consts/constant.ARCH.html
-        let arch: String = match std::env::consts::ARCH {
-            "x86" => "i386",
-            "x86_64" => "amd64",
-            "arm" => "armv7hf",
-            "aarch64" => "aarch64",
-            other => other,
-        }
-        .into();
-
-        // See list in https://doc.rust-lang.org/std/env/consts/constant.OS.html
-        let os: String = std::env::consts::OS.into();
-
-        Self { os, arch }
-    }
-}
-
 pub type RegistryAuthSet = HashSet<RegistryAuth>;
 
 /// The current state of a device that will be stored
@@ -47,13 +22,8 @@ pub struct Device {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
 
-    /// The device type accepted by the backend
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub device_type: Option<String>,
-
-    /// Host system info
-    #[serde(default)]
-    pub host: Host,
+    pub os: Option<OperatingSystem>,
 
     #[serde(default)]
     pub auths: RegistryAuthSet,
@@ -75,12 +45,11 @@ pub struct Device {
 }
 
 impl Device {
-    pub fn new(uuid: Uuid, device_type: Option<DeviceType>, host: Host) -> Self {
+    pub fn new(uuid: Uuid, os: Option<OperatingSystem>) -> Self {
         Self {
             uuid,
             name: None,
-            device_type,
-            host,
+            os,
             auths: RegistryAuthSet::new(),
             images: BTreeMap::new(),
             apps: BTreeMap::new(),
@@ -140,9 +109,9 @@ mod tests {
     fn device_state_should_be_serializable_into_target() {
         let json = json!({
             "uuid": "device-uuid",
-            "host": {
-                "os": "balenaOS 6.3.1",
-                "arch": "aarch64"
+            "os": {
+                "name": "balenaOS",
+                "version": "6.5.4",
             },
             "apps": {
                 "aaa": {

src/state/models/device.rs

@@ -1,12 +1,11 @@
-use bollard::secret::SystemInfo;
 use bollard::{query_parameters::ListImagesOptions, Docker};
 use thiserror::Error;
 use tracing::instrument;
 
-use crate::types::Uuid;
+use crate::types::{OperatingSystem, Uuid};
 use crate::util::docker::{ImageUri, InvalidImageUriError};
 
-use super::models::{Device, Host, Image};
+use super::models::{Device, Image};
 
 #[derive(Debug, Error)]
 pub enum ReadStateError {
@@ -17,50 +16,14 @@ pub enum ReadStateError {
     InvalidRegistryUri(#[from] InvalidImageUriError),
 }
 
-// Convert an architecture from the string returned by he engine
-// to a balenaCloud accepted engine
-fn parse_engine_arch(arch: String) -> Option<String> {
-    // In theory, the list of possible architectures is limited to
-    // https://go.dev/doc/install/source#environment
-    // however in practice, some systems use more specific architecture strings
-    // such as armv6l and armv7l
-    let arch = match arch.as_ref() {
-        "amd64" => "amd64",
-        "arm64" => "aarch644",
-        "386" => "i386",
-        "arm" => "armv7hf",
-        "armv6l" => "rpi",
-        "armv7l" => "armv7hf",
-        _ => return None,
-    };
-
-    Some(arch.into())
-}
-
 /// Read the state of system
 #[instrument(name = "read_state", skip_all)]
 pub async fn read(
     docker: &Docker,
     uuid: Uuid,
-    device_type: Option<String>,
+    os: Option<OperatingSystem>,
 ) -> Result<Device, ReadStateError> {
-    let SystemInfo {
-        operating_system,
-        architecture,
-        ..
-    } = docker.info().await?;
-
-    // XXX: I would like to get the engine name and version but the results
-    // of the /version endpoint are not consistent accross engines
-    let default_host = Host::default();
-    let host = Host {
-        os: operating_system.unwrap_or(default_host.os),
-        arch: architecture
-            .and_then(parse_engine_arch)
-            .unwrap_or(default_host.arch),
-    };
-
-    let mut device = Device::new(uuid, device_type, host);
+    let mut device = Device::new(uuid, os);
 
     let installed_images = docker
         .list_images(Some(ListImagesOptions {