test(api): add web api

Author: Cyberdolfi

src/webapi/mod.rs

@@ -0,0 +1,5 @@
+# Test API
+I recently testet how I could implement the Web API, 
+but was not motivated to implement this in the project.
+
+I would be happy if you can make the API and send a pull request.

test_api/README.md

@@ -0,0 +1,45 @@
+use axum::{Json, extract::Query, http::StatusCode, response::IntoResponse};
+use serde::Deserialize;
+use crate::webapi::stats;
+
+#[derive(Deserialize)]
+pub struct SearchParams {
+    pub query: Option<String>,
+    pub limit: Option<i64>,
+}
+
+#[derive(Deserialize)]
+pub struct DeleteParams {
+    pub id: i32,
+}
+
+#[derive(Deserialize)]
+pub struct ScanParams {
+    pub generate: bool,
+    pub amount: Option<i32>,
+    pub cidr: Option<String>,
+}
+
+pub async fn get_stats() -> impl IntoResponse {
+    Json(stats::fetch_stats().await)
+}
+
+pub async fn search_servers(Query(params): Query<SearchParams>) -> impl IntoResponse {
+    StatusCode::NOT_IMPLEMENTED
+}
+
+pub async fn delete_server(Query(params): Query<DeleteParams>) -> impl IntoResponse {
+    format!("Deleting server with ID: {}", params.id)
+}
+
+pub async fn start_scan(
+    Query(params): Query<ScanParams>,
+    body: String
+) -> impl IntoResponse {
+    if params.generate {
+        (StatusCode::ACCEPTED, "Generation scan started".to_string())
+    } else {
+        let ip_count = body.lines().count();
+        (StatusCode::ACCEPTED, format!("Scanning {} provided IPs", ip_count))
+    }
+}

test_api/handlers.rs

@@ -0,0 +1,61 @@
+use std::net::SocketAddr;
+use axum::Router;
+use axum::routing::get;
+use crate::manager::TaskManager;
+use crate::logger;
+use crate::logger::DefaultColor;
+use colored_text::Colorize;
+use tokio_util::sync::CancellationToken;
+
+pub mod handlers;
+mod stats;
+
+pub async fn start(port: u16) {
+    let _ = TaskManager::spawn("WebAPI", move |cancel_token| async move {
+        let api_v1 = Router::new()
+            .route("/stats", get(handlers::get_stats))
+            .route("/server/search", get(handlers::search_servers))
+            .route("/server", delete(handlers::delete_server))
+            .route("/scan", post(handlers::start_scan));
+
+        let app = Router::new().nest("/api/v1", api_v1);
+
+        let addr = SocketAddr::from(([0, 0, 0, 0], port));
+
+        logger::info(
+            format!(
+                "API starting on {}{}",
+                "http://".hex(DefaultColor::Highlight.hex()),
+                addr.to_string().hex(DefaultColor::Highlight.hex())
+            )
+        ).prefix("WebAPI").send().await;
+
+        let listener = match tokio::net::TcpListener::bind(addr).await {
+            Ok(l) => l,
+            Err(e) => {
+                logger::error(format!(
+                    "Failed to bind API port {}: {}",
+                    port.hex(DefaultColor::Highlight.hex()),
+                    e.to_string().hex(DefaultColor::Highlight.hex())
+                )).prefix("WebAPI").send().await;
+                return;
+            }
+        };
+
+        if let Err(e) = axum::serve(listener, app)
+            .with_graceful_shutdown(shutdown_signal(cancel_token))
+            .await
+        {
+            logger::error(format!(
+                "API Server Error: {}",
+                e.to_string().hex(DefaultColor::Highlight.hex())
+            )).prefix("WebAPI").send().await;
+        }
+    }).await;
+}
+
+async fn shutdown_signal(token: CancellationToken) {
+    token.cancelled().await;
+    logger::warning("API received shutdown signal, closing connections...".into())
+        .prefix("WebAPI").send().await;
+}

test_api/mod.rs

@@ -0,0 +1,34 @@
+use serde::Serialize;
+use crate::database::server;
+
+#[derive(Serialize)]
+pub struct StatsResponse {
+    pub total_servers: i64,
+    pub history_entries: i64,
+    pub player_data_points: i64,
+    pub system: SystemInfo,
+}
+
+#[derive(Serialize)]
+pub struct SystemInfo {
+    pub version: String,
+    pub cpu_arch: String,
+    pub os: String,
+}
+
+pub async fn fetch_stats() -> StatsResponse {
+    let total_servers = server::get_total_servers().await.unwrap_or(-1);
+    let history_entries = server::get_total_history().await.unwrap_or(-1);
+    let player_data_points = server::get_total_player_history().await.unwrap_or(-1);
+
+    StatsResponse {
+        total_servers,
+        history_entries,
+        player_data_points,
+        system: SystemInfo {
+            version: env!("CARGO_PKG_VERSION").to_string(),
+            cpu_arch: std::env::consts::ARCH.to_string(),
+            os: std::env::consts::OS.to_string(),
+        },
+    }
+}