Change get_serving_addrs to get_serving_games

Author: DogLooksGood

transactor/src/context.rs

@@ -1,7 +1,7 @@
 use crate::blacklist::Blacklist;
 use crate::component::{CheckpointBroadcastFrame, CloseReason, WrappedStorage, WrappedTransport};
 use crate::frame::SignalFrame;
-use crate::game_manager::GameManager;
+use crate::game_manager::{ServingGame, GameManager};
 use race_api::event::{Event, Message};
 use race_core::error::{Error, Result};
 use race_core::encryptor::{EncryptorT, NodePublicKeyRaw};
@@ -197,8 +197,8 @@ impl ApplicationContext {
         self.game_manager.send_message(game_addr, message).await
     }
 
-    pub async fn get_serving_addrs(&self) -> Vec<String> {
-        self.game_manager.get_serving_addrs().await
+    pub async fn get_serving_games(&self) -> Vec<ServingGame> {
+        self.game_manager.get_serving_games().await
     }
 
     pub async fn get_broadcast_and_backlogs(

transactor/src/game_manager.rs

@@ -11,13 +11,27 @@ use std::sync::Arc;
 use tokio::sync::{broadcast, mpsc, Mutex, RwLock};
 use tokio::task::JoinHandle;
 use tracing::{error, info, warn};
+use serde::Serialize;
 
 use crate::blacklist::Blacklist;
 use crate::component::{CheckpointBroadcastFrame, BridgeToParent, CloseReason, WrappedStorage, WrappedTransport};
 use crate::frame::{EventFrame, SignalFrame};
 use crate::handle::Handle;
 use crate::utils::current_timestamp;
 
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ServingGame {
+    addr: String,
+    bundle_addr: String,
+}
+
+impl ServingGame {
+    pub fn new(addr: String, bundle_addr: String) -> Self {
+        Self { addr, bundle_addr }
+    }
+}
+
 pub struct GameManager {
     games: Arc<RwLock<HashMap<String, Handle>>>,
 }
@@ -30,6 +44,7 @@ impl Default for GameManager {
     }
 }
 
+
 impl GameManager {
     /// Load a child game
     pub async fn launch_sub_game(
@@ -150,9 +165,10 @@ impl GameManager {
         }
     }
 
-    pub async fn get_serving_addrs(&self) -> Vec<String> {
+    pub async fn get_serving_games(&self) -> Vec<ServingGame> {
         let games = self.games.read().await;
-        games.keys().cloned().collect()
+
+        games.iter().map(|(addr, handle)| ServingGame::new(addr.to_owned(), handle.bundle_addr())).collect()
     }
 
     pub async fn is_game_loaded(&self, game_addr: &str) -> bool {

transactor/src/handle.rs

@@ -124,6 +124,14 @@ impl Handle {
         }
     }
 
+    pub fn bundle_addr(&self) -> String {
+        match self {
+            Handle::Transactor(h) => h.bundle_addr.clone(),
+            Handle::Validator(h) => h.bundle_addr.clone(),
+            Handle::SubGame(h) => h.bundle_addr.clone(),
+        }
+    }
+
     /// Wait handle until it's shutted down.  A
     /// [SignalFrame::RemoveGame] will be sent through `signal_tx`.
     pub fn wait(&mut self, signal_tx: mpsc::Sender<SignalFrame>) -> JoinHandle<CloseReason> {

transactor/src/handle/subgame.rs

@@ -15,6 +15,7 @@ use race_env::TransactorConfig;
 #[allow(dead_code)]
 pub struct SubGameHandle {
     pub(crate) addr: String,
+    pub(crate) bundle_addr: String,
     pub(crate) event_bus: EventBus,
     pub(crate) handles: Vec<PortsHandle>,
     pub(crate) broadcaster: Broadcaster,
@@ -41,6 +42,8 @@ impl SubGameHandle {
             .await?
             .ok_or(Error::GameBundleNotFound)?;
 
+        let bundle_addr = sub_game_init.spec.bundle_addr.clone();
+
         // Build an InitAccount
         let game_context = GameContext::try_new_with_sub_game_spec(sub_game_init)?;
         let access_version = game_context.access_version();
@@ -86,6 +89,7 @@ impl SubGameHandle {
 
         Ok(Self {
             addr: format!("{}:{}", game_addr, game_id),
+            bundle_addr,
             event_bus,
             handles: vec![broadcaster_handle, bridge_handle, event_loop_handle],
             broadcaster,

transactor/src/handle/transactor.rs

@@ -18,6 +18,7 @@ use tracing::info;
 #[allow(dead_code)]
 pub struct TransactorHandle {
     pub(crate) addr: String,
+    pub(crate) bundle_addr: String,
     pub(crate) handles: Vec<PortsHandle>,
     pub(crate) event_bus: EventBus,
     pub(crate) broadcaster: Broadcaster,
@@ -169,6 +170,7 @@ impl TransactorHandle {
 
         Ok(Self {
             addr: game_account.addr.clone(),
+            bundle_addr: game_account.bundle_addr.clone(),
             event_bus,
             handles: vec![
                 broadcaster_handle,

transactor/src/handle/validator.rs

@@ -18,6 +18,7 @@ use tracing::info;
 #[allow(dead_code)]
 pub struct ValidatorHandle {
     pub(crate) addr: String,
+    pub(crate) bundle_addr: String,
     pub(crate) event_bus: EventBus,
     pub(crate) handles: Vec<PortsHandle>,
     pub(crate) bridge_parent: EventBridgeParent,
@@ -124,6 +125,7 @@ impl ValidatorHandle {
         event_bus.attach(&mut subscriber_handle).await;
         Ok(Self {
             addr: game_account.addr.clone(),
+            bundle_addr: game_account.bundle_addr.clone(),
             event_bus,
             handles: vec![
                 subscriber_handle,

transactor/src/server.rs

@@ -2,6 +2,7 @@ use std::{net::SocketAddr, sync::Arc};
 
 use crate::context::ApplicationContext;
 use crate::utils;
+use crate::game_manager::ServingGame;
 use borsh::BorshDeserialize;
 use hyper::Method;
 use jsonrpsee::core::error::Error as RpcError;
@@ -82,9 +83,8 @@ fn ping(_: Params<'_>, _: &ApplicationContext) -> Result<String, RpcError> {
     Ok("pong".to_string())
 }
 
-
-async fn get_serving_addrs(_: Params<'_>, context: Arc<ApplicationContext>) -> Result<Vec<String>, RpcError> {
-    Ok(context.get_serving_addrs().await)
+async fn get_serving_games(_: Params<'_>, context: Arc<ApplicationContext>) -> Result<Vec<ServingGame>, RpcError> {
+    Ok(context.get_serving_games().await)
 }
 
 async fn submit_message(
@@ -344,7 +344,7 @@ pub async fn run_server(
     module.register_async_method("get_checkpoint", get_checkpoint)?;
     module.register_async_method("get_latest_checkpoints", get_latest_checkpoints)?;
     module.register_async_method("attach_game", attach_game)?;
-    module.register_async_method("get_serving_addrs", get_serving_addrs)?;
+    module.register_async_method("get_serving_games", get_serving_games)?;
     module.register_async_method("submit_event", submit_event)?;
     module.register_async_method("submit_message", submit_message)?;
     module.register_async_method("exit_game", exit_game)?;