feat: simplify HTTP API (#2795)

Simplify the HTTP API by removing endpoints for each scope (e.g.,
*/config/storage*) resulting in a smaller API for dealing with the
config:

~~~
GET /extended_config
GET PUT PATCH /config
~~~ 

With this new API, the way for resetting a specific scope consists on
putting the whole current config without including the scope to remove.

In the future, the schema for patching could be extended. For example,
it could provide a way for resetting some scopes without giving the
current config.

Author: joseivanlopez

doc/http_api.md

@@ -20,18 +20,20 @@ The API is designed around 3 main concepts: *system*, *config* and *proposal*.
 The *config* contains elements that can modify the *system*, the *proposal* or both. For example, the *dasd* config changes the *system*, and the *storage* config changes the *proposal*. In other cases like *network*, the config can affect to both *system* and *proposal*.
 
 ~~~
+GET             /status
 GET             /system
 GET             /extended_config
-GET             /extended_config/{scope}
 GET PUT PATCH   /config
-GET PUT PATCH   /config/{scope}
 GET POST PATCH  /questions
 GET             /proposal
-GET             /status
 GET             /issues
 POST            /action
 ~~~
 
+### GET /status
+
+Reports the status of the installation. It contains the installation state (*configuring*, *installing*, *finished*) and the active progresses.
+
 ### GET /system
 
 Returns a JSON with the info of the system (storage devices, network connections, current localization, etc).
@@ -47,39 +49,51 @@ There is a distinction between *extended config* and *config*:
 
 For example, if only the *locale* was configured by the user, then the *config*  has no *keymap* property. Nevertheless, the *extended config* would have a *keymap* with the value from the default *extended config*.
 
-The scope can be indicated to retrieve only a part of the config, for example *GET /extended_config/l10n*.
+### GET PUT /config
 
-### GET PUT PATCH /config
+Reads or replaces the *config*. In case of patching, the given config is merged into the current *extended config*.
 
-Reads, replaces or modifies the explicitly set *config*. In case of patching, the given config is merged into the current *extended config*.
+### PATCH /config
 
-The scope can be indicated to manage only part of the config, for example *PUT /config/l10n*.
+Applies changes in the *config*. There is an own patch document:
 
-### POST /action
+~~~json
+{
+  "update": {
+    "l10n": {
+      "keymap": "es"
+    }
+  }
+}
+~~~
 
-Allows performing actions that cannot be done as side effect of applying a config. For example, start the installation, reload the system, etc. The *actions schema* defines the possible actions, parameters, etc.
+The given config from the *update* key is merged into current *extended config*.
 
-### GET /status
+The patch document could be extended in the future with more options, for example for resetting some parts of the config.
 
-Reports the status of the installation. It contains the installation state (*configuring*, *installing*, *finished*) and the active progresses.
+See https://datatracker.ietf.org/doc/html/rfc5789#section-2
+
+### POST /action
+
+Allows performing actions that cannot be done as side effect of applying a config. For example, start the installation, reload the system, etc. The *actions schema* defines the possible actions, parameters, etc.
 
-### Example: reload the system
+#### Example: reload the system
 
 In some cases, clients need to request a system reload. For example, if you create a RAID device using the terminal, then you need to reload the system in order to see the new device. In the future, reloading the system could be automatically done (e.g., by listening udisk D-Bus). For now, reloading has to be manually requested.
 
 ~~~
-POST /action { "reloadSystem": { scope: "storage" } }
+POST /action { "reloadSystem": "storage" }
 ~~~
 
-### Example: change the system localization
+#### Example: change the system localization
 
 Sometimes we need to directly modify the system without changing the config. For example, switching the locale of the running system (UI language).
 
 ~~~
 POST /action { "configureL10n": { language: "es_ES" } }
 ~~~
 
-### Example: start installation
+#### Example: start installation
 
 The installation can be started by calling the proper action.
 

rust/agama-manager/src/lib.rs

@@ -24,9 +24,6 @@ pub use start::start;
 pub mod service;
 pub use service::Service;
 
-mod scope;
-pub use scope::{ConfigScope, Scope};
-
 mod system_info;
 pub use system_info::SystemInfo;
 

rust/agama-manager/src/message.rs

@@ -18,9 +18,7 @@
 // To contact SUSE LLC about this file by physical or electronic mail, you may
 // find current contact information at www.suse.com.
 
-use crate::{
-    l10n, proposal::Proposal, scope::ConfigScope, scope::Scope, service, system_info::SystemInfo,
-};
+use crate::{l10n, proposal::Proposal, service, system_info::SystemInfo};
 use agama_lib::{install_settings::InstallSettings, issue::Issue};
 use agama_utils::{actor::Message, progress::Progress};
 use serde::{Deserialize, Serialize};
@@ -61,22 +59,6 @@ impl Message for GetExtendedConfig {
     type Reply = InstallSettings;
 }
 
-/// Gets a scope from the full config.
-#[derive(Debug)]
-pub struct GetExtendedConfigScope {
-    pub scope: Scope,
-}
-
-impl GetExtendedConfigScope {
-    pub fn new(scope: Scope) -> Self {
-        Self { scope }
-    }
-}
-
-impl Message for GetExtendedConfigScope {
-    type Reply = Option<ConfigScope>;
-}
-
 /// Gets the current config set by the user.
 #[derive(Debug)]
 pub struct GetConfig;
@@ -117,54 +99,6 @@ impl Message for UpdateConfig {
     type Reply = ();
 }
 
-/// Gets a scope from the config.
-#[derive(Debug)]
-pub struct GetConfigScope {
-    pub scope: Scope,
-}
-
-impl GetConfigScope {
-    pub fn new(scope: Scope) -> Self {
-        Self { scope }
-    }
-}
-
-impl Message for GetConfigScope {
-    type Reply = Option<ConfigScope>;
-}
-
-/// Sets a config scope
-#[derive(Debug)]
-pub struct SetConfigScope {
-    pub config: ConfigScope,
-}
-
-impl SetConfigScope {
-    pub fn new(config: ConfigScope) -> Self {
-        Self { config }
-    }
-}
-
-impl Message for SetConfigScope {
-    type Reply = ();
-}
-
-/// Updates a config scope
-#[derive(Debug)]
-pub struct UpdateConfigScope {
-    pub config: ConfigScope,
-}
-
-impl UpdateConfigScope {
-    pub fn new(config: ConfigScope) -> Self {
-        Self { config }
-    }
-}
-
-impl Message for UpdateConfigScope {
-    type Reply = ();
-}
-
 /// Gets the proposal.
 #[derive(Debug)]
 pub struct GetProposal;

rust/agama-manager/src/scope.rs

@@ -22,7 +22,6 @@ use crate::{
     l10n,
     message::{self, Action},
     proposal::Proposal,
-    scope::{ConfigScope, Scope},
     system_info::SystemInfo,
 };
 use agama_lib::install_settings::InstallSettings;
@@ -147,23 +146,6 @@ impl MessageHandler<message::GetExtendedConfig> for Service {
     }
 }
 
-#[async_trait]
-impl MessageHandler<message::GetExtendedConfigScope> for Service {
-    /// It returns the configuration for the given scope.
-    async fn handle(
-        &mut self,
-        message: message::GetExtendedConfigScope,
-    ) -> Result<Option<ConfigScope>, Error> {
-        let option = match message.scope {
-            Scope::L10n => {
-                let l10n_config = self.l10n.call(l10n::message::GetConfig).await?;
-                Some(ConfigScope::L10n(l10n_config))
-            }
-        };
-        Ok(option)
-    }
-}
-
 #[async_trait]
 impl MessageHandler<message::GetConfig> for Service {
     /// Gets the current configuration set by the user.
@@ -205,63 +187,6 @@ impl MessageHandler<message::UpdateConfig> for Service {
     }
 }
 
-#[async_trait]
-impl MessageHandler<message::GetConfigScope> for Service {
-    /// It returns the configuration set by the user for the given scope.
-    async fn handle(
-        &mut self,
-        message: message::GetConfigScope,
-    ) -> Result<Option<ConfigScope>, Error> {
-        // FIXME: implement this logic at InstallSettings level: self.get_config().by_scope(...)
-        // It would allow us to drop this method.
-        let option = match message.scope {
-            Scope::L10n => self
-                .config
-                .localization
-                .clone()
-                .map(|c| ConfigScope::L10n(c)),
-        };
-        Ok(option)
-    }
-}
-
-#[async_trait]
-impl MessageHandler<message::SetConfigScope> for Service {
-    /// Sets the user configuration within the given scope.
-    ///
-    /// It replaces the current configuration with the given one and calculates a
-    /// new proposal. Only the configuration in the given scope is affected.
-    async fn handle(&mut self, message: message::SetConfigScope) -> Result<(), Error> {
-        match message.config {
-            ConfigScope::L10n(l10n_config) => {
-                self.l10n
-                    .call(l10n::message::SetConfig::new(l10n_config.clone()))
-                    .await?;
-                self.config.localization = Some(l10n_config);
-            }
-        }
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl MessageHandler<message::UpdateConfigScope> for Service {
-    /// Patches the user configuration within the given scope.
-    ///
-    /// It merges the current configuration with the given one.
-    async fn handle(&mut self, message: message::UpdateConfigScope) -> Result<(), Error> {
-        match message.config {
-            ConfigScope::L10n(l10n_config) => {
-                let base_config = self.config.localization.clone().unwrap_or_default();
-                let config = merge(&base_config, &l10n_config).map_err(|_| Error::MergeConfig)?;
-                self.handle(message::SetConfigScope::new(ConfigScope::L10n(config)))
-                    .await?;
-            }
-        }
-        Ok(())
-    }
-}
-
 #[async_trait]
 impl MessageHandler<message::GetProposal> for Service {
     /// It returns the current proposal, if any.

rust/agama-manager/src/service.rs

@@ -20,12 +20,12 @@
 
 //! This module defines some ancillary types for the HTTP API.
 
-use std::collections::HashMap;
-
+use agama_lib::install_settings::InstallSettings;
 use agama_utils::issue;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
-#[derive(Serialize, utoipa::ToSchema)]
+#[derive(Deserialize, Serialize, utoipa::ToSchema)]
 /// Holds the installation issues for each scope.
 pub struct IssuesMap {
     /// iSCSI issues.
@@ -60,3 +60,10 @@ impl From<HashMap<String, Vec<issue::Issue>>> for IssuesMap {
         }
     }
 }
+
+#[derive(Deserialize, Serialize, utoipa::ToSchema)]
+/// Patch for the config.
+pub struct ConfigPatch {
+    /// Update for the current config.
+    pub update: Option<InstallSettings>,
+}