Adapt the software UI to the new HTTP/JSON API

rust/agama-lib/src/software/client.rs

@@ -1,14 +1,15 @@
 use super::proxies::Software1Proxy;
 use crate::error::ServiceError;
 use serde::Serialize;
+use serde_repr::Serialize_repr;
 use std::collections::HashMap;
 use zbus::Connection;
 
 /// Represents a software product
 #[derive(Debug, Serialize, utoipa::ToSchema)]
 pub struct Pattern {
- /// Pattern ID (eg., "aaa_base", "gnome")
- pub id: String,
+ /// Pattern name (eg., "aaa_base", "gnome")
+ pub name: String,
  /// Pattern category (e.g., "Production")
  pub category: String,
  /// Pattern icon path locally on system
@@ -22,7 +23,8 @@ pub struct Pattern {
 }
 
 /// Represents the reason why a pattern is selected.
-#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Serialize_repr)]
+#[repr(u8)]
 pub enum SelectedBy {
  /// The pattern was selected by the user.
  User = 0,
@@ -69,8 +71,8 @@ impl<'a> SoftwareClient<'a> {
  .await?
  .into_iter()
  .map(
- |(id, (category, description, icon, summary, order))| Pattern {
- id,
+ |(name, (category, description, icon, summary, order))| Pattern {
+ name,
  category,
  icon,
  description,
@@ -118,11 +120,19 @@ impl<'a> SoftwareClient<'a> {
  }
 
  /// Selects patterns by user
- pub async fn select_patterns(&self, patterns: &[String]) -> Result<(), ServiceError> {
- let patterns: Vec<&str> = patterns.iter().map(AsRef::as_ref).collect();
+ pub async fn select_patterns(
+ &self,
+ patterns: HashMap<String, bool>,
+ ) -> Result<(), ServiceError> {
+ let (add, remove): (Vec<_>, Vec<_>) =
+ patterns.into_iter().partition(|(_, install)| *install);
+
+ let add: Vec<_> = add.iter().map(|(name, _)| name.as_ref()).collect();
+ let remove: Vec<_> = remove.iter().map(|(name, _)| name.as_ref()).collect();
+
  let wrong_patterns = self
  .software_proxy
- .set_user_patterns(patterns.as_slice())
+ .set_user_patterns(add.as_slice(), remove.as_slice())
  .await?;
  if !wrong_patterns.is_empty() {
  Err(ServiceError::UnknownPatterns(wrong_patterns))

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

@@ -48,7 +48,7 @@ trait Software1 {
  fn remove_pattern(&self, id: &str) -> zbus::Result<bool>;
 
  /// SetUserPatterns method
- fn set_user_patterns(&self, ids: &[&str]) -> zbus::Result<Vec<String>>;
+ fn set_user_patterns(&self, add: &[&str], remove: &[&str]) -> zbus::Result<Vec<String>>;
 
  /// UsedDiskSpace method
  fn used_disk_space(&self) -> zbus::Result<String>;

rust/agama-lib/src/software/store.rs

@@ -1,5 +1,7 @@
 //! Implements the store for the storage settings.
 
+use std::collections::HashMap;
+
 use super::{SoftwareClient, SoftwareSettings};
 use crate::error::ServiceError;
 use zbus::Connection;
@@ -22,9 +24,12 @@ impl<'a> SoftwareStore<'a> {
  }
 
  pub async fn store(&self, settings: &SoftwareSettings) -> Result<(), ServiceError> {
- self.software_client
- .select_patterns(&settings.patterns)
- .await?;
+ let patterns: HashMap<String, bool> = settings
+ .patterns
+ .iter()
+ .map(|name| (name.to_owned(), true))
+ .collect();
+ self.software_client.select_patterns(patterns).await?;
 
  Ok(())
  }

rust/agama-server/src/software/web.rs

@@ -35,9 +35,12 @@ struct SoftwareState<'a> {
  software: SoftwareClient<'a>,
 }
 
+/// Software service configuration (product, patterns, etc.).
 #[derive(Clone, Serialize, Deserialize, utoipa::ToSchema)]
 pub struct SoftwareConfig {
- patterns: Option<Vec<String>>,
+ /// A map where the keys are the pattern names and the values whether to install them or not.
+ patterns: Option<HashMap<String, bool>>,
+ /// Name of the product to install.
  product: Option<String>,
 }
 
@@ -92,7 +95,7 @@ async fn patterns_changed_stream(
  }
  None
  })
- .filter_map(|e| e.map(Event::PatternsChanged));
+ .filter_map(|e| e.map(|patterns| Event::SoftwareProposalChanged { patterns }));
  Ok(stream)
 }
 
@@ -150,43 +153,16 @@ async fn products(State(state): State<SoftwareState<'_>>) -> Result<Json<Vec<Pro
  Ok(Json(products))
 }
 
-/// Represents a pattern.
-///
-/// It augments the information coming from the D-Bus client.
-#[derive(Serialize, utoipa::ToSchema)]
-pub struct PatternEntry {
- #[serde(flatten)]
- pattern: Pattern,
- selected_by: SelectedBy,
-}
-
 /// Returns the list of software patterns.
 ///
 /// * `state`: service state.
 #[utoipa::path(get, path = "/software/patterns", responses(
- (status = 200, description = "List of known software patterns", body = Vec<PatternEntry>),
+ (status = 200, description = "List of known software patterns", body = Vec<Pattern>),
  (status = 400, description = "The D-Bus service could not perform the action")
 ))]
-async fn patterns(
- State(state): State<SoftwareState<'_>>,
-) -> Result<Json<Vec<PatternEntry>>, Error> {
+async fn patterns(State(state): State<SoftwareState<'_>>) -> Result<Json<Vec<Pattern>>, Error> {
  let patterns = state.software.patterns(true).await?;
- let selected = state.software.selected_patterns().await?;
- let items = patterns
- .into_iter()
- .map(|pattern| {
- let selected_by: SelectedBy = selected
- .get(&pattern.id)
- .copied()
- .unwrap_or(SelectedBy::None);
- PatternEntry {
- pattern,
- selected_by,
- }
- })
- .collect();
-
- Ok(Json(items))
+ Ok(Json(patterns))
 }
 
 /// Sets the software configuration.
@@ -206,7 +182,7 @@ async fn set_config(
  }
 
  if let Some(patterns) = config.patterns {
- state.software.select_patterns(&patterns).await?;
+ state.software.select_patterns(patterns).await?;
  }
 
  Ok(())
@@ -226,7 +202,13 @@ async fn get_config(State(state): State<SoftwareState<'_>>) -> Result<Json<Softw
  } else {
  Some(product)
  };
- let patterns = state.software.user_selected_patterns().await?;
+ let patterns = state
+ .software
+ .user_selected_patterns()
+ .await?
+ .into_iter()
+ .map(|p| (p, true))
+ .collect();
  let config = SoftwareConfig {
  patterns: Some(patterns),
  product,
@@ -240,6 +222,9 @@ pub struct SoftwareProposal {
  /// Space required for installation. It is returned as a formatted string which includes
  /// a number and a unit (e.g., "GiB").
  size: String,
+ /// Patterns selection. It is respresented as a hash map where the key is the pattern's name
+ /// and the value why the pattern is selected.
+ patterns: HashMap<String, SelectedBy>,
 }
 
 /// Returns the proposal information.
@@ -251,7 +236,8 @@ pub struct SoftwareProposal {
 ))]
 async fn proposal(State(state): State<SoftwareState<'_>>) -> Result<Json<SoftwareProposal>, Error> {
  let size = state.software.used_disk_space().await?;
- let proposal = SoftwareProposal { size };
+ let patterns = state.software.selected_patterns().await?;
+ let proposal = SoftwareProposal { size, patterns };
  Ok(Json(proposal))
 }
 

rust/agama-server/src/web/docs.rs

@@ -34,7 +34,6 @@ use utoipa::OpenApi;
  schemas(crate::network::model::Device),
  schemas(crate::network::model::Connection),
  schemas(agama_lib::network::types::DeviceType),
- schemas(crate::software::web::PatternEntry),
  schemas(crate::software::web::SoftwareConfig),
  schemas(crate::software::web::SoftwareProposal),
  schemas(crate::manager::web::InstallerStatus),

rust/agama-server/src/web/event.rs

@@ -21,7 +21,11 @@ pub enum Event {
  ProductChanged {
  id: String,
  },
- PatternsChanged(HashMap<String, SelectedBy>),
+ // TODO: it should include the full software proposal or, at least,
+ // all the relevant changes.
+ SoftwareProposalChanged {
+ patterns: HashMap<String, SelectedBy>,
+ },
  QuestionsChanged,
  InstallationPhaseChanged {
  phase: InstallationPhase,

service/lib/agama/dbus/software/manager.rb

@@ -89,7 +89,9 @@ def issues
 
  dbus_method(:AddPattern, "in id:s, out result:b") { |p| backend.add_pattern(p) }
  dbus_method(:RemovePattern, "in id:s, out result:b") { |p| backend.remove_pattern(p) }
- dbus_method(:SetUserPatterns, "in ids:as, out wrong:as") { |ids| [backend.assign_patterns(ids)] }
+ dbus_method(:SetUserPatterns, "in add:as, in remove:as, out wrong:as") do |add, remove|
+ [backend.assign_patterns(add, remove)]
+ end
 
  dbus_method :ProvisionsSelected, "in Provisions:as, out Result:ab" do |provisions|
  [provisions.map { |p| backend.provision_selected?(p) }]

service/lib/agama/software/manager.rb

@@ -249,16 +249,28 @@ def remove_pattern(id)
  true
  end
 
- def assign_patterns(ids)
- wrong_patterns = ids.reject { |p| pattern_exist?(p) }
+ def assign_patterns(add, remove)
+ wrong_patterns = [add, remove].flatten.reject { |p| pattern_exist?(p) }
  return wrong_patterns unless wrong_patterns.empty?
 
  user_patterns = Yast::PackagesProposal.GetResolvables(PROPOSAL_ID, :pattern)
  user_patterns.each { |p| Yast::Pkg.ResolvableNeutral(p, :pattern, force = false) }
- Yast::PackagesProposal.SetResolvables(PROPOSAL_ID, :pattern, ids)
- ids.each { |p| Yast::Pkg.ResolvableInstall(p, :pattern) }
- logger.info "Setting patterns to #{ids.inspect}"
+ logger.info "Adding patterns: #{add.join(", ")}. Removing patterns: #{remove.join(",")}."
+
+ Yast::PackagesProposal.SetResolvables(PROPOSAL_ID, :pattern, add)
+ add.each do |id|
+ res = Yast::Pkg.ResolvableInstall(id, :pattern)
+ logger.info "Adding pattern #{id}: #{res.inspect}"
+ end
+
+ remove.each do |id|
+ res = Yast::Pkg.ResolvableNeutral(id, :pattern, force = false)
+ logger.info "Removing pattern #{id}: #{res.inspect}"
+ Yast::PackagesProposal.RemoveResolvables(PROPOSAL_ID, :pattern, [id])
+ end
+
  proposal.solve_dependencies
+
  selected_patterns_changed
 
  []

web/src/client/index.js

@@ -78,7 +78,7 @@ const createClient = (url) => {
  const manager = new ManagerClient(client);
  // const monitor = new Monitor(address, MANAGER_SERVICE);
  // const network = new NetworkClient(address);
- // const software = new SoftwareClient(address);
+ const software = new SoftwareClient(client);
  // const storage = new StorageClient(address);
  // const users = new UsersClient(address);
  // const questions = new QuestionsClient(address);
@@ -139,7 +139,7 @@ const createClient = (url) => {
  manager,
  // monitor,
  // network,
- // software,
+ software,
  // storage,
  // users,
  // questions,

web/src/client/mixins.js

@@ -150,7 +150,7 @@ const WithStatus = (superclass, status_path, service_name) =>
  * Register a callback to run when the "CurrentInstallationPhase" changes
  *
  * @param {function} handler - callback function
- * @return {function} function to disable the callback
+ * @return {import ("./http").RemoveFn} function to disable the callback
  */
  onStatusChange(handler) {
  return this.client.onEvent("ServiceStatusChanged", ({ status, service }) => {
@@ -207,7 +207,7 @@ const WithProgress = (superclass, progress_path, service_name) =>
  * Register a callback to run when the progress changes
  *
  * @param {ProgressHandler} handler - callback function
- * @return {import ("./dbus").RemoveFn} function to disable the callback
+ * @return {import ("./http").RemoveFn} function to disable the callback
  */
  onProgressChange(handler) {
  return this.client.onEvent("Progress", ({ service, ...progress }) => {