backend: run rust fmt

Author: ffreddow

backend/src/routes/management.rs

@@ -33,7 +33,10 @@ use crate::{
     error::Error,
     rate_limit::ChargerRateLimiter,
     routes::{auth::login::FindBy, charger::add::get_charger_from_db, user::get_user_id},
-    utils::{get_charger_by_uid, get_connection, parse_uuid, update_charger_state_change, web_block_unpacked},
+    utils::{
+        get_charger_by_uid, get_connection, parse_uuid, update_charger_state_change,
+        web_block_unpacked,
+    },
     AppState, BridgeState,
 };
 

backend/src/routes/user/create_authorization_token.rs

@@ -106,7 +106,10 @@ pub mod tests {
         let req = TestRequest::post()
             .uri("/create_authorization_token")
             .cookie(Cookie::new("access_token", token))
-            .set_json(CreateAuthorizationTokenSchema { use_once, name: "Test Token".to_string() })
+            .set_json(CreateAuthorizationTokenSchema {
+                use_once,
+                name: "Test Token".to_string(),
+            })
             .to_request();
 
         let resp: ResponseAuthorizationToken = test::call_and_read_body_json(&app, req).await;
@@ -127,7 +130,10 @@ pub mod tests {
         let req = TestRequest::post()
             .uri("/create_authorization_token")
             .cookie(Cookie::new("access_token", token))
-            .set_json(CreateAuthorizationTokenSchema { use_once: true, name: "Test Token".to_string() })
+            .set_json(CreateAuthorizationTokenSchema {
+                use_once: true,
+                name: "Test Token".to_string(),
+            })
             .to_request();
 
         let resp = test::call_service(&app, req).await;

backend/src/routes/user/get_authorization_tokens.rs

@@ -82,7 +82,7 @@ mod tests {
                 id: String::new(),
                 token: String::new(),
                 use_once: false,
-                name:String::new(),
+                name: String::new(),
                 created_at: 0,
                 last_used_at: None,
             };

backend/src/udp_server/mod.rs

@@ -33,7 +33,10 @@ use std::{
 };
 
 use self::socket::ManagementSocket;
-use crate::{udp_server::multiplex::run_server, utils::update_charger_state_change, AppState, BridgeState, DiscoveryCharger};
+use crate::{
+    udp_server::multiplex::run_server, utils::update_charger_state_change, AppState, BridgeState,
+    DiscoveryCharger,
+};
 use actix_web::web;
 use ipnetwork::IpNetwork;
 use packet::ManagementResponseV2;

backend/src/udp_server/multiplex.rs

@@ -35,7 +35,10 @@ use rand::TryRngCore;
 use rand_core::OsRng;
 
 use crate::{
-    udp_server::{management::RemoteConnMeta, packet::ManagementCommand}, utils::update_charger_state_change, ws_udp_bridge::open_connection, AppState, BridgeState
+    udp_server::{management::RemoteConnMeta, packet::ManagementCommand},
+    utils::update_charger_state_change,
+    ws_udp_bridge::open_connection,
+    AppState, BridgeState,
 };
 
 use super::{management::try_port_discovery, socket::ManagementSocket};
@@ -182,15 +185,22 @@ pub fn send_data(socket: &UdpSocket, addr: SocketAddr, data: &[u8]) {
     }
 }
 
-pub async fn run_server(bridge_state: web::Data<BridgeState>, app_state: web::Data<AppState>, arbiter: Arc<Arbiter>) {
+pub async fn run_server(
+    bridge_state: web::Data<BridgeState>,
+    app_state: web::Data<AppState>,
+    arbiter: Arc<Arbiter>,
+) {
     let mut buf = vec![0u8; 65535];
     loop {
         if let Ok((s, addr)) = bridge_state.socket.recv_from(&mut buf) {
             let bridge_state = bridge_state.clone();
             let buf = buf.clone();
 
             // Check if the packet is for port discovery
-            if try_port_discovery(&bridge_state, &buf[..s], addr).await.is_ok() {
+            if try_port_discovery(&bridge_state, &buf[..s], addr)
+                .await
+                .is_ok()
+            {
                 continue;
             }
 
@@ -212,12 +222,13 @@ pub async fn run_server(bridge_state: web::Data<BridgeState>, app_state: web::Da
                 match charger_map.entry(addr) {
                     Entry::Occupied(tunn) => tunn.into_mut().clone(),
                     Entry::Vacant(v) => {
-                        let (id, tunn_data) = match create_tunn(&bridge_state, addr, &buf[..s]).await {
-                            Ok(tunn) => tunn,
-                            Err(_err) => {
-                                continue;
-                            }
-                        };
+                        let (id, tunn_data) =
+                            match create_tunn(&bridge_state, addr, &buf[..s]).await {
+                                Ok(tunn) => tunn,
+                                Err(_err) => {
+                                    continue;
+                                }
+                            };
 
                         arbiter.spawn(update_charger_state_change(id, app_state.clone()));
 
@@ -227,7 +238,8 @@ pub async fn run_server(bridge_state: web::Data<BridgeState>, app_state: web::Da
                         v.insert(tunn_data.clone());
                         let tunn = tunn_data.clone();
                         let mut lost_map = bridge_state.lost_connections.lock().await;
-                        let mut undiscovered_clients = bridge_state.undiscovered_clients.lock().await;
+                        let mut undiscovered_clients =
+                            bridge_state.undiscovered_clients.lock().await;
                         if let Some(conns) = lost_map.remove(&id) {
                             for (conn_no, recipient) in conns.into_iter() {
                                 let meta = RemoteConnMeta {

backend/src/utils.rs

@@ -155,7 +155,8 @@ pub async fn validate_auth_token(
             Ok(_) => Ok(()),
             Err(_err) => Err(Error::InternalError),
         }
-    }).await?;
+    })
+    .await?;
 
     Ok(())
 }
@@ -189,14 +190,14 @@ pub fn send_email(email: &str, subject: &str, body: String, state: &web::Data<Ap
     {
         let _ = body;
         let _ = state;
-        println!("Test mode: Email would be sent to {} with subject '{}'", email, subject);
+        println!(
+            "Test mode: Email would be sent to {} with subject '{}'",
+            email, subject
+        );
     }
 }
 
-pub async fn update_charger_state_change(
-    charger_id: uuid::Uuid,
-    state: web::Data<AppState>,
-) {
+pub async fn update_charger_state_change(charger_id: uuid::Uuid, state: web::Data<AppState>) {
     let Ok(mut conn) = get_connection(&state) else {
         log::error!("Failed to get database connection for updating charger state change");
         return;
@@ -211,7 +212,11 @@ pub async fn update_charger_state_change(
         {
             Ok(_) => Ok(()),
             Err(_err) => {
-                log::error!("Failed to update last_state_change for charger {}: {}", charger_id, _err);
+                log::error!(
+                    "Failed to update last_state_change for charger {}: {}",
+                    charger_id,
+                    _err
+                );
                 Err(Error::InternalError)
             }
         }