fix(backend): tcp error on closing + fmt

backend/src/authorization.rs

@@ -1,14 +1,14 @@
-use crate::model::DB;
+use axum::extract::{Request, State};
-use axum::{
+use axum::http::StatusCode;
-    extract::{Request, State},
+use axum::middleware::Next;
-    http::StatusCode,
+use axum::response::Response;
-    middleware::Next,
+use axum_extra::headers;
-    response::Response,
+use axum_extra::typed_header::TypedHeader;
-};
-use axum_extra::{headers, typed_header::TypedHeader};
 use jsonwebtoken::{decode, Algorithm, DecodingKey, Validation};
 use serde::{Deserialize, Serialize};
 
+use crate::model::DB;
+
 #[derive(Debug, Serialize, Deserialize)]
 struct Claims {
     sub: String,
@@ -41,7 +41,10 @@ fn check_token(token: &str, jwt: &str) -> Option<User> {
                 None
             }
         }
-        Err(err) => {tracing::debug!("Failed decoding token: {err:?}"); None},
+        Err(err) => {
+            tracing::debug!("Failed decoding token: {err:?}");
+            None
+        }
     }
 }
 
@@ -70,7 +73,7 @@ pub async fn jwt_middleware_cof(
     if let Some(user) = check_token(token, &state.static_state.jwt_key) {
         if user.is_cof {
             request.extensions_mut().insert(user);
-        return Ok(next.run(request).await)
+            return Ok(next.run(request).await);
         };
     };
     Err(StatusCode::FORBIDDEN)

backend/src/handler.rs

@@ -1,15 +1,16 @@
-use crate::authorization::User;
-use crate::model::{ColorArray, DMXAtom, DMXBeam, DMXBeamChange, DMXColorAtom, DMXColor, DB};
-use axum::{
-    debug_handler,
-    extract::{Path, State},
-    http::StatusCode,
-    response::{sse::Event, IntoResponse, Sse},
-    Extension, Json,
-};
 use std::time::{Duration, Instant};
-use tokio_stream::StreamExt;
+
-use tokio_stream::{self as stream};
+use axum::extract::{Path, State};
+use axum::http::StatusCode;
+use axum::response::sse::Event;
+use axum::response::{IntoResponse, Sse};
+use axum::{debug_handler, Extension, Json};
+use tokio_stream::{
+    StreamExt, {self as stream},
+};
+
+use crate::authorization::User;
+use crate::model::{ColorArray, DMXAtom, DMXBeam, DMXBeamChange, DMXColor, DMXColorAtom, DB};
 
 #[debug_handler]
 pub async fn healthcheck_handler() -> impl IntoResponse {
@@ -33,7 +34,12 @@ pub async fn batch_edit_value_handler(
     Json(body): Json<Vec<DMXColorAtom>>,
 ) -> Result<(), StatusCode> {
     let mut lock = db.mut_state.write().await;
-    if lock.ratelimit_info.get(&user).map(|d| d.elapsed() <= Duration::from_millis(500)).unwrap_or(false){
+    if lock
+        .ratelimit_info
+        .get(&user)
+        .map(|d| d.elapsed() <= Duration::from_millis(500))
+        .unwrap_or(false)
+    {
         return Err(StatusCode::TOO_MANY_REQUESTS);
     }
     for i in &body {
@@ -103,13 +109,11 @@ pub async fn edit_motor_value_handler(
     let _ = db
         .static_state
         .change_channel
-        .send(DMXAtom::Motor(lock.dmx.motor))
+        .send(DMXAtom::Motor(lock.dmx.motor));
-        ;
 
     Ok(())
 }
 
-
 #[debug_handler]
 pub async fn sse_handler(State(db): State<DB>) -> impl IntoResponse {
     let rx = db.static_state.change_channel.subscribe();
@@ -120,12 +124,16 @@ pub async fn sse_handler(State(db): State<DB>) -> impl IntoResponse {
         data = lock.dmx.colors.clone();
         motor = lock.dmx.motor.clone();
     }
-    let init_data = data.into_iter().enumerate().map(|(i, x)| {
+    let init_data = data
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| {
             Ok(DMXAtom::Color(DMXColorAtom {
                 address: i,
                 value: x,
             }))
-    }).chain(std::iter::once(Ok(DMXAtom::Motor(motor))));
+        })
+        .chain(std::iter::once(Ok(DMXAtom::Motor(motor))));
     let init = stream::iter(init_data);
     let stream = init
         .chain(stream::wrappers::BroadcastStream::new(rx))

backend/src/main.rs

@@ -2,23 +2,24 @@ mod authorization;
 mod handler;
 mod model;
 mod route;
-mod state_recorder;
 mod socket_listener;
+mod state_recorder;
 
 use dotenvy;
-use crate::state_recorder::record_state;
-use crate::socket_listener::listen_socket;
 use route::create_router;
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 use tower_http::trace::TraceLayer;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
+
+use crate::socket_listener::listen_socket;
+use crate::state_recorder::record_state;
 
 #[tokio::main]
 async fn main() {
     tracing_subscriber::registry()
         .with(
-            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
+            tracing_subscriber::EnvFilter::try_from_default_env()
-                "info,axum::rejection=trace".into()
+                .unwrap_or_else(|_| "info,axum::rejection=trace".into()),
-            }),
         )
         .with(tracing_subscriber::fmt::layer())
         .init();
@@ -37,11 +38,7 @@ async fn main() {
     tracing::debug!("Trying to bind at {bind}");
     let listener = tokio::net::TcpListener::bind(bind).await.unwrap();
 
-
+    let app = create_router(db.clone()).layer(TraceLayer::new_for_http());
-    let app = create_router(db.clone())
-        .layer(
-            TraceLayer::new_for_http()
-        );
     tracing::info!("🚀 Server started successfully");
     axum::serve(listener, app).await.unwrap();
 }

backend/src/model.rs

@@ -1,13 +1,15 @@
-use crate::authorization::User;
-use dotenvy;
-use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Instant;
+
+use dotenvy;
+use serde::{Deserialize, Serialize};
 use tokio::sync::{broadcast, RwLock};
 
+use crate::authorization::User;
+
 #[derive(Debug, Default, Deserialize, Serialize, Copy, Clone)]
 pub struct DMXColor {
     pub red: u8,

backend/src/route.rs

@@ -1,10 +1,11 @@
-use crate::authorization::{jwt_middleware, jwt_middleware_cof};
+use axum::handler::Handler;
-use crate::handler;
+use axum::routing::get;
-use crate::model;
+use axum::{middleware, Router};
-use axum::{handler::Handler, middleware};
-use axum::{routing::get, Router};
 use tower_http::cors::{Any, CorsLayer};
 
+use crate::authorization::{jwt_middleware, jwt_middleware_cof};
+use crate::{handler, model};
+
 pub fn create_router(db: model::DB) -> Router {
     let cors = CorsLayer::new()
         // allow requests from any origin

backend/src/socket_listener.rs

@@ -1,10 +1,9 @@
-use tokio::task;
-
 use axum::extract::State;
 use serde::Deserialize;
-use tokio::io::AsyncBufReadExt;
+use tokio::io::{AsyncBufReadExt, BufReader};
-use tokio::io::BufReader;
 use tokio::net::TcpListener;
+use tokio::task;
+
 use crate::{handler, model};
 
 pub async fn listen_socket(db: model::DB) {
@@ -24,7 +23,11 @@ pub async fn listen_socket(db: model::DB) {
                 task::spawn(async move {
                     loop {
                         buf.clear();
-                            let _ = buf_reader.read_line(&mut buf).await;
+                        match buf_reader.read_line(&mut buf).await {
+                            Ok(0) => break,
+                            Ok(_) => (),
+                            Err(e) => tracing::error!("Error while reading tcp stream: {e:?}"),
+                        };
                         match model::DMXBeamChange::deserialize(
                             &mut serde_json::Deserializer::from_str(&buf),
                         ) {
@@ -37,6 +40,7 @@ pub async fn listen_socket(db: model::DB) {
                             Err(e) => tracing::error!("Error reading incoming data: {e:?}"),
                         }
                     }
+                    tracing::debug!("Closing tcp connection {addr:?}");
                 });
             }
             Err(e) => {

backend/src/state_recorder.rs

@@ -1,7 +1,8 @@
+use std::fs::File;
 
 use serde_json::to_writer;
-use std::fs::File;
 use tokio::time::{sleep, Duration};
+
 use crate::model;
 
 pub async fn record_state(db_to_save: model::DB) {