diff --git a/auth-service/src/grpc.rs b/auth-service/src/grpc.rs index f0229e6..ec0fdef 100644 --- a/auth-service/src/grpc.rs +++ b/auth-service/src/grpc.rs @@ -9,7 +9,7 @@ use crate::users::{hash_password, verify_user}; use chrono::{Duration, Utc}; use rand::Rng; use tonic::{Request, Response, Status}; -use tracing::{error, info, warn}; +use tracing::{debug, error, info, warn}; pub struct MyAuthService { pub db_client: Arc, @@ -105,11 +105,35 @@ impl AuthService for MyAuthService { match response { Ok(res) => { - println!("Session valid: {:?}", res.into_inner()); + debug!("Session valid: {:?}", res.into_inner()); Ok(Response::new(ValidateSessionResponse { valid: true })) } Err(_) => { - println!("Session invalid or not found"); + debug!("Session invalid or not found"); + Ok(Response::new(ValidateSessionResponse { valid: false })) + } + } + } + + async fn refresh_session( + &self, + request: Request, + ) -> Result, Status> { + let req = request.into_inner(); + let response = self + .session_client.as_ref().clone() + .refresh_session(GetSessionRequest { + session_id: req.session_id, + }) + .await; + + match response { + Ok(res) => { + debug!("Session valid: {:?}", res.into_inner()); + Ok(Response::new(ValidateSessionResponse { valid: true })) + } + Err(_) => { + debug!("Session invalid or not found"); Ok(Response::new(ValidateSessionResponse { valid: false })) } } diff --git a/character-service/src/character_db_client.rs b/character-service/src/character_db_client.rs index 4b03999..fa2c59c 100644 --- a/character-service/src/character_db_client.rs +++ b/character-service/src/character_db_client.rs @@ -161,10 +161,11 @@ impl CharacterDbClient { Ok(response.into_inner()) } - pub async fn delete_character(&mut self, user_id: &str, char_id: &str) -> Result> { + pub async fn delete_character(&mut self, user_id: &str, char_id: &str, delete_type: i32) -> Result> { let request = tonic::Request::new(DeleteCharacterRequest { user_id: user_id.parse().unwrap(), character_id: char_id.parse().unwrap(), + delete_type, }); let response = self.client.delete_character(request).await?; Ok(response.into_inner()) diff --git a/character-service/src/character_service.rs b/character-service/src/character_service.rs index 5de725d..7c939d0 100644 --- a/character-service/src/character_service.rs +++ b/character-service/src/character_service.rs @@ -38,7 +38,7 @@ impl CharacterService for MyCharacterService { character_id: character.id.to_string(), name: character.name, last_played: 0, - delete_time: 0, + delete_time: character.deleted_at.parse().unwrap_or_default(), stats: serde_json::from_str(&character.stats).unwrap(), looks: serde_json::from_str(&character.looks).unwrap(), items: serde_json::from_str(&character.inventory).unwrap(), @@ -66,7 +66,7 @@ impl CharacterService for MyCharacterService { let req = request.into_inner(); debug!("{:?}", req); - let delete_character_response = self.character_db_client.as_ref().clone().delete_character(&req.user_id, &req.char_id).await.map_err(|_| Status::not_found("Character not found"))?; + let delete_character_response = self.character_db_client.as_ref().clone().delete_character(&req.user_id, &req.char_id, req.delete_type).await.map_err(|_| Status::not_found("Character not found"))?; let response = DeleteCharacterResponse { remaining_time: delete_character_response.remaining_time, name: delete_character_response.name }; Ok(Response::new(response)) } diff --git a/database-service/src/characters.rs b/database-service/src/characters.rs index 3bab166..28b12dd 100644 --- a/database-service/src/characters.rs +++ b/database-service/src/characters.rs @@ -15,7 +15,7 @@ pub struct Character { pub position: serde_json::Value, pub created_at: chrono::NaiveDateTime, pub updated_at: chrono::NaiveDateTime, - pub deleted_at: Option, + pub deleted_at: Option, pub is_active: bool, } @@ -40,7 +40,7 @@ impl CharacterRepository { // Fetch from database let character = sqlx::query_as::<_, Character>( "SELECT id, user_id, name, inventory, stats, looks, position, \ - created_at, updated_at, deleted_at, is_active \ + created_at, updated_at, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at, is_active \ FROM characters WHERE id = $1 AND is_active = true", ) .bind(character_id) @@ -72,9 +72,13 @@ impl CharacterRepository { Ok(result.get("id")) } - pub async fn delete_character(&self, character_id: i32) -> Result<(), sqlx::Error> { + pub async fn delete_character(&self, character_id: i32, delete_type: i32) -> Result { + let mut query = "UPDATE characters SET updated_at = NOW(), deleted_at = NOW() + '24 hours' WHERE id = $1 RETURNING user_id, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at"; + if 0 == delete_type { + query = "UPDATE characters SET updated_at = NOW(), deleted_at = null WHERE id = $1 RETURNING user_id, 0::BIGINT as deleted_at"; + } let result = sqlx::query( - "UPDATE characters SET deleted_at = NOW(), is_active = false WHERE id = $1 RETURNING user_id", + query, ) .bind(character_id) .fetch_one(&self.pool) @@ -85,7 +89,7 @@ impl CharacterRepository { self.cache.lock().await.delete(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)?; let cache_key = format!("character:{}", character_id); self.cache.lock().await.delete(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)?; - Ok(()) + Ok(result.get::("deleted_at")) } pub async fn get_characters_by_user(&self, user_id: i32) -> Result, sqlx::Error> { @@ -98,9 +102,7 @@ impl CharacterRepository { // Fetch from database let characters = sqlx::query_as::<_, Character>( - "SELECT id, user_id, name, inventory, stats, looks, position, \ - created_at, updated_at, deleted_at, is_active \ - FROM characters WHERE user_id = $1 AND is_active = true", + "SELECT id, user_id, name, inventory, stats, looks, position, created_at, updated_at, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at, is_active FROM characters WHERE user_id = $1 AND is_active = true", ) .bind(user_id) .fetch_all(&self.pool) diff --git a/database-service/src/grpc/character_service.rs b/database-service/src/grpc/character_service.rs index c18267a..423a0a3 100644 --- a/database-service/src/grpc/character_service.rs +++ b/database-service/src/grpc/character_service.rs @@ -1,3 +1,4 @@ +use serde_json::Value::Null; use crate::grpc::{Character, CharacterRequest, CharacterListRequest, CharacterListResponse, CreateCharacterRequest, CreateCharacterResponse, DeleteCharacterRequest, DeleteCharacterResponse, Empty}; use crate::grpc::character_service_server::CharacterService; use crate::grpc::database_service::MyDatabaseService; @@ -17,6 +18,11 @@ impl CharacterService for MyDatabaseService { .await .map_err(|_| Status::not_found("Character not found"))?; + let mut deleted_at= "".to_string(); + if character.deleted_at.is_some() { + deleted_at = character.deleted_at.unwrap().to_string(); + } + let response = Character { id: character.id, user_id: character.user_id, @@ -27,6 +33,7 @@ impl CharacterService for MyDatabaseService { position: character.position.to_string(), created_at: character.created_at.to_string(), updated_at: character.updated_at.to_string(), + deleted_at, is_active: character.is_active, }; @@ -46,8 +53,13 @@ impl CharacterService for MyDatabaseService { .map_err(|_| Status::not_found("Character not found"))?; let mut character_list: Vec = Vec::new(); + for character in characters { + let mut deleted_at= "".to_string(); + if character.deleted_at.is_some() { + deleted_at = character.deleted_at.unwrap_or_default().to_string(); + } let character = Character { id: character.id, user_id: character.user_id, @@ -58,6 +70,7 @@ impl CharacterService for MyDatabaseService { position: character.position.to_string(), created_at: character.created_at.to_string(), updated_at: character.updated_at.to_string(), + deleted_at, is_active: character.is_active, }; character_list.push(character); @@ -111,12 +124,12 @@ impl CharacterService for MyDatabaseService { let req = request.into_inner(); let repo = &self.db.character_repo; - repo.delete_character(req.character_id) + let time_left_in_seconds = repo.delete_character(req.character_id, req.delete_type) .await .map_err(|_| Status::internal("Failed to delete character"))?; let response = DeleteCharacterResponse { - remaining_time: 0, + remaining_time: time_left_in_seconds, name: "".to_string(), }; Ok(Response::new(response)) diff --git a/packet-service/src/auth_client.rs b/packet-service/src/auth_client.rs index 829be6a..92a2c53 100644 --- a/packet-service/src/auth_client.rs +++ b/packet-service/src/auth_client.rs @@ -42,6 +42,15 @@ impl AuthClient { Ok(response.into_inner()) } + pub async fn refresh_session(&mut self, session_id: &str) -> Result> { + let request = ValidateSessionRequest { + session_id: session_id.to_string() + }; + + let response = self.client.refresh_session(request).await?; + Ok(response.into_inner()) + } + pub async fn logout(&mut self, session_id: &str) -> Result> { let request = LogoutRequest { session_id: session_id.to_string(), diff --git a/packet-service/src/character_client.rs b/packet-service/src/character_client.rs index cc86658..5913419 100644 --- a/packet-service/src/character_client.rs +++ b/packet-service/src/character_client.rs @@ -37,10 +37,11 @@ impl CharacterClient { Ok(response.into_inner()) } - pub async fn delete_character(&mut self, user_id: &str, char_id: &str) -> Result> { + pub async fn delete_character(&mut self, user_id: &str, char_id: &str, delete_type: i32) -> Result> { let request = DeleteCharacterRequest { user_id: user_id.to_string(), char_id: char_id.to_string(), + delete_type }; let response = self.client.delete_character(request).await?; diff --git a/packet-service/src/handlers/auth.rs b/packet-service/src/handlers/auth.rs index 108fafb..7656524 100644 --- a/packet-service/src/handlers/auth.rs +++ b/packet-service/src/handlers/auth.rs @@ -26,6 +26,23 @@ use crate::connection_service::ConnectionService; use crate::packets::cli_logout_req::CliLogoutReq; use crate::packets::srv_join_server_reply::SrvJoinServerReply; + +pub(crate) async fn handle_alive_req(stream: &mut TcpStream, packet: Packet, auth_client: Arc>, connection_service: Arc, connection_id: String) -> Result<(), Box> { + if let Some(mut state) = connection_service.get_connection(&connection_id) { + let session_id = state.session_id.clone().unwrap(); + debug!("Attempting to refresh session {}", session_id); + let mut auth_client = auth_client.lock().await; + let session = auth_client.refresh_session(&session_id).await?; + if (!session.valid) { + warn!("Invalid session ID: {}", session_id); + return Err("Session not valid".into()); + } + Ok(()) + } else { + Err("Unable to find connection state".into()) + } +} + pub(crate) async fn handle_accept_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box> { let data = SrvAcceptReply { result: srv_accept_reply::Result::Accepted, rand_value: 0 }; let response_packet = Packet::new(PacketType::PakssAcceptReply, &data)?; diff --git a/packet-service/src/handlers/character.rs b/packet-service/src/handlers/character.rs index a91903a..05acccb 100644 --- a/packet-service/src/handlers/character.rs +++ b/packet-service/src/handlers/character.rs @@ -51,7 +51,6 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, // query the character service for the character list for this user let mut character_client = character_client.lock().await; let character_list = character_client.get_character_list(&user_id.to_string()).await?; - debug!("{:?}", character_list.characters); let mut characters = vec![]; let mut character_id_list:Vec = Vec::new(); for character in character_list.characters { @@ -68,7 +67,6 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, }; } } - debug!("Item list is created as: {:?}", item_list); let character_info = CharInfo { name: NullTerminatedString(character.name), @@ -89,7 +87,6 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, state.character_list = Some(character_id_list); // Save the real character id's for later as the client sends what is selected from 0 index. It does not use the real character idss } - debug!("{:?}", characters); let data = SrvCharListReply { characters }; let response_packet = Packet::new(PacketType::PakccCharListReply, &data)?; send_packet(stream, &response_packet).await?; @@ -144,7 +141,7 @@ pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packe } let mut character_client = character_client.lock().await; - let delete_response = character_client.delete_character(&user_id.to_string(), &character_id_list[request.char_id as usize].to_string()).await?; + let delete_response = character_client.delete_character(&user_id.to_string(), &character_id_list[request.char_id as usize].to_string(), request.is_delete as i32).await?; let character_name = request.name; let data = SrvDeleteCharReply { remaining_time: delete_response.remaining_time as u32, name: character_name }; diff --git a/packet-service/src/router.rs b/packet-service/src/router.rs index 14bd001..1484983 100644 --- a/packet-service/src/router.rs +++ b/packet-service/src/router.rs @@ -60,8 +60,8 @@ impl PacketRouter { pub async fn route_packet(&self, stream: &mut TcpStream, packet: Packet, connection_id: String) -> Result<(), Box> { debug!("Routing packet: {:?}", packet); match packet.packet_type { - PacketType::PakcsAlive => Ok(()), // Generic Server Packets + PacketType::PakcsAlive => auth::handle_alive_req(stream, packet, self.auth_client.clone(), self.connection_service.clone(), connection_id).await, PacketType::PakcsAcceptReq => auth::handle_accept_req(stream, packet).await, PacketType::PakcsJoinServerTokenReq => auth::handle_join_server_req(stream, packet, self.auth_client.clone(), self.connection_service.clone(), connection_id).await, // Login Packets diff --git a/proto/auth.proto b/proto/auth.proto index bf54786..36fc21c 100644 --- a/proto/auth.proto +++ b/proto/auth.proto @@ -7,6 +7,7 @@ service AuthService { rpc Logout(LogoutRequest) returns (Empty); rpc ValidateToken(ValidateTokenRequest) returns (ValidateTokenResponse); rpc ValidateSession(ValidateSessionRequest) returns (ValidateSessionResponse); + rpc RefreshSession(ValidateSessionRequest) returns (ValidateSessionResponse); rpc Register (RegisterRequest) returns (RegisterResponse); rpc RequestPasswordReset (PasswordResetRequest) returns (PasswordResetResponse); rpc ResetPassword (ResetPasswordRequest) returns (ResetPasswordResponse); diff --git a/proto/character.proto b/proto/character.proto index 460bab2..c734713 100644 --- a/proto/character.proto +++ b/proto/character.proto @@ -35,6 +35,7 @@ message CreateCharacterResponse { message DeleteCharacterRequest { string user_id = 1; string char_id = 2; + int32 delete_type = 3; } message DeleteCharacterResponse { diff --git a/proto/character_db_api.proto b/proto/character_db_api.proto index 397a94a..eb4c01d 100644 --- a/proto/character_db_api.proto +++ b/proto/character_db_api.proto @@ -39,6 +39,7 @@ message CreateCharacterResponse { message DeleteCharacterRequest { int32 user_id = 1; int32 character_id = 2; + int32 delete_type = 3; } message DeleteCharacterResponse { @@ -56,7 +57,8 @@ message Character { string position = 9; string created_at = 10; string updated_at = 11; - bool is_active = 12; + string deleted_at = 12; + bool is_active = 13; } message Empty {} diff --git a/proto/session_service_api.proto b/proto/session_service_api.proto index 21a2fbd..3aa3839 100644 --- a/proto/session_service_api.proto +++ b/proto/session_service_api.proto @@ -5,6 +5,7 @@ package session_service_api; service SessionService { rpc CreateSession (CreateSessionRequest) returns (SessionResponse); rpc GetSession (GetSessionRequest) returns (SessionResponse); + rpc RefreshSession (GetSessionRequest) returns (SessionResponse); rpc DeleteSession (DeleteSessionRequest) returns (Empty); } diff --git a/session-service/src/session_service.rs b/session-service/src/session_service.rs index 0570172..4cbbd88 100644 --- a/session-service/src/session_service.rs +++ b/session-service/src/session_service.rs @@ -41,7 +41,7 @@ impl SessionService for SessionServiceImpl { let session_data = serde_json::to_string(&session).map_err(|_| Status::internal("Failed to serialize session"))?; let conn = self.redis.lock().await; - conn.set(&session_id.clone(), &session_data, 0).await.map_err(|_| Status::internal("Failed to store session in Redis"))?; + conn.set(&session_id.clone(), &session_data, 300).await.map_err(|_| Status::internal("Failed to store session in Redis"))?; let response = SessionResponse { session_id, @@ -91,4 +91,29 @@ impl SessionService for SessionServiceImpl { Ok(Response::new(Empty {})) } + async fn refresh_session( + &self, + request: Request, + ) -> Result, Status> { + let req = request.into_inner(); + let conn = self.redis.lock().await; + + if let Some(session_data) = conn.get::(&req.session_id).await.map_err(|_| Status::internal("Failed to fetch session from Redis"))? { + let _ = conn.update(&req.session_id, Some(&session_data), Some(300)); + let session: Session = serde_json::from_str(&session_data).map_err(|_| Status::internal("Failed to deserialize session"))?; + + let response = SessionResponse { + session_id: req.session_id, + user_id: session.user_id, + username: session.username, + character_id: session.character_id, + login_time: session.login_time, + ip_address: session.ip_address, + }; + + Ok(Response::new(response)) + } else { + Err(Status::not_found("Session not found")) + } + } } diff --git a/utils/src/redis_cache.rs b/utils/src/redis_cache.rs index 22824c0..29950c9 100644 --- a/utils/src/redis_cache.rs +++ b/utils/src/redis_cache.rs @@ -1,6 +1,6 @@ use async_trait::async_trait; use deadpool_redis::{Config, Pool, Runtime}; -use redis::{AsyncCommands, RedisError}; +use redis::{AsyncCommands, Commands, RedisError}; use serde::{Deserialize, Serialize}; #[async_trait] @@ -12,6 +12,13 @@ pub trait Cache { ttl: u64, ) -> Result<(), redis::RedisError>; + async fn update( + &self, + key: &String, + value: Option<&T>, + ttl: Option, + ) -> Result<(), redis::RedisError>; + async fn get serde::Deserialize<'de> + Send + Sync>( &self, key: &String, @@ -83,6 +90,38 @@ impl Cache for RedisCache { } } + async fn update( + &self, + key: &String, + value: Option<&T>, + ttl: Option, + ) -> Result<(), redis::RedisError> { + let mut conn = self.pool.get().await + .map_err(|err| { + redis::RedisError::from(( + redis::ErrorKind::IoError, + "Failed to get Redis connection", + format!("{:?}", err), + )) + })?; + let serialized_value; + if value.is_some() { + serialized_value = serde_json::to_string(&value) + .map_err(|err| RedisError::from(( + redis::ErrorKind::IoError, + "Serialization error", + format!("Serialization error: {}", err), + )))?; + } else { + serialized_value = conn.get(key).await?; + } + if ttl != None { + conn.set_ex(key, serialized_value, ttl.unwrap()).await + } else { + conn.set(key, serialized_value).await + } + } + async fn delete(&mut self, key: &str) -> redis::RedisResult<()> { let mut conn = self.pool.get().await .map_err(|err| {