feat(ui): block on external storage changes

rust/agama-lib/Cargo.toml

@@ -45,6 +45,7 @@ fluent-uri = { version = "0.3.2", features = ["serde"] }
 tokio-tungstenite = { version = "0.26.2", features = ["native-tls"] }
 tokio-native-tls = "0.3.1"
 percent-encoding = "2.3.1"
+uuid = { version = "1.17.0", features = ["serde", "v4"] }
 
 [dev-dependencies]
 httpmock = "0.7.0"

rust/agama-lib/src/auth.rs

@@ -45,7 +45,7 @@ const USER_TOKEN_PATH: &str = ".local/agama/token";
 const AGAMA_TOKEN_FILE: &str = "/run/agama/token";
 
 use std::{
-    fmt::Display,
+    fmt,
     fs::{self, File},
     io::{self, BufRead, BufReader, Write},
     os::unix::fs::OpenOptionsExt,
@@ -56,6 +56,7 @@ use chrono::{Duration, Utc};
 use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+use uuid::Uuid;
 
 #[derive(Error, Debug)]
 #[error("Invalid authentication token: {0}")]
@@ -183,8 +184,8 @@ impl AuthToken {
     }
 }
 
-impl Display for AuthToken {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Display for AuthToken {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
     }
 }
@@ -195,8 +196,10 @@ impl Display for AuthToken {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct TokenClaims {
     pub exp: i64,
+    pub client_id: ClientId,
 }
 
+// FIXME: replace with TokenClaims::new, as it does not exist a "default" token.
 impl Default for TokenClaims {
     fn default() -> Self {
         let mut exp = Utc::now();
@@ -207,10 +210,31 @@ impl Default for TokenClaims {
 
         Self {
             exp: exp.timestamp(),
+            client_id: ClientId::new(),
         }
     }
 }
 
+/// Identifies a client.
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct ClientId(Uuid);
+
+impl ClientId {
+    pub fn new() -> Self {
+        ClientId(Uuid::new_v4())
+    }
+
+    pub fn new_from_uuid(uuid: Uuid) -> Self {
+        ClientId(uuid)
+    }
+}
+
+impl fmt::Display for ClientId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use tempfile::tempdir;

rust/agama-lib/src/http.rs

@@ -22,7 +22,7 @@ mod base_http_client;
 pub use base_http_client::{BaseHTTPClient, BaseHTTPClientError};
 
 mod event;
-pub use event::Event;
+pub use event::{Event, EventPayload};
 
 mod websocket;
 pub use websocket::{WebSocketClient, WebSocketError};

rust/agama-lib/src/http/event.rs

@@ -19,6 +19,7 @@
 // find current contact information at www.suse.com.
 
 use crate::{
+    auth::ClientId,
     jobs::Job,
     localization::model::LocaleConfig,
     manager::InstallationPhase,
@@ -39,9 +40,47 @@ use std::collections::HashMap;
 
 use crate::issue::Issue;
 
+/// Agama event.
+///
+/// It represents an event that occurs in Agama.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Event {
+    /// The identifier of the client which caused the event.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<ClientId>,
+    /// Event payload.
+    #[serde(flatten)]
+    pub payload: EventPayload,
+}
+
+impl Event {
+    /// Creates a new event.
+    ///
+    /// * `payload`: event payload.
+    pub fn new(payload: EventPayload) -> Self {
+        Event {
+            client_id: None,
+            payload,
+        }
+    }
+
+    /// Creates a new event with a client ID.
+    ///
+    /// * `payload`: event payload.
+    /// * `client_id`: client ID.
+    pub fn new_with_client_id(payload: EventPayload, client_id: &ClientId) -> Self {
+        Event {
+            client_id: Some(client_id.clone()),
+            payload,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(tag = "type")]
-pub enum Event {
+pub enum EventPayload {
+    ClientConnected,
     L10nConfigChanged(LocaleConfig),
     LocaleChanged {
         locale: String,
@@ -64,6 +103,7 @@ pub enum Event {
         #[serde(flatten)]
         change: NetworkChange,
     },
+    StorageChanged,
     // TODO: it should include the full software proposal or, at least,
     // all the relevant changes.
     SoftwareProposalChanged {
@@ -144,3 +184,69 @@ pub enum Event {
         device: ZFCPController,
     },
 }
+
+/// Makes it easier to create an event, reducing the boilerplate.
+///
+/// # Event without additional data
+///
+/// ```
+/// # use agama_lib::{event, http::EventPayload};
+/// let my_event = event!(ClientConnected);
+/// assert!(matches!(my_event.payload, EventPayload::ClientConnected));
+/// assert!(my_event.client_id.is_none());
+/// ```
+///
+/// # Event with some additional data
+///
+/// ```
+/// # use agama_lib::{event, http::EventPayload};
+/// let my_event = event!(LocaleChanged { locale: "es_ES".to_string() });
+/// assert!(matches!(
+///    my_event.payload,
+///    EventPayload::LocaleChanged { locale: _ }
+/// ));
+/// ```
+///
+/// # Adding the client ID
+///
+/// ```
+/// # use agama_lib::{auth::ClientId, event, http::EventPayload};
+/// let client_id = ClientId::new();
+/// let my_event = event!(ClientConnected, &client_id);
+/// assert!(matches!(my_event.payload, EventPayload::ClientConnected));
+/// assert!(my_event.client_id.is_some());
+/// ```
+///
+/// # Add the client ID to a complex event
+///
+/// ```
+/// # use agama_lib::{auth::ClientId, event, http::EventPayload};
+/// let client_id = ClientId::new();
+/// let my_event = event!(LocaleChanged { locale: "es_ES".to_string() }, &client_id);
+/// assert!(matches!(
+///    my_event.payload,
+///    EventPayload::LocaleChanged { locale: _ }
+/// ));
+/// assert!(my_event.client_id.is_some());
+/// ```
+#[macro_export]
+macro_rules! event {
+    ($variant:ident) => {
+        agama_lib::http::Event::new(agama_lib::http::EventPayload::$variant)
+    };
+    ($variant:ident, $client:expr) => {
+        agama_lib::http::Event::new_with_client_id(
+            agama_lib::http::EventPayload::$variant,
+            $client,
+        )
+    };
+    ($variant:ident $inner:tt, $client:expr) => {
+        agama_lib::http::Event::new_with_client_id(
+            agama_lib::http::EventPayload::$variant $inner,
+            $client
+        )
+    };
+    ($variant:ident $inner:tt) => {
+        agama_lib::http::Event::new(agama_lib::http::EventPayload::$variant $inner)
+    };
+}

rust/agama-lib/src/manager.rs

@@ -23,6 +23,7 @@
 pub mod http_client;
 pub use http_client::ManagerHTTPClient;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 use crate::error::ServiceError;
 use crate::proxies::ServiceStatusProxy;
@@ -141,15 +142,21 @@ impl<'a> ManagerClient<'a> {
     }
 
     /// Starts the probing process.
-    pub async fn probe(&self) -> Result<(), ServiceError> {
+    pub async fn probe(&self, client_id: String) -> Result<(), ServiceError> {
         self.wait().await?;
-        Ok(self.manager_proxy.probe().await?)
+        Ok(self
+            .manager_proxy
+            .probe(HashMap::from([("client_id", &client_id.into())]))
+            .await?)
     }
 
     /// Starts the reprobing process.
-    pub async fn reprobe(&self) -> Result<(), ServiceError> {
+    pub async fn reprobe(&self, client_id: String) -> Result<(), ServiceError> {
         self.wait().await?;
-        Ok(self.manager_proxy.reprobe().await?)
+        Ok(self
+            .manager_proxy
+            .reprobe(HashMap::from([("client_id", &client_id.into())]))
+            .await?)
     }
 
     /// Starts the installation.

rust/agama-lib/src/monitor.rs

@@ -55,7 +55,9 @@ use std::collections::HashMap;
 use tokio::sync::{broadcast, mpsc, oneshot};
 
 use crate::{
-    http::{BaseHTTPClient, BaseHTTPClientError, Event, WebSocketClient, WebSocketError},
+    http::{
+        BaseHTTPClient, BaseHTTPClientError, Event, EventPayload, WebSocketClient, WebSocketError,
+    },
     manager::{InstallationPhase, InstallerStatus},
     progress::Progress,
 };
@@ -223,16 +225,16 @@ impl Monitor {
     ///
     /// * `event`: Agama event.
     fn handle_event(&mut self, event: Event) {
-        match event {
-            Event::ProgressChanged { path, progress } => {
+        match event.payload {
+            EventPayload::ProgressChanged { path, progress } => {
                 self.status.update_progress(path, progress);
             }
-            Event::ServiceStatusChanged { service, status } => {
+            EventPayload::ServiceStatusChanged { service, status } => {
                 if service.as_str() == MANAGER_PROGRESS_OBJECT_PATH {
                     self.status.set_is_busy(status == 1);
                 }
             }
-            Event::InstallationPhaseChanged { phase } => {
+            EventPayload::InstallationPhaseChanged { phase } => {
                 self.status.set_phase(phase);
             }
             _ => {}

rust/agama-lib/src/proxies/manager1.rs

@@ -39,10 +39,16 @@ pub trait Manager1 {
     fn finish(&self, method: &str) -> zbus::Result<bool>;
 
     /// Probe method
-    fn probe(&self) -> zbus::Result<()>;
+    fn probe(
+        &self,
+        data: std::collections::HashMap<&str, &zbus::zvariant::Value<'_>>,
+    ) -> zbus::Result<()>;
 
     /// Reprobe method
-    fn reprobe(&self) -> zbus::Result<()>;
+    fn reprobe(
+        &self,
+        data: std::collections::HashMap<&str, &zbus::zvariant::Value<'_>>,
+    ) -> zbus::Result<()>;
 
     /// BusyServices property
     #[zbus(property)]