Merge pull request #1211 from tonymushah/995-experimental-upload-integration

Feat: finish upload implementation part 1

Author: tonymushah

Cargo.lock

@@ -37,6 +37,7 @@ clap = "4"
 csv = "1"
 hotpath = { version = "0.7" }
 shrink_fit_wrapper = "1"
+rand = "0.9"
 
 [workspace.dependencies.tauri-plugin-notification]
 git = "https://github.com/tauri-apps/plugins-workspace"

Cargo.toml

@@ -58,6 +58,7 @@ serde-xml-rs.workspace = true
 csv.workspace = true
 hotpath = { workspace = true, optional = true }
 shrink_fit_wrapper.workspace = true
+rand.workspace = true
 
 [dependencies.eureka-mmanager]
 version = "0.4"

src-tauri/mangadex/Cargo.toml

@@ -1,4 +1,7 @@
+pub mod inner_queue;
+
 use crate::error::wrapped::Result;
+use crate::mutation::upload::inner_queue::InternalSessionsMutations;
 use crate::utils::traits_utils::{MangadexAsyncGraphQLContextExt, MangadexTauriManagerExt};
 use async_graphql::{Context, Object};
 use mangadex_api::{
@@ -41,6 +44,9 @@ pub struct UploadMutations;
 #[Object]
 #[cfg_attr(feature = "hotpath", hotpath::measure_all)]
 impl UploadMutations {
+    pub async fn internal(&self) -> InternalSessionsMutations {
+        InternalSessionsMutations
+    }
     pub async fn begin_session(
         &self,
         ctx: &Context<'_>,

src-tauri/mangadex/src/mutation/upload.rs

@@ -0,0 +1,135 @@
+use std::path::PathBuf;
+
+use async_graphql::{Context, Object};
+use uuid::Uuid;
+
+use crate::{
+    ErrorWrapper,
+    upload::InternUploadSessionCommitData,
+    utils::traits_utils::{MangadexAsyncGraphQLContextExt, MangadexTauriManagerExt},
+};
+
+pub struct InternalSessionsMutations;
+
+#[Object]
+impl InternalSessionsMutations {
+    pub async fn session(&self, id: Uuid) -> InternalSessionMutation {
+        InternalSessionMutation(id)
+    }
+    /// Returns the internal session id
+    pub async fn create_session(
+        &self,
+        ctx: &Context<'_>,
+        manga_id: Uuid,
+        groups: Option<Vec<Uuid>>,
+    ) -> Result<Uuid, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        Ok(manager.create_session(manga_id, groups).await?)
+    }
+    pub async fn start_queue_runner(
+        &self,
+        ctx: &Context<'_>,
+    ) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager.start_queue_runner().await;
+        Ok(None)
+    }
+    pub async fn swap_queue_order(
+        &self,
+        ctx: &Context<'_>,
+        a: Uuid,
+        b: Uuid,
+    ) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager.swap(a, b).await?;
+        Ok(None)
+    }
+}
+
+pub struct InternalSessionMutation(Uuid);
+
+#[Object]
+impl InternalSessionMutation {
+    pub async fn send_in_queue(&self, ctx: &Context<'_>) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager.send_session_in_queue(self.0).await?;
+        Ok(None)
+    }
+    pub async fn remove(&self, ctx: &Context<'_>) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager.remove_session(self.0).await?;
+        Ok(None)
+    }
+    pub async fn add_file(
+        &self,
+        ctx: &Context<'_>,
+        img_path: String,
+        index: Option<u32>,
+    ) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager
+            .add_file_to_session(self.0, img_path.into(), index)
+            .await?;
+        Ok(None)
+    }
+    pub async fn add_files(
+        &self,
+        ctx: &Context<'_>,
+        img_paths: Vec<String>,
+        index: Option<u32>,
+    ) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager
+            .add_files_to_session(
+                self.0,
+                img_paths.into_iter().map(PathBuf::from).collect(),
+                index,
+            )
+            .await?;
+        Ok(None)
+    }
+    pub async fn remove_file(
+        &self,
+        ctx: &Context<'_>,
+        img_path: String,
+    ) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager.remove_file_from_session(self.0, img_path).await?;
+        Ok(None)
+    }
+    pub async fn remove_files(
+        &self,
+        ctx: &Context<'_>,
+        img_paths: Vec<String>,
+    ) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        manager.remove_files_from_session(self.0, img_paths).await?;
+        Ok(None)
+    }
+    pub async fn set_commit_data(
+        &self,
+        ctx: &Context<'_>,
+        commit_data: Option<InternUploadSessionCommitData>,
+        start_runner: Option<bool>,
+    ) -> Result<Option<bool>, ErrorWrapper> {
+        let app_handle = ctx.get_app_handle::<tauri::Wry>()?;
+        let manager = app_handle.upload_manager();
+        if start_runner.unwrap_or_default() {
+            manager
+                .set_commit_data_and_send_to_queue(self.0, commit_data)
+                .await?;
+        } else {
+            manager.set_commit_data(self.0, commit_data).await?;
+        }
+        Ok(None)
+    }
+}

src-tauri/mangadex/src/mutation/upload/inner_queue.rs

@@ -1,6 +1,7 @@
 pub mod chapters;
 pub mod covers;
 pub mod favicon;
+pub mod upload_image;
 
 use std::error::Error;
 
@@ -124,6 +125,9 @@ fn handle<R: Runtime>(app: AppHandle<R>, req: Request<Vec<u8>>) -> Response<Vec<
                     "chapter-cache" => {
                         chapters::cache::handle_chapters_cache(&app, &req).into_response()
                     }
+                    "upload-image" => {
+                        upload_image::handle_upload_image_req(&app, &req).into_response()
+                    }
                     _ => not_found,
                 }
             } else {

src-tauri/mangadex/src/scheme.rs

@@ -5,7 +5,7 @@ use crate::{
 use eureka_mmanager::prelude::ChapterDataPullAsyncTrait;
 use reqwest::header::{ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_LENGTH, CONTENT_TYPE};
 use std::{
-    io::{self, Write},
+    io::{self, BufReader, Write},
     ops::Deref,
     path::Path,
 };
@@ -53,7 +53,7 @@ impl<'a, R: Runtime> ChaptersHandlerOffline<'a, R> {
                 .map_err(|_| not_found_chapter_image(self.chapter_id, &self.filename))?,
             }
         };
-        io::copy(&mut file, &mut buf)?;
+        io::copy(&mut BufReader::new(&mut file), &mut buf)?;
         buf.flush()?;
         Ok(buf)
     }

src-tauri/mangadex/src/scheme/chapters/offline.rs

@@ -0,0 +1,85 @@
+use std::io::{self, BufReader};
+
+use reqwest::header::{ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_LENGTH, CONTENT_TYPE};
+use tauri::{
+    AppHandle, Runtime,
+    http::{Request, StatusCode},
+};
+
+use crate::utils::traits_utils::MangadexTauriManagerExt;
+
+use super::{SchemeResponseError, SchemeResponseResult, parse_uri};
+use regex::Regex;
+use uuid::Uuid;
+
+#[cfg_attr(feature = "hotpath", hotpath::measure)]
+fn not_found_upload_image(session_id: Uuid, filename: &str) -> SchemeResponseError {
+    SchemeResponseError::NotFound(
+        format!("the given internal session `{session_id}`/{filename} is not found").into_bytes(),
+    )
+}
+
+#[cfg_attr(feature = "hotpath", hotpath::measure)]
+fn get_upload_session_params(req: &Request<Vec<u8>>) -> SchemeResponseResult<(Uuid, String)> {
+    let regex = Regex::new(
+        r"(?x)/(?P<session_id>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/(?P<filename>\w*.*)",
+    )?;
+    let uri = parse_uri(req)?;
+    let captures = regex
+        .captures(uri.path())
+        .ok_or(SchemeResponseError::InvalidURLInput)?;
+    let chapter_id = captures
+        .name("session_id")
+        .and_then(|id| Uuid::parse_str(id.as_str()).ok())
+        .ok_or(SchemeResponseError::InvalidURLInput)?;
+    let filename = captures
+        .name("filename")
+        .map(|match_| match_.as_str().into())
+        .ok_or(SchemeResponseError::InvalidURLInput)?;
+    Ok((chapter_id, filename))
+}
+
+pub fn handle_upload_image_req<'a, R: Runtime>(
+    app: &'a AppHandle<R>,
+    req: &'a Request<Vec<u8>>,
+) -> SchemeResponseResult<tauri::http::Response<Vec<u8>>> {
+    let manager = app.upload_manager();
+    let (id, filename) = get_upload_session_params(req)?;
+    let res = tauri::async_runtime::block_on(async {
+        manager
+            .get_read_file_from_session(id, filename.clone())
+            .await
+    });
+    // preallocating here
+    // to make it more performant?
+    let mut body: Vec<u8> = match &res {
+        Ok(file) => file
+            .metadata()
+            .map(|m| {
+                let cp: usize = m.len().try_into().unwrap_or(1_024);
+                Vec::with_capacity(cp)
+            })
+            .unwrap_or(Vec::with_capacity(1_024)),
+        _ => Vec::with_capacity(1_024),
+    };
+    match res {
+        Ok(file) => {
+            let mut buf_read = BufReader::new(file);
+            io::copy(&mut buf_read, &mut body)
+                .map_err(|e| SchemeResponseError::InternalError(Box::new(e)))?;
+        }
+        Err(crate::Error::Io(io)) if io.kind() == std::io::ErrorKind::NotFound => {
+            return Err(not_found_upload_image(id, &filename));
+        }
+        Err(err) => {
+            return Err(SchemeResponseError::InternalError(Box::new(err)));
+        }
+    }
+    tauri::http::Response::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, "image/*")
+        .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+        .header(CONTENT_LENGTH, format!("{}", body.len()).as_str())
+        .body(body)
+        .map_err(|e| SchemeResponseError::InternalError(Box::new(e)))
+}

src-tauri/mangadex/src/scheme/upload_image.rs

@@ -34,4 +34,5 @@ pub struct Subscriptions(
     chapter_pages::ChapterPagesSubscription,
     user_option_next::UserOptionNextSubscriptions,
     read_marker::ChapterReadMarkerSubscriptions,
+    upload::internal::InternalUploadSubscriptions,
 );

src-tauri/mangadex/src/subscription.rs

@@ -1,2 +1,3 @@
+pub mod internal;
 pub mod session;
 pub mod session_file;