- update: generate_service_id function call now takes in the service name so the id file isn't always called utils_service_id.txt

- add: character grpc client interface to packet service

api-service/src/main.rs

@@ -34,7 +34,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let health_check_url = format!("http://{}:{}/health", service_address, health_port);
 
     // Register service with Consul
-    let service_id = consul_registration::get_or_generate_service_id();
+    let service_id = consul_registration::get_or_generate_service_id(env!("CARGO_PKG_NAME"));
     let tags = vec!["version-1.0".to_string()];
     let meta = HashMap::new();
     consul_registration::register_service(

auth-service/src/main.rs

@@ -38,7 +38,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let session_nodes = get_service_address(&consul_url, "session-service").await?;
 
     // Register service with Consul
-    let service_id = consul_registration::get_or_generate_service_id();
+    let service_id = consul_registration::get_or_generate_service_id(env!("CARGO_PKG_NAME"));
     let tags = vec!["version-1.0".to_string()];
     let mut meta = HashMap::new();
     consul_registration::register_service(

character-service/src/character_service.rs

@@ -0,0 +1,53 @@
+use tracing::debug;
+use tonic::{Request, Response, Status};
+use tracing::field::debug;
+use crate::character_service::character::character_service_server::CharacterService;
+use crate::character_service::character::{Character, GetCharacterListRequest, GetCharacterListResponse};
+
+pub mod character {
+    tonic::include_proto!("character");
+}
+
+#[derive(Default)]
+pub struct MyCharacterService {}
+
+#[tonic::async_trait]
+impl CharacterService for MyCharacterService {
+    async fn get_character_list(&self, request: Request<GetCharacterListRequest>) -> Result<Response<GetCharacterListResponse>, Status> {
+        let req = request.into_inner();
+
+        let user_id = req.user_id;
+        debug!("Character list for User ID: {}", user_id);
+
+        // Simulated database fetch for characters
+        let characters = vec![
+            Character {
+                character_id: "1".to_string(),
+                name: "Warrior123".to_string(),
+                level: 1,
+                race: 1,
+                job: 111,
+                last_played: 1633017600, // Example timestamp
+                delete_time: 0,
+                face: 0,
+                hair: 0,
+                items: vec![],
+            },
+            Character {
+                character_id: "2".to_string(),
+                name: "Mage123".to_string(),
+                level: 20,
+                race: 0,
+                job: 211,
+                last_played: 1633017600, // Example timestamp
+                delete_time: 0,
+                face: 0,
+                hair: 0,
+                items: vec![],
+            },
+        ];
+
+        let response = GetCharacterListResponse { characters };
+        Ok(Response::new(response))
+    }
+}

character-service/src/main.rs

@@ -1,3 +1,5 @@
+mod character_service;
+
 use dotenv::dotenv;
 use std::collections::HashMap;
 use std::env;
@@ -6,6 +8,8 @@ use tokio::{select, signal};
 use tracing::{info, Level};
 use utils::consul_registration;
 use utils::service_discovery::get_service_address;
+use crate::character_service::character::character_service_server::CharacterServiceServer;
+use crate::character_service::MyCharacterService;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -28,7 +32,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let db_nodes = get_service_address(&consul_url, "database-service").await?;
 
     // Register service with Consul
-    let service_id = consul_registration::get_or_generate_service_id();
+    let service_id = consul_registration::get_or_generate_service_id(env!("CARGO_PKG_NAME"));
     let tags = vec!["version-1.0".to_string()];
     let mut meta = HashMap::new();
     meta.insert("name".to_string(), "Rose".to_string());
@@ -47,8 +51,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Start health-check endpoint
     consul_registration::start_health_check(addr.as_str()).await?;
 
+    let full_addr = format!("{}:{}", &addr, port);
+    let address = full_addr.parse().expect("Invalid address");
     let db_address = db_nodes.get(0).unwrap();
     let db_url = format!("http://{}:{}", db_address.ServiceAddress, db_address.ServicePort);
+    let character_service = MyCharacterService::default();
+
+    tonic::transport::Server::builder()
+        .add_service(CharacterServiceServer::new(character_service))
+        .serve(address)
+        .await?;
+
 
     let mut sigterm_stream = signal::unix::signal(signal::unix::SignalKind::terminate())?;
     select! {

database-service/src/main.rs

@@ -36,7 +36,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let health_check_url = format!("http://{}:{}/health", service_address, health_port);
     
     // Register service with Consul
-    let service_id = consul_registration::get_or_generate_service_id();
+    let service_id = consul_registration::get_or_generate_service_id(env!("CARGO_PKG_NAME"));
     let tags = vec!["version-1.0".to_string()];
     let meta = HashMap::new();
     consul_registration::register_service(

packet-service/build.rs

@@ -1,9 +1,9 @@
 fn main() {
     // gRPC Client code
     tonic_build::configure()
-        .build_server(false) // Generate gRPC client code
+        .build_server(false) // Generate gRPC server code?
         .compile_well_known_types(true)
         .type_attribute(".", "#[derive(serde::Serialize, serde::Deserialize)]")
-        .compile_protos(&["../proto/auth.proto"], &["../proto"])
+        .compile_protos(&["../proto/auth.proto", "../proto/character.proto"], &["../proto"])
         .unwrap_or_else(|e| panic!("Failed to compile protos {:?}", e));
 }

packet-service/src/auth_client.rs

@@ -1,5 +1,5 @@
 use crate::auth::auth_service_client::AuthServiceClient;
-use crate::auth::{Empty, LoginRequest, LoginResponse, LogoutRequest, ValidateTokenRequest, ValidateTokenResponse};
+use crate::auth::{Empty, LoginRequest, LoginResponse, LogoutRequest, ValidateSessionRequest, ValidateSessionResponse, ValidateTokenRequest, ValidateTokenResponse};
 use tonic::transport::Channel;
 
 pub struct AuthClient {
@@ -32,6 +32,15 @@ impl AuthClient {
         Ok(response.into_inner())
     }
 
+    pub async fn validate_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.validate_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/connection_state.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 pub struct ConnectionState {
     pub user_id: Option<i32>,
     pub session_id: Option<String>,
-    pub character_id: Option<i32>,
+    pub character_id: Option<i8>,
     pub additional_data: HashMap<String, String>, // Flexible data storage
 }
 

packet-service/src/handlers/auth.rs

@@ -24,6 +24,7 @@ use tracing::{debug, error, info, warn};
 use utils::service_discovery;
 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_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 };
@@ -33,17 +34,37 @@ pub(crate) async fn handle_accept_req(stream: &mut TcpStream, packet: Packet) ->
     Ok(())
 }
 
-pub(crate) async fn handle_join_server_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn handle_join_server_req(stream: &mut TcpStream, packet: Packet, auth_client: Arc<Mutex<AuthClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliJoinServerTokenReq::decode(packet.payload.as_slice());
     debug!("{:?}", request);
-    Ok(())
+
+    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;
+        let session = auth_client.validate_session(&session_id).await?;
+        if (!session.valid) {
+            warn!("Invalid session ID: {}", session_id);
+            
+            let data = SrvJoinServerReply { result: srv_join_server_reply::Result::Failed, id: 0, pay_flag: 0 };
+            let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
+            send_packet(stream, &response_packet).await?;
+            return Err("Session not valid".into());
+        }
+        
+        let data = SrvJoinServerReply { result: srv_join_server_reply::Result::Ok, id: 1, pay_flag: 0 };
+        let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
+        send_packet(stream, &response_packet).await?;
+        Ok(())
+    } else {
+        Err("Unable to find connection state".into())
+    }
 }
 
 pub(crate) async fn handle_logout_req(stream: &mut TcpStream, packet: Packet, auth_client: Arc<Mutex<AuthClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliLogoutReq::decode(packet.payload.as_slice());
-    let mut auth_client = auth_client.lock().await;
     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;
         auth_client.logout(&session_id).await?;
         Ok(())
     } else {
@@ -146,7 +167,7 @@ pub(crate) async fn handle_server_select_req(stream: &mut TcpStream, packet: Pac
     }
 
     let data = SrvSrvSelectReply {
-        result: srv_srv_select_reply::Result::Failed,
+        result: srv_srv_select_reply::Result::Ok,
         session_id: 0, // Client should already have this value
         crypt_val: 0, // This is only for the old encryption
         ip: NullTerminatedString::new(""), // If this is empty, the client should stay connected (requires client change)

packet-service/src/handlers/character.rs

@@ -3,6 +3,7 @@ use crate::packet::{send_packet, Packet, PacketPayload};
 use crate::packet_type::PacketType;
 use crate::packets::cli_char_list_req::CliCharListReq;
 use crate::packets::*;
+use crate::dataconsts::*;
 use std::collections::HashMap;
 use std::env;
 use std::error::Error;
@@ -11,11 +12,127 @@ use tokio::net::TcpStream;
 use tokio::sync::Mutex;
 use tonic::{Code, Status};
 use tracing::{debug, error, info, warn};
-use utils::service_discovery;
+use crate::connection_service::ConnectionService;
+use crate::packets::cli_create_char_req::CliCreateCharReq;
+use crate::packets::cli_delete_char_req::CliDeleteCharReq;
+use crate::packets::cli_select_char_req::CliSelectCharReq;
+use crate::packets::srv_char_list_reply::SrvCharListReply;
+use crate::packets::srv_create_char_reply::SrvCreateCharReply;
+use crate::packets::srv_delete_char_reply::SrvDeleteCharReply;
+use crate::packets::srv_select_char_reply::SrvSelectCharReply;
 
-pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliCharListReq::decode(packet.payload.as_slice());
     debug!("{:?}", request);
+
+    let mut user_id = 0;
+    let session_id;
+    if let Some(mut state) = connection_service.get_connection(&connection_id) {
+        user_id = state.user_id.expect("Missing user id in connection state");
+        session_id = state.session_id.expect("Missing session id in connection state");
+    }
+    
+    // query the character service for the character list for this user
+    
+    let data = SrvCharListReply { characters: vec![] };
+    let response_packet = Packet::new(PacketType::PakccCharListReply, &data)?;
+    send_packet(stream, &response_packet).await?;
     
     Ok(())
 }
+
+pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+    let request = CliCreateCharReq::decode(packet.payload.as_slice())?;
+    debug!("{:?}", request);
+
+    let session_id;
+    if let Some(mut state) = connection_service.get_connection(&connection_id) {
+        session_id = state.session_id.expect("Missing session id in connection state");
+    }
+    
+    // send the data to the character service to create the character
+
+    let data = SrvCreateCharReply { result: srv_create_char_reply::Result::Ok, platininum: 0 };
+    let response_packet = Packet::new(PacketType::PakccCreateCharReply, &data)?;
+    send_packet(stream, &response_packet).await?;
+
+    Ok(())
+}
+
+pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+    let request = CliDeleteCharReq::decode(packet.payload.as_slice())?;
+    debug!("{:?}", request);
+
+    let session_id;
+    if let Some(mut state) = connection_service.get_connection(&connection_id) {
+        session_id = state.session_id.expect("Missing session id in connection state");
+    }
+    
+    // character_client.set_delete_character(request.is_delete, request.char_id, request.name);
+
+    let character_name = request.name;
+    let data = SrvDeleteCharReply { remaining_time: 0, name: character_name };
+    let response_packet = Packet::new(PacketType::PakccDeleteCharReply, &data)?;
+    send_packet(stream, &response_packet).await?;
+
+    Ok(())
+}
+
+pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+    let request = CliSelectCharReq::decode(packet.payload.as_slice())?;
+    debug!("{:?}", request);
+
+    if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
+        state.character_id = Some(request.char_id as i8);
+    }
+
+    let data = SrvSelectCharReply {
+        race: 0,
+        map: 0,
+        x: 0.0,
+        y: 0.0,
+        spawn: 0,
+        body_face: 0,
+        body_hair: 0,
+        equipped_items: vec![],
+        stone: 0,
+        face: 0,
+        hair: 0,
+        job: 0,
+        faction_id: 0,
+        faction_rank: 0,
+        fame: 0,
+        str: 0,
+        dex: 0,
+        int: 0,
+        con: 0,
+        charm: 0,
+        sense: 0,
+        hp: 0,
+        mp: 0,
+        xp: 0,
+        level: 0,
+        stat_points: 0,
+        skill_points: 0,
+        body_size: 0,
+        head_size: 0,
+        penalty_xp: 0,
+        faction_fame: [0u16; 2],
+        faction_points: [0u16; 10],
+        guild_id: 0,
+        guild_contribution: 0,
+        guild_rank: 0,
+        pk_flag: 0,
+        stamina: 0,
+        effects: vec![],
+        pat_hp: 0,
+        pat_cooldown_time: 0,
+        skills: [0u16; (MAX_SKILL_COUNT as usize)],
+        hotbar: vec![],
+        tag: 0,
+        name: request.name,
+    };
+    let response_packet = Packet::new(PacketType::PakwcSelectCharReply, &data)?;
+    send_packet(stream, &response_packet).await?;
+    Ok(())
+}

packet-service/src/main.rs

@@ -66,9 +66,13 @@ async fn handle_connection(stream: &mut TcpStream, pool: Arc<BufferPool>, auth_c
     }
 
     if let Some(state) = connection_service.get_connection(&connection_id) {
-        let session_id = state.session_id.unwrap();
-        let mut auth_client = auth_client.lock().await;
-        auth_client.logout(&session_id).await?;
+        let session_id = state.session_id.unwrap_or_default();
+        if !session_id.is_empty() {
+            let mut auth_client = auth_client.lock().await;
+            auth_client.logout(&session_id).await?;
+        } else {
+            warn!("No session found for {}", stream.peer_addr()?);
+        }
     }
     ACTIVE_CONNECTIONS.dec();
     Ok(())
@@ -95,7 +99,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let auth_node = get_service_address(&consul_url, "auth-service").await?;
 
     // Register service with Consul
-    let service_id = consul_registration::get_or_generate_service_id();
+    let service_id = consul_registration::get_or_generate_service_id(env!("CARGO_PKG_NAME"));
     let tags = vec!["version-1.0".to_string()];
     let mut meta = HashMap::new();
     consul_registration::register_service(

packet-service/src/packet_type.rs

@@ -20,8 +20,8 @@ pub enum PacketType {
     PakcsSrvSelectReq = 0x050D,
     PaklcSrvSelectReply = 0x050E,
     PakcsJoinServerReq = 0x050F,
-    PakscJoinServerReply = 0x0510,
-    PakcsJoinServerTokenReq = 0x0511,
+    PakcsJoinServerTokenReq = 0x0510,
+    PakscJoinServerReply = 0x0511,
     PakwcGmCommand = 0x0512,
     PakwcGlobalVars = 0x0513,
     PakwcGlobalFlags = 0x0514,
@@ -248,8 +248,8 @@ impl TryFrom<u16> for PacketType {
             0x050D => Ok(PacketType::PakcsSrvSelectReq),
             0x050E => Ok(PacketType::PaklcSrvSelectReply),
             0x050F => Ok(PacketType::PakcsJoinServerReq),
-            0x0510 => Ok(PacketType::PakscJoinServerReply),
-            0x0511 => Ok(PacketType::PakcsJoinServerTokenReq),
+            0x0510 => Ok(PacketType::PakcsJoinServerTokenReq),
+            0x0511 => Ok(PacketType::PakscJoinServerReply),
             0x0512 => Ok(PacketType::PakwcGmCommand),
             0x0513 => Ok(PacketType::PakwcGlobalVars),
             0x0514 => Ok(PacketType::PakwcGlobalFlags),

packet-service/src/router.rs

@@ -13,16 +13,20 @@ pub async fn route_packet(stream: &mut TcpStream, packet: Packet, auth_client: A
     debug!("Routing packet: {:?}", packet);
     match packet.packet_type {
         PacketType::PakcsAlive => Ok(()),
+        // Generic Server Packets
         PacketType::PakcsAcceptReq => auth::handle_accept_req(stream, packet).await,
-        PacketType::PakcsJoinServerTokenReq => auth::handle_join_server_req(stream, packet).await,
-        // Login Stuff 
+        PacketType::PakcsJoinServerTokenReq => auth::handle_join_server_req(stream, packet, auth_client, connection_service, connection_id).await,
+        // Login Packets
         PacketType::PakcsLoginTokenReq => auth::handle_login_req(stream, packet, auth_client, connection_service, connection_id, stream.peer_addr()?).await,
         PacketType::PakcsLogoutReq => auth::handle_logout_req(stream, packet, auth_client, connection_service, connection_id).await,
         PacketType::PakcsSrvSelectReq => auth::handle_server_select_req(stream, packet, connection_service, connection_id).await,
         PacketType::PakcsChannelListReq => auth::handle_channel_list_req(stream, packet).await,
         
-        // Character Stuff
-        PacketType::PakcsCharListReq => character::handle_char_list_req(stream, packet).await,
+        // Character Packets
+        PacketType::PakcsCharListReq => character::handle_char_list_req(stream, packet, connection_service, connection_id).await,
+        PacketType::PakcsCreateCharReq => character::handle_create_char_req(stream, packet, connection_service, connection_id).await,
+        PacketType::PakcsDeleteCharReq => character::handle_delete_char_req(stream, packet, connection_service, connection_id).await,
+        PacketType::PakcsSelectCharReq => character::handle_select_char_req(stream, packet, connection_service, connection_id).await,
         
         // 1 => chat::handle_chat(packet).await?,
         // 2 => movement::handle_movement(packet).await?,

proto/character.proto

@@ -3,14 +3,33 @@ syntax = "proto3";
 package character;
 
 service CharacterService {
-    rpc GetCharacterList(CharacterListRequest) returns (CharacterListResponse);
+    rpc GetCharacterList(GetCharacterListRequest) returns (GetCharacterListResponse);
 }
 
-message CharacterListRequest {
-    string token = 1;
-    string user_id = 2;
+message GetCharacterListRequest {
+    string user_id = 1;
 }
 
-message CharacterListResponse {
-    int32 count = 1;
+message GetCharacterListResponse {
+    repeated Character characters = 1;
 }
+
+message Character {
+    string character_id = 1; // Unique ID for the character
+    string name = 2;         // Name of the character
+    int32 level = 3;         // Character's level
+    int32 race = 4;          // Character's level
+    int32 job = 5;           // Character's class or type
+    int64 last_played = 6;   // Last played timestamp (Unix time)
+    int64 delete_time = 7;   // Time until character deletion (seconds)
+    int32 face = 8;          // Character's face
+    int32 hair = 9;          // Character's hair
+    repeated EquippedItem items = 10;
+}
+
+message EquippedItem {
+    int32 id = 1;
+    int32 gem_option = 2;
+    int32 socket = 3;
+    int32 grade = 4;
+}

session-service/src/main.rs

@@ -39,7 +39,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let health_check_url = format!("http://{}:{}/health", service_address, health_port);
 
     // Register service with Consul
-    let service_id = consul_registration::get_or_generate_service_id();
+    let service_id = consul_registration::get_or_generate_service_id(env!("CARGO_PKG_NAME"));
     let tags = vec!["version-1.0".to_string()];
     let meta = HashMap::new();
     consul_registration::register_service(

utils/src/consul_registration.rs

@@ -30,8 +30,8 @@ struct ConsulCheck {
 pub fn generate_service_id() -> String {
     Uuid::new_v4().to_string()
 }
-pub fn get_or_generate_service_id() -> String {
-    let package_name = env!("CARGO_PKG_NAME");
+pub fn get_or_generate_service_id(package_name: &str) -> String {
+    // let package_name = env!("CARGO_PKG_NAME");
     let file_name = format!("{}_service_id.txt", package_name);
     let path = Path::new(&file_name);
 

world-service/src/main.rs

@@ -28,7 +28,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let db_nodes = get_service_address(&consul_url, "database-service").await?;
 
     // Register service with Consul
-    let service_id = consul_registration::get_or_generate_service_id();
+    let service_id = consul_registration::get_or_generate_service_id(env!("CARGO_PKG_NAME"));
     let tags = vec!["version-1.0".to_string()];
     let mut meta = HashMap::new();
     meta.insert("name".to_string(), "Athena".to_string());