Collections & download stability, UI (#130)

* feat: different local path in dev #73

* feat: better error output for downloads

* feat: collections in library view

* feat: improve download manager reliability

* feat: new download UI, more stable downloads

* fix: clippy

* fix: only show admin link if user is admin

* feat: check for libs before building

src-tauri/src/games/downloads/download_logic.rs

@@ -9,7 +9,7 @@ use crate::games::downloads::manifest::{ChunkBody, DownloadBucket, DownloadConte
 use crate::remote::auth::generate_authorization_header;
 use crate::remote::requests::generate_url;
 use crate::remote::utils::DROP_CLIENT_SYNC;
-use log::{info, warn};
+use log::{debug, info, warn};
 use md5::{Context, Digest};
 use reqwest::blocking::Response;
 
@@ -18,6 +18,7 @@ use std::io::Read;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 use std::sync::Arc;
+use std::time::Instant;
 use std::{
     fs::{File, OpenOptions},
     io::{self, BufWriter, Seek, SeekFrom, Write},
@@ -25,6 +26,7 @@ use std::{
 };
 
 static MAX_PACKET_LENGTH: usize = 4096 * 4;
+static BUMP_SIZE: usize = 4096 * 16;
 
 pub struct DropWriter<W: Write> {
     hasher: Context,
@@ -79,6 +81,8 @@ pub struct DropDownloadPipeline<'a, R: Read, W: Write> {
     pub drops: Vec<DownloadDrop>,
     pub destination: Vec<DropWriter<W>>,
     pub control_flag: &'a DownloadThreadControl,
+    #[allow(dead_code)]
+    progress: ProgressHandle,
 }
 
 impl<'a> DropDownloadPipeline<'a, Response, File> {
@@ -96,6 +100,7 @@ impl<'a> DropDownloadPipeline<'a, Response, File> {
                 .try_collect()?,
             drops,
             control_flag,
+            progress,
         })
     }
 
@@ -111,13 +116,24 @@ impl<'a> DropDownloadPipeline<'a, Response, File> {
             if drop.start != 0 {
                 destination.seek(SeekFrom::Start(drop.start.try_into().unwrap()))?;
             }
+            let mut last_bump = 0;
             loop {
                 let size = MAX_PACKET_LENGTH.min(remaining);
-                self.source.read_exact(&mut copy_buffer[0..size])?;
+                let size = self.source.read(&mut copy_buffer[0..size]).inspect_err(|_| {
+                    info!("got error from {}", drop.filename);
+                })?;
                 remaining -= size;
+                last_bump += size;
 
                 destination.write_all(&copy_buffer[0..size])?;
 
+                if last_bump > BUMP_SIZE {
+                    last_bump -= BUMP_SIZE;
+                    if self.control_flag.get() == DownloadThreadControlFlag::Stop {
+                        return Ok(false);
+                    }
+                }
+
                 if remaining == 0 {
                     break;
                 };
@@ -131,6 +147,13 @@ impl<'a> DropDownloadPipeline<'a, Response, File> {
         Ok(true)
     }
 
+    #[allow(dead_code)]
+    fn debug_skip_checksum(self) {
+        self.destination
+            .into_iter()
+            .for_each(|mut e| e.flush().unwrap());
+    }
+
     fn finish(self) -> Result<Vec<Digest>, io::Error> {
         let checksums = self
             .destination
@@ -153,6 +176,8 @@ pub fn download_game_bucket(
         return Ok(false);
     }
 
+    let start = Instant::now();
+
     let header = generate_authorization_header();
 
     let url = generate_url(&["/api/v2/client/chunk"], &[])
@@ -195,9 +220,7 @@ pub fn download_game_bucket(
     for (i, raw_length) in lengths.split(",").enumerate() {
         let length = raw_length.parse::<usize>().unwrap_or(0);
         let Some(drop) = bucket.drops.get(i) else {
-            warn!(
-                "invalid number of Content-Lengths recieved: {i}, {lengths}"
-            );
+            warn!("invalid number of Content-Lengths recieved: {i}, {lengths}");
             return Err(ApplicationDownloadError::DownloadError);
         };
         if drop.length != length {
@@ -209,6 +232,10 @@ pub fn download_game_bucket(
         }
     }
 
+    let timestep = start.elapsed().as_millis();
+
+    debug!("took {}ms to start downloading", timestep);
+
     let mut pipeline =
         DropDownloadPipeline::new(response, bucket.drops.clone(), control_flag, progress)
             .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;