Upgrade/Migrate to newer dependencies (check diff Cargo.toml)

+ Rename: api/v1 to api/sculptor

src/api/figura/websocket/handler.rs

@@ -1,11 +1,12 @@
 use anyhow::bail;
-use axum::extract::{ws::{Message, WebSocket}, State};
+use axum::{body::Bytes, extract::{ws::{Message, WebSocket}, State}};
 use dashmap::DashMap;
 use tokio::sync::{broadcast, mpsc};
+use tracing::instrument;
 
 use crate::{auth::Userinfo, AppState};
 
-use super::{processor::*, AuthModeError, S2CMessage, C2SMessage, WSSession, SessionMessage, RADError};
+use super::{AuthModeError, C2SMessage, RADError, RecvAndDecode, S2CMessage, SessionMessage, WSSession};
 
 pub async fn initial(
     ws: axum::extract::WebSocketUpgrade,
@@ -42,9 +43,8 @@ async fn handle_socket(mut ws: WebSocket, state: AppState) {
             };
 
             // Starting main worker
-            match main_worker(&mut session, &mut ws, &state).await {
-                Ok(_) => (),
-                Err(kind) => tracing::error!("[WebSocket] Main worker halted due to {}.",  kind),
+            if let Err(kind) = main_worker(&mut session, &mut ws, &state).await {
+                tracing::error!("[WebSocket] Main worker halted due to {}.",  kind)
             }
 
             for (_, handle) in session.sub_workers_aborthandles {
@@ -61,9 +61,10 @@ async fn handle_socket(mut ws: WebSocket, state: AppState) {
     }
 
     // Closing connection
-    if let Err(kind) = ws.close().await { tracing::trace!("[WebSocket] Closing fault: {}", kind) }
+    if let Err(kind) = ws.send(Message::Close(None)).await { tracing::trace!("[WebSocket] Closing fault: {}", kind) }
 }
 
+#[instrument(skip_all, fields(nickname = %session.user.nickname))]
 async fn main_worker(session: &mut WSSession, ws: &mut WebSocket, state: &AppState) -> anyhow::Result<()> {
     tracing::debug!("WebSocket control for {} is transferred to the main worker", session.user.nickname);
     loop {
@@ -90,7 +91,7 @@ async fn main_worker(session: &mut WSSession, ws: &mut WebSocket, state: &AppSta
                         
                         // Echo check
                         if echo {
-                            ws.send(Message::Binary(s2c_ping.clone())).await?
+                            ws.send(Message::Binary(s2c_ping.clone().into())).await?
                         }
                         // Sending to others
                         let _ = session.subs_tx.send(s2c_ping);
@@ -127,7 +128,7 @@ async fn main_worker(session: &mut WSSession, ws: &mut WebSocket, state: &AppSta
                 let internal_msg = internal_msg.ok_or(anyhow::anyhow!("Unexpected error! Session channel broken!"))?;
                 match internal_msg {
                     SessionMessage::Ping(msg) => {
-                        ws.send(Message::Binary(msg)).await?
+                        ws.send(Message::Binary(msg.into())).await?
                     },
                     SessionMessage::Banned => {
                         let _ = ban_action(ws).await
@@ -169,7 +170,7 @@ async fn authenticate(socket: &mut WebSocket, state: &AppState) -> Result<Userin
                     let token = String::from_utf8(token.to_vec()).map_err(|_| AuthModeError::ConvertError)?;
                     match state.user_manager.get(&token) {
                         Some(user) => {
-                            if socket.send(Message::Binary(S2CMessage::Auth.into())).await.is_err() {
+                            if socket.send(Message::Binary(Bytes::from(Into::<Vec<u8>>::into(S2CMessage::Auth)))).await.is_err() {
                                 Err(AuthModeError::SendError)
                             } else if !user.banned {
                                 Ok(user.clone())
@@ -204,7 +205,7 @@ async fn authenticate(socket: &mut WebSocket, state: &AppState) -> Result<Userin
 }
 
 async fn ban_action(ws: &mut WebSocket) -> anyhow::Result<()> {
-    ws.send(Message::Binary(S2CMessage::Toast(2, "You're banned!".to_string(), None).into())).await?;
+    ws.send(Message::Binary(Into::<Vec<u8>>::into(S2CMessage::Toast(2, "You're banned!".to_string(), None)).into())).await?;
     tokio::time::sleep(std::time::Duration::from_secs(6)).await;
     ws.send(Message::Close(Some(axum::extract::ws::CloseFrame { code: 4001, reason: "You're banned!".into() }))).await?;