apply clippy fixes

bin/src/command/requests.rs

@@ -612,7 +612,7 @@ impl CommandServer {
             old_worker.channel.set_blocking(false);
             */
             let (sockets_return_tx, mut sockets_return_rx) = futures::channel::mpsc::channel(3);
-            let id = format!("{}-return-sockets", client_id);
+            let id = format!("{client_id}-return-sockets");
             self.in_flight.insert(id.clone(), (sockets_return_tx, 1));
             old_worker
                 .send(
@@ -678,7 +678,7 @@ impl CommandServer {
             old_worker.run_state = RunState::Stopping;
 
             let (softstop_tx, mut softstop_rx) = futures::channel::mpsc::channel(10);
-            let softstop_id = format!("{}-softstop", client_id);
+            let softstop_id = format!("{client_id}-softstop");
             self.in_flight.insert(softstop_id.clone(), (softstop_tx, 1));
             old_worker
                 .send(
@@ -754,7 +754,7 @@ impl CommandServer {
         let activate_requests = self.state.generate_activate_requests();
         for (count, request) in activate_requests.into_iter().enumerate() {
             new_worker
-                .send(format!("{}-ACTIVATE-{}", client_id, count), request)
+                .send(format!("{client_id}-ACTIVATE-{count}"), request)
                 .await;
         }
 
@@ -882,7 +882,7 @@ impl CommandServer {
         // create a status list with the available info of the main process
         let mut worker_info_map: BTreeMap<String, WorkerInfo> = BTreeMap::new();
 
-        let prefix = format!("{}-status-", client_id);
+        let prefix = format!("{client_id}-status-");
 
         return_processing(
             self.command_tx.clone(),
@@ -988,7 +988,7 @@ impl CommandServer {
             self.in_flight.insert(req_id, (metrics_tx.clone(), 1));
         }
 
-        let prefix = format!("{}-metrics-", client_id);
+        let prefix = format!("{client_id}-metrics-");
 
         let command_tx = self.command_tx.clone();
         let thread_client_id = client_id.clone();
@@ -1125,11 +1125,9 @@ impl CommandServer {
             let mut worker_responses: BTreeMap<String, ResponseContent> = responses
                 .into_iter()
                 .filter_map(|(worker_id, proxy_response)| {
-                    if let Some(response_content) = proxy_response.content {
-                        Some((worker_id.to_string(), response_content))
-                    } else {
-                        None
-                    }
+                    proxy_response
+                        .content
+                        .map(|response_content| (worker_id.to_string(), response_content))
                 })
                 .collect();
 
@@ -1407,7 +1405,7 @@ impl CommandServer {
             Some(client_tx) => {
                 trace!("sending from main process to client loop");
                 client_tx.send(command_response).await.with_context(|| {
-                    format!("Could not notify client {} about request", client_id)
+                    format!("Could not notify client {client_id} about request")
                 })?;
             }
             None => bail!(format!("Could not find client {client_id}")),

bin/src/ctl/command.rs

@@ -65,8 +65,8 @@ impl CommandManager {
                     } else {
                         println!("Success: {}", response.message);
                     }
-                    match response.content {
-                        Some(response_content) => match response_content.content_type {
+                    if let Some(response_content) = response.content {
+                        match response_content.content_type {
                             Some(ContentType::FrontendList(frontends)) => {
                                 print_frontend_list(frontends)
                             }
@@ -79,8 +79,7 @@ impl CommandManager {
                             }
                             Some(ContentType::ListenersList(list)) => print_listeners(list),
                             _ => {}
-                        },
-                        None => {}
+                        }
                     }
                     break;
                 }

bin/src/ctl/display.rs

@@ -323,11 +323,8 @@ fn print_percentiles(filtered_metrics: &BTreeMap<String, FilteredMetrics>) {
     let mut percentile_titles: Vec<String> = filtered_metrics
         .iter()
         .filter_map(|(title, filtered_data)| match filtered_data.inner.clone() {
-            Some(filtered_metrics) => match filtered_metrics {
-                filtered_metrics::Inner::Percentiles(_) => Some(title.to_owned()),
-                _ => None,
-            },
-            None => None,
+            Some(filtered_metrics::Inner::Percentiles(_)) => Some(title.to_owned()),
+            _ => None,
         })
         .collect();
 
@@ -354,24 +351,23 @@ fn print_percentiles(filtered_metrics: &BTreeMap<String, FilteredMetrics>) {
     ]));
 
     for title in percentile_titles {
-        match filtered_metrics.get(&title) {
-            Some(filtered_metrics) => match filtered_metrics.inner.clone() {
-                Some(filtered_metrics::Inner::Percentiles(p)) => {
-                    percentile_table.add_row(Row::new(vec![
-                        cell!(title),
-                        cell!(p.samples),
-                        cell!(p.p_50),
-                        cell!(p.p_90),
-                        cell!(p.p_99),
-                        cell!(p.p_99_9),
-                        cell!(p.p_99_99),
-                        cell!(p.p_99_999),
-                        cell!(p.p_100),
-                    ]));
-                }
-                _ => {}
-            },
-            None => println!("Something went VERY wrong here"),
+        if let Some(FilteredMetrics {
+            inner: Some(filtered_metrics::Inner::Percentiles(percentiles)),
+        }) = filtered_metrics.get(&title)
+        {
+            percentile_table.add_row(Row::new(vec![
+                cell!(title),
+                cell!(percentiles.samples),
+                cell!(percentiles.p_50),
+                cell!(percentiles.p_90),
+                cell!(percentiles.p_99),
+                cell!(percentiles.p_99_9),
+                cell!(percentiles.p_99_99),
+                cell!(percentiles.p_99_999),
+                cell!(percentiles.p_100),
+            ]));
+        } else {
+            println!("Something went VERY wrong here");
         }
     }
 
@@ -655,7 +651,7 @@ pub fn print_certificates(
                         println!(
                             "\t\t{}:\t{}",
                             summary.domain,
-                            hex::encode(summary.fingerprint.to_owned())
+                            hex::encode(&summary.fingerprint)
                         );
                     }
 
@@ -694,7 +690,7 @@ pub fn print_available_metrics(available_metrics: &AvailableMetrics) -> anyhow::
     Ok(())
 }
 
-fn list_string_vec(vec: &Vec<String>) -> String {
+fn list_string_vec(vec: &[String]) -> String {
     let mut output = String::new();
     for item in vec.iter() {
         output.push_str(item);

bin/src/ctl/request_builder.rs

@@ -190,7 +190,7 @@ impl CommandManager {
                         cluster_id: id,
                         sticky_session,
                         https_redirect,
-                        proxy_protocol: proxy_protocol.and_then(|pp| Some(pp as i32)),
+                        proxy_protocol: proxy_protocol.map(|pp| pp as i32),
                         load_balancing: load_balancing_policy as i32,
                         ..Default::default()
                     })),
@@ -512,6 +512,7 @@ impl CommandManager {
         })
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn replace_certificate(
         &mut self,
         address: String,

command/build.rs

@@ -1,5 +1,3 @@
-use prost_build;
-
 pub fn main() {
     prost_build::Config::new()
         .btree_map(["."])

command/src/config.rs

@@ -813,7 +813,7 @@ impl HttpClusterConfig {
                 proxy_protocol: None,
                 load_balancing: self.load_balancing as i32,
                 answer_503: self.answer_503.clone(),
-                load_metric: self.load_metric.and_then(|s| Some(s as i32)),
+                load_metric: self.load_metric.map(|s| s as i32),
             })),
         }];
 
@@ -869,9 +869,9 @@ impl TcpClusterConfig {
                 cluster_id: self.cluster_id.clone(),
                 sticky_session: false,
                 https_redirect: false,
-                proxy_protocol: self.proxy_protocol.and_then(|s| Some(s as i32)),
+                proxy_protocol: self.proxy_protocol.map(|s| s as i32),
                 load_balancing: self.load_balancing as i32,
-                load_metric: self.load_metric.and_then(|s| Some(s as i32)),
+                load_metric: self.load_metric.map(|s| s as i32),
                 answer_503: None,
             })),
         }];

command/src/proto/mod.rs

@@ -8,4 +8,4 @@ impl From<command::response_content::ContentType> for command::ResponseContent {
             content_type: Some(value),
         }
     }
-}
+}

command/src/request.rs

@@ -91,10 +91,10 @@ impl Request {
 
     /// True if the request is a SoftStop or a HardStop
     pub fn is_a_stop(&self) -> bool {
-        match self.request_type {
-            Some(RequestType::SoftStop(_)) | Some(RequestType::HardStop(_)) => true,
-            _ => false,
-        }
+        matches!(
+            self.request_type,
+            Some(RequestType::SoftStop(_)) | Some(RequestType::HardStop(_))
+        )
     }
 }
 

command/src/response.rs

@@ -41,33 +41,33 @@ pub struct HttpFrontend {
     pub tags: Option<BTreeMap<String, String>>,
 }
 
-impl Into<RequestHttpFrontend> for HttpFrontend {
-    fn into(self) -> RequestHttpFrontend {
-        let tags = match self.tags {
+impl From<HttpFrontend> for RequestHttpFrontend {
+    fn from(val: HttpFrontend) -> Self {
+        let tags = match val.tags {
             Some(tags) => tags,
             None => BTreeMap::new(),
         };
         RequestHttpFrontend {
-            cluster_id: self.cluster_id,
-            address: self.address.to_string(),
-            hostname: self.hostname,
-            path: self.path,
-            method: self.method,
-            position: self.position.into(),
+            cluster_id: val.cluster_id,
+            address: val.address.to_string(),
+            hostname: val.hostname,
+            path: val.path,
+            method: val.method,
+            position: val.position.into(),
             tags,
         }
     }
 }
 
-impl Into<AddBackend> for Backend {
-    fn into(self) -> AddBackend {
+impl From<Backend> for AddBackend {
+    fn from(val: Backend) -> Self {
         AddBackend {
-            cluster_id: self.cluster_id,
-            backend_id: self.backend_id,
-            address: self.address.to_string(),
-            sticky_id: self.sticky_id,
-            load_balancing_parameters: self.load_balancing_parameters,
-            backup: self.backup,
+            cluster_id: val.cluster_id,
+            backend_id: val.backend_id,
+            address: val.address.to_string(),
+            sticky_id: val.sticky_id,
+            load_balancing_parameters: val.load_balancing_parameters,
+            backup: val.backup,
         }
     }
 }
@@ -150,12 +150,12 @@ pub struct TcpFrontend {
     pub tags: BTreeMap<String, String>,
 }
 
-impl Into<RequestTcpFrontend> for TcpFrontend {
-    fn into(self) -> RequestTcpFrontend {
+impl From<TcpFrontend> for RequestTcpFrontend {
+    fn from(val: TcpFrontend) -> Self {
         RequestTcpFrontend {
-            cluster_id: self.cluster_id,
-            address: self.address.to_string(),
-            tags: self.tags.clone(),
+            cluster_id: val.cluster_id,
+            address: val.address.to_string(),
+            tags: val.tags,
         }
     }
 }

command/src/state.rs

@@ -427,7 +427,7 @@ impl ConfigState {
             bail!("This tcp frontend is already present: {:?}", tcp_frontend);
         }
 
-        tcp_frontends.push(tcp_frontend.clone());
+        tcp_frontends.push(tcp_frontend);
         Ok(())
     }
 
@@ -1157,15 +1157,15 @@ impl ConfigState {
         let mut tcp_frontends = Vec::new();
         let mut backends = Vec::new();
 
-        for (_k, http_frontend) in &self.http_fronts {
+        for http_frontend in self.http_fronts.values() {
             if let Some(id) = &http_frontend.cluster_id {
                 if id == cluster_id {
                     http_frontends.push(http_frontend.clone().into());
                 }
             }
         }
 
-        for (_k, https_frontend) in &self.https_fronts {
+        for https_frontend in self.https_fronts.values() {
             if let Some(id) = &https_frontend.cluster_id {
                 if id == cluster_id {
                     https_frontends.push(https_frontend.clone().into());

e2e/src/tests/tests.rs

@@ -981,13 +981,13 @@ pub fn try_blue_geen() -> State {
         "PRIMARY",
         primary_address,
         aggrerator.clone(),
-        AsyncBackend::http_handler(format!("pong_primary")),
+        AsyncBackend::http_handler("pong_primary".to_string()),
     );
     let mut secondary = AsyncBackend::spawn_detached_backend(
         "SECONDARY",
         secondary_address,
-        aggrerator.clone(),
-        AsyncBackend::http_handler(format!("pong_secondary")),
+        aggrerator,
+        AsyncBackend::http_handler("pong_secondary".to_string()),
     );
 
     worker.send_proxy_request(Request {

lib/src/http.rs

@@ -89,6 +89,7 @@ pub struct HttpSession {
 }
 
 impl HttpSession {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         answers: Rc<RefCell<HttpAnswers>>,
         configured_backend_timeout: Duration,

lib/src/https.rs

@@ -123,6 +123,7 @@ pub struct HttpsSession {
 }
 
 impl HttpsSession {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         answers: Rc<RefCell<HttpAnswers>>,
         configured_backend_timeout: Duration,
@@ -985,14 +986,12 @@ impl HttpsProxy {
                 let resolver = unwrap_msg!(owned.resolver.0.lock());
                 let mut certificate_summaries = vec![];
 
-                resolver
-                    .domain_lookup(domain.as_bytes(), true)
-                    .map(|(k, fingerprint)| {
-                        certificate_summaries.push(CertificateSummary {
-                            domain: String::from_utf8(k.to_vec()).unwrap(),
-                            fingerprint: fingerprint.to_string(),
-                        });
+                if let Some((k, fingerprint)) = resolver.domain_lookup(domain.as_bytes(), true) {
+                    certificate_summaries.push(CertificateSummary {
+                        domain: String::from_utf8(k.to_vec()).unwrap(),
+                        fingerprint: fingerprint.to_string(),
                     });
+                }
                 CertificatesByAddress {
                     address: owned.address.to_string(),
                     certificate_summaries,

lib/src/metrics/local_drain.rs

@@ -360,8 +360,7 @@ impl LocalDrain {
                 .context(format!("No metrics found for backend with id {backend_id}"))?
                 .to_owned();
 
-            let mut backends = Vec::new();
-            backends.push(self.metrics_of_one_backend(backend_id, metric_names)?);
+            let backends = vec![self.metrics_of_one_backend(backend_id, metric_names)?];
 
             clusters.insert(
                 cluster_id,