Update cache and routing

Author: lucemans

app/src/cache.rs

@@ -1,28 +1,77 @@
 use std::time::Duration;
 
+use futures::future::join_all;
+use futures::FutureExt;
 use moka::future::Cache;
 
 use crate::models::bm::player::BattleMetricsPlayerResponse;
 use crate::models::bm::recent::BattleMetricsRecentServers;
+use crate::models::rm::MapResponse;
+use crate::models::rm::SearchResponse;
+use crate::state::AppState;
 
 pub struct AppCache {
     pub bm_user_from_name: Cache<String, BattleMetricsPlayerResponse>,
     pub bm_recent_servers: Cache<String, BattleMetricsRecentServers>,
+    pub rm_search: Cache<String, SearchResponse>,
+    pub rm_map: Cache<String, MapResponse>,
 }
 
 impl AppCache {
     pub fn new() -> Self {
         Self {
             bm_user_from_name: Cache::builder()
                 .time_to_live(Duration::from_secs(5 * 60))
+                .time_to_idle(Duration::from_secs(1 * 60))
                 .max_capacity(1000)
                 .build(),
             bm_recent_servers: Cache::builder()
                 .time_to_live(Duration::from_secs(5 * 60))
+                .time_to_idle(Duration::from_secs(1 * 60))
+                .max_capacity(1000)
+                .build(),
+            rm_search: Cache::builder()
+                .time_to_live(Duration::from_secs(5 * 60))
+                .time_to_idle(Duration::from_secs(1 * 60))
+                .max_capacity(1000)
+                .build(),
+            rm_map: Cache::builder()
+                .time_to_live(Duration::from_secs(5 * 60))
+                .time_to_idle(Duration::from_secs(1 * 60))
                 .max_capacity(1000)
                 .build(),
         }
     }
+
+    pub async fn get_sizes(&self) -> (u64, u64, u64, u64) {
+        (
+            self.bm_user_from_name.weighted_size(),
+            self.bm_recent_servers.weighted_size(),
+            self.rm_search.weighted_size(),
+            self.rm_map.weighted_size(),
+        )
+    }
+
+    pub async fn collect(&self, state: &AppState) {
+        loop {
+            self.collect_all().await;
+
+            let (bm_user_from_name, bm_recent_servers, rm_search, rm_map) = self.get_sizes().await;
+            tracing::info!("Cache sizes: bm_user_from_name: {}, bm_recent_servers: {}, rm_search: {}, rm_map: {}", bm_user_from_name, bm_recent_servers, rm_search, rm_map);
+            async_std::task::sleep(std::time::Duration::from_secs(10)).await;
+        }
+    }
+
+    pub async fn collect_all(&self) {
+        let tasks = vec![
+            async { self.bm_user_from_name.run_pending_tasks().await }.boxed(),
+            async { self.bm_recent_servers.run_pending_tasks().await }.boxed(),
+            async { self.rm_search.run_pending_tasks().await }.boxed(),
+            async { self.rm_map.run_pending_tasks().await }.boxed(),
+        ];
+
+        join_all(tasks).await;
+    }
 }
 
 impl Default for AppCache {

app/src/main.rs

@@ -1,10 +1,11 @@
+use async_std::prelude::FutureExt;
 use state::{AppState, AppStateInner};
 use std::sync::Arc;
 
+pub mod cache;
 pub mod database;
 pub mod models;
 pub mod server;
-pub mod cache;
 pub mod state;
 pub mod util;
 
@@ -21,5 +22,9 @@ async fn main() {
     // let http = async { server::start_http(state.clone()).await };
 
     // telegram.race(http).await;
-    server::start_http(state).await;
+    let http = server::start_http(state.clone());
+
+    let cache_size_notifier = state.cache.collect(&state);
+
+    cache_size_notifier.race(http).await;
 }

app/src/models/mod.rs

@@ -1,2 +1,3 @@
 pub mod user;
 pub mod bm;
+pub mod rm;

app/src/models/rm/map.rs

@@ -0,0 +1,42 @@
+use crate::models::rm::MapResponse;
+use crate::state::AppState;
+use poem::Result;
+use reqwest::ClientBuilder;
+use reqwest::Client;
+use tracing::{info, warn};
+
+pub async fn get_map(map_id: String) -> Result<MapResponse> {
+    info!("Getting map: {}", map_id);
+    let url = format!("https://api.rustmaps.com/internal/v1/maps/{}", map_id);
+
+    let client = ClientBuilder::new()
+        .timeout(std::time::Duration::from_secs(10))
+        .use_rustls_tls()
+        .build()
+        .unwrap_or_else(|e| {
+            warn!(
+                "Failed to build custom HTTP client with rustls: {}, using default",
+                e
+            );
+            Client::new()
+        });
+    let response = client.get(url).send().await.unwrap();
+    let body = response.text().await.unwrap();
+    tracing::info!("{}", body);
+    let map_response: MapResponse = serde_json::from_str(&body).unwrap();
+
+    Ok(map_response)
+}
+
+pub async fn get_map_cached(map_id: String, state: &AppState) -> Result<MapResponse> {
+    let cache = state.cache.rm_map.try_get_with(map_id.clone(), get_map(map_id)).await;
+
+    match cache {
+        Ok(map_response) => Ok(map_response),
+        Err(e) => {
+            tracing::error!("Failed to get cached map response: {}", e);
+            let err: poem::Error = poem::Error::from_string(e.to_string(), poem::http::StatusCode::INTERNAL_SERVER_ERROR);
+            Err(err)
+        }
+    }
+}

app/src/models/rm/mod.rs

@@ -0,0 +1,85 @@
+use poem_openapi::Object;
+use serde::{Deserialize, Serialize};
+
+pub mod map;
+pub mod search;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct SearchResponse {
+    pub meta: SearchMeta,
+    pub data: Vec<Server>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct SearchMeta {
+    pub status: String,
+    #[serde(rename = "statusCode")]
+    pub status_code: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct Server {
+    pub name: String,
+    #[serde(rename = "mapId")]
+    pub map_id: String,
+    pub ip: String,
+    #[serde(rename = "gamePort")]
+    pub game_port: u16,
+    #[serde(rename = "lastWipeUtc")]
+    pub last_wipe_utc: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct MapResponse {
+    pub meta: MapMeta,
+    pub data: MapData,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct MapMeta {
+    pub status: String,
+    #[serde(rename = "statusCode")]
+    pub status_code: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct MapData {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub _type: String,
+    pub seed: u64,
+    pub size: u32,
+    #[serde(rename = "saveVersion")]
+    pub save_version: u32,
+    #[serde(rename = "imageUrl")]
+    pub image_url: String,
+    #[serde(rename = "titleBaseUrl")]
+    pub title_base_url: Option<String>,
+    #[serde(rename = "imageIconUrl")]
+    pub image_icon_url: Option<String>,
+    #[serde(rename = "thumbnailUrl")]
+    pub thumbnail_url: Option<String>,
+    #[serde(rename = "undergroundOverlayUrl")]
+    pub underground_overlay_url: Option<String>,
+    #[serde(rename = "buildingBlockAreaUrl")]
+    pub building_block_area_url: Option<String>,
+    #[serde(rename = "isStaging")]
+    pub is_staging: bool,
+    #[serde(rename = "isCustomMap")]
+    pub is_custom_map: bool,
+    #[serde(rename = "isForSale")]
+    pub is_for_sale: bool,
+    #[serde(rename = "isFeatured")]
+    pub is_featured: bool,
+    #[serde(rename = "hasCustomMonuments")]
+    pub has_custom_monuments: bool,
+    #[serde(rename = "canDownload")]
+    pub can_download: bool,
+    #[serde(rename = "downloadUrl")]
+    pub download_url: Option<String>,
+    pub slug: Option<String>,
+    pub monuments: Vec<serde_json::Value>,
+
+    #[serde(flatten)]
+    pub extra: serde_json::Value,
+}

app/src/models/rm/search.rs

@@ -0,0 +1,48 @@
+use poem::Result;
+use reqwest::ClientBuilder;
+use reqwest::Client;
+use tracing::{error, info, warn};
+
+use crate::state::AppState;
+
+use super::SearchResponse;
+
+pub async fn search_maps(query: String) -> Result<SearchResponse> {
+    info!("Searching for maps: {}", query);
+
+    let url = format!(
+        "https://api.rustmaps.com/internal/v1/servers/search?input={}",
+        query
+    );
+
+    let client = ClientBuilder::new()
+        .timeout(std::time::Duration::from_secs(10))
+        .use_rustls_tls()
+        .build()
+        .unwrap_or_else(|e| {
+            warn!(
+                "Failed to build custom HTTP client with rustls: {}, using default",
+                e
+            );
+            Client::new()
+        });
+    let response = client.get(url).send().await.unwrap();
+    let body = response.text().await.unwrap();
+    tracing::info!("{}", body);
+    let search_response: SearchResponse = serde_json::from_str(&body).unwrap();
+
+    Ok(search_response)
+}
+
+pub async fn search_maps_cached(query: String, state: &AppState) -> Result<SearchResponse> {
+    let cache = state.cache.rm_search.try_get_with(query.clone(), search_maps(query)).await;
+
+    match cache {
+        Ok(search_response) => Ok(search_response),
+        Err(e) => {
+            error!("Failed to get cached search response: {}", e);
+            let err: poem::Error = poem::Error::from_string(e.to_string(), poem::http::StatusCode::INTERNAL_SERVER_ERROR);
+            Err(err)
+        }
+    }
+}