chore: fmt code

Signed-off-by: Xin Liu <[email protected]>

Author: apepkuss

Cargo.toml

@@ -4,35 +4,35 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+
+# Error handling
+anyhow = "1.0"
 # Web framework
 axum = { version = "0.8", features = ["ws"] }
-tokio = { version = "1", features = ["full"] }
 
 # CLI argument parsing
 clap = { version = "4.5", features = ["derive", "env"] }
+futures-util = "0.3"
 
 # HTTP client - Using rustls instead of native-tls/openssl
 reqwest = { version = "0.12", features = ["json", "rustls-tls"], default-features = false }
 
-# Database
-sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite"] }
-
 # Serialization
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
-# Logging
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-
-# Error handling
-anyhow = "1.0"
+# Database
+sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite"] }
 thiserror = "1.0"
+tokio = { version = "1", features = ["full"] }
 
 # WebSocket
 tokio-tungstenite = "0.24"
-futures-util = "0.3"
 
 # Utilities
 tower = "0.5"
 tower-http = { version = "0.6", features = ["trace", "cors"] }
+
+# Logging
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }

src/db/mod.rs

@@ -1,4 +1,4 @@
-use sqlx::{sqlite::SqlitePool, Error as SqlxError};
+use sqlx::{Error as SqlxError, sqlite::SqlitePool};
 use tracing::info;
 
 use crate::models::Session;

src/handlers/mod.rs

@@ -1,5 +1,5 @@
 pub mod http;
 pub mod websocket;
 
-pub use http::{health_check, http_proxy_handler, AppState};
+pub use http::{AppState, health_check, http_proxy_handler};
 pub use websocket::websocket_handler;

src/handlers/websocket.rs

@@ -1,7 +1,7 @@
 use axum::{
     extract::{
-        ws::{WebSocket, WebSocketUpgrade},
         Path, State,
+        ws::{WebSocket, WebSocketUpgrade},
     },
     http::StatusCode,
     response::Response,
@@ -18,7 +18,10 @@ pub async fn websocket_handler(
     Path(session_id): Path<String>,
     ws: WebSocketUpgrade,
 ) -> Result<Response, StatusCode> {
-    info!("Received WebSocket connection request: session_id={}", session_id);
+    info!(
+        "Received WebSocket connection request: session_id={}",
+        session_id
+    );
 
     // 1. Query database to get session information
     let session = match db::get_session(&pool, &session_id).await {

src/main.rs

@@ -1,6 +1,6 @@
 use axum::{
-    routing::{any, get},
     Router,
+    routing::{any, get},
 };
 use clap::Parser;
 use std::{sync::Arc, time::Duration};
@@ -15,7 +15,7 @@ mod models;
 mod proxy;
 
 use config::Config;
-use handlers::{health_check, http_proxy_handler, websocket_handler, AppState};
+use handlers::{AppState, health_check, http_proxy_handler, websocket_handler};
 use proxy::HttpProxy;
 
 /// SS Proxy - HTTP/HTTPS/WebSocket Proxy Server
@@ -53,8 +53,9 @@ async fn main() -> anyhow::Result<()> {
     // Initialize logging with CLI-specified log level
     tracing_subscriber::registry()
         .with(
-            tracing_subscriber::EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| format!("ss_proxy={},tower_http={}", log_level, log_level).into()),
+            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
+                format!("ss_proxy={},tower_http={}", log_level, log_level).into()
+            }),
         )
         .with(tracing_subscriber::fmt::layer())
         .init();
@@ -73,7 +74,10 @@ async fn main() -> anyhow::Result<()> {
     let http_proxy = HttpProxy::new(Duration::from_secs(config.request_timeout));
 
     // Create shared state
-    let http_state = Arc::new(AppState { pool: pool.clone(), http_proxy });
+    let http_state = Arc::new(AppState {
+        pool: pool.clone(),
+        http_proxy,
+    });
     let ws_state = Arc::new(pool);
 
     // Build router
@@ -100,4 +104,3 @@ async fn main() -> anyhow::Result<()> {
 
     Ok(())
 }
-

src/proxy/http_proxy.rs

@@ -48,8 +48,7 @@ impl HttpProxy {
                 key_str,
                 "host" | "connection" | "transfer-encoding" | "content-length"
             ) {
-                if let Ok(name) = reqwest::header::HeaderName::from_bytes(key.as_str().as_bytes())
-                {
+                if let Ok(name) = reqwest::header::HeaderName::from_bytes(key.as_str().as_bytes()) {
                     if let Ok(val) = reqwest::header::HeaderValue::from_bytes(value.as_bytes()) {
                         request_headers.insert(name, val);
                     }
@@ -68,7 +67,10 @@ impl HttpProxy {
             ProxyError::RequestFailed(e.to_string())
         })?;
 
-        info!("Received response from downstream server: {}", response.status());
+        info!(
+            "Received response from downstream server: {}",
+            response.status()
+        );
 
         // Build response
         let mut builder = axum::http::Response::builder().status(response.status());
@@ -85,10 +87,12 @@ impl HttpProxy {
         })?;
 
         // Build final response
-        let final_response = builder.body(axum::body::Body::from(body_bytes)).map_err(|e| {
-            error!("Failed to build response: {}", e);
-            ProxyError::ResponseBuildFailed(e.to_string())
-        })?;
+        let final_response = builder
+            .body(axum::body::Body::from(body_bytes))
+            .map_err(|e| {
+                error!("Failed to build response: {}", e);
+                ProxyError::ResponseBuildFailed(e.to_string())
+            })?;
 
         Ok(final_response)
     }

src/proxy/ws_proxy.rs

@@ -12,15 +12,16 @@ impl WsProxy {
         client_ws: WebSocket,
         downstream_url: &str,
     ) -> Result<(), WsProxyError> {
-        info!("Establishing connection to downstream WebSocket: {}", downstream_url);
+        info!(
+            "Establishing connection to downstream WebSocket: {}",
+            downstream_url
+        );
 
         // Connect to downstream WebSocket server
-        let (downstream_ws, _) = connect_async(downstream_url)
-            .await
-            .map_err(|e| {
-                error!("Failed to connect to downstream WebSocket: {}", e);
-                WsProxyError::ConnectionFailed(e.to_string())
-            })?;
+        let (downstream_ws, _) = connect_async(downstream_url).await.map_err(|e| {
+            error!("Failed to connect to downstream WebSocket: {}", e);
+            WsProxyError::ConnectionFailed(e.to_string())
+        })?;
 
         info!("Successfully connected to downstream WebSocket");
 
@@ -32,7 +33,10 @@ impl WsProxy {
             while let Some(msg) = client_read.next().await {
                 match msg {
                     Ok(Message::Text(buffer)) => {
-                        info!("Client -> Downstream: Text message ({} bytes)", buffer.len());
+                        info!(
+                            "Client -> Downstream: Text message ({} bytes)",
+                            buffer.len()
+                        );
                         if let Err(e) = downstream_write
                             .send(TungsteniteMessage::Text(buffer.to_string()))
                             .await
@@ -42,7 +46,10 @@ impl WsProxy {
                         }
                     }
                     Ok(Message::Binary(data)) => {
-                        info!("Client -> Downstream: Binary message ({} bytes)", data.len());
+                        info!(
+                            "Client -> Downstream: Binary message ({} bytes)",
+                            data.len()
+                        );
                         if let Err(e) = downstream_write
                             .send(TungsteniteMessage::Binary(data.into()))
                             .await
@@ -96,7 +103,10 @@ impl WsProxy {
                         }
                     }
                     Ok(TungsteniteMessage::Binary(data)) => {
-                        info!("Downstream -> Client: Binary message ({} bytes)", data.len());
+                        info!(
+                            "Downstream -> Client: Binary message ({} bytes)",
+                            data.len()
+                        );
                         if let Err(e) = client_write.send(Message::Binary(data.into())).await {
                             error!("Failed to forward binary message to client: {}", e);
                             break;
@@ -153,4 +163,3 @@ pub enum WsProxyError {
     #[error("Failed to connect to downstream WebSocket: {0}")]
     ConnectionFailed(String),
 }
-