- add: consul tags and metadata

- update: login reply now requests for the character services from consul to build the server list

packet-service/src/handlers/auth.rs

@@ -1,11 +1,14 @@
 use std::collections::HashMap;
+use std::env;
 use tonic::{Code, Status};
 use std::error::Error;
 use std::sync::Arc;
 use tokio::net::TcpStream;
 use tokio::sync::Mutex;
 use tracing::{debug, error, info, warn};
+use utils::service_discovery;
 use crate::auth_client::AuthClient;
+use crate::handlers::null_string::NullTerminatedString;
 use crate::packet::{send_packet, Packet, PacketPayload};
 use crate::packet_type::PacketType;
 use crate::packets::cli_accept_req::CliAcceptReq;
@@ -13,7 +16,7 @@ use crate::packets::cli_join_server_req::CliJoinServerReq;
 use crate::packets::cli_login_req::CliLoginReq;
 use crate::packets::{srv_accept_reply, srv_login_reply};
 use crate::packets::srv_accept_reply::SrvAcceptReply;
-use crate::packets::srv_login_reply::SrvLoginReply;
+use crate::packets::srv_login_reply::{ServerInfo, SrvLoginReply};
 
 pub(crate) async fn handle_accept_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
     let data = CliAcceptReq::decode(packet.payload.as_slice());
@@ -50,7 +53,30 @@ pub(crate) async fn handle_login_req(stream: &mut TcpStream, packet: Packet, aut
                 send_packet(stream, &response_packet).await?;
             } else {
                 debug!("Successfully logged in");
-                let data = SrvLoginReply { result: srv_login_reply::Result::Ok, right: 0, type_: 0, servers_info: Vec::new() };
+                
+                let consul_url = env::var("CONSUL_URL").unwrap_or_else(|_| "http://127.0.0.1:8500".to_string());
+                let servers = service_discovery::get_service_address(&consul_url, "character-service").await.unwrap_or_else(|err| {
+                    warn!(err);
+                    Vec::new()
+                });
+                
+                if servers.len() == 0 {
+                    let data = SrvLoginReply { result: srv_login_reply::Result::Failed, right: 0, type_: 0, servers_info: Vec::new() };
+                    let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
+                    send_packet(stream, &response_packet).await?;
+                    return Ok(());
+                }
+                
+                let mut server_info: Vec<ServerInfo> = Vec::new();
+                let mut id = 0;
+                for server in servers {
+                    let name = server.ServiceMeta.get("name").unwrap_or(&"".to_string()).clone();
+                    let is_test = server.ServiceTags.contains(&"test".to_string()) || server.ServiceTags.contains(&"staging".to_string());
+                    server_info.push(ServerInfo { test: u8::from(is_test), name: NullTerminatedString::new(&name), id});
+                    id = id + 1;
+                }
+                
+                let data = SrvLoginReply { result: srv_login_reply::Result::Ok, right: 0, type_: 0, servers_info: server_info };
                 let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
                 send_packet(stream, &response_packet).await?;
             }

packet-service/src/main.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::env;
 use std::error::Error;
 use std::net::ToSocketAddrs;
@@ -85,12 +86,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Register service with Consul
     let service_id = consul_registration::generate_service_id();
+    let tags = vec!["version-1.0".to_string()];
+    let mut meta = HashMap::new();
+    meta.insert("name".to_string(), "Athena".to_string());
     consul_registration::register_service(
         &consul_url,
         service_id.as_str(),
         service_name.as_str(),
         service_address,
         service_port.parse().unwrap_or(50052),
+        tags,
+        meta,
         &health_check_url,
     )
         .await?;
@@ -102,7 +108,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tokio::spawn(warp::serve(health_route).run(health_check_endpoint_addr.to_socket_addrs()?.next().unwrap()));
 
     let auth_address = auth_node.get(0).unwrap();
-    let auth_url = format!("http://{}:{}", auth_address.0, auth_address.1);
+    let auth_url = format!("http://{}:{}", auth_address.ServiceAddress, auth_address.ServicePort);
     let auth_client = Arc::new(Mutex::new(AuthClient::connect(&auth_url).await?));
 
     let full_addr = format!("{}:{}", &addr, port);