- add: ability to refresh the current session

- add: delete type to delete character request
- add: ability to update key in redis
- add: handle alive packet to refresh the session
- fix: delete now actually returns the time remaining correctly
- fix: character list now has the correct time until character deletion

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<ValidateSessionResponse, Box<dyn std::error::Error + Send + Sync>> {
+        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<Empty, Box<dyn std::error::Error + Send + Sync>> {
         let request = LogoutRequest {
             session_id: session_id.to_string(),

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<DeleteCharacterResponse, Box<dyn std::error::Error + Send + Sync>> {
+    pub async fn delete_character(&mut self, user_id: &str, char_id: &str, delete_type: i32) -> Result<DeleteCharacterResponse, Box<dyn std::error::Error + Send + Sync>> {
         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?;

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<Mutex<AuthClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+    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<dyn Error + Send + Sync>> {
     let data = SrvAcceptReply { result: srv_accept_reply::Result::Accepted, rand_value: 0 };
     let response_packet = Packet::new(PacketType::PakssAcceptReply, &data)?;

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<u8> = 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 };

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<dyn Error + Send + Sync>> {
         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