gsadmin/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-07-26 08:18:18 +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
&& !src_bucket.starts_with(RUSTFS_META_BUCKET)
&& 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
.is_ok()
{
@@ -1529,7 +1529,7 @@ impl StorageAPI for SetDisks {
if err == DiskError::ErasureReadQuorum
&& !bucket.starts_with(RUSTFS_META_BUCKET)
&& 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
.is_ok()
{
@@ -3052,17 +3052,17 @@ pub struct HealEntryResult {
pub name: String,
}
fn is_object_dang_ling(
fn is_object_dangling(
meta_arr: &[FileInfo],
errs: &[Option<DiskError>],
data_errs_by_part: &HashMap<usize, Vec<usize>>,
) -> (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);
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 {
(not_found_parts_errs, non_actionable_parts_errs) = (nf, na);
}
@@ -3106,7 +3106,7 @@ fn is_object_dang_ling(
(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);
cerrs.iter().for_each(|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)
}
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);
results.iter().for_each(|result| {
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)
}
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 not_found = 0;
let mut found_not_empty = 0;
@@ -4014,33 +4014,33 @@ mod tests {
}
#[test]
fn test_dang_ling_meta_errs_count() {
fn test_dangling_meta_errs_count() {
// Test counting dangling metadata errors
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!(non_actionable_count, 0); // No other errors
}
#[test]
fn test_dang_ling_part_errs_count() {
fn test_dangling_part_errs_count() {
// Test counting dangling part errors
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!(non_actionable_count, 0); // No other errors
}
#[test]
fn test_is_object_dir_dang_ling() {
fn test_is_object_dir_dangling() {
// Test object directory dangling detection
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];
assert!(!is_object_dir_dang_ling(&errs2));
assert!(!is_object_dir_dangling(&errs2));
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]
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.
// this would end up restoring the correct readable versions.
return match self
.delete_if_dang_ling(
.delete_if_dangling(
bucket,
object,
&parts_metadata,
@@ -548,7 +548,7 @@ impl SetDisks {
Err(err) => {
let data_errs_by_part = HashMap::new();
match self
.delete_if_dang_ling(
.delete_if_dangling(
bucket,
object,
&parts_metadata,
@@ -605,8 +605,8 @@ impl SetDisks {
result.after.drives = vec![HealDriveInfo::default(); disks.len()];
let errs = stat_all_dirs(&disks, bucket, object).await;
let dang_ling_object = is_object_dir_dang_ling(&errs);
if dang_ling_object && !dry_run && remove {
let dangling_object = is_object_dir_dangling(&errs);
if dangling_object && !dry_run && remove {
let mut futures = Vec::with_capacity(disks.len());
for disk in disks.iter().flatten() {
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)));
}
crates/ecstore/src/set_disk/write.rs
+2 -2
View File
@@ -440,7 +440,7 @@ impl SetDisks {
Ok(())
}
pub(super) async fn delete_if_dang_ling(
pub(super) async fn delete_if_dangling(
&self,
bucket: &str,
object: &str,
@@ -449,7 +449,7 @@ impl SetDisks {
data_errs_by_part: &HashMap<usize, Vec<usize>>,
opts: ObjectOptions,
) -> 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 {
return Err(DiskError::ErasureReadQuorum);