Report storage issues

Author: joseivanlopez

rust/agama-l10n/src/service.rs

@@ -123,7 +123,7 @@ impl Service {
                 details: None,
                 source: IssueSource::Config,
                 severity: IssueSeverity::Error,
-                kind: "unknown_locale".to_string(),
+                class: "unknown_locale".to_string(),
             });
         }
 
@@ -133,7 +133,7 @@ impl Service {
                 details: None,
                 source: IssueSource::Config,
                 severity: IssueSeverity::Error,
-                kind: "unknown_keymap".to_string(),
+                class: "unknown_keymap".to_string(),
             });
         }
 
@@ -143,7 +143,7 @@ impl Service {
                 details: None,
                 source: IssueSource::Config,
                 severity: IssueSeverity::Error,
-                kind: "unknown_timezone".to_string(),
+                class: "unknown_timezone".to_string(),
             });
         }
 
@@ -210,7 +210,7 @@ impl MessageHandler<message::SetConfig<api::l10n::Config>> for Service {
         self.config = config;
         let issues = self.find_issues();
         self.issues
-            .cast(issue::message::Update::new(Scope::L10n, issues))?;
+            .cast(issue::message::Set::new(Scope::L10n, issues))?;
         self.events
             .send(Event::ProposalChanged { scope: Scope::L10n })?;
         Ok(())

rust/agama-manager/src/start.rs

@@ -50,7 +50,7 @@ pub async fn start(
     let issues = issue::start(events.clone(), dbus.clone()).await?;
     let progress = progress::start(events.clone()).await?;
     let l10n = l10n::start(issues.clone(), events.clone()).await?;
-    let storage = storage::start(progress.clone(), events.clone(), dbus).await?;
+    let storage = storage::start(progress.clone(), issues.clone(), events.clone(), dbus).await?;
 
     let service = Service::new(l10n, storage, issues, progress, questions, events);
     let handler = actor::spawn(service);

rust/agama-storage/src/client.rs

@@ -21,6 +21,7 @@
 //! Implements a client to access Agama's storage service.
 
 use crate::config::Config;
+use agama_utils::api::Issue;
 use serde_json::{value::RawValue, Value};
 use zbus::{names::BusName, zvariant::OwnedObjectPath, Connection, Message};
 
@@ -73,27 +74,27 @@ impl Client {
 
     pub async fn get_system(&self) -> Result<Option<Box<RawValue>>, Error> {
         let message = self.call("GetSystem", &()).await?;
-        self.json_from(message)
+        try_from_message(message)
     }
 
     pub async fn get_config(&self) -> Result<Option<Config>, Error> {
         let message = self.call("GetConfig", &()).await?;
-        self.json_from(message)
+        try_from_message(message)
     }
 
     pub async fn get_config_model(&self) -> Result<Option<Box<RawValue>>, Error> {
         let message = self.call("GetConfigModel", &()).await?;
-        self.json_from(message)
+        try_from_message(message)
     }
 
     pub async fn get_proposal(&self) -> Result<Option<Box<RawValue>>, Error> {
         let message = self.call("GetProposal", &()).await?;
-        self.json_from(message)
+        try_from_message(message)
     }
 
-    pub async fn get_issues(&self) -> Result<Option<Box<RawValue>>, Error> {
+    pub async fn get_issues(&self) -> Result<Vec<Issue>, Error> {
         let message = self.call("GetIssues", &()).await?;
-        self.json_from(message)
+        try_from_message(message)
     }
 
     //TODO: send a product config instead of an id.
@@ -119,7 +120,7 @@ impl Client {
         model: Box<RawValue>,
     ) -> Result<Option<Box<RawValue>>, Error> {
         let message = self.call("SolveConfigModel", &(model.to_string())).await?;
-        self.json_from(message)
+        try_from_message(message)
     }
 
     pub async fn set_locale(&self, locale: String) -> Result<(), Error> {
@@ -139,25 +140,24 @@ impl Client {
             .await
             .map_err(|e| e.into())
     }
+}
 
-    fn json_from<T: serde::de::DeserializeOwned>(
-        &self,
-        message: Message,
-    ) -> Result<Option<T>, Error> {
-        let value: String = message.body().deserialize()?;
-        if self.is_null(value.as_str()) {
-            return Ok(None);
-        }
-        let json = serde_json::from_str(value.as_str())?;
-        Ok(Some(json))
-    }
-
-    fn is_null(&self, value: &str) -> bool {
-        let value = serde_json::from_str::<Value>(value);
-        match value {
-            Ok(Value::Null) => true,
-            Ok(_) => false,
-            Err(_) => false,
-        }
+fn try_from_message<T: serde::de::DeserializeOwned + Default>(
+    message: Message,
+) -> Result<T, Error> {
+    let json: String = message.body().deserialize()?;
+    if is_json_null(&json) {
+        return Ok(T::default());
+    }
+    let value = serde_json::from_str(&json)?;
+    Ok(value)
+}
+
+fn is_json_null(value: &str) -> bool {
+    let value = serde_json::from_str::<Value>(value);
+    match value {
+        Ok(Value::Null) => true,
+        Ok(_) => false,
+        Err(_) => false,
     }
 }

rust/agama-storage/src/message.rs

@@ -19,7 +19,7 @@
 // find current contact information at www.suse.com.
 
 use crate::config::Config;
-use agama_utils::actor::Message;
+use agama_utils::{actor::Message, api::Issue};
 use serde_json::value::RawValue;
 
 #[derive(Clone)]
@@ -78,6 +78,13 @@ impl Message for GetProposal {
     type Reply = Option<Box<RawValue>>;
 }
 
+#[derive(Clone)]
+pub struct GetIssues;
+
+impl Message for GetIssues {
+    type Reply = Vec<Issue>;
+}
+
 #[derive(Clone)]
 pub struct SetProduct {
     pub id: String,

rust/agama-storage/src/monitor.rs

@@ -18,13 +18,17 @@
 // To contact SUSE LLC about this file by physical or electronic mail, you may
 // find current contact information at www.suse.com.
 
+use crate::{
+    message,
+    service::{self, Service},
+};
 use agama_utils::{
     actor::Handler,
     api::{
         event::{self, Event},
         Progress, Scope,
     },
-    progress::{self, message},
+    issue, progress,
 };
 use serde::Deserialize;
 use serde_json;
@@ -40,6 +44,10 @@ pub enum Error {
     #[error("Wrong signal data")]
     ProgressChangedData,
     #[error(transparent)]
+    Service(#[from] service::Error),
+    #[error(transparent)]
+    Issue(#[from] issue::service::Error),
+    #[error(transparent)]
     Progress(#[from] progress::service::Error),
     #[error(transparent)]
     DBus(#[from] zbus::Error),
@@ -96,19 +104,25 @@ impl From<ProgressData> for Progress {
 }
 
 pub struct Monitor {
+    storage: Handler<Service>,
     progress: Handler<progress::Service>,
+    issues: Handler<issue::Service>,
     events: event::Sender,
     connection: Connection,
 }
 
 impl Monitor {
     pub fn new(
+        storage: Handler<Service>,
         progress: Handler<progress::Service>,
+        issues: Handler<issue::Service>,
         events: event::Sender,
         connection: Connection,
     ) -> Self {
         Self {
+            storage,
             progress,
+            issues,
             events,
             connection,
         }
@@ -124,16 +138,16 @@ impl Monitor {
         tokio::pin!(streams);
 
         while let Some((_, signal)) = streams.next().await {
-            self.handle_signal(signal)?;
+            self.handle_signal(signal).await?;
         }
 
         Ok(())
     }
 
-    fn handle_signal(&self, signal: Signal) -> Result<(), Error> {
+    async fn handle_signal(&self, signal: Signal) -> Result<(), Error> {
         match signal {
             Signal::SystemChanged(signal) => self.handle_system_changed(signal)?,
-            Signal::ProposalChanged(signal) => self.handle_proposal_changed(signal)?,
+            Signal::ProposalChanged(signal) => self.handle_proposal_changed(signal).await?,
             Signal::ProgressChanged(signal) => self.handle_progress_changed(signal)?,
             Signal::ProgressFinished(signal) => self.handle_progress_finished(signal)?,
         }
@@ -147,10 +161,16 @@ impl Monitor {
         Ok(())
     }
 
-    fn handle_proposal_changed(&self, _signal: ProposalChanged) -> Result<(), Error> {
+    async fn handle_proposal_changed(&self, _signal: ProposalChanged) -> Result<(), Error> {
         self.events.send(Event::ProposalChanged {
             scope: Scope::Storage,
         })?;
+
+        let issues = self.storage.call(message::GetIssues).await?;
+        self.issues
+            .call(issue::message::Set::new(Scope::Storage, issues))
+            .await?;
+
         Ok(())
     }
 
@@ -162,13 +182,14 @@ impl Monitor {
             return Err(Error::ProgressChangedData);
         };
         self.progress
-            .cast(message::Set::new(progress_data.into()))?;
+            .cast(progress::message::Set::new(progress_data.into()))?;
 
         Ok(())
     }
 
     fn handle_progress_finished(&self, _signal: ProgressFinished) -> Result<(), Error> {
-        self.progress.cast(message::Finish::new(Scope::Storage))?;
+        self.progress
+            .cast(progress::message::Finish::new(Scope::Storage))?;
         Ok(())
     }
 

rust/agama-storage/src/service.rs

@@ -23,7 +23,11 @@ use crate::{
     config::Config,
     message,
 };
-use agama_utils::actor::{self, Actor, MessageHandler};
+use agama_utils::{
+    actor::{self, Actor, Handler, MessageHandler},
+    api::{Issue, Scope},
+    issue,
+};
 use async_trait::async_trait;
 use serde_json::value::RawValue;
 
@@ -33,19 +37,31 @@ pub enum Error {
     Actor(#[from] actor::Error),
     #[error(transparent)]
     Client(#[from] client::Error),
+    #[error(transparent)]
+    Issue(#[from] issue::service::Error),
 }
 
 /// Storage service.
 pub struct Service {
+    issues: Handler<issue::Service>,
     client: Client,
 }
 
 impl Service {
-    pub fn new(connection: zbus::Connection) -> Service {
+    pub fn new(issues: Handler<issue::Service>, connection: zbus::Connection) -> Service {
         Self {
+            issues,
             client: Client::new(connection),
         }
     }
+
+    pub async fn start(self) -> Result<Self, Error> {
+        let issues = self.client.get_issues().await?;
+        self.issues
+            .call(issue::message::Set::new(Scope::Storage, issues))
+            .await?;
+        Ok(self)
+    }
 }
 
 impl Actor for Service {
@@ -121,6 +137,13 @@ impl MessageHandler<message::GetProposal> for Service {
     }
 }
 
+#[async_trait]
+impl MessageHandler<message::GetIssues> for Service {
+    async fn handle(&mut self, _message: message::GetIssues) -> Result<Vec<Issue>, Error> {
+        self.client.get_issues().await.map_err(|e| e.into())
+    }
+}
+
 #[async_trait]
 impl MessageHandler<message::SetProduct> for Service {
     async fn handle(&mut self, message: message::SetProduct) -> Result<(), Error> {

rust/agama-storage/src/start.rs

@@ -20,32 +20,34 @@
 
 use crate::{
     monitor::{self, Monitor},
-    service::Service,
+    service::{self, Service},
 };
 use agama_utils::{
     actor::{self, Handler},
     api::event,
-    progress,
+    issue, progress,
 };
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error(transparent)]
     Monitor(#[from] monitor::Error),
+    #[error(transparent)]
+    Service(#[from] service::Error),
 }
 
 /// Starts the storage service.
-///
-/// * `dbus`: connection to Agama's D-Bus server.
 pub async fn start(
     progress: Handler<progress::Service>,
+    issues: Handler<issue::Service>,
     events: event::Sender,
     dbus: zbus::Connection,
 ) -> Result<Handler<Service>, Error> {
-    let monitor = Monitor::new(progress, events, dbus.clone());
+    let service = Service::new(issues.clone(), dbus.clone()).start().await?;
+    let handler = actor::spawn(service);
+
+    let monitor = Monitor::new(handler.clone(), progress, issues, events, dbus);
     monitor::spawn(monitor)?;
 
-    let service = Service::new(dbus);
-    let handler = actor::spawn(service);
     Ok(handler)
 }