chore: bump Rust edition to 2024 and apply cargo fix + clippy updates (#841)

Saul-STFC · web-flow · commit adf386330922 · 2026-06-08T07:19:11.000Z
Run `cargo fix --edition` and resolve resulting warnings:

- Add `use&lt;&gt;` syntax to `impl Trait` return types (auto-fixed)
- Fix Rust 2024 temporary drop order changes across async main tasks and backend helpers
  - Unnest nested `Ok(Json(...))` block in user-info endpoint to isolate temporary lifetimes
  - Rewrite immediate `let` bindings to use `?` followed by explicit `Ok(...)` returns
  - Fix Rust 2024 temporary drop order change by simplifying `_initial_reconcile_rx` handling
- Apply Clippy suggestions
  - Use `&amp;&amp; let` chaining instead of nested `if let` blocks in `controller.rs`
diff --git a/Cargo.nix b/Cargo.nix
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,7 +6,7 @@ resolver = "2"
 version = "0.0.0-dev"
 authors = ["Stackable GmbH <info@stackable.tech>"]
 license = "OSL-3.0"
-edition = "2021"
+edition = "2024"
 repository = "https://github.com/stackabletech/opa-operator"
 
 [workspace.dependencies]
diff --git a/rust/bundle-builder/src/main.rs b/rust/bundle-builder/src/main.rs
@@ -210,7 +210,8 @@ async fn main() -> Result<(), StartupError> {
             .context(RunServerSnafu)
     });
 
-    future::select(reflector, server).await.factor_first().0
+    future::select(reflector, server).await.factor_first().0?;
+    Ok(())
 }
 
 #[derive(Snafu, Debug)]
@@ -244,7 +245,7 @@ enum BundleError {
 }
 
 impl BundleError {
-    fn to_http_response(&self) -> impl IntoResponse {
+    fn to_http_response(&self) -> impl IntoResponse + use<> {
         (
             http::StatusCode::INTERNAL_SERVER_ERROR,
             "failed to build bundle, see opa-bundle-builder logs for more details",
diff --git a/rust/operator-binary/src/controller.rs b/rust/operator-binary/src/controller.rs
@@ -1203,10 +1203,9 @@ fn build_config_file(
     if let Some(ContainerLogConfig {
         choice: Some(ContainerLogConfigChoice::Automatic(log_config)),
     }) = merged_config.logging.containers.get(&Container::Opa)
+        && let Some(config) = log_config.loggers.get("decision")
     {
-        if let Some(config) = log_config.loggers.get("decision") {
-            decision_logging_enabled = config.level != LogLevel::NONE;
-        }
+        decision_logging_enabled = config.level != LogLevel::NONE;
     }
 
     let decision_logging = if decision_logging_enabled {
@@ -1341,13 +1340,11 @@ fn build_bundle_builder_start_command(merged_config: &OpaConfig, container_name:
         .logging
         .containers
         .get(&Container::BundleBuilder)
-    {
-        if let Some(AppenderConfig {
+        && let Some(AppenderConfig {
             level: Some(log_level),
         }) = log_config.console
-        {
-            console_logging_off = log_level == LogLevel::NONE
-        }
+    {
+        console_logging_off = log_level == LogLevel::NONE
     };
 
     formatdoc! {"
@@ -1401,13 +1398,11 @@ fn sidecar_container_log_level(
     if let Some(ContainerLogConfig {
         choice: Some(ContainerLogConfigChoice::Automatic(log_config)),
     }) = merged_config.logging.containers.get(sidecar_container)
-    {
-        if let Some(logger) = log_config
+        && let Some(logger) = log_config
             .loggers
             .get(AutomaticContainerLogConfig::ROOT_LOGGER)
-        {
-            return BundleBuilderLogLevel::from(logger.level);
-        }
+    {
+        return BundleBuilderLogLevel::from(logger.level);
     }
 
     BundleBuilderLogLevel::Info
diff --git a/rust/operator-binary/src/webhooks/conversion.rs b/rust/operator-binary/src/webhooks/conversion.rs
@@ -34,7 +34,7 @@ pub async fn create_webhook_server(
         disable_crd_maintenance,
     };
 
-    let (conversion_webhook, _initial_reconcile_rx) =
+    let (conversion_webhook, _) =
         ConversionWebhook::new(crds_and_handlers, client, conversion_webhook_options);
 
     let webhook_server_options = WebhookServerOptions {
diff --git a/rust/user-info-fetcher/src/backend/active_directory.rs b/rust/user-info-fetcher/src/backend/active_directory.rs
@@ -181,14 +181,15 @@ pub(crate) async fn get_user_info(
         .context(UserNotFoundSnafu { request })?;
     let user = SearchEntry::construct(user);
     tracing::debug!(?user, "got user from LDAP");
-    user_attributes(
+    let attrs = user_attributes(
         &mut ldap,
         base_distinguished_name,
         &user,
         custom_attribute_mappings,
         additional_group_attribute_filters,
     )
-    .await
+    .await?;
+    Ok(attrs)
 }
 
 /// Constructs a user filter that searches both the UPN as well as the sAMAccountName attributes.
diff --git a/rust/user-info-fetcher/src/backend/openldap.rs b/rust/user-info-fetcher/src/backend/openldap.rs
@@ -178,14 +178,15 @@ impl ResolvedOpenLdapBackend {
         // Search for groups that contain this user
         let groups = search_user_groups(&mut ldap, &user, &self.config).await?;
 
-        user_attributes(
+        let attrs = user_attributes(
             user_id_attribute,
             user_name_attribute,
             &user,
             groups,
             &self.config.custom_attribute_mappings,
         )
-        .await
+        .await?;
+        Ok(attrs)
     }
 }
 
diff --git a/rust/user-info-fetcher/src/main.rs b/rust/user-info-fetcher/src/main.rs
@@ -209,7 +209,8 @@ async fn main() -> Result<(), StartupError> {
     axum::serve(listener, app.into_make_service())
         .with_graceful_shutdown(shutdown_requested)
         .await
-        .context(RunServerSnafu)
+        .context(RunServerSnafu)?;
+    Ok(())
 }
 
 #[derive(Debug, Deserialize, PartialEq, Eq, Hash, Clone)]
@@ -315,64 +316,64 @@ async fn get_user_info(
         backend,
         user_info_cache,
     } = state;
-    Ok(Json(
-        user_info_cache
-            .try_get_with_by_ref(&req, async {
-                match backend.as_ref() {
-                    ResolvedBackend::None => {
-                        let user_id = match &req {
-                            UserInfoRequest::UserInfoRequestById(UserInfoRequestById { id }) => {
-                                Some(id)
-                            }
-                            _ => None,
-                        };
-                        let username = match &req {
-                            UserInfoRequest::UserInfoRequestByName(UserInfoRequestByName {
-                                username,
-                            }) => Some(username),
-                            _ => None,
-                        };
-                        Ok(UserInfo {
-                            id: user_id.cloned(),
-                            username: username.cloned(),
-                            groups: vec![],
-                            custom_attributes: HashMap::new(),
-                        })
-                    }
-                    ResolvedBackend::Keycloak(keycloak) => keycloak
-                        .get_user_info(&req)
-                        .await
-                        .context(get_user_info_error::KeycloakSnafu),
-                    ResolvedBackend::ExperimentalXfscAas(aas) => aas
-                        .get_user_info(&req)
-                        .await
-                        .context(get_user_info_error::ExperimentalXfscAasSnafu),
-                    ResolvedBackend::ActiveDirectory {
-                        ldap_server,
-                        tls,
-                        base_distinguished_name,
-                        custom_attribute_mappings,
-                        additional_group_attribute_filters,
-                    } => backend::active_directory::get_user_info(
-                        &req,
-                        ldap_server,
-                        tls,
-                        base_distinguished_name,
-                        custom_attribute_mappings,
-                        additional_group_attribute_filters,
-                    )
-                    .await
-                    .context(get_user_info_error::ActiveDirectorySnafu),
-                    ResolvedBackend::Entra(entra) => entra
-                        .get_user_info(&req)
-                        .await
-                        .context(get_user_info_error::EntraSnafu),
-                    ResolvedBackend::OpenLdap(openldap) => openldap
-                        .get_user_info(&req)
-                        .await
-                        .context(get_user_info_error::OpenLdapSnafu),
+    let user_info = user_info_cache
+        .try_get_with_by_ref(&req, async {
+            match backend.as_ref() {
+                ResolvedBackend::None => {
+                    let user_id = match &req {
+                        UserInfoRequest::UserInfoRequestById(UserInfoRequestById { id }) => {
+                            Some(id)
+                        }
+                        _ => None,
+                    };
+                    let username = match &req {
+                        UserInfoRequest::UserInfoRequestByName(UserInfoRequestByName {
+                            username,
+                        }) => Some(username),
+                        _ => None,
+                    };
+                    Ok(UserInfo {
+                        id: user_id.cloned(),
+                        username: username.cloned(),
+                        groups: vec![],
+                        custom_attributes: HashMap::new(),
+                    })
                 }
-            })
-            .await?,
-    ))
+                ResolvedBackend::Keycloak(keycloak) => keycloak
+                    .get_user_info(&req)
+                    .await
+                    .context(get_user_info_error::KeycloakSnafu),
+                ResolvedBackend::ExperimentalXfscAas(aas) => aas
+                    .get_user_info(&req)
+                    .await
+                    .context(get_user_info_error::ExperimentalXfscAasSnafu),
+                ResolvedBackend::ActiveDirectory {
+                    ldap_server,
+                    tls,
+                    base_distinguished_name,
+                    custom_attribute_mappings,
+                    additional_group_attribute_filters,
+                } => backend::active_directory::get_user_info(
+                    &req,
+                    ldap_server,
+                    tls,
+                    base_distinguished_name,
+                    custom_attribute_mappings,
+                    additional_group_attribute_filters,
+                )
+                .await
+                .context(get_user_info_error::ActiveDirectorySnafu),
+                ResolvedBackend::Entra(entra) => entra
+                    .get_user_info(&req)
+                    .await
+                    .context(get_user_info_error::EntraSnafu),
+                ResolvedBackend::OpenLdap(openldap) => openldap
+                    .get_user_info(&req)
+                    .await
+                    .context(get_user_info_error::OpenLdapSnafu),
+            }
+        })
+        .await?;
+
+    Ok(Json(user_info))
 }

Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,8 @@ async fn main() -> Result<(), StartupError> {`
`210`	`210`	`.context(RunServerSnafu)`
`211`	`211`	`});`
`212`	`212`
`213`		`- future::select(reflector, server).await.factor_first().0`
	`213`	`+ future::select(reflector, server).await.factor_first().0?;`
	`214`	`+ Ok(())`
`214`	`215`	`}`
`215`	`216`
`216`	`217`	`#[derive(Snafu, Debug)]`
`@@ -244,7 +245,7 @@ enum BundleError {`
`244`	`245`	`}`
`245`	`246`
`246`	`247`	`impl BundleError {`
`247`		`- fn to_http_response(&self) -> impl IntoResponse {`
	`248`	`+ fn to_http_response(&self) -> impl IntoResponse + use<> {`
`248`	`249`	`(`
`249`	`250`	`http::StatusCode::INTERNAL_SERVER_ERROR,`
`250`	`251`	`"failed to build bundle, see opa-bundle-builder logs for more details",`
Original file line number	Diff line number	Diff line change
`@@ -178,14 +178,15 @@ impl ResolvedOpenLdapBackend {`
`178`	`178`	`// Search for groups that contain this user`
`179`	`179`	`let groups = search_user_groups(&mut ldap, &user, &self.config).await?;`
`180`	`180`
`181`		`- user_attributes(`
	`181`	`+ let attrs = user_attributes(`
`182`	`182`	`user_id_attribute,`
`183`	`183`	`user_name_attribute,`
`184`	`184`	`&user,`
`185`	`185`	`groups,`
`186`	`186`	`&self.config.custom_attribute_mappings,`
`187`	`187`	`)`
`188`		`- .await`
	`188`	`+ .await?;`
	`189`	`+ Ok(attrs)`
`189`	`190`	`}`
`190`	`191`	`}`
`191`	`192`