Ask cli

rust/agama-cli/src/main.rs

@@ -118,28 +118,30 @@ async fn build_manager<'a>() -> anyhow::Result<ManagerClient<'a>> {
     Ok(ManagerClient::new(conn).await?)
 }
 
-async fn run_command(cli: Cli) -> anyhow::Result<()> {
+async fn run_command(cli: Cli) -> Result<(), ServiceError> {
     match cli.command {
         Commands::Config(subcommand) => {
             let manager = build_manager().await?;
             wait_for_services(&manager).await?;
-            run_config_cmd(subcommand).await
+            run_config_cmd(subcommand).await?
         }
         Commands::Probe => {
             let manager = build_manager().await?;
             wait_for_services(&manager).await?;
-            probe().await
+            probe().await?
         }
-        Commands::Profile(subcommand) => Ok(run_profile_cmd(subcommand).await?),
+        Commands::Profile(subcommand) => run_profile_cmd(subcommand).await?,
         Commands::Install => {
             let manager = build_manager().await?;
-            install(&manager, 3).await
+            install(&manager, 3).await?
         }
-        Commands::Questions(subcommand) => run_questions_cmd(subcommand).await,
-        Commands::Logs(subcommand) => run_logs_cmd(subcommand).await,
-        Commands::Auth(subcommand) => run_auth_cmd(subcommand).await,
-        Commands::Download { url } => crate::profile::download(&url, std::io::stdout()),
-    }
+        Commands::Questions(subcommand) => run_questions_cmd(subcommand).await?,
+        Commands::Logs(subcommand) => run_logs_cmd(subcommand).await?,
+        Commands::Auth(subcommand) => run_auth_cmd(subcommand).await?,
+        Commands::Download { url } => crate::profile::download(&url, std::io::stdout())?,
+    };
+
+    Ok(())
 }
 
 /// Represents the result of execution.

rust/agama-cli/src/questions.rs

@@ -1,6 +1,6 @@
-use agama_lib::connection;
 use agama_lib::proxies::Questions1Proxy;
-use anyhow::Context;
+use agama_lib::questions::http_client::HTTPClient;
+use agama_lib::{connection, error::ServiceError};
 use clap::{Args, Subcommand, ValueEnum};
 
 #[derive(Subcommand, Debug)]
@@ -19,6 +19,8 @@ pub enum QuestionsCommands {
         /// Path to a file containing the answers in YAML format.
         path: String,
     },
+    /// prints list of questions that is waiting for answer in YAML format
+    List,
 }
 
 #[derive(Args, Debug)]
@@ -35,30 +37,40 @@ pub enum Modes {
     NonInteractive,
 }
 
-async fn set_mode(proxy: Questions1Proxy<'_>, value: Modes) -> anyhow::Result<()> {
-    // TODO: how to print dbus error in that anyhow?
+async fn set_mode(proxy: Questions1Proxy<'_>, value: Modes) -> Result<(), ServiceError> {
     proxy
         .set_interactive(value == Modes::Interactive)
         .await
-        .context("Failed to set mode for answering questions.")
+        .map_err(|e| e.into())
 }
 
-async fn set_answers(proxy: Questions1Proxy<'_>, path: String) -> anyhow::Result<()> {
-    // TODO: how to print dbus error in that anyhow?
+async fn set_answers(proxy: Questions1Proxy<'_>, path: String) -> Result<(), ServiceError> {
     proxy
         .add_answer_file(path.as_str())
         .await
-        .context("Failed to set answers from answers file")
+        .map_err(|e| e.into())
 }
 
-pub async fn run(subcommand: QuestionsCommands) -> anyhow::Result<()> {
+async fn list_questions() -> Result<(), ServiceError> {
+    let client = HTTPClient::new().await?;
+    let questions = client.list_questions().await?;
+    // FIXME: that conversion to anyhow error is nasty, but we do not expect issue
+    // when questions are already read from json
+    // 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
+    let questions_json =
+        serde_json::to_string_pretty(&questions).map_err(Into::<anyhow::Error>::into)?;
+    println!("{}", questions_json);
+    Ok(())
+}
+
+pub async fn run(subcommand: QuestionsCommands) -> Result<(), ServiceError> {
     let connection = connection().await?;
-    let proxy = Questions1Proxy::new(&connection)
-        .await
-        .context("Failed to connect to Questions service")?;
+    let proxy = Questions1Proxy::new(&connection).await?;
 
     match subcommand {
         QuestionsCommands::Mode(value) => set_mode(proxy, value.value).await,
         QuestionsCommands::Answers { path } => set_answers(proxy, path).await,
+        QuestionsCommands::List => list_questions().await,
     }
 }

rust/agama-lib/src/base_http_client.rs

@@ -0,0 +1,133 @@
+use anyhow::Context;
+use reqwest::{header, Client, Response};
+use serde::{de::DeserializeOwned, Serialize};
+
+use crate::{auth::AuthToken, error::ServiceError};
+
+/// Base that all http clients should use.
+///
+/// It provides several features including automatic base url switching,
+/// websocket events listening or object constructions.
+///
+/// Usage should be just thin layer in domain specific client.
+///
+/// ```no_run
+///   use agama_lib::questions::model::Question;
+///   use agama_lib::base_http_client::BaseHTTPClient;
+///   use agama_lib::error::ServiceError;
+///
+///   async fn get_questions() -> Result<Vec<Question>, ServiceError> {
+///     let client = BaseHTTPClient::new()?;
+///     client.get("/questions").await
+///   }
+/// ```
+pub struct BaseHTTPClient {
+    client: Client,
+    pub base_url: String,
+}
+
+const API_URL: &str = "http://localhost/api";
+
+impl BaseHTTPClient {
+    // if there is need for client without authorization, create new constructor for it
+    pub fn new() -> Result<Self, ServiceError> {
+        let token = AuthToken::find().context("You are not logged in")?;
+
+        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))?;
+
+        headers.insert(header::AUTHORIZATION, value);
+
+        let client = Client::builder().default_headers(headers).build()?;
+
+        Ok(Self {
+            client,
+            base_url: API_URL.to_string(), // TODO: add support for remote server
+        })
+    }
+
+    const NO_TEXT: &'static str = "No text";
+    /// Simple wrapper around Response to get object from response.
+    /// If complete Response is needed use get_response method.
+    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)
+        }
+    }
+
+    /// Calls GET method on given path and return Response that can be further
+    /// processed. If only simple object from json is required, use method get.
+    pub async fn get_response(&self, path: &str) -> Result<Response, ServiceError> {
+        self.client
+            .get(self.url(path))
+            .send()
+            .await
+            .map_err(|e| e.into())
+    }
+
+    fn url(&self, path: &str) -> String {
+        self.base_url.clone() + path
+    }
+
+    /// post object to given path and report error if response is not success
+    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)
+        }
+    }
+
+    /// 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.
+    /// In general unless specific response handling is needed, simple post should be used.
+    pub async fn post_response(
+        &self,
+        path: &str,
+        object: &impl Serialize,
+    ) -> Result<Response, ServiceError> {
+        self.client
+            .post(self.url(path))
+            .json(object)
+            .send()
+            .await
+            .map_err(|e| e.into())
+    }
+
+    /// delete call on given path and report error if failed
+    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)
+        }
+    }
+
+    /// delete call on 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.
+    /// 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.
+    pub async fn delete_response(&self, path: &str) -> Result<Response, ServiceError> {
+        self.client
+            .delete(self.url(path))
+            .send()
+            .await
+            .map_err(|e| e.into())
+    }
+
+    pub async fn build_backend_error(&self, response: Response) -> ServiceError {
+        let code = response.status().as_u16();
+        let text = response
+            .text()
+            .await
+            .unwrap_or_else(|_| Self::NO_TEXT.to_string());
+        ServiceError::BackendError(code, text)
+    }
+}

rust/agama-lib/src/error.rs

@@ -16,6 +16,8 @@ pub enum ServiceError {
     DBusProtocol(#[from] zbus::fdo::Error),
     #[error("Unexpected type on D-Bus '{0}'")]
     ZVariant(#[from] zvariant::Error),
+    #[error("Failed to communicate with HTTP backend '{0}'")]
+    HTTPError(#[from] reqwest::Error),
     // it's fine to say only "Error" because the original
     // specific error will be printed too
     #[error("Error: {0}")]
@@ -33,6 +35,8 @@ pub enum ServiceError {
     UnsuccessfulAction(String),
     #[error("Unknown installation phase: '{0}")]
     UnknownInstallationPhase(u32),
+    #[error("Backend call failed with status '{0}' and text '{1}'")]
+    BackendError(u16, String),
 }
 
 #[derive(Error, Debug)]

rust/agama-lib/src/lib.rs

@@ -24,6 +24,7 @@
 //! As said, those modules might implement additional stuff, like specific types, clients, etc.
 
 pub mod auth;
+pub mod base_http_client;
 pub mod error;
 pub mod install_settings;
 pub mod localization;

rust/agama-lib/src/questions.rs

@@ -1,8 +1,12 @@
 //! Data model for Agama questions
 
 use std::collections::HashMap;
+pub mod http_client;
+pub mod model;
 
 /// Basic generic question that fits question without special needs
+/// NOTE: structs below is for dbus usage and holds complete questions data
+/// for user side data model see questions::model
 #[derive(Clone, Debug)]
 pub struct GenericQuestion {
     /// numeric id used to identify question on D-Bus

rust/agama-lib/src/questions/http_client.rs

@@ -0,0 +1,69 @@
+use std::time::Duration;
+
+use reqwest::StatusCode;
+use tokio::time::sleep;
+
+use crate::{base_http_client::BaseHTTPClient, error::ServiceError};
+
+use super::model::{self, Answer, Question};
+
+pub struct HTTPClient {
+    client: BaseHTTPClient,
+}
+
+impl HTTPClient {
+    pub async fn new() -> Result<Self, ServiceError> {
+        Ok(Self {
+            client: BaseHTTPClient::new()?,
+        })
+    }
+
+    pub async fn list_questions(&self) -> Result<Vec<model::Question>, ServiceError> {
+        self.client.get("/questions").await
+    }
+
+    /// Creates question and return newly created question including id
+    pub async fn create_question(&self, question: &Question) -> Result<Question, ServiceError> {
+        let response = self.client.post_response("/questions", question).await?;
+        if response.status().is_success() {
+            let question = response.json().await?;
+            Ok(question)
+        } else {
+            Err(self.client.build_backend_error(response).await)
+        }
+    }
+
+    /// non blocking varient of checking if question has already answer
+    pub async fn try_answer(&self, question_id: u32) -> Result<Option<Answer>, ServiceError> {
+        let path = format!("/questions/{}/answer", question_id);
+        let response = self.client.get_response(path.as_str()).await?;
+        if response.status() == StatusCode::NOT_FOUND {
+            Ok(None)
+        } else if response.status().is_success() {
+            let answer = response.json().await?;
+            Ok(answer)
+        } else {
+            Err(self.client.build_backend_error(response).await)
+        }
+    }
+
+    /// Blocking variant of getting answer for given question.
+    pub async fn get_answer(&self, question_id: u32) -> Result<Answer, ServiceError> {
+        loop {
+            let answer = self.try_answer(question_id).await?;
+            if let Some(result) = answer {
+                return Ok(result);
+            }
+            let duration = Duration::from_secs(1);
+            sleep(duration).await;
+            // TODO: use websocket to get events instead of polling, but be aware of race condition that
+            // auto answer can answer faster before we connect to socket. So ask for answer
+            // and meanwhile start checking for events
+        }
+    }
+
+    pub async fn delete_question(&self, question_id: u32) -> Result<(), ServiceError> {
+        let path = format!("/questions/{}/answer", question_id);
+        self.client.delete(path.as_str()).await
+    }
+}