Ryan/drop-app
1
0
Fork 0
mirror of https://github.com/Drop-OSS/drop-app.git synced 2025-11-14 00:31:33 +10:00
Code Issues Packages Projects Releases Wiki Activity

refactor(downloads): Ran cargo fmt

Browse Source 
Signed-off-by: quexeky <git@quexeky.dev>
This commit is contained in:
quexeky
2024-11-13 21:28:24 +11:00
parent 075d6ecf3c
commit b8cf44c0b2
7 changed files with 119 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src-tauri/src/downloads/download_agent.rs
View File

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

19
src-tauri/src/downloads/download_commands.rs
View File

@ -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
}
*/
*/

97
src-tauri/src/downloads/download_manager.rs
View File

@ -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(
terminator,
queue,
active_progress,
sender,
)
DownloadManagerInterface::new(terminator, queue, active_progress, sender)
}
fn manage_queue(mut self) -> Result<(), ()> {
loop {
let signal = match self.receiver.recv() {
Ok(signal) => signal,
Err(e) => {
return Err(())
},
Err(e) => 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));
self.download_agent_registry.insert(game_id.clone(), download_agent);
let download_agent = Arc::new(GameDownloadAgent::new(
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");
}
}
}
}

52
src-tauri/src/downloads/download_manager_interface.rs
View File

@ -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<(),()>>,
download_queue: Arc<Mutex<VecDeque<String>>>,
progress: Arc<Mutex<Option<ProgressObject>>>,
sender: Sender<DownloadManagerSignal>) -> Self {
Self { terminator, download_queue, progress, sender }
terminator: JoinHandle<Result<(), ()>>,
download_queue: Arc<Mutex<VecDeque<String>>>,
progress: Arc<Mutex<Option<ProgressObject>>>,
sender: Sender<DownloadManagerSignal>,
) -> 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> {
queue.iter().position(|download_agent| {
download_agent == &id
})
fn get_index_from_id(queue: &mut MutexGuard<'_, VecDeque<String>>, id: String) -> Option<usize> {
queue
.iter()
.position(|download_agent| download_agent == &id)
}

6
src-tauri/src/downloads/mod.rs
View File

@ -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;

3
src-tauri/src/downloads/progress_object.rs
View File

@ -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 {