Include Name When Listing Peers

citadel-internal-service-types/src/lib.rs

@@ -498,10 +498,18 @@ pub struct LocalDBClearAllKVSuccess {
     pub request_id: Option<Uuid>,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct PeerInformation {
+    pub cid: u64,
+    pub online_status: bool,
+    pub name: Option<String>,
+    pub username: Option<String>,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ListAllPeersResponse {
     pub cid: u64,
-    pub online_status: HashMap<u64, bool>,
+    pub peer_information: HashMap<u64, PeerInformation>,
     pub request_id: Option<Uuid>,
 }
 
@@ -522,8 +530,7 @@ pub struct ListRegisteredPeersFailure {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ListRegisteredPeersResponse {
     pub cid: u64,
-    pub peers: HashMap<u64, PeerSessionInformation>,
-    pub online_status: HashMap<u64, bool>,
+    pub peers: HashMap<u64, PeerInformation>,
     pub request_id: Option<Uuid>,
 }
 

citadel-internal-service/src/kernel/requests/mod.rs

@@ -31,11 +31,14 @@ mod local_db;
 mod peer;
 
 #[async_recursion]
-pub async fn handle_request<T: IOInterface>(
+pub async fn handle_request<T>(
     this: &CitadelWorkspaceService<T>,
     uuid: Uuid,
     command: InternalServiceRequest,
-) -> Option<HandledRequestResult> {
+) -> Option<HandledRequestResult>
+where
+    T: IOInterface,
+{
     match &command {
         InternalServiceRequest::GetAccountInformation { .. } => {
             return get_account_information::handle(this, uuid, command).await

citadel-internal-service/src/kernel/requests/peer/list_all.rs

@@ -3,6 +3,7 @@ use crate::kernel::CitadelWorkspaceService;
 use citadel_internal_service_connector::io_interface::IOInterface;
 use citadel_internal_service_types::{
     InternalServiceRequest, InternalServiceResponse, ListAllPeersFailure, ListAllPeersResponse,
+    PeerInformation,
 };
 use citadel_sdk::prelude::ProtocolRemoteExt;
 use uuid::Uuid;
@@ -21,10 +22,20 @@ pub async fn handle<T: IOInterface>(
         Ok(peers) => {
             let peers = ListAllPeersResponse {
                 cid,
-                online_status: peers
+                peer_information: peers
                     .into_iter()
                     .filter(|peer| peer.cid != cid)
-                    .map(|peer| (peer.cid, peer.is_online))
+                    .map(|peer| {
+                        (
+                            peer.cid,
+                            PeerInformation {
+                                cid: peer.cid,
+                                online_status: peer.is_online,
+                                name: peer.full_name,
+                                username: peer.username,
+                            },
+                        )
+                    })
                     .collect(),
                 request_id: Some(request_id),
             };

citadel-internal-service/src/kernel/requests/peer/list_registered.rs

@@ -3,10 +3,9 @@ use crate::kernel::CitadelWorkspaceService;
 use citadel_internal_service_connector::io_interface::IOInterface;
 use citadel_internal_service_types::{
     InternalServiceRequest, InternalServiceResponse, ListRegisteredPeersFailure,
-    ListRegisteredPeersResponse, PeerSessionInformation,
+    ListRegisteredPeersResponse, PeerInformation,
 };
-use citadel_sdk::prelude::{ProtocolRemoteExt, TargetLockedRemote};
-use std::collections::HashMap;
+use citadel_sdk::prelude::ProtocolRemoteExt;
 use uuid::Uuid;
 
 pub async fn handle<T: IOInterface>(
@@ -21,32 +20,23 @@ pub async fn handle<T: IOInterface>(
 
     match remote.get_local_group_mutual_peers(cid).await {
         Ok(peers) => {
-            let mut accounts = HashMap::new();
-            for peer in &peers {
-                // TOOD: Do not unwrap below
-                let peer_username = remote
-                    .find_target(cid, peer.cid)
-                    .await
-                    .unwrap()
-                    .target_username()
-                    .cloned()
-                    .unwrap_or_default();
-                accounts.insert(
-                    peer.cid,
-                    PeerSessionInformation {
-                        cid,
-                        peer_cid: peer.cid,
-                        peer_username,
-                    },
-                );
-            }
-
             let peers = ListRegisteredPeersResponse {
                 cid,
-                peers: accounts,
-                online_status: peers
-                    .iter()
-                    .map(|peer| (peer.cid, peer.is_online))
+                peers: peers
+                    .clone()
+                    .into_iter()
+                    .filter(|peer| peer.cid != cid)
+                    .map(|peer| {
+                        (
+                            peer.cid,
+                            PeerInformation {
+                                cid,
+                                online_status: peer.is_online,
+                                name: peer.full_name,
+                                username: peer.username,
+                            },
+                        )
+                    })
                     .collect(),
                 request_id: Some(request_id),
             };

citadel-internal-service/tests/common/mod.rs

@@ -517,13 +517,13 @@ pub fn server_info_skip_cert_verification_with_password<'a>(
     server_test_node_skip_cert_verification_with_password(EmptyKernel, server_password, |_| {})
 }
 
-pub fn server_info_reactive_skip_cert_verification<'a, F: 'a, Fut: 'a>(
+pub fn server_info_reactive_skip_cert_verification<'a, F, Fut>(
     f: F,
     opts: impl FnOnce(&mut NodeBuilder),
 ) -> (NodeFuture<'a, Box<dyn NetKernel + 'a>>, SocketAddr)
 where
-    F: Fn(ConnectionSuccess, ClientServerRemote) -> Fut + Send + Sync,
-    Fut: Future<Output = Result<(), NetworkError>> + Send + Sync,
+    F: Fn(ConnectionSuccess, ClientServerRemote) -> Fut + Send + Sync + 'a,
+    Fut: Future<Output = Result<(), NetworkError>> + Send + Sync + 'a,
 {
     server_test_node_skip_cert_verification(
         Box::new(ClientConnectListenerKernel::new(f)) as Box<dyn NetKernel>,

citadel-internal-service/tests/service.rs

@@ -502,8 +502,8 @@ mod tests {
 
         let resp = from_service.recv().await.unwrap();
         if let InternalServiceResponse::ListAllPeersResponse(list) = resp {
-            assert_eq!(list.online_status.len(), 1);
-            assert!(list.online_status.contains_key(&peer_cid))
+            assert_eq!(list.peer_information.len(), 1);
+            assert!(list.peer_information.contains_key(&peer_cid))
         } else {
             panic!("Invalid ListAllPeers response")
         }
@@ -517,8 +517,8 @@ mod tests {
 
         let resp = from_service.recv().await.unwrap();
         if let InternalServiceResponse::ListRegisteredPeersResponse(list) = resp {
-            assert_eq!(list.online_status.len(), 1);
-            assert!(list.online_status.contains_key(&peer_cid))
+            assert_eq!(list.peers.len(), 1);
+            assert!(list.peers.contains_key(&peer_cid))
         } else {
             panic!("Invalid ListAllPeers response")
         }