fix(scanner): scope long walk timeouts (#4376)

* fix(scanner): scope long walk timeouts

* fix(scanner): bound IAM config walks

---------

Co-authored-by: Henry Guo <marshawcoco@users.noreply.github.com>

crates/ecstore/src/disk/disk_store.rs

@@ -1221,7 +1221,7 @@ impl DiskAPI for LocalDiskWrapper {
         let timeout_duration = if opts.skip_total_timeout {
             Duration::ZERO
         } else {
-            get_drive_walkdir_timeout()
+            opts.timeout_duration().unwrap_or_else(get_drive_walkdir_timeout)
         };
 
         self.track_disk_health_with_op_and_timeout_action(
@@ -1545,6 +1545,52 @@ mod tests {
         });
     }
 
+    #[test]
+    fn drive_walkdir_timeout_uses_default_when_unset() {
+        temp_env::with_var_unset(rustfs_config::ENV_DRIVE_WALKDIR_TIMEOUT_SECS, || {
+            temp_env::with_var_unset(rustfs_config::ENV_DRIVE_MAX_TIMEOUT_DURATION, || {
+                temp_env::with_var_unset(rustfs_config::ENV_DRIVE_TIMEOUT_PROFILE, || {
+                    assert_eq!(
+                        get_drive_walkdir_timeout(),
+                        Duration::from_secs(rustfs_config::DEFAULT_DRIVE_WALKDIR_TIMEOUT_SECS)
+                    );
+                });
+            });
+        });
+    }
+
+    #[test]
+    fn drive_walkdir_stall_timeout_uses_default_when_unset() {
+        temp_env::with_var_unset(rustfs_config::ENV_DRIVE_WALKDIR_STALL_TIMEOUT_SECS, || {
+            temp_env::with_var_unset(rustfs_config::ENV_DRIVE_MAX_TIMEOUT_DURATION, || {
+                temp_env::with_var_unset(rustfs_config::ENV_DRIVE_TIMEOUT_PROFILE, || {
+                    assert_eq!(
+                        get_drive_walkdir_stall_timeout(),
+                        Duration::from_secs(rustfs_config::DEFAULT_DRIVE_WALKDIR_STALL_TIMEOUT_SECS)
+                    );
+                });
+            });
+        });
+    }
+
+    #[test]
+    fn drive_walkdir_timeout_prefers_canonical_over_legacy() {
+        temp_env::with_var(rustfs_config::ENV_DRIVE_WALKDIR_TIMEOUT_SECS, Some("11"), || {
+            temp_env::with_var(rustfs_config::ENV_DRIVE_MAX_TIMEOUT_DURATION, Some("17"), || {
+                assert_eq!(get_drive_walkdir_timeout(), Duration::from_secs(11));
+            });
+        });
+    }
+
+    #[test]
+    fn drive_walkdir_stall_timeout_prefers_canonical_over_legacy() {
+        temp_env::with_var(rustfs_config::ENV_DRIVE_WALKDIR_STALL_TIMEOUT_SECS, Some("13"), || {
+            temp_env::with_var(rustfs_config::ENV_DRIVE_MAX_TIMEOUT_DURATION, Some("17"), || {
+                assert_eq!(get_drive_walkdir_stall_timeout(), Duration::from_secs(13));
+            });
+        });
+    }
+
     #[test]
     fn object_disk_read_timeout_uses_default_when_unset() {
         temp_env::with_var_unset(rustfs_config::ENV_OBJECT_DISK_READ_TIMEOUT, || {
@@ -1795,6 +1841,50 @@ mod tests {
         .await;
     }
 
+    #[tokio::test]
+    async fn walk_dir_uses_per_request_timeout_before_env_default() {
+        temp_env::async_with_vars([(rustfs_config::ENV_DRIVE_WALKDIR_TIMEOUT_SECS, Some("60"))], async {
+            let dir = tempfile::tempdir().expect("temp dir should be created");
+            let endpoint =
+                Endpoint::try_from(dir.path().to_str().expect("temp dir should be valid UTF-8")).expect("endpoint should parse");
+            let disk = Arc::new(LocalDisk::new(&endpoint, false).await.expect("local disk should be created"));
+            let wrapper = LocalDiskWrapper::new(disk, false);
+            let bucket = "test-bucket";
+            let object = "test-object";
+
+            wrapper.make_volume(bucket).await.expect("bucket should be created");
+
+            let mut file_info = FileInfo::new(&format!("{bucket}/{object}"), 1, 0);
+            file_info.volume = bucket.to_string();
+            file_info.name = object.to_string();
+            file_info.mod_time = Some(::time::OffsetDateTime::now_utc());
+            file_info.erasure.index = 1;
+
+            wrapper
+                .write_metadata("", bucket, object, file_info)
+                .await
+                .expect("object metadata should be written");
+
+            let mut writer = PendingWriter;
+            let result = wrapper
+                .walk_dir(
+                    WalkDirOptions {
+                        bucket: bucket.to_string(),
+                        recursive: true,
+                        timeout_ms: Some(10),
+                        ..Default::default()
+                    },
+                    &mut writer,
+                )
+                .await;
+
+            assert_eq!(result.expect_err("walk_dir should use per-request timeout"), DiskError::Timeout);
+            assert_eq!(wrapper.runtime_state(), RuntimeDriveHealthState::Online);
+            assert!(!wrapper.health.is_faulty());
+        })
+        .await;
+    }
+
     #[tokio::test]
     async fn walk_dir_skip_total_timeout_keeps_stream_pending() {
         temp_env::async_with_vars([(rustfs_config::ENV_DRIVE_WALKDIR_TIMEOUT_SECS, Some("1"))], async {

crates/ecstore/src/disk/mod.rs

@@ -813,6 +813,24 @@ pub struct WalkDirOptions {
     // Skip the wrapper-level total timeout for long streaming walks.
     #[serde(default)]
     pub skip_total_timeout: bool,
+
+    // Override the wrapper-level total timeout for long background walks.
+    #[serde(default)]
+    pub timeout_ms: Option<u64>,
+
+    // Override the remote stream stall timeout for long background walks.
+    #[serde(default)]
+    pub stall_timeout_ms: Option<u64>,
+}
+
+impl WalkDirOptions {
+    pub fn timeout_duration(&self) -> Option<std::time::Duration> {
+        self.timeout_ms.map(std::time::Duration::from_millis)
+    }
+
+    pub fn stall_timeout_duration(&self) -> Option<std::time::Duration> {
+        self.stall_timeout_ms.map(std::time::Duration::from_millis)
+    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -1046,6 +1064,8 @@ mod tests {
             limit: 100,
             disk_id: "disk-123".to_string(),
             skip_total_timeout: false,
+            timeout_ms: Some(10_000),
+            stall_timeout_ms: Some(20_000),
         };
 
         assert_eq!(opts.bucket, "test-bucket");
@@ -1058,6 +1078,8 @@ mod tests {
         assert_eq!(opts.limit, 100);
         assert_eq!(opts.disk_id, "disk-123");
         assert!(!opts.skip_total_timeout);
+        assert_eq!(opts.timeout_duration(), Some(std::time::Duration::from_secs(10)));
+        assert_eq!(opts.stall_timeout_duration(), Some(std::time::Duration::from_secs(20)));
     }
 
     /// Test DeleteOptions structure