feat: enable uploading map images

Author: chatasma

Cargo.lock

@@ -31,3 +31,9 @@ enum_dispatch = "0.3.8"
 async-trait = "0.1.89"
 reqwest = { version = "0.11.17", features = ["json"] }
 rocket_cors = "0.6.0"
+image = "0.25.9"
+ravif = "0.12.0"
+rgb = "0.8.52"
+imgref = "1.12.0"
+bytes = "1.11.0"
+tokio-util = "0.7.17"

Cargo.toml

@@ -1,4 +1,5 @@
-FROM rust:1.72
+FROM rust:latest
+RUN apt-get update && apt-get install -y nasm
 WORKDIR /usr/src/mars-api
 RUN mkdir /app
 COPY . .

Dockerfile

@@ -98,7 +98,9 @@ async fn deserialize_mars_options() -> Result<MarsConfigOptions, ConfigDeseriali
             "webhooks.reports" => { config.reports_webhook_url = v.to_string(); },
             "webhooks.notes" => { config.notes_webhook_url = v.to_string(); },
             "webhooks.debug" => { config.debug_log_webhook_url = v.to_string(); },
-            "enable-exponential-exp" => { if let Ok(b) = v.to_string().parse::<bool>() { config.use_exponential_exp = b; } }
+            "enable-exponential-exp" => { if let Ok(b) = v.to_string().parse::<bool>() { config.use_exponential_exp = b; } },
+            "images-path" => { config.images_path = Some(v.to_string()); },
+            "avif-transcode" => { config.avif_transcode = false; }
             _ => {}
         }
     });
@@ -175,7 +177,10 @@ pub struct MarsConfigOptions {
     pub reports_webhook_url: String,
     pub notes_webhook_url: String,
     pub debug_log_webhook_url: String,
-    pub use_exponential_exp: bool
+    pub use_exponential_exp: bool,
+    pub images_path: Option<String>,
+    // not supported yet
+    pub avif_transcode: bool
 }
 
 impl Default for MarsConfigOptions {
@@ -190,7 +195,9 @@ impl Default for MarsConfigOptions {
             reports_webhook_url: String::new(),
             notes_webhook_url: String::new(),
             debug_log_webhook_url: String::new(),
-            use_exponential_exp: false
+            use_exponential_exp: false,
+            images_path: None,
+            avif_transcode: false
         }
     }
 }

src/config.rs

@@ -70,7 +70,7 @@ impl Default for LevelRecords {
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct LevelContributor {
     uuid: String,

src/database/models/level.rs

@@ -98,7 +98,7 @@ async fn get_achievements(
     Json(state.database.get_all_documents::<Achievement>().await)
 }
 
-pub fn mount(rocket_build: Rocket<Build>) -> Rocket<Build> {
+pub fn mount(rocket_build: Rocket<Build>, state: &MarsAPIState) -> Rocket<Build> {
     rocket_build.mount("/mc/achievements", routes![
        get_achievements,
        get_achievement_by_id,

src/http/achievements/mod.rs

@@ -6,6 +6,6 @@ pub fn broadcasts(state: &State<MarsAPIState>) -> Json<&Vec<Broadcast>> {
     Json(&state.config.data.broadcasts) 
 }
 
-pub fn mount(rocket_build: Rocket<Build>) -> Rocket<Build> {
+pub fn mount(rocket_build: Rocket<Build>, state: &MarsAPIState) -> Rocket<Build> {
     rocket_build.mount("/mc/broadcasts", routes![broadcasts])
 }

src/http/broadcast/mod.rs

@@ -47,6 +47,6 @@ async fn get_leaderboard_entries(
     Ok(Json(leaderboard))
 }
 
-pub fn mount(rocket: Rocket<Build>) -> Rocket<Build> {
+pub fn mount(rocket: Rocket<Build>, state: &MarsAPIState) -> Rocket<Build> {
     rocket.mount("/mc/leaderboards", routes![get_leaderboard_entries])
 }

src/http/leaderboard/mod.rs

@@ -6,6 +6,6 @@ fn get_level_colors(state: &State<MarsAPIState>) -> Json<&Vec<LevelColor>> {
     Json(&state.config.data.level_colors)
 }
 
-pub fn mount(rocket_build: Rocket<Build>) -> Rocket<Build> {
+pub fn mount(rocket_build: Rocket<Build>, state: &MarsAPIState) -> Rocket<Build> {
     rocket_build.mount("/mc/levels", routes![get_level_colors])
 }

src/http/level/mod.rs

@@ -0,0 +1,91 @@
+use std::{io::Cursor, path::PathBuf, sync::Arc};
+
+use bytes::Bytes;
+use image::{GenericImageView, ImageReader};
+use log::{error, warn};
+use rgb::FromSlice;
+use tokio::sync::{Semaphore, mpsc::{self, Sender}};
+
+use crate::util::{r#macro::unwrap_helper, stream::{BoundedFrameDecoder, LengthPrefixedDataDecoder}};
+
+pub struct ImageState {
+    pub transmit: Arc<Sender<(String, Vec<u8>)>>
+}
+
+pub fn image_queue_processor(
+    base_path: Arc<PathBuf>, transcode: bool, image_guard: Arc<Semaphore>
+) -> mpsc::Sender<(String, Vec<u8>)> {
+    let (tx, mut rx) = mpsc::channel::<(String, Vec<u8>)>(
+        128
+    );
+    tokio::spawn(async move {
+        while let Some(data) = rx.recv().await {
+            submit_image(base_path.clone(), transcode, image_guard.clone(), data).await;
+        }
+    });
+    tx
+}
+
+async fn submit_image(base_path: Arc<PathBuf>, transcode: bool, image_guard: Arc<Semaphore>, data: (String, Vec<u8>)) {
+    let permit = image_guard.clone().acquire_owned().await.unwrap();
+    tokio::task::spawn_blocking(move || {
+        let _permit_use = permit;
+        store_map_image(base_path, transcode, data);
+    });
+}
+
+fn store_map_image(
+    base_path: Arc<PathBuf>, 
+    transcode: bool, 
+    image_and_name: (String, Vec<u8>)
+) {
+    let (file_name, image) = image_and_name;
+    if !transcode {
+        let destination = base_path.join(format!("{}.png", file_name));
+        std::fs::write(destination, image);
+    } else {
+        let destination = base_path.join(format!("{}.avif", file_name));
+        let data = image;
+
+        let mut image_reader = ImageReader::new(Cursor::new(data));
+        image_reader.set_format(image::ImageFormat::Png);
+        let image = match image_reader.decode() {
+            Ok(image) => image,
+            Err(e) => {
+                error!("Could not save {} due to {:?}", file_name, e);
+                return;
+            },
+        };
+        let (width, height) = image.dimensions();
+        let rgb_image = image.into_rgba8();
+        let rgb_data = rgb_image.into_raw();
+        let encoder = ravif::Encoder::new();
+        let img = imgref::Img::new(rgb_data.as_rgba(), width as usize, height as usize);
+        let avif_data = unwrap_helper::result_return_default!(encoder.encode_rgba(img), ());
+        std::fs::write(destination, avif_data.avif_file);
+    }
+}
+
+pub fn create_image_decoder() -> BoundedFrameDecoder {
+    BoundedFrameDecoder::new(
+        1024, 
+        Box::new(
+            LengthPrefixedDataDecoder::new()
+        )
+    )
+}
+
+pub fn parse_image_data(mut bytes: Bytes) -> (String, Vec<u8>)  {
+    let image_name = read_length_prefixed_string(&mut bytes);
+    (image_name, Vec::from(bytes))
+}
+
+fn read_length_prefixed_string(bytes: &mut Bytes) -> String {
+    String::from_utf8(Vec::from(read_length_prefixed_data(bytes))).unwrap()
+}
+
+fn read_length_prefixed_data(bytes: &mut Bytes) -> Bytes {
+    let arr = <[u8; 4]>::try_from(bytes.split_to(4).as_ref()).unwrap();
+    let size = u32::from_be_bytes(arr);
+    bytes.split_to(size as usize)
+}