Merge pull request 'multithreaded' (#6) from multithreaded into master

Reviewed-on: http://raspberrypi.fritz.box:7920/fx/modlist/pulls/6

1 files changed, 132 insertions, 67 deletions

diff --git a/src/files.rs b/src/files.rs
index a4c128e..3a16c62 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -1,10 +1,13 @@
 use futures_util::StreamExt;
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use reqwest::Client;
 use std::{
+    cmp::min,
     collections::HashMap,
     fs::{copy, read_dir, remove_file, rename, File},
     io::Write,
 };
+use tokio::task::JoinSet;
 
 use crate::{
     cache::{copy_cached_version, get_cached_versions},
@@ -12,99 +15,160 @@ use crate::{
     db::{mods_get_info, userlist_add_disabled_versions},
     error::{ErrorType, MLError, MLE},
     modrinth::Version,
-    List,
+    List, PROGRESS_CHARS, STYLE_BAR_BYTE, STYLE_BAR_POS, STYLE_SPINNER,
 };
 
-pub async fn download_versions(list: List, config: Cfg, versions: Vec<Version>) -> MLE<String> {
-    let mut cached = get_cached_versions(&config.cache);
+pub async fn download_versions(
+    list: List,
+    config: Cfg,
+    versions: Vec<Version>,
+    progress: &MultiProgress,
+    progress_before: &ProgressBar,
+) -> MLE<()> {
+    let cached = get_cached_versions(&config.cache);
 
-    // println!("{:#?}", cached);
+    let mut js = JoinSet::new();
 
-    let dl_path = String::from(&list.download_folder);
+    let style_spinner = ProgressStyle::with_template(STYLE_SPINNER).unwrap();
 
-    println!("  └Download mods to {}", dl_path);
+    let all = progress.insert_before(
+        progress_before,
+        ProgressBar::new(versions.len().try_into().unwrap()),
+    );
+    all.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
+    all.set_message(format!("✓Downloading {}", list.id));
 
     for ver in versions {
-        let project_info = mods_get_info(config.clone(), &ver.project_id)?;
-
-        //Check cache if already downloaded
-        let c = cached.remove(&ver.id);
-        if c.is_some() {
-            print!(
-                "\t└({})Get version {} from cache",
-                project_info.title, ver.id
-            );
-            //Force flush of stdout, else print! doesn't print instantly
-            std::io::stdout().flush()?;
-            copy_cached_version(&c.unwrap(), &dl_path);
-            println!(" ✓");
-        } else {
-            print!("\t└({})Download version {}", project_info.title, ver.id);
-            //Force flush of stdout, else print! doesn't print instantly
-            std::io::stdout().flush().unwrap();
-            let files = ver.files;
-            let file = match files.clone().into_iter().find(|f| f.primary) {
-                Some(f) => f,
-                None => files[0].clone()
-            };
-            let mut splitname: Vec<&str> = file.filename.split('.').collect();
-            let extension = match splitname.pop().ok_or("") {
-                Ok(e) => e,
-                Err(..) => return Err(MLError::new(ErrorType::Other, "NO_FILE_EXTENSION")),
-            };
-            let filename = format!(
-                "{}.mr.{}.{}.{}",
-                splitname.join("."),
-                ver.project_id,
-                ver.id,
-                extension
-            );
-            download_file(
-                file.url,
-                list.clone().download_folder,
-                filename.clone(),
-            )
+        let p = progress.insert_before(&all, ProgressBar::new(1));
+        p.set_style(style_spinner.clone());
+        js.spawn(download_version(
+            config.clone(),
+            list.clone(),
+            ver,
+            cached.clone(),
+            p,
+        ));
+    }
+
+    while js.join_next().await.is_some() {
+        all.inc(1)
+    }
+
+    all.finish_with_message(format!("✓Downloading {}", list.id));
+
+    Ok(())
+}
+
+async fn download_version(
+    config: Cfg,
+    list: List,
+    version: Version,
+    mut cached: HashMap<String, String>,
+    progress: ProgressBar,
+) -> MLE<()> {
+    let project_info = mods_get_info(&config, &version.project_id)?;
+
+    let dl_path = String::from(&list.download_folder);
+
+    progress.set_message(format!("{} - {}", project_info.title, version.id));
+
+    let mut cache_msg = "";
+    //Check cache if already downloaded
+    let c = cached.remove(&version.id);
+    if c.is_some() {
+        progress.set_message(format!("Get {} from cache", version.id));
+        cache_msg = " (cached)";
+        copy_cached_version(&c.unwrap(), &dl_path);
+    } else {
+        let files = version.files;
+        let file = match files.clone().into_iter().find(|f| f.primary) {
+            Some(f) => f,
+            None => files[0].clone(),
+        };
+        let mut splitname: Vec<&str> = file.filename.split('.').collect();
+        let extension = match splitname.pop().ok_or("") {
+            Ok(e) => e,
+            Err(..) => {
+                return Err(MLError::new(ErrorType::Other, "NO_FILE_EXTENSION"))
+            }
+        };
+        let filename = format!(
+            "{}.mr.{}.{}.{}",
+            splitname.join("."),
+            version.project_id,
+            version.id,
+            extension
+        );
+
+        download_file(&file.url, &list.download_folder, &filename, &progress)
             .await?;
-            println!(" ✓");
-            //Copy file to cache
-            print!("\t  └Copy to cache");
-            //Force flush of stdout, else print! doesn't print instantly
-            std::io::stdout().flush().unwrap();
-            let dl_path_file = format!("{}/{}", list.download_folder, filename);
-            let cache_path = format!("{}/{}", &config.clone().cache, filename);
-            // println!("{}:{}", dl_path_file, cache_path);
-            copy(dl_path_file, cache_path)?;
-            println!(" ✓");
-        }
+
+        progress.set_message(format!("Copy {} to cache", version.id));
+        let dl_path_file = format!("{}/{}", list.download_folder, filename);
+        let cache_path = format!("{}/{}", &config.cache, filename);
+
+        copy(dl_path_file, cache_path)?;
     }
 
-    Ok(dl_path)
+    progress.finish_with_message(format!(
+        "✓{} - {}{}",
+        project_info.title, version.id, cache_msg
+    ));
+
+    Ok(())
 }
 
-async fn download_file(url: String, path: String, name: String) -> MLE<()> {
+async fn download_file(
+    url: &str,
+    path: &str,
+    name: &str,
+    progress: &ProgressBar,
+) -> MLE<()> {
     let dl_path_file = format!("{}/{}", path, name);
-    let res = Client::new().get(String::from(&url)).send().await?;
+    let res = Client::new().get(url).send().await?;
+
+    let size = res.content_length().expect("Couldn't get content length");
+
+    let style_bar_byte = ProgressStyle::with_template(STYLE_BAR_BYTE)
+        .unwrap()
+        .progress_chars(PROGRESS_CHARS);
+
+    progress.set_length(size);
+    progress.set_style(style_bar_byte);
 
     // download chunks
     let mut file = File::create(&dl_path_file)?;
     let mut stream = res.bytes_stream();
 
+    let mut downloaded: u64 = 0;
+
     while let Some(item) = stream.next().await {
+        // progress.inc(1);
         let chunk = item?;
         file.write_all(&chunk)?;
+
+        // Progress bar
+        let new = min(downloaded + (chunk.len() as u64), size);
+        downloaded = new;
+        progress.set_position(new);
+
+        // std::thread::sleep(std::time::Duration::from_millis(100));
     }
 
     Ok(())
 }
 
 pub fn disable_version(
-    config: Cfg,
+    config: &Cfg,
     current_list: List,
     versionid: String,
     mod_id: String,
 ) -> MLE<()> {
-    //println!("Disabling version {} for mod {}", versionid, mod_id);
-    let file = get_file_path(current_list.clone(), String::from(&versionid))?;
+    let file = get_file_path(&current_list, String::from(&versionid))?;
     let disabled = format!("{}.disabled", file);
 
     rename(file, disabled)?;
@@ -114,7 +178,7 @@ pub fn disable_version(
     Ok(())
 }
 
-pub fn delete_version(list: List, version: String) -> MLE<()> {
+pub fn delete_version(list: &List, version: String) -> MLE<()> {
     let file = get_file_path(list, version)?;
 
     remove_file(file)?;
@@ -122,14 +186,16 @@ pub fn delete_version(list: List, version: String) -> MLE<()> {
     Ok(())
 }
 
-pub fn get_file_path(list: List, versionid: String) -> MLE<String> {
+pub fn get_file_path(list: &List, versionid: String) -> MLE<String> {
     let mut names: HashMap<String, String> = HashMap::new();
-    for file in read_dir(list.download_folder)? {
+    for file in read_dir(&list.download_folder)? {
         let path = file?.path();
         if path.is_file() {
             let pathstr = match path.to_str().ok_or("") {
                 Ok(s) => s,
-                Err(..) => return Err(MLError::new(ErrorType::Other, "INVALID_PATH")),
+                Err(..) => {
+                    return Err(MLError::new(ErrorType::Other, "INVALID_PATH"))
+                }
             };
             let namesplit: Vec<&str> = pathstr.split('.').collect();
             let ver_id = namesplit[namesplit.len() - 2];
@@ -168,7 +234,6 @@ pub fn get_downloaded_versions(list: List) -> MLE<HashMap<String, String>> {
 
 pub fn clean_list_dir(list: &List) -> MLE<()> {
     let dl_path = &list.download_folder;
-    println!("  └Clean directory for: {}", list.id);
     for entry in std::fs::read_dir(dl_path)? {
         let entry = entry?;
         std::fs::remove_file(entry.path())?;