refactor(downloads): Ran cargo fmt

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

src-tauri/src/downloads/download_agent.rs

@@ -207,7 +207,6 @@ impl GameDownloadAgent {
             .build()
             .unwrap();
 
-
         pool.scope(move |scope| {
             let contexts = self.contexts.lock().unwrap();
 

src-tauri/src/downloads/download_commands.rs

@@ -1,7 +1,6 @@
 use std::sync::Mutex;
 
-
+use crate::AppState;
-use crate::{AppState};
 
 #[tauri::command]
 pub fn download_game(
@@ -27,7 +26,12 @@ pub fn download_game(
         download_agent_ref.clone().run();
     });
     */
-    state.lock().unwrap().download_manager.queue_game(game_id, game_version, 0).unwrap();
+    state
+        .lock()
+        .unwrap()
+        .download_manager
+        .queue_game(game_id, game_version, 0)
+        .unwrap();
     Ok(())
 }
 
@@ -43,7 +47,12 @@ pub fn get_game_download_progress(
 
     Ok(progress.get_progress())
     */
-    let progress = state.lock().unwrap().download_manager.get_current_game_download_progress().unwrap_or(0.0);
+    let progress = state
+        .lock()
+        .unwrap()
+        .download_manager
+        .get_current_game_download_progress()
+        .unwrap_or(0.0);
 
     Ok(progress)
 }
@@ -56,4 +65,4 @@ fn use_download_agent(
     let download_agent = lock.download_manager.get(&game_id).ok_or("Invalid game ID")?;
     Ok(download_agent.clone()) // Clones the Arc, not the underlying data structure
 }
-*/
+*/

src-tauri/src/downloads/download_manager.rs

@@ -1,10 +1,20 @@
 use std::{
-    collections::{HashMap, VecDeque}, sync::{mpsc::{channel, Receiver, SendError, Sender}, Arc, Mutex, MutexGuard}, thread::{spawn, JoinHandle},
+    collections::{HashMap, VecDeque},
+    sync::{
+        mpsc::{channel, Receiver, Sender},
+        Arc, Mutex,
+    },
+    thread::spawn,
 };
 
 use log::info;
 
-use super::{download_agent::GameDownloadAgent, download_manager_interface::DownloadManagerInterface, download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag}, progress_object::ProgressObject};
+use super::{
+    download_agent::GameDownloadAgent,
+    download_manager_interface::DownloadManagerInterface,
+    download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
+    progress_object::ProgressObject,
+};
 
 pub struct DownloadManager {
     download_agent_registry: HashMap<String, Arc<GameDownloadAgent>>,
@@ -14,16 +24,16 @@ pub struct DownloadManager {
     progress: Arc<Mutex<Option<ProgressObject>>>,
 
     current_game_id: Option<String>, // Should be the only game download agent in the map with the "Go" flag
-    active_control_flag: Option<DownloadThreadControl>
+    active_control_flag: Option<DownloadThreadControl>,
 }
 pub enum DownloadManagerSignal {
     Go,
     Stop,
     Completed(String),
-    Queue(String, String, usize)
+    Queue(String, String, usize),
+    Finish,
 }
 
-
 impl DownloadManager {
     pub fn generate() -> DownloadManagerInterface {
         let queue = Arc::new(Mutex::new(VecDeque::new()));
@@ -40,38 +50,40 @@ impl DownloadManager {
             progress: active_progress.clone(),
         };
 
-        let terminator = spawn(|| {manager.manage_queue()});
+        let terminator = spawn(|| manager.manage_queue());
 
-        DownloadManagerInterface::new(
+        DownloadManagerInterface::new(terminator, queue, active_progress, sender)
-            terminator,
-            queue,
-            active_progress,
-            sender,
-        )
     }
 
     fn manage_queue(mut self) -> Result<(), ()> {
         loop {
             let signal = match self.receiver.recv() {
                 Ok(signal) => signal,
-                Err(e) => {
+                Err(e) => return Err(()),
-                    return Err(())
-                },
             };
 
             match signal {
                 DownloadManagerSignal::Go => {
                     self.manage_go_signal();
-                },
+                }
                 DownloadManagerSignal::Stop => {
                     self.manage_stop_signal();
-                },
+                }
                 DownloadManagerSignal::Completed(game_id) => {
                     self.manage_completed_signal(game_id);
                 }
                 DownloadManagerSignal::Queue(game_id, version, target_download_dir) => {
                     self.manage_queue_signal(game_id, version, target_download_dir);
-                },
+                }
+                DownloadManagerSignal::Finish => {
+                    match self.active_control_flag {
+                        Some(active_control_flag) => {
+                            active_control_flag.set(DownloadThreadControlFlag::Stop)
+                        }
+                        None => {}
+                    }
+                    return Ok(());
+                }
             };
         }
     }
@@ -82,7 +94,7 @@ impl DownloadManager {
             active_control_flag.set(DownloadThreadControlFlag::Stop);
         }
     }
-    
+
     fn manage_completed_signal(&mut self, game_id: String) {
         info!("Got signal 'Completed'");
         if self.current_game_id == Some(game_id.clone()) {
@@ -94,47 +106,60 @@ impl DownloadManager {
         }
         self.sender.send(DownloadManagerSignal::Go).unwrap();
     }
-    
+
-    fn manage_queue_signal(&mut self, game_id: String, version: String, target_download_dir: usize) {
+    fn manage_queue_signal(
+        &mut self,
+        game_id: String,
+        version: String,
+        target_download_dir: usize,
+    ) {
         info!("Got signal Queue");
-        let download_agent = Arc::new(GameDownloadAgent::new(game_id.clone(), version, target_download_dir));
+        let download_agent = Arc::new(GameDownloadAgent::new(
-        self.download_agent_registry.insert(game_id.clone(), download_agent);
+            game_id.clone(),
+            version,
+            target_download_dir,
+        ));
+        self.download_agent_registry
+            .insert(game_id.clone(), download_agent);
         self.download_queue.lock().unwrap().push_back(game_id);
     }
-    
+
     fn manage_go_signal(&mut self) {
         info!("Got signal 'Go'");
         if self.active_control_flag.is_none() && !self.download_agent_registry.is_empty() {
             info!("Starting download agent");
             let download_agent = {
                 let lock = self.download_queue.lock().unwrap();
-                self.download_agent_registry.get(&lock.front().unwrap().clone()).unwrap().clone()
+                self.download_agent_registry
+                    .get(&lock.front().unwrap().clone())
+                    .unwrap()
+                    .clone()
             };
             self.current_game_id = Some(download_agent.id.clone());
-    
+
             let progress_object = download_agent.progress.clone();
             *self.progress.lock().unwrap() = Some(progress_object);
-    
+
             let active_control_flag = download_agent.control_flag.clone();
             self.active_control_flag = Some(active_control_flag.clone());
-    
+
             let sender = self.sender.clone();
-    
+
             info!("Spawning download");
             spawn(move || {
                 download_agent.download().unwrap();
-                sender.send(DownloadManagerSignal::Completed(download_agent.id.clone())).unwrap();
+                sender
+                    .send(DownloadManagerSignal::Completed(download_agent.id.clone()))
+                    .unwrap();
             });
             info!("Finished spawning Download");
-    
+
             active_control_flag.set(DownloadThreadControlFlag::Go);
-        }
+        } else if let Some(active_control_flag) = self.active_control_flag.clone() {
-        else if let Some(active_control_flag) = self.active_control_flag.clone() {
             info!("Restarting current download");
             active_control_flag.set(DownloadThreadControlFlag::Go);
-        }
+        } else {
-        else {
             info!("Nothing was set");
         }
     }
-}
+}

src-tauri/src/downloads/download_manager_interface.rs

@@ -1,29 +1,50 @@
-use std::{collections::VecDeque, sync::{mpsc::{SendError, Sender}, Arc, Mutex, MutexGuard}, thread::JoinHandle};
+use std::{
+    collections::VecDeque,
+    sync::{
+        mpsc::{SendError, Sender},
+        Arc, Mutex, MutexGuard,
+    },
+    thread::JoinHandle,
+};
 
 use log::info;
 
 use super::{download_manager::DownloadManagerSignal, progress_object::ProgressObject};
 
 pub struct DownloadManagerInterface {
-    terminator: JoinHandle<Result<(),()>>,
+    terminator: JoinHandle<Result<(), ()>>,
     download_queue: Arc<Mutex<VecDeque<String>>>,
     progress: Arc<Mutex<Option<ProgressObject>>>,
     sender: Sender<DownloadManagerSignal>,
 }
 
 impl DownloadManagerInterface {
-    
     pub fn new(
-        terminator: JoinHandle<Result<(),()>>,
+        terminator: JoinHandle<Result<(), ()>>,
-         download_queue: Arc<Mutex<VecDeque<String>>>,
+        download_queue: Arc<Mutex<VecDeque<String>>>,
-          progress: Arc<Mutex<Option<ProgressObject>>>,
+        progress: Arc<Mutex<Option<ProgressObject>>>,
-          sender: Sender<DownloadManagerSignal>) -> Self {
+        sender: Sender<DownloadManagerSignal>,
-        Self { terminator, download_queue, progress, sender }
+    ) -> Self {
+        Self {
+            terminator,
+            download_queue,
+            progress,
+            sender,
+        }
     }
-    
+
-    pub fn queue_game(&self, game_id: String, version: String, target_download_dir: usize) -> Result<(), SendError<DownloadManagerSignal>> {
+    pub fn queue_game(
+        &self,
+        game_id: String,
+        version: String,
+        target_download_dir: usize,
+    ) -> Result<(), SendError<DownloadManagerSignal>> {
         info!("Adding game id {}", game_id);
-        self.sender.send(DownloadManagerSignal::Queue(game_id, version, target_download_dir))?;
+        self.sender.send(DownloadManagerSignal::Queue(
+            game_id,
+            version,
+            target_download_dir,
+        ))?;
         self.sender.send(DownloadManagerSignal::Go)
     }
     pub fn edit(&self) -> MutexGuard<'_, VecDeque<String>> {
@@ -59,6 +80,7 @@ impl DownloadManagerInterface {
         self.sender.send(DownloadManagerSignal::Go)
     }
     pub fn ensure_terminated(self) -> Result<(), ()> {
+        self.sender.send(DownloadManagerSignal::Finish).unwrap();
         match self.terminator.join() {
             Ok(o) => o,
             Err(_) => Err(()),
@@ -66,8 +88,8 @@ impl DownloadManagerInterface {
     }
 }
 
-pub fn get_index_from_id(queue: &mut MutexGuard<'_, VecDeque<String>>, id: String) -> Option<usize> {
+fn get_index_from_id(queue: &mut MutexGuard<'_, VecDeque<String>>, id: String) -> Option<usize> {
-    queue.iter().position(|download_agent| {
+    queue
-        download_agent == &id
+        .iter()
-    })
+        .position(|download_agent| download_agent == &id)
 }

src-tauri/src/downloads/mod.rs

@@ -1,8 +1,8 @@
 pub mod download_agent;
 pub mod download_commands;
-pub mod download_manager;
-mod download_manager_interface;
 mod download_logic;
+pub mod download_manager;
+pub mod download_manager_interface;
 mod download_thread_control_flag;
 mod manifest;
-mod progress_object;
+mod progress_object;

src-tauri/src/downloads/progress_object.rs

@@ -32,7 +32,8 @@ impl ProgressObject {
         *self.max.lock().unwrap() = new_max
     }
     pub fn set_size(&self, length: usize) {
-        *self.progress_instances.lock().unwrap() = (0..length).map(|_| Arc::new(AtomicUsize::new(0))).collect();
+        *self.progress_instances.lock().unwrap() =
+            (0..length).map(|_| Arc::new(AtomicUsize::new(0))).collect();
     }
 
     pub fn get_progress(&self) -> f64 {

src-tauri/src/lib.rs

@@ -12,7 +12,8 @@ use crate::db::DatabaseImpls;
 use auth::{auth_initiate, generate_authorization_header, recieve_handshake};
 use db::{add_new_download_dir, DatabaseInterface, DATA_ROOT_DIR};
 use downloads::download_commands::*;
-use downloads::download_manager::{DownloadManager, DownloadManagerInterface};
+use downloads::download_manager::DownloadManager;
+use downloads::download_manager_interface::DownloadManagerInterface;
 use env_logger::Env;
 use http::{header::*, response::Builder as ResponseBuilder};
 use library::{fetch_game, fetch_library, Game};