Add a new API to handle issues (#2775)

Add a new service to handle issues in the new API. The new service
allows any other one to register its issues.

## Registering issues

A service that needs to register issues, receives an
`agama_utils::actor::Handler<agama_utils::issue::Service>`. It can
update the list of issues through the
[Update](https://github.com/agama-project/agama/pull/2775/files#diff-473781875264b7e4d4e408a101a973115f312b6305deff38a2d6e135cdc88082R33)
action.

## Dealing with D-Bus services

The new service reads the issues from the D-Bus services too. When
booting, it reads the existing issues and starts listening for changes
on the `org.opensuse.Agama1.Issues` interfaces.

## Localization issues

As part of this PR, the localization service reports issues now in case
of a locale, keymap or timezone is unknown.

## Adapted UI

The code to deal with the issues in the web UI has been adapted to the
new API.

## Other smaller changes

- Make `*_db` functions in `ModelAdapter` to return references instead
of mutable references.
- In a `TimezoneEntry`, rename `code` to `id` for consistency.
Additionally, use `TimezoneId` instead of a string.

Author: imobachgs

rust/Cargo.lock

@@ -73,7 +73,7 @@ impl<T> SetConfig<T> {
 pub struct GetProposal;
 
 impl Message for GetProposal {
-    type Reply = Proposal;
+    type Reply = Option<Proposal>;
 }
 
 pub struct Install;

rust/agama-l10n/src/message.rs

@@ -39,13 +39,13 @@ use std::{env, fs::OpenOptions, io::Write, process::Command};
 /// tests.
 pub trait ModelAdapter: Send + 'static {
     /// Locales database.
-    fn locales_db(&mut self) -> &mut LocalesDatabase;
+    fn locales_db(&self) -> &LocalesDatabase;
 
     /// Timezones database.
-    fn timezones_db(&mut self) -> &mut TimezonesDatabase;
+    fn timezones_db(&self) -> &TimezonesDatabase;
 
     /// Keymaps database.
-    fn keymaps_db(&mut self) -> &mut KeymapsDatabase;
+    fn keymaps_db(&self) -> &KeymapsDatabase;
 
     /// Current system locale.
     fn locale(&self) -> LocaleId;
@@ -67,9 +67,9 @@ pub trait ModelAdapter: Send + 'static {
     /// at the end of the installation.
     fn install(
         &self,
-        _locale: LocaleId,
-        _keymap: KeymapId,
-        _timezone: TimezoneId,
+        _locale: &LocaleId,
+        _keymap: &KeymapId,
+        _timezone: &TimezoneId,
     ) -> Result<(), service::Error> {
         Ok(())
     }
@@ -110,15 +110,15 @@ impl Model {
 }
 
 impl ModelAdapter for Model {
-    fn locales_db(&mut self) -> &mut LocalesDatabase {
-        &mut self.locales_db
+    fn locales_db(&self) -> &LocalesDatabase {
+        &self.locales_db
     }
-    fn timezones_db(&mut self) -> &mut TimezonesDatabase {
-        &mut self.timezones_db
+    fn timezones_db(&self) -> &TimezonesDatabase {
+        &self.timezones_db
     }
 
-    fn keymaps_db(&mut self) -> &mut KeymapsDatabase {
-        &mut self.keymaps_db
+    fn keymaps_db(&self) -> &KeymapsDatabase {
+        &self.keymaps_db
     }
 
     fn keymap(&self) -> Result<KeymapId, service::Error> {
@@ -172,9 +172,9 @@ impl ModelAdapter for Model {
 
     fn install(
         &self,
-        locale: LocaleId,
-        keymap: KeymapId,
-        timezone: TimezoneId,
+        locale: &LocaleId,
+        keymap: &KeymapId,
+        timezone: &TimezoneId,
     ) -> Result<(), service::Error> {
         const ROOT: &str = "/mnt";
         const VCONSOLE_CONF: &str = "/etc/vconsole.conf";

rust/agama-l10n/src/model.rs

@@ -59,7 +59,7 @@ impl LocalesDatabase {
     #[cfg(test)]
     pub fn with_entries(data: &[LocaleEntry]) -> Self {
         Self {
-            known_locales: vec![],
+            known_locales: data.iter().map(|l| l.id.clone()).collect(),
             locales: data.to_vec(),
         }
     }

rust/agama-l10n/src/model/locale.rs

@@ -20,16 +20,15 @@
 
 //! This module provides support for reading the timezones database.
 
-use agama_locale_data::territory::Territories;
-use agama_locale_data::timezone_part::TimezoneIdParts;
+use agama_locale_data::{territory::Territories, timezone_part::TimezoneIdParts, TimezoneId};
 use serde::Serialize;
 use std::collections::HashMap;
 
 /// Represents a timezone, including each part as localized.
 #[derive(Clone, Debug, Serialize, utoipa::ToSchema)]
 pub struct TimezoneEntry {
     /// Timezone identifier (e.g. "Atlantic/Canary").
-    pub code: String,
+    pub id: TimezoneId,
     /// Localized parts (e.g., "Atlántico", "Canarias").
     pub parts: Vec<String>,
     /// Localized name of the territory this timezone is associated to
@@ -62,8 +61,8 @@ impl TimezonesDatabase {
     }
 
     /// Determines whether a timezone exists in the database.
-    pub fn exists(&self, timezone: &String) -> bool {
-        self.timezones.iter().any(|t| &t.code == timezone)
+    pub fn exists(&self, timezone: &TimezoneId) -> bool {
+        self.timezones.iter().any(|t| &t.id == timezone)
     }
 
     /// Returns the list of timezones.
@@ -87,15 +86,17 @@ impl TimezonesDatabase {
         let ret = timezones
             .into_iter()
             .filter_map(|tz| {
-                let parts = translate_parts(&tz, ui_language, &tz_parts);
-                let country = translate_country(&tz, ui_language, &tz_countries, &territories);
+                tz.parse::<TimezoneId>()
+                    .inspect_err(|e| println!("Ignoring timezone {tz}: {e}"))
+                    .ok()
+            })
+            .filter_map(|id| {
+                let parts = translate_parts(id.as_str(), ui_language, &tz_parts);
+                let country =
+                    translate_country(id.as_str(), ui_language, &tz_countries, &territories);
                 match country {
-                    None if !COUNTRYLESS.contains(&tz.as_str()) => None,
-                    _ => Some(TimezoneEntry {
-                        code: tz,
-                        parts,
-                        country,
-                    }),
+                    None if !COUNTRYLESS.contains(&id.as_str()) => None,
+                    _ => Some(TimezoneEntry { id, parts, country }),
                 }
             })
             .collect();
@@ -143,9 +144,9 @@ mod tests {
         let found_timezones = db.entries();
         let found = found_timezones
             .iter()
-            .find(|tz| tz.code == "Europe/Berlin")
+            .find(|tz| tz.id.as_str() == "Europe/Berlin")
             .unwrap();
-        assert_eq!(&found.code, "Europe/Berlin");
+        assert_eq!(found.id.as_str(), "Europe/Berlin");
         assert_eq!(
             found.parts,
             vec!["Europa".to_string(), "Berlín".to_string()]
@@ -157,7 +158,11 @@ mod tests {
     fn test_read_timezone_without_country() {
         let mut db = TimezonesDatabase::new();
         db.read("es").unwrap();
-        let timezone = db.entries().iter().find(|tz| tz.code == "UTC").unwrap();
+        let timezone = db
+            .entries()
+            .iter()
+            .find(|tz| tz.id.as_str() == "UTC")
+            .unwrap();
         assert_eq!(timezone.country, None);
     }
 
@@ -168,7 +173,7 @@ mod tests {
         let timezone = db
             .entries()
             .iter()
-            .find(|tz| tz.code == "Europe/Kiev")
+            .find(|tz| tz.id.as_str() == "Europe/Kiev")
             .unwrap();
         assert_eq!(timezone.country, Some("Ukraine".to_string()));
     }
@@ -177,7 +182,9 @@ mod tests {
     fn test_timezone_exists() {
         let mut db = TimezonesDatabase::new();
         db.read("es").unwrap();
-        assert!(db.exists(&"Atlantic/Canary".to_string()));
-        assert!(!db.exists(&"Unknown/Unknown".to_string()));
+        let canary = "Atlantic/Canary".parse().unwrap();
+        let unknown = "Unknown/Unknown".parse().unwrap();
+        assert!(db.exists(&canary));
+        assert!(!db.exists(&unknown));
     }
 }

rust/agama-l10n/src/model/timezone.rs

@@ -28,7 +28,10 @@ use crate::{
     system_info::SystemInfo,
 };
 use agama_locale_data::{InvalidKeymapId, InvalidLocaleId, InvalidTimezoneId, KeymapId, LocaleId};
-use agama_utils::actor::{self, Actor, MessageHandler};
+use agama_utils::{
+    actor::{self, Actor, Handler, MessageHandler},
+    issue::{self, Issue},
+};
 use async_trait::async_trait;
 
 #[derive(thiserror::Error, Debug)]
@@ -39,11 +42,11 @@ pub enum Error {
     UnknownKeymap(KeymapId),
     #[error("Unknown timezone: {0}")]
     UnknownTimezone(String),
-    #[error("Invalid locale: {0}")]
+    #[error(transparent)]
     InvalidLocale(#[from] InvalidLocaleId),
-    #[error("Invalid keymap: {0}")]
+    #[error(transparent)]
     InvalidKeymap(#[from] InvalidKeymapId),
-    #[error("Invalid timezone")]
+    #[error(transparent)]
     InvalidTimezone(#[from] InvalidTimezoneId),
     #[error("l10n service could not send the event")]
     Event,
@@ -53,31 +56,92 @@ pub enum Error {
     IO(#[from] std::io::Error),
     #[error(transparent)]
     Generic(#[from] anyhow::Error),
+    #[error("There is no proposal for localization")]
+    MissingProposal,
 }
 
+/// Localization service.
+///
+/// It is responsible for handling the localization part of the installation:
+///
+/// * Reads the list of known locales, keymaps and timezones.
+/// * Keeps track of the localization settings of the underlying system (the installer).
+/// * Holds the user configuration.
+/// * Applies the user configuration at the end of the installation.
 pub struct Service {
     state: State,
     model: Box<dyn ModelAdapter + Send + 'static>,
+    issues: Handler<issue::Service>,
     events: event::Sender,
 }
 
 struct State {
     system: SystemInfo,
     config: ExtendedConfig,
+    proposal: Option<Proposal>,
 }
 
 impl Service {
-    pub fn new<T: ModelAdapter + Send + 'static>(mut model: T, events: event::Sender) -> Service {
-        let system = SystemInfo::read_from(&mut model);
+    pub fn new<T: ModelAdapter + Send + 'static>(
+        model: T,
+        issues: Handler<issue::Service>,
+        events: event::Sender,
+    ) -> Service {
+        let system = SystemInfo::read_from(&model);
         let config = ExtendedConfig::new_from(&system);
-        let state = State { system, config };
+        let proposal = (&config).into();
+        let state = State {
+            system,
+            config,
+            proposal: Some(proposal),
+        };
 
         Self {
             state,
             model: Box::new(model),
+            issues,
             events,
         }
     }
+
+    /// Returns configuration issues.
+    ///
+    /// It returns an issue for each unknown element (locale, keymap and timezone).
+    fn find_issues(&self) -> Vec<Issue> {
+        let config = &self.state.config;
+        let mut issues = vec![];
+        if !self.model.locales_db().exists(&config.locale) {
+            issues.push(Issue {
+                description: format!("Locale '{}' is unknown", &config.locale),
+                details: None,
+                source: issue::IssueSource::Config,
+                severity: issue::IssueSeverity::Error,
+                kind: "unknown_locale".to_string(),
+            });
+        }
+
+        if !self.model.keymaps_db().exists(&config.keymap) {
+            issues.push(Issue {
+                description: format!("Keymap '{}' is unknown", &config.keymap),
+                details: None,
+                source: issue::IssueSource::Config,
+                severity: issue::IssueSeverity::Error,
+                kind: "unknown_keymap".to_string(),
+            });
+        }
+
+        if !self.model.timezones_db().exists(&config.timezone) {
+            issues.push(Issue {
+                description: format!("Timezone '{}' is unknown", &config.timezone),
+                details: None,
+                source: issue::IssueSource::Config,
+                severity: issue::IssueSeverity::Error,
+                kind: "unknown_timezone".to_string(),
+            });
+        }
+
+        issues
+    }
 }
 
 impl Actor for Service {
@@ -121,28 +185,43 @@ impl MessageHandler<message::GetConfig> for Service {
 impl MessageHandler<message::SetConfig<Config>> for Service {
     async fn handle(&mut self, message: message::SetConfig<Config>) -> Result<(), Error> {
         let merged = self.state.config.merge(&message.config)?;
-        if merged != self.state.config {
-            self.state.config = merged;
-            _ = self.events.send(Event::ProposalChanged);
+        if merged == self.state.config {
+            return Ok(());
         }
+
+        self.state.config = merged;
+        let issues = self.find_issues();
+
+        self.state.proposal = if issues.is_empty() {
+            Some((&self.state.config).into())
+        } else {
+            None
+        };
+
+        _ = self
+            .issues
+            .cast(issue::message::Update::new("localization", issues));
+        _ = self.events.send(Event::ProposalChanged);
         Ok(())
     }
 }
 
 #[async_trait]
 impl MessageHandler<message::GetProposal> for Service {
-    async fn handle(&mut self, _message: message::GetProposal) -> Result<Proposal, Error> {
-        Ok((&self.state.config).into())
+    async fn handle(&mut self, _message: message::GetProposal) -> Result<Option<Proposal>, Error> {
+        Ok(self.state.proposal.clone())
     }
 }
 
 #[async_trait]
 impl MessageHandler<message::Install> for Service {
     async fn handle(&mut self, _message: message::Install) -> Result<(), Error> {
-        let proposal: Proposal = (&self.state.config).into();
+        let Some(proposal) = &self.state.proposal else {
+            return Err(Error::MissingProposal);
+        };
+
         self.model
-            .install(proposal.locale, proposal.keymap, proposal.timezone)
-            .unwrap();
+            .install(&proposal.locale, &proposal.keymap, &proposal.timezone)?;
         Ok(())
     }
 }