@ -1,45 +1,18 @@
use std ::collections ::BTreeMap ; use std ::collections ::BTreeMap ;
use std ::fs ::{ File , Metadata } ; use std ::fs ;
use std ::fs ::File ;
use std ::io ::{ BufWriter , Write } ; use std ::io ::{ BufWriter , Write } ;
use std ::path ::{ Path , PathBuf } ; use std ::path ::PathBuf ;
use std ::sync ::atomic ::{ AtomicBool , AtomicUsize , Ordering } ; use std ::time ::SystemTime ;
use std ::sync ::Arc ;
use std ::thread ::sleep ;
use std ::time ::{ Duration , SystemTime , UNIX_EPOCH } ;
use std ::{ fs , thread } ;
use crossbeam_channel ::Receiver ; use crossbeam_channel ::Receiver ;
use crate ::common ::Common ; use crate ::common ::Common ;
use crate ::common_dir_traversal ::{ Collect , DirTraversalBuilder , DirTraversalResult , FolderEmptiness , FolderEntry , ProgressData } ;
use crate ::common_directory ::Directories ; use crate ::common_directory ::Directories ;
use crate ::common_items ::ExcludedItems ; use crate ::common_items ::ExcludedItems ;
use crate ::common_messages ::Messages ; use crate ::common_messages ::Messages ;
use crate ::common_traits ::{ DebugPrint , PrintResults , SaveResults } ; use crate ::common_traits ::{ DebugPrint , PrintResults , SaveResults } ;
use crate ::fl ;
use crate ::localizer ::generate_translation_hashmap ;
#[ derive(Debug) ]
pub struct ProgressData {
pub current_stage : u8 ,
pub max_stage : u8 ,
pub folders_checked : usize ,
}
/// Enum with values which show if folder is empty.
/// In function "optimize_folders" automatically "Maybe" is changed to "Yes", so it is not necessary to put it here
#[ derive(Eq, PartialEq, Copy, Clone) ]
enum FolderEmptiness {
No ,
Maybe ,
}
/// Struct assigned to each checked folder with parent path(used to ignore parent if children are not empty) and flag which shows if folder is empty
#[ derive(Clone) ]
pub struct FolderEntry {
parent_path : Option < PathBuf > , // Usable only when finding
is_empty : FolderEmptiness ,
pub modified_date : u64 ,
}
/// Struct to store most basics info about all folder
/// Struct to store most basics info about all folder
pub struct EmptyFolder { pub struct EmptyFolder {
@ -143,147 +116,41 @@ impl EmptyFolder {
/// Function to check if folder are empty.
/// Function to check if folder are empty.
/// Parameter initial_checking for second check before deleting to be sure that checked folder is still 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 ::UnboundedSender < ProgressData > > ) -> bool { fn check_for_empty_folders ( & mut self , stop_receiver : Option < & Receiver < ( ) > > , progress_sender : Option < & futures ::channel ::mpsc ::UnboundedSender < ProgressData > > ) -> bool {
let start_time : SystemTime = SystemTime ::now ( ) ; let result = DirTraversalBuilder ::new ( )
let mut folders_to_check : Vec < PathBuf > = 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
. root_dirs ( self . directories . included_directories . clone ( ) )
let mut folders_checked : BTreeMap < PathBuf , FolderEntry > = Default ::default ( ) ; . group_by ( | _fe | ( ) )
. stop_receiver ( stop_receiver )
//// PROGRESS THREAD START
. progress_sender ( progress_sender )
const LOOP_DURATION : u32 = 200 ; //in ms
. directories ( self . directories . clone ( ) )
let progress_thread_run = Arc ::new ( AtomicBool ::new ( true ) ) ; . excluded_items ( self . excluded_items . clone ( ) )
. collect ( Collect ::EmptyFolders )
let atomic_folder_counter = Arc ::new ( AtomicUsize ::new ( 0 ) ) ; . max_stage ( 0 )
. build ( )
let progress_thread_handle = if let Some ( progress_sender ) = progress_sender { . run ( ) ;
let progress_send = progress_sender . clone ( ) ; match result {
let progress_thread_run = progress_thread_run . clone ( ) ; DirTraversalResult ::SuccessFiles { .. } = > {
let atomic_folder_counter = atomic_folder_counter . clone ( ) ; unreachable! ( )
thread ::spawn ( move | | loop {
progress_send
. unbounded_send ( ProgressData {
current_stage : 0 ,
max_stage : 0 ,
folders_checked : atomic_folder_counter . load ( Ordering ::Relaxed ) as usize ,
} )
. unwrap ( ) ;
if ! progress_thread_run . load ( Ordering ::Relaxed ) {
break ;
}
sleep ( Duration ::from_millis ( LOOP_DURATION as u64 ) ) ;
} )
} else {
thread ::spawn ( | | { } )
} ;
//// PROGRESS THREAD END
// Add root folders for finding
for id in & self . directories . included_directories {
folders_checked . insert (
id . clone ( ) ,
FolderEntry {
parent_path : None ,
is_empty : FolderEmptiness ::Maybe ,
modified_date : 0 ,
} ,
) ;
folders_to_check . push ( id . clone ( ) ) ;
}
while ! folders_to_check . is_empty ( ) {
if stop_receiver . is_some ( ) & & stop_receiver . unwrap ( ) . try_recv ( ) . is_ok ( ) {
// End thread which send info to gui
progress_thread_run . store ( false , Ordering ::Relaxed ) ;
progress_thread_handle . join ( ) . unwrap ( ) ;
return false ;
} }
let current_folder = folders_to_check . pop ( ) . unwrap ( ) ; DirTraversalResult ::SuccessFolders {
// Checked folder may be deleted or we may not have permissions to open it so we assume that this folder is not be empty
start_time ,
// Read current dir childrens
folder_entries ,
let read_dir = match fs ::read_dir ( & current_folder ) { warnings ,
Ok ( t ) = > t , } = > {
Err ( e ) = > { // We need to set empty folder list
self . text_messages . warnings . push ( fl ! ( #[ allow(unused_mut) ] // Used is later by Windows build
"core_cannot_open_dir" , for ( mut name , folder_entry ) in folder_entries {
generate_translation_hashmap ( vec! [ ( "dir" , current_folder . display ( ) . to_string ( ) ) , ( "reason" , e . to_string ( ) ) ] ) if folder_entry . is_empty ! = FolderEmptiness ::No {
) ) ; self . empty_folder_list . insert ( name , folder_entry ) ;
continue ;
}
} ;
// Check every sub folder/file/link etc.
' dir : for entry in read_dir {
let entry_data = match entry {
Ok ( t ) = > t ,
Err ( e ) = > {
self . text_messages . warnings . push ( fl ! (
"core_cannot_read_entry_dir" ,
generate_translation_hashmap ( vec! [ ( "dir" , current_folder . display ( ) . to_string ( ) ) , ( "reason" , e . to_string ( ) ) ] )
) ) ;
continue 'dir ;
} }
} ;
let metadata : Metadata = match entry_data . metadata ( ) {
Ok ( t ) = > t ,
Err ( e ) = > {
self . text_messages . warnings . push ( fl ! (
"core_cannot_read_metadata_dir" ,
generate_translation_hashmap ( vec! [ ( "dir" , current_folder . display ( ) . to_string ( ) ) , ( "reason" , e . to_string ( ) ) ] )
) ) ;
continue 'dir ;
}
} ;
if metadata . is_dir ( ) {
atomic_folder_counter . fetch_add ( 1 , Ordering ::Relaxed ) ;
let next_folder = current_folder . join ( entry_data . file_name ( ) ) ;
if self . excluded_items . is_excluded ( & next_folder ) | | self . directories . is_excluded ( & next_folder ) {
set_as_not_empty_folder ( & mut folders_checked , & current_folder ) ;
continue 'dir ;
}
folders_to_check . push ( next_folder . clone ( ) ) ;
folders_checked . insert (
next_folder . clone ( ) ,
FolderEntry {
parent_path : Some ( current_folder . clone ( ) ) ,
is_empty : FolderEmptiness ::Maybe ,
modified_date : match metadata . modified ( ) {
Ok ( t ) = > match t . duration_since ( UNIX_EPOCH ) {
Ok ( d ) = > d . as_secs ( ) ,
Err ( _inspected ) = > {
self . text_messages . warnings . push ( fl ! (
"core_folder_modified_before_epoch" ,
generate_translation_hashmap ( vec! [ ( "name" , current_folder . display ( ) . to_string ( ) ) ] )
) ) ;
0
}
} ,
Err ( e ) = > {
self . text_messages . warnings . push ( fl ! (
"core_folder_no_modification_date" ,
generate_translation_hashmap ( vec! [ ( "name" , current_folder . display ( ) . to_string ( ) ) , ( "reason" , e . to_string ( ) ) ] )
) ) ;
0
}
} ,
} ,
) ;
} else {
set_as_not_empty_folder ( & mut folders_checked , & current_folder )
} }
}
}
// End thread which send info to gui
progress_thread_run . store ( false , Ordering ::Relaxed ) ;
progress_thread_handle . join ( ) . unwrap ( ) ;
// We need to set empty folder list
self . text_messages . warnings . extend ( warnings ) ;
#[ allow(unused_mut) ] // Used is later by Windows build
for ( mut name , folder_entry ) in folders_checked { Common ::print_time ( start_time , SystemTime ::now ( ) , "check_for_empty_folder" . to_string ( ) ) ;
if folder_entry . is_empty ! = FolderEmptiness ::No { true
self . empty_folder_list . insert ( name , folder_entry ) ;
} }
DirTraversalResult ::Stopped = > false ,
} }
Common ::print_time ( start_time , SystemTime ::now ( ) , "check_for_empty_folder" . to_string ( ) ) ;
true
} }
/// Deletes earlier found empty folders
/// Deletes earlier found empty folders
@ -306,22 +173,6 @@ impl EmptyFolder {
} }
} }
fn set_as_not_empty_folder ( folders_checked : & mut BTreeMap < PathBuf , FolderEntry > , current_folder : & Path ) {
// Not folder so it may be a file or symbolic link so it isn't empty
folders_checked . get_mut ( current_folder ) . unwrap ( ) . is_empty = FolderEmptiness ::No ;
let mut d = folders_checked . get_mut ( current_folder ) . unwrap ( ) ;
// Loop to recursively set as non empty this and all his parent folders
loop {
d . is_empty = FolderEmptiness ::No ;
if d . parent_path ! = None {
let cf = d . parent_path . clone ( ) . unwrap ( ) ;
d = folders_checked . get_mut ( & cf ) . unwrap ( ) ;
} else {
break ;
}
}
}
impl Default for EmptyFolder { impl Default for EmptyFolder {
fn default ( ) -> Self { fn default ( ) -> Self {
Self ::new ( ) Self ::new ( )
Peter Blackson
2 years ago
committed by
GitHub