Ask cli

rust/agama-cli/src/main.rs

@@ -119,7 +119,7 @@ async fn build_manager<'a>() -> anyhow::Result<ManagerClient<'a>> {
 }
 
 async fn run_command(cli: Cli) -> Result<(), ServiceError> {
-    Ok(match cli.command {
+    match cli.command {
         Commands::Config(subcommand) => {
             let manager = build_manager().await?;
             wait_for_services(&manager).await?;
@@ -139,7 +139,9 @@ async fn run_command(cli: Cli) -> Result<(), ServiceError> {
         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-lib/src/base_http_client.rs

@@ -0,0 +1,81 @@
+use anyhow::Context;
+use reqwest::{header, Client, Response};
+use serde::de::DeserializeOwned;
+
+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 {
+            let code = response.status().as_u16();
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| Self::NO_TEXT.to_string());
+            Err(ServiceError::BackendError(code, text))
+        }        
+    }
+
+    /// 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
+    }
+}

rust/agama-lib/src/lib.rs

@@ -25,7 +25,7 @@
 
 pub mod auth;
 pub mod error;
-mod http_client;
+pub mod base_http_client;
 pub mod install_settings;
 pub mod localization;
 pub mod manager;

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

@@ -1,20 +1,19 @@
-use crate::error::ServiceError;
+use crate::{base_http_client::BaseHTTPClient, error::ServiceError};
 
 use super::model;
 
 pub struct HTTPClient {
-    client: crate::http_client::HTTPClient,
+    client: BaseHTTPClient,
 }
 
 impl HTTPClient {
     pub async fn new() -> Result<Self, ServiceError> {
         Ok(Self {
-            client: crate::http_client::HTTPClient::new().await?,
+            client: BaseHTTPClient::new()?,
         })
     }
 
     pub async fn list_questions(&self) -> Result<Vec<model::Question>, ServiceError> {
-        let questions = self.client.get_type("/questions").await?;
-        Ok(questions)
+        self.client.get("/questions").await
     }
 }