From 775b6b4f10cfa1074e0d0433eab9d3a8eeed31dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Mikrut?= <41945903+qarmin@users.noreply.github.com> Date: Wed, 14 Apr 2021 08:23:59 +0200 Subject: [PATCH] Fix crashes with too small message queue (#316) --- czkawka_core/src/big_file.rs | 8 ++++---- czkawka_core/src/broken_files.rs | 14 ++++++------- czkawka_core/src/duplicate.rs | 24 +++++++++++----------- czkawka_core/src/empty_files.rs | 8 ++++---- czkawka_core/src/empty_folder.rs | 8 ++++---- czkawka_core/src/invalid_symlinks.rs | 8 ++++---- czkawka_core/src/same_music.rs | 20 +++++++++--------- czkawka_core/src/similar_images.rs | 14 ++++++------- czkawka_core/src/temporary.rs | 8 ++++---- czkawka_core/src/zeroed.rs | 14 ++++++------- czkawka_gui/src/connect_button_search.rs | 20 +++++++++--------- czkawka_gui/src/connect_progress_window.rs | 20 +++++++++--------- czkawka_gui/src/main.rs | 22 +++++++++++--------- 13 files changed, 95 insertions(+), 93 deletions(-) diff --git a/czkawka_core/src/big_file.rs b/czkawka_core/src/big_file.rs index 5c8ed2a..9a50255 100644 --- a/czkawka_core/src/big_file.rs +++ b/czkawka_core/src/big_file.rs @@ -79,7 +79,7 @@ impl BigFile { } } - pub fn find_big_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_big_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.optimize_directories(); if !self.look_for_big_files(stop_receiver, progress_sender) { self.stopped_search = true; @@ -117,7 +117,7 @@ impl BigFile { self.allowed_extensions.set_allowed_extensions(allowed_extensions, &mut self.text_messages); } - fn look_for_big_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn look_for_big_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -134,12 +134,12 @@ impl BigFile { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, }) .unwrap(); diff --git a/czkawka_core/src/broken_files.rs b/czkawka_core/src/broken_files.rs index d8dc151..184f955 100644 --- a/czkawka_core/src/broken_files.rs +++ b/czkawka_core/src/broken_files.rs @@ -98,7 +98,7 @@ impl BrokenFiles { } } - pub fn find_broken_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_broken_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(self.recursive_search, &mut self.text_messages); if !self.check_files(stop_receiver, progress_sender) { self.stopped_search = true; @@ -155,7 +155,7 @@ impl BrokenFiles { self.excluded_items.set_excluded_items(excluded_items, &mut self.text_messages); } - fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -172,12 +172,12 @@ impl BrokenFiles { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 1, files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, @@ -300,7 +300,7 @@ impl BrokenFiles { Common::print_time(start_time, SystemTime::now(), "check_files".to_string()); true } - fn look_for_broken_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn look_for_broken_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let system_time = SystemTime::now(); let loaded_hash_map; @@ -341,13 +341,13 @@ impl BrokenFiles { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let files_to_check = non_cached_files_to_check.len(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 1, max_stage: 1, files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_core/src/duplicate.rs b/czkawka_core/src/duplicate.rs index 70ed85d..e6e772f 100644 --- a/czkawka_core/src/duplicate.rs +++ b/czkawka_core/src/duplicate.rs @@ -177,7 +177,7 @@ impl DuplicateFinder { } } - pub fn find_duplicates(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_duplicates(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(self.recursive_search, &mut self.text_messages); match self.check_method { @@ -289,7 +289,7 @@ impl DuplicateFinder { self.excluded_items.set_excluded_items(excluded_items, &mut self.text_messages); } - fn check_files_name(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files_name(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -306,12 +306,12 @@ impl DuplicateFinder { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { checking_method: CheckingMethod::Name, current_stage: 0, max_stage: 0, @@ -454,7 +454,7 @@ impl DuplicateFinder { /// Read file length and puts it to different boxes(each for different lengths) /// If in box is only 1 result, then it is removed - fn check_files_size(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files_size(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -471,7 +471,7 @@ impl DuplicateFinder { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let checking_method = self.check_method.clone(); @@ -482,7 +482,7 @@ impl DuplicateFinder { }; progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { checking_method: checking_method.clone(), current_stage: 0, max_stage, @@ -636,7 +636,7 @@ impl DuplicateFinder { } /// The slowest checking type, which must be applied after checking for size - fn check_files_hash(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files_hash(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let check_type = Arc::new(self.hash_type); let start_time: SystemTime = SystemTime::now(); @@ -651,14 +651,14 @@ impl DuplicateFinder { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let files_to_check = self.files_with_identical_size.iter().map(|e| e.1.len()).sum(); let checking_method = self.check_method.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { checking_method: checking_method.clone(), current_stage: 1, max_stage: 2, @@ -741,14 +741,14 @@ impl DuplicateFinder { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let files_to_check = pre_checked_map.iter().map(|e| e.1.len()).sum(); let checking_method = self.check_method.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { checking_method: checking_method.clone(), current_stage: 2, max_stage: 2, diff --git a/czkawka_core/src/empty_files.rs b/czkawka_core/src/empty_files.rs index 2df9684..db2dddc 100644 --- a/czkawka_core/src/empty_files.rs +++ b/czkawka_core/src/empty_files.rs @@ -77,7 +77,7 @@ impl EmptyFiles { } /// Finding empty files, save results to internal struct variables - pub fn find_empty_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_empty_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(self.recursive_search, &mut self.text_messages); if !self.check_files(stop_receiver, progress_sender) { self.stopped_search = true; @@ -127,7 +127,7 @@ impl EmptyFiles { } /// Check files for any with size == 0 - fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -144,12 +144,12 @@ impl EmptyFiles { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 0, files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_core/src/empty_folder.rs b/czkawka_core/src/empty_folder.rs index c04730a..9ab7bb0 100644 --- a/czkawka_core/src/empty_folder.rs +++ b/czkawka_core/src/empty_folder.rs @@ -97,7 +97,7 @@ impl EmptyFolder { self.directories.set_excluded_directory(excluded_directory, &mut self.text_messages); } /// Public function used by CLI to search for empty folders - pub fn find_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(true, &mut self.text_messages); if !self.check_for_empty_folders(stop_receiver, progress_sender) { self.stopped_search = true; @@ -137,7 +137,7 @@ impl EmptyFolder { /// Function to check if folder are empty. /// Parameter initial_checking for second check before deleting to be sure that checked folder is still empty - fn check_for_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_for_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector let mut folders_checked: BTreeMap = Default::default(); @@ -150,12 +150,12 @@ impl EmptyFolder { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_folder_counter = atomic_folder_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 0, folders_checked: atomic_folder_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_core/src/invalid_symlinks.rs b/czkawka_core/src/invalid_symlinks.rs index f577fa3..525131a 100644 --- a/czkawka_core/src/invalid_symlinks.rs +++ b/czkawka_core/src/invalid_symlinks.rs @@ -86,7 +86,7 @@ impl InvalidSymlinks { } } - pub fn find_invalid_links(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_invalid_links(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(self.recursive_search, &mut self.text_messages); if !self.check_files(stop_receiver, progress_sender) { self.stopped_search = true; @@ -136,7 +136,7 @@ impl InvalidSymlinks { } /// Check files for any with size == 0 - fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -153,12 +153,12 @@ impl InvalidSymlinks { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 0, files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_core/src/same_music.rs b/czkawka_core/src/same_music.rs index 80c23f6..82f8ab7 100644 --- a/czkawka_core/src/same_music.rs +++ b/czkawka_core/src/same_music.rs @@ -112,7 +112,7 @@ impl SameMusic { } } - pub fn find_same_music(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_same_music(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(self.recursive_search, &mut self.text_messages); if !self.check_files(stop_receiver, progress_sender) { self.stopped_search = true; @@ -174,7 +174,7 @@ impl SameMusic { } /// Check files for any with size == 0 - fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -191,12 +191,12 @@ impl SameMusic { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 2, music_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, @@ -312,7 +312,7 @@ impl SameMusic { true } - fn check_records_multithreaded(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_records_multithreaded(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let check_was_breaked = AtomicBool::new(false); // Used for breaking from GUI and ending check thread @@ -325,13 +325,13 @@ impl SameMusic { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let music_to_check = self.music_to_check.len(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 1, max_stage: 2, music_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, @@ -408,7 +408,7 @@ impl SameMusic { true } - fn check_for_duplicates(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_for_duplicates(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { if MusicSimilarity::NONE == self.music_similarity { panic!("This can't be none"); } @@ -422,13 +422,13 @@ impl SameMusic { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let music_to_check = self.music_to_check.len(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 2, max_stage: 2, music_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_core/src/similar_images.rs b/czkawka_core/src/similar_images.rs index 6bc7557..242962a 100644 --- a/czkawka_core/src/similar_images.rs +++ b/czkawka_core/src/similar_images.rs @@ -151,7 +151,7 @@ impl SimilarImages { } /// Public function used by CLI to search for empty folders - pub fn find_similar_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_similar_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(true, &mut self.text_messages); if !self.check_for_similar_images(stop_receiver, progress_sender) { self.stopped_search = true; @@ -173,7 +173,7 @@ impl SimilarImages { /// Function to check if folder are empty. /// Parameter initial_checking for second check before deleting to be sure that checked folder is still empty - fn check_for_similar_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_for_similar_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -190,12 +190,12 @@ impl SimilarImages { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 1, images_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, @@ -324,7 +324,7 @@ impl SimilarImages { // - Join already read hashes with hashes which were read from file // - Join all hashes and save it to file - fn sort_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn sort_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let hash_map_modification = SystemTime::now(); let loaded_hash_map; @@ -367,13 +367,13 @@ impl SimilarImages { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let images_to_check = non_cached_files_to_check.len(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 1, max_stage: 1, images_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_core/src/temporary.rs b/czkawka_core/src/temporary.rs index 414854f..92cb57c 100644 --- a/czkawka_core/src/temporary.rs +++ b/czkawka_core/src/temporary.rs @@ -74,7 +74,7 @@ impl Temporary { } /// Finding temporary files, save results to internal struct variables - pub fn find_temporary_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_temporary_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(self.recursive_search, &mut self.text_messages); if !self.check_files(stop_receiver, progress_sender) { self.stopped_search = true; @@ -118,7 +118,7 @@ impl Temporary { self.excluded_items.set_excluded_items(excluded_items, &mut self.text_messages); } - fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -135,12 +135,12 @@ impl Temporary { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 0, files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_core/src/zeroed.rs b/czkawka_core/src/zeroed.rs index 98886c1..b1b46c1 100644 --- a/czkawka_core/src/zeroed.rs +++ b/czkawka_core/src/zeroed.rs @@ -83,7 +83,7 @@ impl ZeroedFiles { } } - pub fn find_zeroed_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) { + pub fn find_zeroed_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) { self.directories.optimize_directories(self.recursive_search, &mut self.text_messages); if !self.check_files(stop_receiver, progress_sender) { self.stopped_search = true; @@ -144,7 +144,7 @@ impl ZeroedFiles { } /// Check files for files which have 0 - fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); let mut folders_to_check: Vec = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector @@ -161,12 +161,12 @@ impl ZeroedFiles { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 0, max_stage: 1, files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, @@ -286,7 +286,7 @@ impl ZeroedFiles { } /// Check files for files which have 0 - fn check_for_zeroed_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::Sender>) -> bool { + fn check_for_zeroed_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&futures::channel::mpsc::UnboundedSender>) -> bool { let start_time: SystemTime = SystemTime::now(); //// PROGRESS THREAD START @@ -297,13 +297,13 @@ impl ZeroedFiles { let progress_thread_handle; if let Some(progress_sender) = progress_sender { - let mut progress_send = progress_sender.clone(); + let progress_send = progress_sender.clone(); let progress_thread_run = progress_thread_run.clone(); let atomic_file_counter = atomic_file_counter.clone(); let files_to_check = self.files_to_check.len(); progress_thread_handle = thread::spawn(move || loop { progress_send - .try_send(ProgressData { + .unbounded_send(ProgressData { current_stage: 1, max_stage: 1, files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize, diff --git a/czkawka_gui/src/connect_button_search.rs b/czkawka_gui/src/connect_button_search.rs index db3c2fa..cd714be 100644 --- a/czkawka_gui/src/connect_button_search.rs +++ b/czkawka_gui/src/connect_button_search.rs @@ -27,16 +27,16 @@ use crate::taskbar_progress::tbp_flags::TBPF_NOPROGRESS; pub fn connect_button_search( gui_data: &GuiData, glib_stop_sender: Sender, - futures_sender_duplicate_files: futures::channel::mpsc::Sender, - futures_sender_empty_files: futures::channel::mpsc::Sender, - futures_sender_empty_folder: futures::channel::mpsc::Sender, - futures_sender_big_file: futures::channel::mpsc::Sender, - futures_sender_same_music: futures::channel::mpsc::Sender, - futures_sender_similar_images: futures::channel::mpsc::Sender, - futures_sender_temporary: futures::channel::mpsc::Sender, - futures_sender_zeroed: futures::channel::mpsc::Sender, - futures_sender_invalid_symlinks: futures::channel::mpsc::Sender, - futures_sender_broken_files: futures::channel::mpsc::Sender, + futures_sender_duplicate_files: futures::channel::mpsc::UnboundedSender, + futures_sender_empty_files: futures::channel::mpsc::UnboundedSender, + futures_sender_empty_folder: futures::channel::mpsc::UnboundedSender, + futures_sender_big_file: futures::channel::mpsc::UnboundedSender, + futures_sender_same_music: futures::channel::mpsc::UnboundedSender, + futures_sender_similar_images: futures::channel::mpsc::UnboundedSender, + futures_sender_temporary: futures::channel::mpsc::UnboundedSender, + futures_sender_zeroed: futures::channel::mpsc::UnboundedSender, + futures_sender_invalid_symlinks: futures::channel::mpsc::UnboundedSender, + futures_sender_broken_files: futures::channel::mpsc::UnboundedSender, ) { let entry_info = gui_data.entry_info.clone(); let notebook_main = gui_data.main_notebook.notebook_main.clone(); diff --git a/czkawka_gui/src/connect_progress_window.rs b/czkawka_gui/src/connect_progress_window.rs index ecab795..6eac1fa 100644 --- a/czkawka_gui/src/connect_progress_window.rs +++ b/czkawka_gui/src/connect_progress_window.rs @@ -9,16 +9,16 @@ use gtk::{LabelExt, ProgressBarExt, WidgetExt}; #[allow(clippy::too_many_arguments)] pub fn connect_progress_window( gui_data: &GuiData, - mut futures_receiver_duplicate_files: futures::channel::mpsc::Receiver, - mut futures_receiver_empty_files: futures::channel::mpsc::Receiver, - mut futures_receiver_empty_folder: futures::channel::mpsc::Receiver, - mut futures_receiver_big_files: futures::channel::mpsc::Receiver, - mut futures_receiver_same_music: futures::channel::mpsc::Receiver, - mut futures_receiver_similar_images: futures::channel::mpsc::Receiver, - mut futures_receiver_temporary: futures::channel::mpsc::Receiver, - mut futures_receiver_zeroed: futures::channel::mpsc::Receiver, - mut futures_receiver_invalid_symlinks: futures::channel::mpsc::Receiver, - mut futures_receiver_broken_files: futures::channel::mpsc::Receiver, + mut futures_receiver_duplicate_files: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_empty_files: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_empty_folder: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_big_files: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_same_music: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_similar_images: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_temporary: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_zeroed: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_invalid_symlinks: futures::channel::mpsc::UnboundedReceiver, + mut futures_receiver_broken_files: futures::channel::mpsc::UnboundedReceiver, ) { let main_context = glib::MainContext::default(); diff --git a/czkawka_gui/src/main.rs b/czkawka_gui/src/main.rs index 4ea17a7..8348331 100644 --- a/czkawka_gui/src/main.rs +++ b/czkawka_gui/src/main.rs @@ -88,16 +88,18 @@ fn main() { let (glib_stop_sender, glib_stop_receiver) = glib::MainContext::channel(glib::PRIORITY_DEFAULT); // Futures progress report - let (futures_sender_duplicate_files, futures_receiver_duplicate_files): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_empty_files, futures_receiver_empty_files): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_empty_folder, futures_receiver_empty_folder): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_big_file, futures_receiver_big_file): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_same_music, futures_receiver_same_music): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_similar_images, futures_receiver_similar_images): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_temporary, futures_receiver_temporary): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_zeroed, futures_receiver_zeroed): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_invalid_symlinks, futures_receiver_invalid_symlinks): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); - let (futures_sender_broken_files, futures_receiver_broken_files): (futures::channel::mpsc::Sender, futures::channel::mpsc::Receiver) = futures::channel::mpsc::channel(20); + let (futures_sender_duplicate_files, futures_receiver_duplicate_files): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); + let (futures_sender_empty_files, futures_receiver_empty_files): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); + let (futures_sender_empty_folder, futures_receiver_empty_folder): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); + let (futures_sender_big_file, futures_receiver_big_file): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); + let (futures_sender_same_music, futures_receiver_same_music): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); + let (futures_sender_similar_images, futures_receiver_similar_images): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = + futures::channel::mpsc::unbounded(); + let (futures_sender_temporary, futures_receiver_temporary): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); + let (futures_sender_zeroed, futures_receiver_zeroed): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); + let (futures_sender_invalid_symlinks, futures_receiver_invalid_symlinks): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = + futures::channel::mpsc::unbounded(); + let (futures_sender_broken_files, futures_receiver_broken_files): (futures::channel::mpsc::UnboundedSender, futures::channel::mpsc::UnboundedReceiver) = futures::channel::mpsc::unbounded(); initialize_gui(&mut gui_data); reset_configuration(&gui_data, false); // Fallback for invalid loading setting project