Replace D-Bus with HTTP-based clients (#1438)

## Problem

- https://trello.com/c/hvPtBtMD

When moving to the new HTTP-based architecture, we took some shortcuts.
One of them was not using HTTP clients in the command-line interface. We
need to adapt the following clients:

-
[UsersClient](https://github.com/openSUSE/agama/blob/master/rust/agama-lib/src/users/client.rs)
-
[LocalizationClient](https://github.com/openSUSE/agama/blob/master/rust/agama-lib/src/localization/client.rs)
-
[ProductClient](https://github.com/openSUSE/agama/blob/master/rust/agama-lib/src/product/client.rs)
-
[StorageClient](https://github.com/openSUSE/agama/blob/master/rust/agama-lib/src/storage/client.rs)
-
[SoftwareClient](https://github.com/openSUSE/agama/blob/master/rust/agama-lib/src/software/client.rs)


## Solution

- `UsersClient` - still needed, because the HTTP service uses it to talk
to the Ruby backend. `UsersHTTPClient` added.
- `LocalizationClient` replaced with `LocalizationHTTPClient`

The rest will be done in subsequent PRs.


## Testing

- Tested manually with various correct and incorrect configs via `agama
config show` and `agama config load`. This is ripe for automation, even
in this PR.
- aaand: added tests that
- set up a trivial HTTP server (using
[httpmock](https://crates.io/crates/httpmock) - is the dependency size
OK?),
    -  mocking the JSON data and
    -  asserting what the Store classes make out of it


## Screenshots

*If the fix affects the UI attach some screenshots here.*

rust/agama-cli/src/config.rs

@@ -43,7 +43,7 @@ pub enum ConfigCommands {
 
 pub async fn run(subcommand: ConfigCommands) -> anyhow::Result<()> {
  let Some(token) = AuthToken::find() else {
- println!("You need to login for generating a valid token");
+ println!("You need to login for generating a valid token: agama auth login");
  return Ok(());
  };
 

rust/agama-cli/src/profile.rs

@@ -38,7 +38,7 @@ pub enum ProfileCommands {
  /// Evaluate a profile, injecting the hardware information from D-Bus
  ///
  /// For an example of Jsonnet-based profile, see
- /// https://github.com/openSUSE/agama/blob/master/rust/agama-lib/share/examples/profile.jsonnet
+ /// <https://github.com/openSUSE/agama/blob/master/rust/agama-lib/share/examples/profile.jsonnet>
  Evaluate {
  /// Path to jsonnet file.
  path: PathBuf,

rust/agama-cli/src/questions.rs

@@ -15,7 +15,7 @@ pub enum QuestionsCommands {
  /// mode or change the answer in automatic mode.
  ///
  /// Please check Agama documentation for more details and examples:
- /// https://github.com/openSUSE/agama/blob/master/doc/questions.md
+ /// <https://github.com/openSUSE/agama/blob/master/doc/questions.md>
  Answers {
  /// Path to a file containing the answers in YAML format.
  path: String,
@@ -55,7 +55,7 @@ async fn set_answers(proxy: Questions1Proxy<'_>, path: String) -> Result<(), Ser
 }
 
 async fn list_questions() -> Result<(), ServiceError> {
- let client = HTTPClient::new().await?;
+ let client = HTTPClient::new()?;
  let questions = client.list_questions().await?;
  // FIXME: if performance is bad, we can skip converting json from http to struct and then
  // serialize it, but it won't be pretty string
@@ -66,7 +66,7 @@ async fn list_questions() -> Result<(), ServiceError> {
 }
 
 async fn ask_question() -> Result<(), ServiceError> {
- let client = HTTPClient::new().await?;
+ let client = HTTPClient::new()?;
  let question = serde_json::from_reader(std::io::stdin())?;
 
  let created_question = client.create_question(&question).await?;

rust/agama-lib/Cargo.toml

@@ -28,3 +28,7 @@ curl = { version = "0.4.44", features = ["protocol-ftp"] }
 jsonwebtoken = "9.3.0"
 chrono = { version = "0.4.38", default-features = false, features = ["now", "std", "alloc", "clock"] }
 home = "0.5.9"
+
+[dev-dependencies]
+httpmock = "0.7.0"
+env_logger = "0.11.5"

rust/agama-lib/src/auth.rs

@@ -166,7 +166,7 @@ impl Display for AuthToken {
 
 /// Claims that are included in the token.
 ///
-/// See https://datatracker.ietf.org/doc/html/rfc7519 for reference.
+/// See <https://datatracker.ietf.org/doc/html/rfc7519> for reference.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct TokenClaims {
  pub exp: i64,

rust/agama-lib/src/base_http_client.rs

@@ -56,7 +56,7 @@ impl BaseHTTPClient {
  let mut headers = header::HeaderMap::new();
  // just use generic anyhow error here as Bearer format is constructed by us, so failures can come only from token
  let value = header::HeaderValue::from_str(format!("Bearer {}", token).as_str())
- .map_err(|e| anyhow::Error::new(e))?;
+ .map_err(anyhow::Error::new)?;
 
  headers.insert(header::AUTHORIZATION, value);
 
@@ -66,40 +66,36 @@ impl BaseHTTPClient {
  Ok(client)
  }
 
- /// Simple wrapper around [`Response`] to get object from response.
- ///
- /// If a complete [`Response`] is needed, use the [`Self::get_response`] method.
- ///
- /// Arguments:
- ///
- /// * `path`: path relative to HTTP API like `/questions`
- pub async fn get<T: DeserializeOwned>(&self, path: &str) -> Result<T, ServiceError> {
- let response = self.get_response(path).await?;
- if response.status().is_success() {
- response.json::<T>().await.map_err(|e| e.into())
- } else {
- Err(self.build_backend_error(response).await)
- }
+ fn url(&self, path: &str) -> String {
+ self.base_url.clone() + path
  }
 
- /// Calls GET method on the given path and returns [`Response`] that can be further
- /// processed.
- ///
- /// If only simple object from JSON is required, use method get.
+ /// Simple wrapper around [`Response`] to get object from response.
  ///
  /// Arguments:
  ///
  /// * `path`: path relative to HTTP API like `/questions`
- pub async fn get_response(&self, path: &str) -> Result<Response, ServiceError> {
- self.client
+ pub async fn get<T>(&self, path: &str) -> Result<T, ServiceError>
+ where
+ T: DeserializeOwned,
+ {
+ let response: Result<_, ServiceError> = self
+ .client
  .get(self.url(path))
  .send()
  .await
- .map_err(|e| e.into())
+ .map_err(|e| e.into());
+ self.deserialize_or_error(response?).await
  }
 
- fn url(&self, path: &str) -> String {
- self.base_url.clone() + path
+ pub async fn post<T>(&self, path: &str, object: &impl Serialize) -> Result<T, ServiceError>
+ where
+ T: DeserializeOwned,
+ {
+ let response = self
+ .request_response(reqwest::Method::POST, path, object)
+ .await?;
+ self.deserialize_or_error(response).await
  }
 
  /// post object to given path and report error if response is not success
@@ -108,77 +104,154 @@ impl BaseHTTPClient {
  ///
  /// * `path`: path relative to HTTP API like `/questions`
  /// * `object`: Object that can be serialiazed to JSON as body of request.
- pub async fn post(&self, path: &str, object: &impl Serialize) -> Result<(), ServiceError> {
- let response = self.post_response(path, object).await?;
- if response.status().is_success() {
- Ok(())
- } else {
- Err(self.build_backend_error(response).await)
- }
+ pub async fn post_void(&self, path: &str, object: &impl Serialize) -> Result<(), ServiceError> {
+ let response = self
+ .request_response(reqwest::Method::POST, path, object)
+ .await?;
+ self.unit_or_error(response).await
  }
 
- /// post object to given path and returns server response. Reports error only if failed to send
- /// request, but if server returns e.g. 500, it will be in Ok result.
+ /// put object to given path, deserializes the response
  ///
- /// In general unless specific response handling is needed, simple post should be used.
+ /// Arguments:
+ ///
+ /// * `path`: path relative to HTTP API like `/users/first`
+ /// * `object`: Object that can be serialiazed to JSON as body of request.
+ pub async fn put<T>(&self, path: &str, object: &impl Serialize) -> Result<T, ServiceError>
+ where
+ T: DeserializeOwned,
+ {
+ let response = self
+ .request_response(reqwest::Method::PUT, path, object)
+ .await?;
+ self.deserialize_or_error(response).await
+ }
+
+ /// put object to given path and report error if response is not success
  ///
  /// Arguments:
  ///
- /// * `path`: path relative to HTTP API like `/questions`
+ /// * `path`: path relative to HTTP API like `/users/first`
+ /// * `object`: Object that can be serialiazed to JSON as body of request.
+ pub async fn put_void(&self, path: &str, object: &impl Serialize) -> Result<(), ServiceError> {
+ let response = self
+ .request_response(reqwest::Method::PUT, path, object)
+ .await?;
+ self.unit_or_error(response).await
+ }
+
+ /// patch object at given path and report error if response is not success
+ ///
+ /// Arguments:
+ ///
+ /// * `path`: path relative to HTTP API like `/users/first`
  /// * `object`: Object that can be serialiazed to JSON as body of request.
- pub async fn post_response(
+ pub async fn patch<T>(&self, path: &str, object: &impl Serialize) -> Result<T, ServiceError>
+ where
+ T: DeserializeOwned,
+ {
+ let response = self
+ .request_response(reqwest::Method::PATCH, path, object)
+ .await?;
+ self.deserialize_or_error(response).await
+ }
+
+ pub async fn patch_void(
  &self,
  path: &str,
  object: &impl Serialize,
- ) -> Result<Response, ServiceError> {
- self.client
- .post(self.url(path))
- .json(object)
- .send()
- .await
- .map_err(|e| e.into())
+ ) -> Result<(), ServiceError> {
+ let response = self
+ .request_response(reqwest::Method::PATCH, path, object)
+ .await?;
+ self.unit_or_error(response).await
  }
 
  /// delete call on given path and report error if failed
  ///
  /// Arguments:
  ///
  /// * `path`: path relative to HTTP API like `/questions/1` 
- pub async fn delete(&self, path: &str) -> Result<(), ServiceError> {
- let response = self.delete_response(path).await?;
- if response.status().is_success() {
- Ok(())
- } else {
- Err(self.build_backend_error(response).await)
- }
+ pub async fn delete_void(&self, path: &str) -> Result<(), ServiceError> {
+ let response: Result<_, ServiceError> = self
+ .client
+ .delete(self.url(path))
+ .send()
+ .await
+ .map_err(|e| e.into());
+ self.unit_or_error(response?).await
  }
 
- /// delete call on given path and returns server response. Reports error only if failed to send
+ /// POST/PUT/PATCH an object to a given path and returns server response.
+ /// Reports Err only if failed to send
  /// request, but if server returns e.g. 500, it will be in Ok result.
  ///
- /// In general unless specific response handling is needed, simple delete should be used.
- /// TODO: do not need variant with request body? if so, then create additional method.
+ /// In general unless specific response handling is needed, simple post should be used.
  ///
  /// Arguments:
  ///
- /// * `path`: path relative to HTTP API like `/questions/1` 
- pub async fn delete_response(&self, path: &str) -> Result<Response, ServiceError> {
+ /// * `method`: for example `reqwest::Method::PUT`
+ /// * `path`: path relative to HTTP API like `/questions`
+ /// * `object`: Object that can be serialiazed to JSON as body of request.
+ async fn request_response(
+ &self,
+ method: reqwest::Method,
+ path: &str,
+ object: &impl Serialize,
+ ) -> Result<Response, ServiceError> {
  self.client
- .delete(self.url(path))
+ .request(method, self.url(path))
+ .json(object)
  .send()
  .await
  .map_err(|e| e.into())
  }
 
+ /// Return deserialized JSON body as `Ok(T)` or an `Err` with [`ServiceError::BackendError`]
+ async fn deserialize_or_error<T>(&self, response: Response) -> Result<T, ServiceError>
+ where
+ T: DeserializeOwned,
+ {
+ // DEBUG: This dbg is nice but it omits the body, thus we try harder below
+ // let response = dbg!(response);
+
+ if response.status().is_success() {
+ // We'd like to simply:
+ // response.json::<T>().await.map_err(|e| e.into())
+ // BUT also peek into the response text, in case something is wrong
+ // so this copies the implementation from the above and adds a debug part
+
+ let bytes_r: Result<_, ServiceError> = response.bytes().await.map_err(|e| e.into());
+ let bytes = bytes_r?;
+
+ // DEBUG: (we expect JSON so dbg! would escape too much, eprintln! is better)
+ // let text = String::from_utf8_lossy(&bytes);
+ // eprintln!("Response body: {}", text);
+
+ serde_json::from_slice(&bytes).map_err(|e| e.into())
+ } else {
+ Err(self.build_backend_error(response).await)
+ }
+ }
+
+ /// Return `Ok(())` or an `Err` with [`ServiceError::BackendError`]
+ async fn unit_or_error(&self, response: Response) -> Result<(), ServiceError> {
+ if response.status().is_success() {
+ Ok(())
+ } else {
+ Err(self.build_backend_error(response).await)
+ }
+ }
+
  const NO_TEXT: &'static str = "(Failed to extract error text from HTTP response)";
- /// Builds [`BackendError`] from response.
+ /// Builds [`ServiceError::BackendError`] from response.
  ///
  /// It contains also processing of response body, that is why it has to be async.
  ///
  /// Arguments:
  ///
  /// * `response`: response from which generate error
- pub async fn build_backend_error(&self, response: Response) -> ServiceError {
+ async fn build_backend_error(&self, response: Response) -> ServiceError {
  let code = response.status().as_u16();
  let text = response
  .text()

rust/agama-lib/src/dbus.rs

@@ -58,7 +58,7 @@ macro_rules! property_from_dbus {
 /// NOTE: we could follow a different approach like building our own type (e.g.
 /// using the newtype idiom) and offering a better API.
 ///
-/// * `source`: hash map containing non-onwed values ([zbus::zvariant::Value]).
+/// * `source`: hash map containing non-onwed values ([enum@zbus::zvariant::Value]).
 pub fn to_owned_hash(source: &HashMap<&str, Value<'_>>) -> HashMap<String, OwnedValue> {
  let mut owned = HashMap::new();
  for (key, value) in source.iter() {

rust/agama-lib/src/lib.rs

@@ -3,7 +3,7 @@
 //! This library offers an API to interact with Agama services. At this point, the library allows:
 //!
 //! * Reading and writing [installation settings](install_settings::InstallSettings).
-//! * Monitoring the [progress](progress).
+//! * Monitoring the [progress].
 //! * Triggering actions through the [manager] (e.g., starting installation).
 //!
 //! ## Handling installation settings

rust/agama-lib/src/localization.rs

@@ -1,11 +1,12 @@
 //! Implements support for handling the localization settings
 
-mod client;
+mod http_client;
+pub mod model;
 mod proxies;
 mod settings;
 mod store;
 
-pub use client::LocalizationClient;
+pub use http_client::LocalizationHTTPClient;
 pub use proxies::LocaleProxy;
 pub use settings::LocalizationSettings;
 pub use store::LocalizationStore;