CodeMirror/czkawka
1
0
Fork 0
mirror of synced 2024-05-17 19:03:08 +12:00
Code Issues Projects Releases Wiki Activity

Check was stopped

Browse source
This commit is contained in:
Rafał Mikrut 2023-05-06 21:09:43 +02:00
parent cb32ad515d
commit 9a559d201f
10 changed files with 30 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
czkawka_core/src/bad_extensions.rs
View file

@ -313,9 +313,8 @@ impl BadExtensions {
}
fn look_for_bad_extensions_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 1, 1, self.files_to_check.len(), CheckingMethod::None);
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 1, 1, self.files_to_check.len(), CheckingMethod::None);
let files_to_check = mem::take(&mut self.files_to_check);

2
czkawka_core/src/big_file.rs
View file

@ -148,7 +148,7 @@ impl BigFile {
folders_to_check.push(id.clone());
}
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 0, 0, 0, CheckingMethod::None);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) = prepare_thread_handler_common(progress_sender, 0, 0, 0, CheckingMethod::None);
while !folders_to_check.is_empty() {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {

4
czkawka_core/src/broken_files.rs
View file

@ -200,7 +200,7 @@ impl BrokenFiles {
folders_to_check.push(id.clone());
}
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 0, 1, 0, CheckingMethod::None);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) = prepare_thread_handler_common(progress_sender, 0, 1, 0, CheckingMethod::None);
while !folders_to_check.is_empty() {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
@ -435,7 +435,7 @@ impl BrokenFiles {
non_cached_files_to_check = files_to_check;
}
let (progress_thread_handle, progress_thread_run, atomic_counter) =
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) =
prepare_thread_handler_common(progress_sender, 1, 1, non_cached_files_to_check.len(), CheckingMethod::None);
let mut vec_file_entry: Vec<FileEntry> = non_cached_files_to_check

5
czkawka_core/src/common.rs
View file

@ -392,9 +392,10 @@ pub fn prepare_thread_handler_common(
max_stage: u8,
max_value: usize,
checking_method: CheckingMethod,
) -> (JoinHandle<()>, Arc<AtomicBool>, Arc<AtomicUsize>) {
) -> (JoinHandle<()>, Arc<AtomicBool>, Arc<AtomicUsize>, AtomicBool) {
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let check_was_stopped = AtomicBool::new(false);
let progress_thread_sender = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
@ -417,7 +418,7 @@ pub fn prepare_thread_handler_common(
} else {
thread::spawn(|| {})
};
(progress_thread_sender, progress_thread_run, atomic_counter)
(progress_thread_sender, progress_thread_run, atomic_counter, check_was_stopped)
}
pub fn send_info_and_wait_for_ending_all_threads(progress_thread_run: &Arc<AtomicBool>, progress_thread_handle: JoinHandle<()>) {

3
czkawka_core/src/common_dir_traversal.rs
View file

@ -338,7 +338,8 @@ where
// Add root folders for finding
folders_to_check.extend(self.root_dirs);
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(self.progress_sender, 0, self.max_stage, 0, self.checking_method);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) =
prepare_thread_handler_common(self.progress_sender, 0, self.max_stage, 0, self.checking_method);
let DirTraversal {
collect,

10
czkawka_core/src/duplicate.rs
View file

@ -9,7 +9,7 @@ use std::io::{BufReader, BufWriter};
#[cfg(target_family = "unix")]
use std::os::unix::fs::MetadataExt;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::atomic::Ordering;
use std::{fs, mem};
@ -675,9 +675,7 @@ impl DuplicateFinder {
pre_checked_map: &mut BTreeMap<u64, Vec<FileEntry>>,
) -> Option<()> {
let check_type = self.hash_type;
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let (progress_thread_handle, progress_thread_run, atomic_counter) =
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 1, 2, self.files_with_identical_size.values().map(Vec::len).sum(), self.check_method);
let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.prehash_load_cache_at_start();
@ -830,11 +828,9 @@ impl DuplicateFinder {
progress_sender: Option<&UnboundedSender<ProgressData>>,
pre_checked_map: BTreeMap<u64, Vec<FileEntry>>,
) -> Option<()> {
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let check_type = self.hash_type;
let (progress_thread_handle, progress_thread_run, atomic_counter) =
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 2, 2, pre_checked_map.values().map(Vec::len).sum(), self.check_method);
///////////////////////////////////////////////////////////////////////////// HASHING START

18
czkawka_core/src/same_music.rs
View file

@ -3,7 +3,7 @@ use std::fs::File;
use std::io::prelude::*;
use std::io::{BufReader, BufWriter};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::{mem, panic};
@ -392,9 +392,8 @@ impl SameMusic {
fn calculate_fingerprint(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.load_cache(false);
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 1, 2, non_cached_files_to_check.len(), self.check_type);
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 1, 2, non_cached_files_to_check.len(), self.check_type);
let configuration = &self.hash_preset_config;
// Clean for duplicate files
@ -439,9 +438,8 @@ impl SameMusic {
fn read_tags(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.load_cache(true);
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 1, 2, non_cached_files_to_check.len(), self.check_type);
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 1, 2, non_cached_files_to_check.len(), self.check_type);
// Clean for duplicate files
let mut vec_file_entry = non_cached_files_to_check
@ -571,7 +569,8 @@ impl SameMusic {
fn check_for_duplicate_tags(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
assert_ne!(MusicSimilarity::NONE, self.music_similarity, "This can't be none");
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 2, 2, self.music_to_check.len(), self.check_type);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) =
prepare_thread_handler_common(progress_sender, 2, 2, self.music_to_check.len(), self.check_type);
let mut old_duplicates: Vec<Vec<MusicEntry>> = vec![self.music_entries.clone()];
let mut new_duplicates: Vec<Vec<MusicEntry>> = Vec::new();
@ -746,7 +745,8 @@ impl SameMusic {
assert_ne!(MusicSimilarity::NONE, self.music_similarity, "This can't be none");
let (base_files, files_to_compare) = self.split_fingerprints_to_check();
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 2, 2, base_files.len(), self.check_type);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) =
prepare_thread_handler_common(progress_sender, 2, 2, base_files.len(), self.check_type);
let Some(duplicated_music_entries) = self.compare_fingerprints(stop_receiver, &atomic_counter, base_files, &files_to_compare) else {
send_info_and_wait_for_ending_all_threads(&progress_thread_run, progress_thread_handle);

11
czkawka_core/src/similar_images.rs
View file

@ -300,7 +300,7 @@ impl SimilarImages {
folders_to_check.push(id.clone());
}
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 0, 2, 0, CheckingMethod::None);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) = prepare_thread_handler_common(progress_sender, 0, 2, 0, CheckingMethod::None);
while !folders_to_check.is_empty() {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
@ -434,8 +434,7 @@ impl SimilarImages {
fn hash_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.hash_images_load_cache();
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let (progress_thread_handle, progress_thread_run, atomic_counter) =
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 1, 2, non_cached_files_to_check.len(), CheckingMethod::None);
let mut vec_file_entry: Vec<(FileEntry, ImHash)> = non_cached_files_to_check
@ -816,10 +815,8 @@ impl SimilarImages {
}
}
} else {
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let _progress_thread_run = Arc::new(AtomicBool::new(true));
let _atomic_counter = Arc::new(AtomicUsize::new(0));
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 2, 2, all_hashes.len(), CheckingMethod::None);
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 2, 2, all_hashes.len(), CheckingMethod::None);
// Don't use hashes with multiple images in bktree, because they will always be master of group and cannot be find by other hashes

11
czkawka_core/src/similar_videos.rs
View file

@ -4,8 +4,7 @@ use std::io::Write;
use std::io::*;
use std::mem;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc;
use std::sync::atomic::Ordering;
use crossbeam_channel::Receiver;
use ffmpeg_cmdline_utils::FfmpegErrorKind::FfmpegNotFound;
@ -262,7 +261,7 @@ impl SimilarVideos {
folders_to_check.push(id.clone());
}
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 0, 1, 0, CheckingMethod::None);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) = prepare_thread_handler_common(progress_sender, 0, 1, 0, CheckingMethod::None);
while !folders_to_check.is_empty() {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
@ -390,11 +389,7 @@ impl SimilarVideos {
fn sort_videos(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.load_cache_at_start();
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let _progress_thread_run = Arc::new(AtomicBool::new(true));
let _atomic_counter = Arc::new(AtomicUsize::new(0));
let (progress_thread_handle, progress_thread_run, atomic_counter) =
let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
prepare_thread_handler_common(progress_sender, 1, 1, non_cached_files_to_check.len(), CheckingMethod::None);
let mut vec_file_entry: Vec<FileEntry> = non_cached_files_to_check

2
czkawka_core/src/temporary.rs
View file

@ -149,7 +149,7 @@ impl Temporary {
folders_to_check.push(id.clone());
}
let (progress_thread_handle, progress_thread_run, atomic_counter) = prepare_thread_handler_common(progress_sender, 0, 0, 0, CheckingMethod::None);
let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) = prepare_thread_handler_common(progress_sender, 0, 0, 0, CheckingMethod::None);
while !folders_to_check.is_empty() {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {