From fdbc98d7a7aef412b41048a8ed71847e06e6fa76 Mon Sep 17 00:00:00 2001 From: Igor Novgorodov Date: Tue, 12 May 2026 17:48:31 +0200 Subject: [PATCH] Fix clippy --- src/api.rs | 14 +++++++------- src/backend.rs | 33 ++++++++++++++++----------------- src/cli.rs | 2 ++ src/core.rs | 10 +++++----- src/main.rs | 5 +++++ src/metrics.rs | 6 ++++-- src/middleware/metrics.rs | 20 ++++++-------------- src/routing.rs | 16 ++++++---------- src/tls.rs | 4 ++-- 9 files changed, 53 insertions(+), 57 deletions(-) diff --git a/src/api.rs b/src/api.rs index 41e8444..4819221 100644 --- a/src/api.rs +++ b/src/api.rs @@ -52,10 +52,10 @@ pub async fn auth_middleware( } pub async fn health_handler(State(state): State>) -> impl IntoResponse { - if !state.backend_manager.get_healthy_nodes().is_empty() { - StatusCode::NO_CONTENT - } else { + if state.backend_manager.get_healthy_nodes().is_empty() { StatusCode::SERVICE_UNAVAILABLE + } else { + StatusCode::NO_CONTENT } } @@ -71,11 +71,11 @@ pub async fn backend_handler( .backend_manager .set_backend_state(backend, action == "enable") .await - .map_err(|e| (StatusCode::BAD_REQUEST, format!("Error: {e:#}")))? + .map_err(|e| (StatusCode::BAD_REQUEST, format!("Error: {e:#}")))?; } _ => return Err((StatusCode::BAD_REQUEST, format!("Unknown action: {action}"))), - }; + } Ok((StatusCode::OK, "Ok\n".to_string())) } @@ -106,7 +106,7 @@ pub async fn config_reload(State(state): State>) -> Response { format!("Error reloading config: {e:#}"), ) .into_response(); - }; + } "Ok\n".into_response() } @@ -187,7 +187,7 @@ pub fn setup_api_axum_router( .route("/config/put", put(config_put).layer(auth.clone())); if let Some(v) = waf_layer { - router = router.nest("/waf", waf::create_router(v).layer(auth)) + router = router.nest("/waf", waf::create_router(v).layer(auth)); } #[allow(unused_mut)] diff --git a/src/backend.rs b/src/backend.rs index 0efd960..36c4f6d 100644 --- a/src/backend.rs +++ b/src/backend.rs @@ -1,3 +1,5 @@ +#![allow(clippy::significant_drop_tightening)] + use std::{cell::RefCell, fmt::Display, path::PathBuf, sync::Arc, time::Duration}; use anyhow::{Context, Error, anyhow, bail}; @@ -108,7 +110,7 @@ impl From for Backend { } } -/// Sets up the LBBackendRouter instance using the given config parameters +/// Sets up the `LBBackendRouter` instance using the given config parameters pub fn setup_backend_router( client: Arc>, backends: Vec, @@ -158,7 +160,7 @@ impl Display for BackendManager { } impl BackendManager { - /// Create a new BackendManager + /// Create a new `BackendManager` pub fn new( client: Arc>, config_path: PathBuf, @@ -201,7 +203,7 @@ impl BackendManager { ) -> LBBackendRouter { setup_backend_router( self.client.clone(), - backends.clone(), + backends, strategy, self.check_interval, self.check_timeout, @@ -218,13 +220,13 @@ impl BackendManager { strategy: Strategy, ) { // Prepare new BackendRouter - let router_new = if !backends.is_empty() { + let router_new = if backends.is_empty() { + None + } else { let r = self.create_backend_router(backends.clone(), strategy); // Wait until all backends have known health status Self::wait_healthchecks(&r).await; Some(Arc::new(r)) - } else { - None }; // Get the old BackendRouter @@ -337,8 +339,7 @@ impl BackendManager { pub fn get_healthy_nodes(&self) -> Arc>> { self.backend_router .load_full() - .map(|x| x.get_healthy()) - .unwrap_or_else(|| Arc::new(vec![])) + .map_or_else(|| Arc::new(vec![]), |x| x.get_healthy()) } /// Enables or disables the given backend @@ -369,7 +370,7 @@ impl Run for BackendManager { warn!("{self}: task started"); loop { select! { - _ = token.cancelled() => { + () = token.cancelled() => { warn!("{self}: task stopped"); break; }, @@ -377,7 +378,7 @@ impl Run for BackendManager { _ = sig.recv() => { warn!("{self}: received config reload signal"); match self.load_config().await { - Ok(_) => warn!("{self}: configuration reloaded successfully"), + Ok(()) => warn!("{self}: configuration reloaded successfully"), Err(e) => warn!("{self}: failed to reload config: {e:#}"), } } @@ -402,19 +403,17 @@ impl ChecksTarget> for BackendHealthChecker { .body(Body::empty()) .unwrap(); // This should never fail - let res = match timeout(self.timeout, self.client.execute(req)).await { - Ok(res) => match res { + let res = if let Ok(res) = timeout(self.timeout, self.client.execute(req)).await { + match res { Ok(v) => v, Err(e) => { info!("Health check failed for {target}: request failed: {e:#}"); return TargetState::Degraded; } - }, - - Err(_) => { - info!("Health check failed for {target}: request timed out"); - return TargetState::Degraded; } + } else { + info!("Health check failed for {target}: request timed out"); + return TargetState::Degraded; }; if !res.status().is_success() { diff --git a/src/cli.rs b/src/cli.rs index 5eda06e..3d32c89 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -1,3 +1,5 @@ +#![allow(clippy::struct_field_names)] + use std::{net::SocketAddr, path::PathBuf, time::Duration}; use clap::{Args, Parser}; diff --git a/src/core.rs b/src/core.rs index 4c59051..9a8ed8c 100644 --- a/src/core.rs +++ b/src/core.rs @@ -40,6 +40,7 @@ pub const AUTHOR_NAME: &str = "Boundary Node Team "; pub static ENV: OnceLock = OnceLock::new(); pub static HOSTNAME: OnceLock = OnceLock::new(); +#[allow(clippy::too_many_lines)] pub async fn main( cli: &Cli, log_handle: Handle, @@ -134,17 +135,16 @@ pub async fn main( vector.clone(), ®istry, waf_layer, - ) - .context("unable to setup Axum Router")?; + ); // HTTP server metrics let http_metrics = Metrics::new(®istry); // Set up HTTP router (redirecting to HTTPS or serving all endpoints) - let axum_router_http = if !cli.listen.listen_insecure_serve_http_only { - Router::new().fallback(redirect_to_https) - } else { + let axum_router_http = if cli.listen.listen_insecure_serve_http_only { axum_router.clone() + } else { + Router::new().fallback(redirect_to_https) }; let server_http = Arc::new( diff --git a/src/main.rs b/src/main.rs index b948aa4..5d0ff1a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,8 @@ +#![warn(clippy::pedantic)] +#![warn(clippy::nursery)] +#![allow(clippy::redundant_closure_for_method_calls)] +#![allow(clippy::doc_markdown)] + mod api; mod backend; mod cli; diff --git a/src/metrics.rs b/src/metrics.rs index 562294f..0c1006e 100644 --- a/src/metrics.rs +++ b/src/metrics.rs @@ -1,3 +1,5 @@ +#![allow(clippy::cast_possible_wrap)] + use std::{ sync::Arc, time::{Duration, Instant}, @@ -71,7 +73,7 @@ impl MetricsRunner { } impl MetricsRunner { - async fn update(&self) -> Result<(), Error> { + fn update(&self) -> Result<(), Error> { // Record jemalloc memory usage epoch::advance().map_err(|e| anyhow!("unable to advance epoch: {e:#}"))?; @@ -102,7 +104,7 @@ impl MetricsRunner { impl Run for MetricsRunner { async fn run(&self, _: CancellationToken) -> Result<(), Error> { let start = Instant::now(); - if let Err(e) = self.update().await { + if let Err(e) = self.update() { warn!("Unable to update metrics: {e:#}"); } else { debug!("Metrics updated in {}ms", start.elapsed().as_millis()); diff --git a/src/middleware/metrics.rs b/src/middleware/metrics.rs index 041b661..e93225b 100644 --- a/src/middleware/metrics.rs +++ b/src/middleware/metrics.rs @@ -1,3 +1,5 @@ +#![allow(clippy::cast_possible_wrap)] + use std::{ cell::RefCell, sync::Arc, @@ -96,6 +98,7 @@ pub struct MetricsState { log_requests_long: Option, } +#[allow(clippy::too_many_lines)] pub async fn middleware( State(state): State>, Extension(conn_info): Extension>, @@ -114,12 +117,7 @@ pub async fn middleware( .remove::() .map(|x| x.to_string()) .unwrap_or_default(); - let request_size = request - .body() - .size_hint() - .exact() - .map(|x| x as i64) - .unwrap_or(-1); + let request_size = request.body().size_hint().exact().map_or(-1, |x| x as i64); let remote_addr = conn_info.remote_addr.ip().to_canonical().to_string(); let timestamp = time::OffsetDateTime::now_utc(); let (tls_version, tls_cipher, tls_handshake) = @@ -147,8 +145,7 @@ pub async fn middleware( let backend = meta .ctx .backend - .map(|x| x.name.clone()) - .unwrap_or_else(|| "unknown".into()); + .map_or_else(|| "unknown".into(), |x| x.name.clone()); let labels = &[ tls_version, @@ -243,12 +240,7 @@ pub async fn middleware( .await; let duration = start.elapsed().as_secs_f64(); - let response_size = response - .body() - .size_hint() - .exact() - .map(|x| x as i64) - .unwrap_or(-1); + let response_size = response.body().size_hint().exact().map_or(-1, |x| x as i64); let retries = response .extensions_mut() .remove::() diff --git a/src/routing.rs b/src/routing.rs index c8e9606..42839a7 100644 --- a/src/routing.rs +++ b/src/routing.rs @@ -92,8 +92,7 @@ async fn buffer_response(state: &HandlerState, response: Response) -> Response { .body() .size_hint() .exact() - .map(|x| x <= state.response_body_size_limit as u64) - == Some(true); + .is_some_and(|x| x <= state.response_body_size_limit as u64); // Return the response as-is if the body isn't bufferable if !body_bufferable { @@ -107,10 +106,9 @@ async fn buffer_response(state: &HandlerState, response: Response) -> Response { .unwrap_or_default() .into_inner() .backend - .map(|x| x.name.clone()) - .unwrap_or_else(|| "unknown".into()); - let body = Limited::new(body, state.response_body_size_limit); + .map_or_else(|| "unknown".into(), |x| x.name.clone()); + let body = Limited::new(body, state.response_body_size_limit); let Ok(body) = timeout(state.response_body_timeout, body.collect()).await else { info!("Timed out reading response body from backend '{backend}'"); return ( @@ -246,7 +244,7 @@ pub fn setup_axum_router( vector: Option>, registry: &Registry, waf_layer: Option, -) -> Result { +) -> Router { let state = Arc::new(HandlerState::new( backend_manager, cli.network.network_request_body_buffer, @@ -277,7 +275,7 @@ pub fn setup_axum_router( )) .layer(option_layer(waf_layer)); - let router = Router::new() + Router::new() .fallback(|request: Request| async move { let Some(host) = extract_authority(&request) else { return Ok((StatusCode::BAD_REQUEST, "Unable to extract authority").into_response()); @@ -296,7 +294,5 @@ pub fn setup_axum_router( Ok(handler.call(request, state).await) }) - .layer(middlewares); - - Ok(router) + .layer(middlewares) } diff --git a/src/tls.rs b/src/tls.rs index f1f7aa1..7e8f6c5 100644 --- a/src/tls.rs +++ b/src/tls.rs @@ -22,7 +22,7 @@ use prometheus::Registry; use crate::{cli::Cli, core::HOSTNAME}; -// Prepares the stuff needed for serving TLS +/// Prepares the stuff needed for serving TLS pub async fn setup( cli: &Cli, tasks: &mut TaskManager, @@ -124,7 +124,7 @@ async fn setup_custom_domains( } tasks.add("custom_domains_canister_client", client.clone()); - certificate_providers.push(client.clone()); + certificate_providers.push(client); Ok(()) }