gitdata.ai/imks
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(tests): reformat code and update dependency management

Browse Source 
- Reorganized import statements in adapter tests for better readability
- Replaced or_insert_with(Vec::new) with or_default() in test closures
- Updated Cargo.lock with new dependency versions and checksums
- Added TLS features to tonic dependency configuration
- Included sqlx, chrono, and uuid dependencies with specific features
- Added jsonwebtoken and arc-swap as project dependencies
- Reformatted assertion statements to comply with line length limits
- Adjusted base64 import order in engine codec module
- Updated protobuf include statement formatting
This commit is contained in:
zhenyi
2026-06-11 12:11:05 +08:00
parent 06e8ee96a5
commit 821537186e
111 changed files with 10458 additions and 385 deletions
Download Patch File Download Diff File Expand all files Collapse all files
engine/websocket.rs
+55 -42
View File
@@ -1,6 +1,6 @@
use std::sync::Arc;
use actix_web::{web, HttpRequest, HttpResponse};
use actix_web::{HttpRequest, HttpResponse, web};
use actix_ws::Message;
use crate::engine::codec;
@@ -36,37 +36,37 @@ pub async fn websocket_handler(
let sid = query.sid.clone();
let is_upgrade = sid.as_ref().map(|s| store.exists(s)).unwrap_or(false);
if let Some(ref sid) = sid
&& !store.exists(sid)
{
return Ok(HttpResponse::BadRequest().body("unknown session"));
}
// Create or reuse session, obtaining the mpsc receiver for the forwarding task
let (session_sid, mut session_rx) = if let Some(ref sid) = sid {
if is_upgrade {
// Upgrade: session already exists, replace its channel and drain pending packets
let session_arc = store.get(sid).unwrap();
let (new_tx, new_rx) = tokio::sync::mpsc::channel(256);
{
let mut s = session_arc.write().await;
// Swap tx atomically: old_tx will be dropped, closing its channel.
// Any packets in the old rx are consumed by the old send_handle,
// which then exits when it sees the channel close.
// Drain pending_packets (from polling buffering) into new channel.
let pending = s.take_pending();
for packet in pending {
let _ = new_tx.try_send(packet);
}
s.tx = new_tx;
s.set_transport(TransportType::WebSocket);
// Upgrade: session already exists, replace its channel and drain pending packets
let session_arc = match store.get(sid) {
Some(s) => s,
None => {
tracing::error!("Session {} not found for upgrade", sid);
return Ok(HttpResponse::InternalServerError().body("session not found"));
}
(sid.clone(), new_rx)
} else {
// Reconnect with known SID: create new session
let rx = store.create(sid.clone(), TransportType::WebSocket);
if let Some(s) = store.get(sid) {
let mut s = s.write().await;
s.set_state(SessionState::Open);
};
let (new_tx, new_rx) = tokio::sync::mpsc::channel(256);
{
let mut s = session_arc.write().await;
// Swap tx atomically: old_tx will be dropped, closing its channel.
// Any packets in the old rx are consumed by the old send_handle,
// which then exits when it sees the channel close.
// Drain pending_packets (from polling buffering) into new channel.
let pending = s.take_pending();
for packet in pending {
let _ = new_tx.try_send(packet);
}
(sid.clone(), rx)
s.tx = new_tx;
s.set_transport(TransportType::WebSocket);
}
(sid.clone(), new_rx)
} else {
// New connection: generate SID and create session
let new_sid = crate::engine::session::generate_sid();
@@ -89,7 +89,10 @@ pub async fn websocket_handler(
let open_packet = Packet::open(&handshake);
let open_msg = codec::encode_packet(&open_packet);
if ws_session.text(open_msg).await.is_err() {
tracing::warn!("Failed to send open packet to WebSocket session {}", session_sid);
tracing::warn!(
"Failed to send open packet to WebSocket session {}",
session_sid
);
store.remove(&session_sid);
return Ok(response);
}
@@ -121,16 +124,26 @@ pub async fn websocket_handler(
while let Some(Ok(msg)) = msg_stream.recv().await {
match msg {
Message::Text(text) => {
if text.len() > max_payload {
tracing::warn!(
"Text payload too large ({}) for session {}",
text.len(),
sid_clone
);
let _ = ws_session.close(None).await;
break;
}
if let Ok(packet) = codec::decode_packet(&text) {
match packet.packet_type {
PacketType::Ping => {
if let PacketData::Text(ref data) = packet.data {
if data == "probe" {
let pong = Packet::pong("probe");
let pong_msg = codec::encode_packet(&pong);
let _ = ws_session.text(pong_msg).await;
continue;
}
if let PacketData::Text(ref data) = packet.data
&& data == "probe"
{
let pong = Packet::pong("probe");
let pong_msg = codec::encode_packet(&pong);
let _ = ws_session.text(pong_msg).await;
continue;
}
let pong = Packet::pong("");
let pong_msg = codec::encode_packet(&pong);
@@ -180,14 +193,14 @@ pub async fn websocket_handler(
continue;
}
if let Ok(packet) = codec::decode_packet_ws(&bin) {
if packet.packet_type == PacketType::Message {
let on_msg = on_message_clone.clone();
let sid = sid_clone.clone();
tokio::spawn(async move {
on_msg(sid, packet);
});
}
if let Ok(packet) = codec::decode_packet_ws(&bin)
&& packet.packet_type == PacketType::Message
{
let on_msg = on_message_clone.clone();
let sid = sid_clone.clone();
tokio::spawn(async move {
on_msg(sid, packet);
});
}
}
Message::Close(_) => {