refactor(download manager): Moved manifest and stored_manifest to download_manager

Signed-off-by: quexeky <git@quexeky.dev>

src-tauri/src/download_manager/download_logic.rs

@@ -0,0 +1,213 @@
+use crate::auth::generate_authorization_header;
+use crate::db::DatabaseImpls;
+use crate::download_manager::application_download_error::ApplicationDownloadError;
+use crate::download_manager::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
+use crate::download_manager::progress_object::ProgressHandle;
+use crate::remote::RemoteAccessError;
+use crate::DB;
+use http::StatusCode;
+use log::{info, warn};
+use md5::{Context, Digest};
+use reqwest::blocking::Response;
+
+use std::fs::{set_permissions, Permissions};
+use std::io::Read;
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+use std::{
+    fs::{File, OpenOptions},
+    io::{self, BufWriter, Seek, SeekFrom, Write},
+    path::PathBuf,
+};
+use urlencoding::encode;
+
+use super::manifest::DropDownloadContext;
+
+pub struct DropWriter<W: Write> {
+    hasher: Context,
+    destination: W,
+}
+impl DropWriter<File> {
+    fn new(path: PathBuf) -> Self {
+        Self {
+            destination: OpenOptions::new().write(true).open(path).unwrap(),
+            hasher: Context::new(),
+        }
+    }
+
+    fn finish(mut self) -> io::Result<Digest> {
+        self.flush().unwrap();
+        Ok(self.hasher.compute())
+    }
+}
+// Write automatically pushes to file and hasher
+impl Write for DropWriter<File> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        /*
+        self.hasher.write_all(buf).map_err(|e| {
+            io::Error::new(
+                ErrorKind::Other,
+                format!("Unable to write to hasher: {}", e),
+            )
+        })?;
+         */
+        self.destination.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        // self.hasher.flush()?;
+        self.destination.flush()
+    }
+}
+// Seek moves around destination output
+impl Seek for DropWriter<File> {
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        self.destination.seek(pos)
+    }
+}
+
+pub struct DropDownloadPipeline<R: Read, W: Write> {
+    pub source: R,
+    pub destination: DropWriter<W>,
+    pub control_flag: DownloadThreadControl,
+    pub progress: ProgressHandle,
+    pub size: usize,
+}
+impl DropDownloadPipeline<Response, File> {
+    fn new(
+        source: Response,
+        destination: DropWriter<File>,
+        control_flag: DownloadThreadControl,
+        progress: ProgressHandle,
+        size: usize,
+    ) -> Self {
+        Self {
+            source,
+            destination,
+            control_flag,
+            progress,
+            size,
+        }
+    }
+
+    fn copy(&mut self) -> Result<bool, io::Error> {
+        let copy_buf_size = 512;
+        let mut copy_buf = vec![0; copy_buf_size];
+        let mut buf_writer = BufWriter::with_capacity(1024 * 1024, &mut self.destination);
+
+        let mut current_size = 0;
+        loop {
+            if self.control_flag.get() == DownloadThreadControlFlag::Stop {
+                return Ok(false);
+            }
+
+            let bytes_read = self.source.read(&mut copy_buf)?;
+            current_size += bytes_read;
+
+            buf_writer.write_all(&copy_buf[0..bytes_read])?;
+            self.progress.add(bytes_read);
+
+            if current_size == self.size {
+                break;
+            }
+        }
+
+        Ok(true)
+    }
+
+    fn finish(self) -> Result<Digest, io::Error> {
+        let checksum = self.destination.finish()?;
+        Ok(checksum)
+    }
+}
+
+pub fn download_game_chunk(
+    ctx: DropDownloadContext,
+    control_flag: DownloadThreadControl,
+    progress: ProgressHandle,
+) -> Result<bool, ApplicationDownloadError> {
+    // If we're paused
+    if control_flag.get() == DownloadThreadControlFlag::Stop {
+        progress.set(0);
+        return Ok(false);
+    }
+
+    let base_url = DB.fetch_base_url();
+
+    let client = reqwest::blocking::Client::new();
+    let chunk_url = base_url
+        .join(&format!(
+            "/api/v1/client/chunk?id={}&version={}&name={}&chunk={}",
+            // Encode the parts we don't trust
+            ctx.game_id,
+            encode(&ctx.version),
+            encode(&ctx.file_name),
+            ctx.index
+        ))
+        .unwrap();
+
+    let header = generate_authorization_header();
+
+    let response = client
+        .get(chunk_url)
+        .header("Authorization", header)
+        .send()
+        .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
+
+    if response.status() != 200 {
+        warn!("{}", response.text().unwrap());
+        return Err(ApplicationDownloadError::Communication(
+            RemoteAccessError::InvalidCodeError(400),
+        ));
+    }
+
+    let mut destination = DropWriter::new(ctx.path.clone());
+
+    if ctx.offset != 0 {
+        destination
+            .seek(SeekFrom::Start(ctx.offset))
+            .expect("Failed to seek to file offset");
+    }
+
+    let content_length = response.content_length();
+    if content_length.is_none() {
+        return Err(ApplicationDownloadError::Communication(
+            RemoteAccessError::InvalidResponse,
+        ));
+    }
+
+    let mut pipeline = DropDownloadPipeline::new(
+        response,
+        destination,
+        control_flag,
+        progress,
+        content_length.unwrap().try_into().unwrap(),
+    );
+
+    let completed = pipeline
+        .copy()
+        .map_err(|e| ApplicationDownloadError::IoError(e.kind()))?;
+    if !completed {
+        return Ok(false);
+    };
+
+    // If we complete the file, set the permissions (if on Linux)
+    #[cfg(unix)]
+    {
+        let permissions = Permissions::from_mode(ctx.permissions);
+        set_permissions(ctx.path, permissions).unwrap();
+    }
+
+    /*
+    let checksum = pipeline
+        .finish()
+        .map_err(|e| GameDownloadError::IoError(e))?;
+
+    let res = hex::encode(checksum.0);
+    if res != ctx.checksum {
+        return Err(GameDownloadError::Checksum);
+    }
+     */
+
+    Ok(true)
+}

src-tauri/src/download_manager/manifest.rs

@@ -0,0 +1,27 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+pub type DropManifest = HashMap<String, DropChunk>;
+#[derive(Serialize, Deserialize, Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct DropChunk {
+    pub permissions: u32,
+    pub ids: Vec<String>,
+    pub checksums: Vec<String>,
+    pub lengths: Vec<usize>,
+    pub version_name: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct DropDownloadContext {
+    pub file_name: String,
+    pub version: String,
+    pub index: usize,
+    pub offset: u64,
+    pub game_id: String,
+    pub path: PathBuf,
+    pub checksum: String,
+    pub length: usize,
+    pub permissions: u32,
+}

src-tauri/src/download_manager/mod.rs

@@ -4,4 +4,7 @@ pub mod progress_object;
 pub mod queue;
 pub mod download_thread_control_flag;
 pub mod downloadable;
-pub mod application_download_error;
+pub mod application_download_error;
+pub mod download_logic;
+pub mod manifest;
+pub mod stored_manifest;

src-tauri/src/download_manager/stored_manifest.rs

@@ -0,0 +1,81 @@
+use std::{
+    fs::File,
+    io::{Read, Write},
+    path::PathBuf,
+    sync::Mutex,
+};
+
+use log::error;
+use serde::{Deserialize, Serialize};
+use serde_binary::binary_stream::Endian;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct StoredManifest {
+    game_id: String,
+    game_version: String,
+    pub completed_contexts: Mutex<Vec<usize>>,
+    pub base_path: PathBuf,
+}
+
+static DROP_DATA_PATH: &str = ".dropdata";
+
+impl StoredManifest {
+    pub fn new(game_id: String, game_version: String, base_path: PathBuf) -> Self {
+        Self {
+            base_path,
+            game_id,
+            game_version,
+            completed_contexts: Mutex::new(Vec::new()),
+        }
+    }
+    pub fn generate(game_id: String, game_version: String, base_path: PathBuf) -> Self {
+        let mut file = match File::open(base_path.join(DROP_DATA_PATH)) {
+            Ok(file) => file,
+            Err(_) => return StoredManifest::new(game_id, game_version, base_path),
+        };
+
+        let mut s = Vec::new();
+        match file.read_to_end(&mut s) {
+            Ok(_) => {}
+            Err(e) => {
+                error!("{}", e);
+                return StoredManifest::new(game_id, game_version, base_path);
+            }
+        };
+
+        
+
+        match serde_binary::from_vec::<StoredManifest>(s, Endian::Little) {
+            Ok(manifest) => manifest,
+            Err(e) => {
+                error!("{}", e);
+                StoredManifest::new(game_id, game_version, base_path)
+            }
+        }
+    }
+    pub fn write(&self) {
+        let manifest_raw = match serde_binary::to_vec(&self, Endian::Little) {
+            Ok(json) => json,
+            Err(_) => return,
+        };
+
+        let mut file = match File::create(self.base_path.join(DROP_DATA_PATH)) {
+            Ok(file) => file,
+            Err(e) => {
+                error!("{}", e);
+                return;
+            }
+        };
+
+        match file.write_all(&manifest_raw) {
+            Ok(_) => {}
+            Err(e) => error!("{}", e),
+        };
+    }
+    pub fn set_completed_contexts(&self, completed_contexts: &Vec<usize>) {
+        *self.completed_contexts.lock().unwrap() = completed_contexts.clone();
+    }
+    pub fn get_completed_contexts(&self) -> Vec<usize> {
+        self.completed_contexts.lock().unwrap().clone()
+    }
+}