Raven/osirose-new
SHA256
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 6 Releases Wiki Activity

More work.

Browse Source 
Added chat service
Updated packet service to pass the tcp stream around in a Arc type.
Updated character position data to not require multiplying the coords
Added more debug logs
Added an interceptor for gRPC comms with the chat server
Updated build and push script for the chat server changes
This commit is contained in:
raven
2025-06-06 17:52:29 -04:00
parent 85d41c0239
commit ad6ba2c8e6
32 changed files with 787 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
packet-service/src/handlers/auth.rs
View File

@@ -2,16 +2,6 @@ use crate::auth_client::AuthClient;
use crate::connection_service::ConnectionService;
use crate::packet::{send_packet, Packet, PacketPayload};
use crate::packet_type::PacketType;
use crate::packets::cli_channel_list_req::CliChannelListReq;
use crate::packets::cli_join_server_token_req::CliJoinServerTokenReq;
use crate::packets::cli_login_token_req::CliLoginTokenReq;
use crate::packets::cli_srv_select_req::CliSrvSelectReq;
use crate::packets::srv_accept_reply::SrvAcceptReply;
use crate::packets::srv_channel_list_reply::{ChannelInfo, SrvChannelListReply};
use crate::packets::srv_join_server_reply::SrvJoinServerReply;
use crate::packets::srv_login_reply::{ServerInfo, SrvLoginReply};
use crate::packets::srv_logout_reply::SrvLogoutReply;
use crate::packets::srv_srv_select_reply::SrvSrvSelectReply;
use crate::packets::*;
use std::collections::HashMap;
use std::env;
@@ -26,9 +16,11 @@ use tracing::{debug, error, info, warn};
use utils::null_string::NullTerminatedString;
use utils::service_discovery;
use utils::service_discovery::{get_kube_service_endpoints_by_dns, get_service_info};
use crate::handlers::chat::create_chat_client_handler;
use crate::handlers::chat_client::ChatClientHandler;
pub(crate) async fn handle_alive_req(
stream: &mut TcpStream,
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
@@ -50,26 +42,30 @@ pub(crate) async fn handle_alive_req(
}
pub(crate) async fn handle_accept_req(
stream: &mut TcpStream,
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::srv_accept_reply::SrvAcceptReply;
let data = SrvAcceptReply {
result: srv_accept_reply::Result::Accepted,
rand_value: 0,
};
let response_packet = Packet::new(PacketType::PakssAcceptReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
Ok(())
}
pub(crate) async fn handle_join_server_req(
stream: &mut TcpStream,
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
connection_id: String,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::cli_join_server_token_req::CliJoinServerTokenReq;
use crate::packets::srv_join_server_reply::SrvJoinServerReply;
let request = CliJoinServerTokenReq::decode(packet.payload.as_slice());
debug!("{:?}", request);
@@ -86,7 +82,8 @@ pub(crate) async fn handle_join_server_req(
pay_flag: 0,
};
let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
return Err("Session not valid".into());
}
@@ -96,7 +93,8 @@ pub(crate) async fn handle_join_server_req(
pay_flag: 0,
};
let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
Ok(())
} else {
Err("Unable to find connection state".into())
@@ -104,12 +102,13 @@ pub(crate) async fn handle_join_server_req(
}
pub(crate) async fn handle_logout_req(
stream: &mut TcpStream,
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
connection_id: String,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::srv_logout_reply::SrvLogoutReply;
if let Some(mut state) = connection_service.get_connection(&connection_id) {
let session_id = state.session_id.clone().unwrap();
let mut auth_client = auth_client.lock().await;
@@ -117,8 +116,9 @@ pub(crate) async fn handle_logout_req(
let data = SrvLogoutReply { wait_time: 1 };
let response_packet = Packet::new(PacketType::PakwcLogoutReply, &data)?;
send_packet(stream, &response_packet).await?;
stream.shutdown().await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
locked_stream.shutdown().await?;
Ok(())
} else {
Err("Unable to find connection state".into())
@@ -126,13 +126,14 @@ pub(crate) async fn handle_logout_req(
}
pub(crate) async fn handle_login_req(
stream: &mut TcpStream,
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
connection_id: String,
addr: SocketAddr,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::cli_login_token_req::CliLoginTokenReq;
use crate::packets::srv_login_reply::{ServerInfo, SrvLoginReply};
debug!("decoding packet payload of size {}", packet.payload.as_slice().len());
let data = CliLoginTokenReq::decode(packet.payload.as_slice())?;
debug!("{:?}", data);
@@ -140,6 +141,7 @@ pub(crate) async fn handle_login_req(
let mut auth_client = auth_client.lock().await;
match auth_client.validate_session(&data.token.0).await {
Ok(response) => {
debug!("Response: {:?}", response);
if response.valid == false {
info!("Login failed: Invalid credentials");
@@ -150,14 +152,32 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
} else {
debug!("Successfully logged in");
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
debug!("Response: {:?}", response);
state.user_id = Some(response.user_id);
state.session_id = Some(response.session_id);
state.session_id = Some(response.session_id.clone());
}
let chat_url = format!(
"http://{}",
get_kube_service_endpoints_by_dns("chat-service", "tcp", "chat-service")
.await
.expect("Failed to get chat service endpoints")
.get(0)
.unwrap()
);
let handler = ChatClientHandler::new(chat_url, connection_id.clone(), response.session_id.clone()).await?;
let chat_handler = Arc::new(handler);
create_chat_client_handler(stream.clone(), chat_handler.clone()).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
state.chat_handler = Some(chat_handler);
}
let mut id = 0;
@@ -196,7 +216,8 @@ pub(crate) async fn handle_login_req(
servers_info: server_info,
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
Err(err) => {
@@ -208,7 +229,8 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
return Ok(());
}
}
@@ -227,7 +249,8 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
Code::Unavailable => {
warn!("Login failed: Service is unavailable");
@@ -238,7 +261,8 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
_ => {
error!("Unexpected error: {}", tonic_status.message());
@@ -249,7 +273,8 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
}
@@ -260,11 +285,13 @@ pub(crate) async fn handle_login_req(
}
pub(crate) async fn handle_server_select_req(
stream: &mut TcpStream,
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
connection_service: Arc<ConnectionService>,
connection_id: String,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::cli_srv_select_req::CliSrvSelectReq;
use crate::packets::srv_srv_select_reply::SrvSrvSelectReply;
let request = CliSrvSelectReq::decode(packet.payload.as_slice())?;
debug!("{:?}", request);
@@ -286,14 +313,17 @@ pub(crate) async fn handle_server_select_req(
};
let response_packet = Packet::new(PacketType::PaklcSrvSelectReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
Ok(())
}
pub(crate) async fn handle_channel_list_req(
stream: &mut TcpStream,
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::cli_channel_list_req::CliChannelListReq;
use crate::packets::srv_channel_list_reply::{ChannelInfo, SrvChannelListReply};
let request = CliChannelListReq::decode(packet.payload.as_slice());
debug!("{:?}", request);
@@ -326,7 +356,8 @@ pub(crate) async fn handle_channel_list_req(
channels: channel_info,
};
let response_packet = Packet::new(PacketType::PaklcChannelListReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
Err(err) => {
@@ -335,7 +366,8 @@ pub(crate) async fn handle_channel_list_req(
channels: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcChannelListReply, &data)?;
send_packet(stream, &response_packet).await?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
return Ok(());
}
}