gsadmin/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-08-23 12:49:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix(typo): change dang_ling to dangling (#1968)

Browse Source
This commit is contained in:
evan slack
2026-02-26 00:03:36 -05:00
committed by GitHub
parent 4b82cc20bb
commit ae6eacd7e3
3 changed files with 23 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ecstore/src/set_disk.rs
+16 -16
View File
@@ -900,7 +900,7 @@ impl StorageAPI for SetDisks {
if err == DiskError::ErasureReadQuorum if err == DiskError::ErasureReadQuorum
&& !src_bucket.starts_with(RUSTFS_META_BUCKET) && !src_bucket.starts_with(RUSTFS_META_BUCKET)
&& self && self
.delete_if_dang_ling(src_bucket, src_object, &metas, &errs, &HashMap::new(), src_opts.clone()) .delete_if_dangling(src_bucket, src_object, &metas, &errs, &HashMap::new(), src_opts.clone())
.await .await
.is_ok() .is_ok()
{ {
@@ -1529,7 +1529,7 @@ impl StorageAPI for SetDisks {
if err == DiskError::ErasureReadQuorum if err == DiskError::ErasureReadQuorum
&& !bucket.starts_with(RUSTFS_META_BUCKET) && !bucket.starts_with(RUSTFS_META_BUCKET)
&& self && self
.delete_if_dang_ling(bucket, object, &metas, &errs, &HashMap::new(), opts.clone()) .delete_if_dangling(bucket, object, &metas, &errs, &HashMap::new(), opts.clone())
.await .await
.is_ok() .is_ok()
{ {
@@ -3052,17 +3052,17 @@ pub struct HealEntryResult {
pub name: String, pub name: String,
} }
fn is_object_dang_ling( fn is_object_dangling(
meta_arr: &[FileInfo], meta_arr: &[FileInfo],
errs: &[Option<DiskError>], errs: &[Option<DiskError>],
data_errs_by_part: &HashMap<usize, Vec<usize>>, data_errs_by_part: &HashMap<usize, Vec<usize>>,
) -> (FileInfo, bool) { ) -> (FileInfo, bool) {
let (not_found_meta_errs, non_actionable_meta_errs) = dang_ling_meta_errs_count(errs); let (not_found_meta_errs, non_actionable_meta_errs) = dangling_meta_errs_count(errs);
let (mut not_found_parts_errs, mut non_actionable_parts_errs) = (0, 0); let (mut not_found_parts_errs, mut non_actionable_parts_errs) = (0, 0);
data_errs_by_part.iter().for_each(|(_, v)| { data_errs_by_part.iter().for_each(|(_, v)| {
let (nf, na) = dang_ling_part_errs_count(v); let (nf, na) = dangling_part_errs_count(v);
if nf > not_found_parts_errs { if nf > not_found_parts_errs {
(not_found_parts_errs, non_actionable_parts_errs) = (nf, na); (not_found_parts_errs, non_actionable_parts_errs) = (nf, na);
} }
@@ -3106,7 +3106,7 @@ fn is_object_dang_ling(
(valid_meta, false) (valid_meta, false)
} }
fn dang_ling_meta_errs_count(cerrs: &[Option<DiskError>]) -> (usize, usize) { fn dangling_meta_errs_count(cerrs: &[Option<DiskError>]) -> (usize, usize) {
let (mut not_found_count, mut non_actionable_count) = (0, 0); let (mut not_found_count, mut non_actionable_count) = (0, 0);
cerrs.iter().for_each(|err| { cerrs.iter().for_each(|err| {
if let Some(err) = err { if let Some(err) = err {
@@ -3121,7 +3121,7 @@ fn dang_ling_meta_errs_count(cerrs: &[Option<DiskError>]) -> (usize, usize) {
(not_found_count, non_actionable_count) (not_found_count, non_actionable_count)
} }
fn dang_ling_part_errs_count(results: &[usize]) -> (usize, usize) { fn dangling_part_errs_count(results: &[usize]) -> (usize, usize) {
let (mut not_found_count, mut non_actionable_count) = (0, 0); let (mut not_found_count, mut non_actionable_count) = (0, 0);
results.iter().for_each(|result| { results.iter().for_each(|result| {
if *result == CHECK_PART_SUCCESS { if *result == CHECK_PART_SUCCESS {
@@ -3136,7 +3136,7 @@ fn dang_ling_part_errs_count(results: &[usize]) -> (usize, usize) {
(not_found_count, non_actionable_count) (not_found_count, non_actionable_count)
} }
fn is_object_dir_dang_ling(errs: &[Option<DiskError>]) -> bool { fn is_object_dir_dangling(errs: &[Option<DiskError>]) -> bool {
let mut found = 0; let mut found = 0;
let mut not_found = 0; let mut not_found = 0;
let mut found_not_empty = 0; let mut found_not_empty = 0;
@@ -4014,33 +4014,33 @@ mod tests {
} }
#[test] #[test]
fn test_dang_ling_meta_errs_count() { fn test_dangling_meta_errs_count() {
// Test counting dangling metadata errors // Test counting dangling metadata errors
let errs = vec![None, Some(DiskError::FileNotFound), None]; let errs = vec![None, Some(DiskError::FileNotFound), None];
let (not_found_count, non_actionable_count) = dang_ling_meta_errs_count(&errs); let (not_found_count, non_actionable_count) = dangling_meta_errs_count(&errs);
assert_eq!(not_found_count, 1); // One FileNotFound error assert_eq!(not_found_count, 1); // One FileNotFound error
assert_eq!(non_actionable_count, 0); // No other errors assert_eq!(non_actionable_count, 0); // No other errors
} }
#[test] #[test]
fn test_dang_ling_part_errs_count() { fn test_dangling_part_errs_count() {
// Test counting dangling part errors // Test counting dangling part errors
let results = vec![CHECK_PART_SUCCESS, CHECK_PART_FILE_NOT_FOUND, CHECK_PART_SUCCESS]; let results = vec![CHECK_PART_SUCCESS, CHECK_PART_FILE_NOT_FOUND, CHECK_PART_SUCCESS];
let (not_found_count, non_actionable_count) = dang_ling_part_errs_count(&results); let (not_found_count, non_actionable_count) = dangling_part_errs_count(&results);
assert_eq!(not_found_count, 1); // One FILE_NOT_FOUND error assert_eq!(not_found_count, 1); // One FILE_NOT_FOUND error
assert_eq!(non_actionable_count, 0); // No other errors assert_eq!(non_actionable_count, 0); // No other errors
} }
#[test] #[test]
fn test_is_object_dir_dang_ling() { fn test_is_object_dir_dangling() {
// Test object directory dangling detection // Test object directory dangling detection
let errs = vec![Some(DiskError::FileNotFound), Some(DiskError::FileNotFound), None]; let errs = vec![Some(DiskError::FileNotFound), Some(DiskError::FileNotFound), None];
assert!(is_object_dir_dang_ling(&errs)); assert!(is_object_dir_dangling(&errs));
let errs2 = vec![None, None, None]; let errs2 = vec![None, None, None];
assert!(!is_object_dir_dang_ling(&errs2)); assert!(!is_object_dir_dangling(&errs2));
let errs3 = vec![Some(DiskError::FileCorrupt), Some(DiskError::FileNotFound)]; let errs3 = vec![Some(DiskError::FileCorrupt), Some(DiskError::FileNotFound)];
assert!(!is_object_dir_dang_ling(&errs3)); // Mixed errors, not all not found assert!(!is_object_dir_dangling(&errs3)); // Mixed errors, not all not found
} }
#[test] #[test]
crates/ecstore/src/set_disk/heal.rs
+5 -5
View File
@@ -226,7 +226,7 @@ impl SetDisks {
// Allow for dangling deletes, on versions that have DataDir missing etc. // Allow for dangling deletes, on versions that have DataDir missing etc.
// this would end up restoring the correct readable versions. // this would end up restoring the correct readable versions.
return match self return match self
.delete_if_dang_ling( .delete_if_dangling(
bucket, bucket,
object, object,
&parts_metadata, &parts_metadata,
@@ -548,7 +548,7 @@ impl SetDisks {
Err(err) => { Err(err) => {
let data_errs_by_part = HashMap::new(); let data_errs_by_part = HashMap::new();
match self match self
.delete_if_dang_ling( .delete_if_dangling(
bucket, bucket,
object, object,
&parts_metadata, &parts_metadata,
@@ -605,8 +605,8 @@ impl SetDisks {
result.after.drives = vec![HealDriveInfo::default(); disks.len()]; result.after.drives = vec![HealDriveInfo::default(); disks.len()];
let errs = stat_all_dirs(&disks, bucket, object).await; let errs = stat_all_dirs(&disks, bucket, object).await;
let dang_ling_object = is_object_dir_dang_ling(&errs); let dangling_object = is_object_dir_dangling(&errs);
if dang_ling_object && !dry_run && remove { if dangling_object && !dry_run && remove {
let mut futures = Vec::with_capacity(disks.len()); let mut futures = Vec::with_capacity(disks.len());
for disk in disks.iter().flatten() { for disk in disks.iter().flatten() {
let disk = disk.clone(); let disk = disk.clone();
@@ -654,7 +654,7 @@ impl SetDisks {
}); });
} }
if dang_ling_object || DiskError::is_all_not_found(&errs) { if dangling_object || DiskError::is_all_not_found(&errs) {
return Ok((result, Some(DiskError::FileNotFound))); return Ok((result, Some(DiskError::FileNotFound)));
} }
crates/ecstore/src/set_disk/write.rs
+2 -2
View File
@@ -440,7 +440,7 @@ impl SetDisks {
Ok(()) Ok(())
} }
pub(super) async fn delete_if_dang_ling( pub(super) async fn delete_if_dangling(
&self, &self,
bucket: &str, bucket: &str,
object: &str, object: &str,
@@ -449,7 +449,7 @@ impl SetDisks {
data_errs_by_part: &HashMap<usize, Vec<usize>>, data_errs_by_part: &HashMap<usize, Vec<usize>>,
opts: ObjectOptions, opts: ObjectOptions,
) -> disk::error::Result<FileInfo> { ) -> disk::error::Result<FileInfo> {
let (m, can_heal) = is_object_dang_ling(meta_arr, errs, data_errs_by_part); let (m, can_heal) = is_object_dangling(meta_arr, errs, data_errs_by_part);
if !can_heal { if !can_heal {
return Err(DiskError::ErasureReadQuorum); return Err(DiskError::ErasureReadQuorum);