refactor: keep embedded identity with startup config (#3668)

rustfs/src/startup_embedded.rs

@@ -28,7 +28,6 @@ use crate::{
 use std::{io, net::SocketAddr, path::PathBuf};
 use tokio_util::sync::CancellationToken;
 
-#[derive(Clone)]
 pub(crate) struct EmbeddedStartupArgs {
     address: String,
     access_key: String,
@@ -104,19 +103,18 @@ pub(crate) async fn run_embedded_startup(args: EmbeddedStartupArgs) -> Result<Em
         volumes,
         region,
     } = args;
-    let server_access_key = access_key.clone();
-    let server_secret_key = secret_key.clone();
-    let server_region = region.clone();
-
     // Build is allowed to fail before irreversible global initialization
     // (for example on temporary I/O or directory setup errors), and in that
     // case callers can retry.
     let mut startup_guard = EmbeddedStartupGuard::new();
 
-    let EmbeddedStartupConfig { config, temp_dir_guard } =
-        prepare_embedded_startup_config(address, access_key, secret_key, volumes, region)
-            .await
-            .map_err(init_error)?;
+    let EmbeddedStartupConfig {
+        config,
+        identity,
+        temp_dir_guard,
+    } = prepare_embedded_startup_config(address, access_key, secret_key, volumes, region)
+        .await
+        .map_err(init_error)?;
 
     init_embedded_runtime_hooks(config.obs_endpoint.clone())
         .await
@@ -176,9 +174,9 @@ pub(crate) async fn run_embedded_startup(args: EmbeddedStartupArgs) -> Result<Em
 
     Ok(EmbeddedStartedServer {
         bound_addr,
-        access_key: server_access_key,
-        secret_key: server_secret_key,
-        region: server_region,
+        access_key: identity.access_key,
+        secret_key: identity.secret_key,
+        region: identity.region,
         shutdown_handle,
         cancel_token,
         temp_dir: temp_dir_guard.map(|guard| guard.keep()),

rustfs/src/startup_server.rs

@@ -54,9 +54,16 @@ pub struct EmbeddedStartupListenContext {
 
 pub(crate) struct EmbeddedStartupConfig {
     pub config: Config,
+    pub identity: EmbeddedServerIdentity,
     pub(crate) temp_dir_guard: Option<TempDir>,
 }
 
+pub(crate) struct EmbeddedServerIdentity {
+    pub access_key: String,
+    pub secret_key: String,
+    pub region: String,
+}
+
 pub(crate) struct EmbeddedHttpServer {
     pub shutdown_handle: ShutdownHandle,
     pub bound_addr: SocketAddr,
@@ -141,12 +148,20 @@ pub(crate) async fn prepare_embedded_startup_config(
     }
 
     let mut config = Config::new(&address, volumes);
-    config.access_key = access_key;
-    config.secret_key = secret_key;
-    config.region = Some(region);
+    config.access_key = access_key.clone();
+    config.secret_key = secret_key.clone();
+    config.region = Some(region.clone());
     config.console_enable = false;
 
-    Ok(EmbeddedStartupConfig { config, temp_dir_guard })
+    Ok(EmbeddedStartupConfig {
+        config,
+        identity: EmbeddedServerIdentity {
+            access_key,
+            secret_key,
+            region,
+        },
+        temp_dir_guard,
+    })
 }
 
 pub(crate) fn find_embedded_available_port() -> Result<u16> {
@@ -380,6 +395,9 @@ mod tests {
         assert_eq!(prepared.config.access_key, "access");
         assert_eq!(prepared.config.secret_key, "secret");
         assert_eq!(prepared.config.region.as_deref(), Some("us-west-2"));
+        assert_eq!(prepared.identity.access_key, "access");
+        assert_eq!(prepared.identity.secret_key, "secret");
+        assert_eq!(prepared.identity.region, "us-west-2");
         assert!(!prepared.config.console_enable);
         assert_eq!(prepared.config.volumes.len(), 1);
         assert!(std::path::Path::new(&prepared.config.volumes[0]).exists());