alhp_api general should be working

crates/alhp_api/src/lib.rs

@@ -1,17 +1,18 @@
-use log::{error, info};
-use reqwest::StatusCode;
-use reqwest::blocking::Client;
-use serde::{Deserialize, Serialize};
-use std::error::Error;
-use std::fmt;
-
 const API_BASE_URL: &str = "https://api.alhp.dev";
 const API_PACKAGES_EXT: &str = "/packages?";
 const API_GENERAL_EXT: &str = "/stats?";
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
+pub mod packages {
-#[serde(rename_all = "lowercase")]
+    use crate::{API_BASE_URL, API_PACKAGES_EXT};
-pub enum PackageStatus {
+    use log::{error, info};
+    use reqwest::StatusCode;
+    use serde::{Deserialize, Serialize};
+    use std::error::Error;
+    use std::fmt;
+
+    #[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
+    #[serde(rename_all = "lowercase")]
+    pub enum PackageStatus {
         Latest,
         Failed,
         Built,
@@ -21,9 +22,9 @@ pub enum PackageStatus {
         Signing,
         Unknown,
         Queued,
-}
+    }
 
-impl fmt::Display for PackageStatus {
+    impl fmt::Display for PackageStatus {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             write!(
                 f,
@@ -41,10 +42,10 @@ impl fmt::Display for PackageStatus {
                 }
             )
         }
-}
+    }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+    #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Package {
+    pub struct Package {
         pkgbase: String,
         repo: String,
         split_packages: Vec<String>,
@@ -56,26 +57,26 @@ pub struct Package {
         repo_version: String,
         build_date: Option<String>,
         peak_mem: Option<String>,
-}
+    }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+    #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PackageResponse {
+    pub struct PackageResponse {
         pub total: usize,
         pub offset: usize,
         pub limit: usize,
         pub packages: Vec<Package>,
-}
+    }
-#[derive(Debug, Serialize, Default)]
+    #[derive(Debug, Serialize, Default)]
-pub struct PackageRequest {
+    pub struct PackageRequest {
         pub status: Vec<PackageStatus>,
         pub pkgbase: Option<String>,
         pub exact: bool,
         pub repo: Option<String>,
         pub offset: usize,
         pub limit: usize,
-}
+    }
 
-impl PackageRequest {
+    impl PackageRequest {
         fn query_string(&self) -> String {
             let mut params = Vec::new();
             for status in &self.status {
@@ -101,14 +102,11 @@ impl PackageRequest {
                 API_PACKAGES_EXT,
                 self.query_string()
             );
-        println!("{}", query_url);
-        let client = Client::new();
             info!("Fetching URL: {}", query_url);
-        let response = client.get(query_url).send()?;
+            let response = reqwest::blocking::get(query_url)?;
             match response.status() {
                 StatusCode::OK => {
                     let response = response.text()?;
-                println!("{}", response);
                     match serde_json::from_str(&response) {
                         Ok(json) => Ok(json),
                         Err(e) => {
@@ -120,7 +118,7 @@ impl PackageRequest {
                 }
                 StatusCode::NOT_FOUND => {
                     info!("No packages found");
-                Ok(PackageResponse{
+                    Ok(PackageResponse {
                         total: 0,
                         offset: 0,
                         limit: 0,
@@ -137,7 +135,69 @@ impl PackageRequest {
                         API_PACKAGES_EXT,
                         self.query_string()
                     );
-                panic!("Unexpected server response: {:?} for query url: {}", response, query_url);
+                    panic!(
+                        "Unexpected server response: {:?} for query url: {}",
+                        response, query_url
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub mod general {
+    use crate::{API_BASE_URL, API_GENERAL_EXT};
+    use log::error;
+    use reqwest::StatusCode;
+    use serde::{Deserialize, Serialize};
+    use std::error::Error;
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct LtoStats {
+        pub enabled: usize,
+        pub disabled: usize,
+        pub unknown: usize,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct GeneralResponse {
+        pub failed: usize,
+        pub skipped: usize,
+        pub latest: usize,
+        pub queued: usize,
+        pub lto: LtoStats,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct GeneralRequest {
+        //No params yet.
+    }
+    impl GeneralRequest {
+        pub fn response(&self) -> Result<GeneralResponse, Box<dyn Error>> {
+            let query_url = format!("{}{}", API_BASE_URL, API_GENERAL_EXT);
+            let response = reqwest::blocking::get(query_url)?;
+            match response.status() {
+                StatusCode::OK => {
+                    let response = response.text()?;
+                    match serde_json::from_str(&response) {
+                        Ok(json) => Ok(json),
+                        Err(e) => {
+                            error!("Failed to deserialize JSON: {}", e);
+                            error!("Response body: {}", response);
+                            Err(Box::new(e))
+                        }
+                    }
+                }
+                StatusCode::INTERNAL_SERVER_ERROR => {
+                    panic!("Internal Server Error");
+                }
+                _ => {
+                    let query_url = format!("{}{}", API_BASE_URL, API_GENERAL_EXT,);
+                    panic!(
+                        "Unexpected server response: {:?} for query url: {}",
+                        response, query_url
+                    );
+                }
             }
         }
     }

src/main.rs

@@ -1,13 +1,14 @@
 use alhp_api;
-use alpm::{Alpm};
+use alhp_api::general::GeneralRequest;
-use alhp_api::{PackageRequest, PackageStatus};
+use alhp_api::packages::{PackageRequest, PackageStatus};
+use alpm::Alpm;
 
 fn query_installed_packages() {
-    let alpm = match Alpm::new("/", "/var/lib/pacman"){
+    let alpm = match Alpm::new("/", "/var/lib/pacman") {
         Ok(alpm) => alpm,
         Err(_) => panic!("Error establishing ALPM handle."),
     };
-    let local_db= alpm.localdb();
+    let local_db = alpm.localdb();
     let server = local_db.servers();
     for s in server {
         println!("{}", s);
@@ -15,15 +16,19 @@ fn query_installed_packages() {
 }
 
 fn main() {
-    let pkg = PackageRequest{
+    let pkg = PackageRequest {
         status: vec![PackageStatus::Building, PackageStatus::Queued],
         pkgbase: None,
-        exact: true,
+        exact: false,
-        repo: Some("extra-x86-64-v3".to_string()),
+        // repo: Some("extra-x86-64-v3".to_string()),
+        repo: None,
         offset: 0,
         limit: 0,
     };
     let pkg = pkg.response().unwrap();
     println!("{:#?}", pkg);
+    let stats = GeneralRequest {};
+    let stats = stats.response().unwrap();
+    println!("{:#?}", stats);
     query_installed_packages();
 }