Silence warnings, run cargo fmt

This commit is contained in:
Evan Carroll 2026-01-18 16:27:31 -06:00
parent fe1c1d3655
commit af1c767f5f
77 changed files with 1904 additions and 903 deletions

View file

@ -4,8 +4,8 @@
use axum::{
extract::{
ws::{CloseFrame, Message, WebSocket, WebSocketUpgrade},
FromRef, Path, State,
ws::{CloseFrame, Message, WebSocket, WebSocketUpgrade},
},
response::IntoResponse,
};
@ -109,7 +109,11 @@ impl WebSocketState {
}
/// Find a user by display name within a realm.
pub fn find_user_by_display_name(&self, realm_id: Uuid, display_name: &str) -> Option<(Uuid, UserConnection)> {
pub fn find_user_by_display_name(
&self,
realm_id: Uuid,
display_name: &str,
) -> Option<(Uuid, UserConnection)> {
for entry in self.users.iter() {
let (user_id, conn) = entry.pair();
if conn.realm_id == realm_id && conn.display_name.eq_ignore_ascii_case(display_name) {
@ -148,11 +152,19 @@ where
"[WS] Connection attempt to {}/channels/{} - auth: {:?}",
slug,
channel_id,
auth_result.as_ref().map(|a| a.0.id).map_err(|e| format!("{:?}", e))
auth_result
.as_ref()
.map(|a| a.0.id)
.map_err(|e| format!("{:?}", e))
);
let AuthUser(user) = auth_result.map_err(|e| {
tracing::warn!("[WS] Auth failed for {}/channels/{}: {:?}", slug, channel_id, e);
tracing::warn!(
"[WS] Auth failed for {}/channels/{}: {:?}",
slug,
channel_id,
e
);
AppError::from(e)
})?;
@ -181,7 +193,9 @@ where
);
Ok(ws.on_upgrade(move |socket| {
handle_socket(socket, user, channel_id, realm.id, pool, ws_state, ws_config)
handle_socket(
socket, user, channel_id, realm.id, pool, ws_state, ws_config,
)
}))
}
@ -225,7 +239,11 @@ async fn handle_socket(
// Set RLS context on this dedicated connection
if let Err(e) = set_rls_user_id(&mut conn, user.id).await {
tracing::error!("[WS] Failed to set RLS context for user {}: {:?}", user.id, e);
tracing::error!(
"[WS] Failed to set RLS context for user {}: {:?}",
user.id,
e
);
return;
}
tracing::info!("[WS] RLS context set on dedicated connection");
@ -266,8 +284,10 @@ async fn handle_socket(
}
};
let member = match channel_members::get_channel_member(&mut *conn, channel_id, user.id, realm_id)
.await
let member = match channel_members::get_channel_member(
&mut *conn, channel_id, user.id, realm_id,
)
.await
{
Ok(Some(m)) => m,
Ok(None) => {
@ -389,15 +409,21 @@ async fn handle_socket(
#[cfg(debug_assertions)]
tracing::debug!("[WS<-Client] {}", text);
let Ok(client_msg) = serde_json::from_str::<ClientMessage>(&text) else {
let Ok(client_msg) = serde_json::from_str::<ClientMessage>(&text)
else {
continue;
};
match client_msg {
ClientMessage::UpdatePosition { x, y } => {
if let Err(e) =
channel_members::update_position(&mut *recv_conn, channel_id, user_id, x, y)
.await
if let Err(e) = channel_members::update_position(
&mut *recv_conn,
channel_id,
user_id,
x,
y,
)
.await
{
#[cfg(debug_assertions)]
tracing::error!("[WS] Position update failed: {:?}", e);
@ -416,7 +442,10 @@ async fn handle_socket(
Ok(e) => e,
Err(_) => {
#[cfg(debug_assertions)]
tracing::warn!("[WS] Invalid emotion name: {}", emotion);
tracing::warn!(
"[WS] Invalid emotion name: {}",
emotion
);
continue;
}
};
@ -444,11 +473,19 @@ async fn handle_socket(
}
ClientMessage::Ping => {
// Update last_moved_at to keep member alive for cleanup
let _ = channel_members::touch_member(&mut *recv_conn, channel_id, user_id).await;
let _ = channel_members::touch_member(
&mut *recv_conn,
channel_id,
user_id,
)
.await;
// Respond with pong directly (not broadcast)
let _ = direct_tx.send(ServerMessage::Pong).await;
}
ClientMessage::SendChatMessage { content, target_display_name } => {
ClientMessage::SendChatMessage {
content,
target_display_name,
} => {
// Validate message
if content.is_empty() || content.len() > 500 {
continue;
@ -465,18 +502,20 @@ async fn handle_socket(
if let Ok(Some(member)) = member_info {
// Convert emotion index to name
let emotion_name = EmotionState::from_index(member.current_emotion as u8)
.map(|e| e.to_string())
.unwrap_or_else(|| "neutral".to_string());
let emotion_name =
EmotionState::from_index(member.current_emotion as u8)
.map(|e| e.to_string())
.unwrap_or_else(|| "neutral".to_string());
// Handle whisper (direct message) vs broadcast
if let Some(target_name) = target_display_name {
// Whisper: send directly to target user
if let Some((_target_user_id, target_conn)) =
ws_state.find_user_by_display_name(realm_id, &target_name)
if let Some((_target_user_id, target_conn)) = ws_state
.find_user_by_display_name(realm_id, &target_name)
{
// Determine if same scene
let is_same_scene = target_conn.channel_id == channel_id;
let is_same_scene =
target_conn.channel_id == channel_id;
let msg = ServerMessage::ChatMessageReceived {
message_id: Uuid::new_v4(),
@ -487,29 +526,33 @@ async fn handle_socket(
emotion: emotion_name.clone(),
x: member.position_x,
y: member.position_y,
timestamp: chrono::Utc::now().timestamp_millis(),
timestamp: chrono::Utc::now()
.timestamp_millis(),
is_whisper: true,
is_same_scene,
};
// Send to target user
let _ = target_conn.direct_tx.send(msg.clone()).await;
let _ =
target_conn.direct_tx.send(msg.clone()).await;
// Also send back to sender (so they see their own whisper)
// For sender, is_same_scene is always true (they see it as a bubble)
let sender_msg = ServerMessage::ChatMessageReceived {
message_id: Uuid::new_v4(),
user_id: Some(user_id),
guest_session_id: None,
display_name: member.display_name.clone(),
content,
emotion: emotion_name,
x: member.position_x,
y: member.position_y,
timestamp: chrono::Utc::now().timestamp_millis(),
is_whisper: true,
is_same_scene: true, // Sender always sees as bubble
};
let sender_msg =
ServerMessage::ChatMessageReceived {
message_id: Uuid::new_v4(),
user_id: Some(user_id),
guest_session_id: None,
display_name: member.display_name.clone(),
content,
emotion: emotion_name,
x: member.position_x,
y: member.position_y,
timestamp: chrono::Utc::now()
.timestamp_millis(),
is_whisper: true,
is_same_scene: true, // Sender always sees as bubble
};
let _ = direct_tx.send(sender_msg).await;
#[cfg(debug_assertions)]
@ -581,20 +624,26 @@ async fn handle_socket(
pos_x,
pos_y
);
let _ = tx.send(ServerMessage::PropDropped { prop });
let _ =
tx.send(ServerMessage::PropDropped { prop });
}
Err(e) => {
tracing::error!("[WS] Drop prop failed: {:?}", e);
let (code, message) = match &e {
chattyness_error::AppError::Forbidden(msg) => {
("PROP_NOT_DROPPABLE".to_string(), msg.clone())
}
chattyness_error::AppError::Forbidden(msg) => (
"PROP_NOT_DROPPABLE".to_string(),
msg.clone(),
),
chattyness_error::AppError::NotFound(msg) => {
("PROP_NOT_FOUND".to_string(), msg.clone())
}
_ => ("DROP_FAILED".to_string(), format!("{:?}", e)),
_ => (
"DROP_FAILED".to_string(),
format!("{:?}", e),
),
};
let _ = tx.send(ServerMessage::Error { code, message });
let _ =
tx.send(ServerMessage::Error { code, message });
}
}
}
@ -653,7 +702,10 @@ async fn handle_socket(
}
Ok(None) => {
#[cfg(debug_assertions)]
tracing::warn!("[WS] No avatar found for user {} to sync", user_id);
tracing::warn!(
"[WS] No avatar found for user {} to sync",
user_id
);
}
Err(e) => {
tracing::error!("[WS] Avatar sync failed: {:?}", e);