fix: only return active maps

Author: chatasma

src/database/mod.rs

@@ -5,6 +5,7 @@ use anyhow::anyhow;
 use futures::stream::FuturesUnordered;
 use futures::StreamExt;
 use mars_api_rs_macro::IdentifiableDocument;
+use mongodb::bson::Document;
 use mongodb::{bson::{doc, oid::ObjectId}, Client, Collection, Cursor, options::{ClientOptions, FindOneOptions, UpdateOptions}, results::DeleteResult};
 use mongodb::options::FindOptions;
 use rand::Rng;
@@ -14,7 +15,7 @@ use serde::Serialize;
 
 use models::tag::Tag;
 
-use crate::{database::models::player::Player, util::r#macro::unwrap_helper};
+use crate::database::models::player::Player;
 use crate::database::models::ip_identity::IpIdentity;
 use crate::database::models::player::SimplePlayer;
 use crate::util::validation::verbose_result_ok;
@@ -106,6 +107,19 @@ impl Database {
         }
     }
 
+    pub async fn get_all_active_maps(&self, time: u64) -> Vec<Level> {
+        let cursor = 
+            match Level::get_collection(&self)
+                .find(doc! { "updatedAt": { "$gte": time as i64 } }, None).await {
+                    Ok(cursor) => cursor,
+                    Err(e) => {
+                        warn!("Error retrieving latest maps: {}", e);
+                        return Vec::new();
+                    }
+                };
+        Self::consume_cursor_into_owning_vec_option(Some(cursor)).await
+    }
+
     pub async fn ensure_player_name_uniqueness(&self, name: &String, keep_id: &String) {
         let num: u16;
         {
@@ -206,6 +220,15 @@ impl Database {
         R::get_collection(&self).find_one(doc! { "nameLower": name.to_lowercase() }, None).await.unwrap_or(None)
     }
 
+    pub async fn find_by_fields<R>(&self, value: &str, field_names: Vec<String>) -> Option<R>
+        where R: CollectionOwner<R> + Serialize + IdentifiableDocument + DeserializeOwned + Unpin + Send + Sync {
+        let conditions: Vec<Document> = field_names
+            .iter()
+            .map(|name| doc! { name: value })
+            .collect();
+        R::get_collection(&self).find_one(doc! { "$or": conditions }, None).await.unwrap_or(None)
+    }
+
     pub async fn get_recent_matches(&self, limit: i64) -> Vec<Match> {
         let opts = FindOptions::builder().sort(doc! { "loadedAt": -1 }).limit(limit).build();
         let cursor = self.matches.find(doc! {}, Some(opts)).await.ok();

src/database/models/level.rs

@@ -15,6 +15,8 @@ pub struct Level {
     pub loaded_at: u64,
     pub name: String,
     pub name_lower: String,
+    #[serde(default)]
+    pub slug: Option<String>,
     pub version: String,
     pub gamemodes: Vec<LevelGamemode>,
     pub updated_at: u64,

src/http/map/mod.rs

@@ -1,9 +1,10 @@
-use std::path::{Path, PathBuf};
+use std::{path::Path, sync::Arc};
 
-use futures::{StreamExt, future::join_all};
+use futures::{FutureExt, StreamExt, future::join_all};
 use image::{create_image_decoder, parse_image_data};
 use mongodb::bson::doc;
 use rocket::{Build, Data, Rocket, State, data::ToByteUnit, fs::FileServer, serde::json::Json};
+use tokio::sync::RwLock;
 use tokio_util::codec::FramedRead;
 
 use crate::{MarsAPIState, database::{Database, models::level::{Level, LevelRecords}}, http::map::payload::MapLoadOneRequest, util::{auth::AuthorizationToken, error::ApiErrorResponder, r#macro::unwrap_helper, stream::LengthPrefixedDataDecoder, time::get_u64_time_millis}};
@@ -17,14 +18,16 @@ async fn add_maps(
     maps: Json<Vec<MapLoadOneRequest>>,
     _auth_guard: AuthorizationToken
 ) -> Json<Vec<Level>> {
-    let mut map_list = maps.0;
-    debug!("maps incoming are {:?}", &map_list);
+    let map_list = maps.0;
     let map_list_length = map_list.len();
     let time_millis = get_u64_time_millis();
     let mut maps_to_save : Vec<Level> = Vec::new();
 
     let query_tasks : Vec<_> = map_list.iter().map(|map| {
-        state.database.find_by_name::<Level>(&map.name)
+        state.database.find_by_fields::<Level>(
+            map.slug.as_ref().unwrap_or(&map.name), 
+            vec![String::from("slug"), String::from("nameLower")]
+        )
     }).collect();
     let level_docs = join_all(query_tasks).await;
     for (map, level_opt) in map_list.into_iter().zip(level_docs) {
@@ -44,6 +47,7 @@ async fn add_maps(
                 id: map.id,
                 name: map.name,
                 name_lower: lowercase_map_name,
+                slug: map.slug,
                 version: map.version,
                 gamemodes: map.gamemodes,
                 loaded_at: time_millis,
@@ -57,8 +61,23 @@ async fn add_maps(
         });
     }
 
-    let save_tasks : Vec<_> = maps_to_save.iter().map(|map| { state.database.save(map) }).collect();
-    join_all(save_tasks).await;
+
+    let tasks = {
+        let mut all_tasks = Vec::new();
+        let save_tasks : Vec<_> = 
+            maps_to_save.iter().map(|map| { state.database.save(map).boxed() }).collect();
+        let update_map_state = {
+            let rwlock = state.map_state.last_update.clone();
+            async move {
+                let mut timestamp = rwlock.write().await;
+                *timestamp = time_millis;
+            }.boxed()
+        };
+        all_tasks.extend(save_tasks);
+        all_tasks.push(update_map_state);
+        all_tasks
+    };
+    join_all(tasks).await;
 
     info!("Received {} maps. Updating {} maps.", map_list_length, maps_to_save.len());
     Json(state.database.get_all_documents().await)
@@ -97,7 +116,7 @@ async fn add_map_images(
 
 #[get("/")]
 async fn get_all_maps(state: &State<MarsAPIState>) -> Json<Vec<Level>> {
-    Json(state.database.get_all_documents::<Level>().await)
+    Json(state.database.get_all_active_maps(*state.map_state.last_update.read().await).await)
 }
 
 #[get("/<map_id>")]
@@ -106,15 +125,9 @@ async fn get_map_by_id(state: &State<MarsAPIState>, map_id: &str) -> Result<Json
     Ok(Json(map))
 }
 
-fn get_map_images_directory(state: &State<MarsAPIState>) -> Option<PathBuf> {
-    match state.config.options.images_path.as_ref() {
-        Some(path) => {
-            let mut p = PathBuf::new();
-            p.push(path);
-            Some(p)
-        },
-        None => None
-    }
+#[derive(Clone)]
+pub struct MapState {
+    pub last_update: Arc<RwLock<u64>>
 }
 
 pub fn mount(build: Rocket<Build>, state: &MarsAPIState) -> Rocket<Build> {

src/http/map/payload.rs

@@ -7,6 +7,8 @@ pub struct MapLoadOneRequest {
     #[serde(rename = "_id")] 
     pub id: String,
     pub name: String,
+    #[serde(default)] 
+    pub slug: Option<String>,
     pub version: String,
     pub gamemodes: Vec<LevelGamemode>,
     pub authors: Vec<LevelContributor>,

src/main.rs

@@ -5,11 +5,11 @@ use std::{env, marker::PhantomData, net::{IpAddr, Ipv4Addr}, path::PathBuf, sync
 use anyhow::anyhow;
 use config::{deserialize_mars_config, MarsConfig};
 use database::{Database, cache::{Cache, get_redis_pool, RedisAdapter}, models::{player::Player, r#match::Match}};
-use http::map::image::{ImageState, image_queue_processor};
+use http::map::{MapState, image::{ImageState, image_queue_processor}};
 use rocket::{figment::Figment, http::Method, Build, Config, Rocket, Shutdown};
 use rocket_cors::{AllowedOrigins, CorsOptions};
 use socket::leaderboard::MarsLeaderboards;
-use tokio::sync::Semaphore;
+use tokio::sync::{RwLock, Semaphore};
 use crate::database::migrations::MigrationExecutor;
 
 use crate::socket::socket_handler::{SocketState, setup_socket};
@@ -48,7 +48,8 @@ pub struct MarsAPIState {
     pub player_cache: Arc<Cache<Player>>,
     pub match_cache: Arc<Cache<Match>>,
     pub leaderboards: Arc<MarsLeaderboards>,
-    pub image_state: Arc<Option<ImageState>>
+    pub image_state: Arc<Option<ImageState>>,
+    pub map_state: Arc<MapState>
 }
 
 fn rocket(state: MarsAPIState) -> Rocket<Build> {
@@ -205,7 +206,12 @@ async fn main() -> Result<(), String> {
         player_cache, 
         match_cache,
         leaderboards,
-        image_state
+        image_state,
+        map_state: Arc::new(MapState { 
+            last_update: Arc::new(
+                RwLock::new(0)
+            ) 
+        })
     };