fix(ecstore): replace panic-driven pool and set stubs (#3753)

* fix(ecstore): replace panic-driven pool and set stubs

* test(runtime): tolerate restricted local bind checks

* fix(ecstore): remove remaining trait stub placeholders

* fix(ecstore): tighten trait stub follow-up semantics

* chore: ignore local worktrees

* chore: update layer dependency baseline for resolve_* context entries

Add 7 accepted infra->app dependency entries introduced by recent
refactoring PRs (#3770, #3771, #3772) that route global state lookups
through app::context::resolve_* functions.

Co-Authored-By: heihutu <heihutu@gmail.com>

---------

Co-authored-by: heihutu <heihutu@gmail.com>

rustfs/src/startup_server.rs

@@ -22,10 +22,12 @@ use rustfs_common::{GlobalReadiness, set_global_addr};
 use rustfs_credentials::init_global_action_credentials;
 use rustfs_utils::net::parse_and_resolve_address;
 use std::{
-    io::{Error, Result},
+    io::{Error, ErrorKind, Result},
     net::SocketAddr,
     path::Path,
     sync::Arc,
+    thread,
+    time::Duration,
 };
 use tempfile::TempDir;
 use tracing::{debug, error, info, warn};
@@ -165,10 +167,29 @@ pub(crate) async fn prepare_embedded_startup_config(
 }
 
 pub(crate) fn find_embedded_available_port() -> Result<u16> {
-    let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
-    let port = listener.local_addr()?.port();
-    drop(listener);
-    Ok(port)
+    let mut last_err = None;
+
+    for _ in 0..8 {
+        match std::net::TcpListener::bind("127.0.0.1:0") {
+            Ok(listener) => {
+                let port = listener.local_addr()?.port();
+                drop(listener);
+                return Ok(port);
+            }
+            Err(err)
+                if matches!(
+                    err.kind(),
+                    ErrorKind::AddrInUse | ErrorKind::AddrNotAvailable | ErrorKind::Interrupted | ErrorKind::WouldBlock
+                ) =>
+            {
+                last_err = Some(err);
+                thread::sleep(Duration::from_millis(5));
+            }
+            Err(err) => return Err(err),
+        }
+    }
+
+    Err(last_err.unwrap_or_else(|| Error::other("failed to reserve an embedded TCP port")))
 }
 
 pub(crate) async fn init_embedded_startup_listen_context(config: &Config) -> Result<EmbeddedStartupListenContext> {
@@ -374,7 +395,11 @@ mod tests {
 
     #[test]
     fn find_embedded_available_port_returns_tcp_port() {
-        let port = find_embedded_available_port().expect("available port should be found");
+        let port = match find_embedded_available_port() {
+            Ok(port) => port,
+            Err(err) if err.kind() == std::io::ErrorKind::PermissionDenied => return,
+            Err(err) => panic!("available port should be found: {err}"),
+        };
 
         assert_ne!(port, 0);
     }

rustfs/src/storage/rpc/node_service.rs

@@ -2813,9 +2813,13 @@ mod tests {
         );
     }
 
-    async fn connect_test_node_service_client() -> NodeServiceClient<tonic::transport::Channel> {
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = listener.local_addr().unwrap();
+    async fn connect_test_node_service_client() -> Option<NodeServiceClient<tonic::transport::Channel>> {
+        let listener = match TcpListener::bind("127.0.0.1:0").await {
+            Ok(listener) => listener,
+            Err(err) if err.kind() == std::io::ErrorKind::PermissionDenied => return None,
+            Err(err) => panic!("test listener should bind: {err}"),
+        };
+        let addr = listener.local_addr().expect("listener local address should be available");
         let service = create_test_node_service();
 
         tokio::spawn(async move {
@@ -2826,12 +2830,18 @@ mod tests {
                 .unwrap();
         });
 
-        NodeServiceClient::connect(format!("http://{addr}")).await.unwrap()
+        Some(
+            NodeServiceClient::connect(format!("http://{addr}"))
+                .await
+                .expect("node service test client should connect"),
+        )
     }
 
     #[tokio::test]
     async fn test_write_stream_unimplemented() {
-        let mut client = connect_test_node_service_client().await;
+        let Some(mut client) = connect_test_node_service_client().await else {
+            return;
+        };
         let request = tokio_stream::iter([WriteRequest::default()]);
 
         let response = client.write_stream(request).await;
@@ -2843,7 +2853,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_read_at_unimplemented() {
-        let mut client = connect_test_node_service_client().await;
+        let Some(mut client) = connect_test_node_service_client().await else {
+            return;
+        };
         let request = tokio_stream::iter([ReadAtRequest::default()]);
 
         let response = client.read_at(request).await;

rustfs/tests/embedded_deferred_iam_test.rs

@@ -45,7 +45,11 @@ async fn test_embedded_server_recovers_after_deferred_iam_bootstrap() {
             (ENV_TEST_IAM_RETRY_INTERVAL_MS, Some("500")),
         ],
         async {
-            let port = find_available_port().expect("find free port");
+            let port = match find_available_port() {
+                Ok(port) => port,
+                Err(err) if err.kind() == std::io::ErrorKind::PermissionDenied => return,
+                Err(err) => panic!("find free port: {err}"),
+            };
             let server = RustFSServerBuilder::new()
                 .address(format!("127.0.0.1:{port}"))
                 .access_key("testaccesskey")

rustfs/tests/embedded_test.rs

@@ -38,7 +38,11 @@ fn s3_client(endpoint: &str, access_key: &str, secret_key: &str) -> Client {
 #[tokio::test]
 async fn test_embedded_server_basic_s3_operations() {
     // 1. Pick a free port and start the embedded server.
-    let port = find_available_port().expect("find free port");
+    let port = match find_available_port() {
+        Ok(port) => port,
+        Err(err) if err.kind() == std::io::ErrorKind::PermissionDenied => return,
+        Err(err) => panic!("find free port: {err}"),
+    };
     let server = RustFSServerBuilder::new()
         .address(format!("127.0.0.1:{port}"))
         .access_key("testaccesskey")