Fixed call_token requests timing out

src/calls/call_manager.rs

@@ -1,6 +1,5 @@
-use std::sync::Arc;
-
 use once_cell::sync::Lazy;
+use std::sync::Arc;
 use tokio::sync::RwLock;
 use uuid::Uuid;
 
@@ -11,7 +10,8 @@ static CALL_GROUPS: Lazy<RwLock<Vec<Arc<CallGroup>>>> = Lazy::new(|| RwLock::new
 pub async fn get_call_invites(user_id: Uuid) -> Vec<Arc<Caller>> {
     let mut callers = Vec::new();
     for cg in CALL_GROUPS.read().await.iter() {
-        for member in cg.members.read().await.iter() {
+        let members = cg.members.read().await;
+        for member in members.iter() {
             if member.user_id == user_id {
                 callers.push(member.clone());
             }
@@ -23,60 +23,95 @@ pub async fn get_call_invites(user_id: Uuid) -> Vec<Arc<Caller>> {
 pub async fn get_call_groups(user_id: Uuid) -> Vec<Arc<CallGroup>> {
     let mut call_groups = Vec::new();
     for cg in CALL_GROUPS.read().await.iter() {
-        for member in cg.members.read().await.iter() {
+        let is_member = {
-            if member.user_id == user_id {
+            let members = cg.members.read().await;
+            members.iter().any(|m| m.user_id == user_id)
+        };
+
+        if is_member {
             call_groups.push(cg.clone());
         }
     }
-    }
     call_groups
 }
 
 pub async fn get_call_token(user_id: Uuid, call_id: Uuid) -> Option<String> {
-    let call_groups = { CALL_GROUPS.read().await.clone() };
+    let existing_group = {
+        let call_groups = CALL_GROUPS.read().await;
+        call_groups.iter().find(|g| g.call_id == call_id).cloned()
+    };
 
-    for cg in call_groups.iter() {
+    if let Some(cg) = existing_group {
-        if cg.call_id == call_id {
+        let mut members = cg.members.write().await;
-            for member in cg.members.read().await.iter() {
+
-                if member.user_id == user_id {
+        if let Some(member) = members.iter().find(|m| m.user_id == user_id) {
             return Some(member.create_token());
         }
+
+        let new_caller = Arc::new(Caller::new(user_id, call_id, user_id));
+        let token = new_caller.create_token();
+
+        members.push(new_caller);
+
+        return Some(token);
     }
-            return None;
+
+    let mut call_groups = CALL_GROUPS.write().await;
+
+    if let Some(cg) = call_groups.iter().find(|g| g.call_id == call_id) {
+        let cg_clone = cg.clone();
+        drop(call_groups);
+
+        let mut members = cg_clone.members.write().await;
+        if let Some(member) = members.iter().find(|m| m.user_id == user_id) {
+            return Some(member.create_token());
         }
+        let new_caller = Arc::new(Caller::new(user_id, call_id, user_id));
+        let token = new_caller.create_token();
+        members.push(new_caller);
+        return Some(token);
     }
-    let caller = Arc::new(Caller::new(user_id, user_id, call_id));
+
+    let caller = Arc::new(Caller::new(user_id, call_id, user_id));
     let call_group = CallGroup::new(call_id, caller.clone());
-    {
+
-        CALL_GROUPS.write().await.push(Arc::new(call_group));
+    call_groups.push(Arc::new(call_group));
-    }
+
     Some(caller.create_token())
 }
 
 pub async fn add_invite(call_id: Uuid, inviter_id: Uuid, invitee_id: Uuid) -> bool {
+    let target_group = {
         let call_groups = CALL_GROUPS.read().await;
-    for cg in call_groups.iter() {
+        call_groups.iter().find(|g| g.call_id == call_id).cloned()
-        if cg.call_id == call_id {
+    };
-            for member in cg.members.read().await.iter() {
+
-                if member.user_id == inviter_id {
+    if let Some(cg) = target_group {
-                    cg.clone().add_member(inviter_id, invitee_id).await;
+        let mut members = cg.members.write().await;
+
+        let is_inviter_member = members.iter().any(|m| m.user_id == inviter_id);
+
+        if is_inviter_member {
+            if !members.iter().any(|m| m.user_id == invitee_id) {
+                members.push(Arc::new(Caller::new(invitee_id, call_id, inviter_id)));
+            }
             return true;
         }
     }
-            return false;
-        }
-    }
     false
 }
 
 pub async fn get_call_group_by_user(user_id: Uuid) -> Option<Arc<CallGroup>> {
     let call_groups = CALL_GROUPS.read().await;
     for cg in call_groups.iter() {
-        for member in cg.members.read().await.iter() {
+        let is_member = {
-            if member.user_id == user_id {
+            let members = cg.members.read().await;
+            members.iter().any(|m| m.user_id == user_id)
+        };
+
+        if is_member {
             return Some(cg.clone());
         }
     }
-    }
     None
 }

src/data/communication.rs

@@ -178,11 +178,11 @@ pub enum CommunicationType {
     add_community,
     remove_community,
     get_communities,
-    challenge,
-    challenge_response,
     register,
     register_response,
     identification,
+    challenge,
+    challenge_response,
     identification_response,
     ping,
     pong,
@@ -230,11 +230,11 @@ impl CommunicationType {
             "addcommunity" => CommunicationType::add_community,
             "removecommunity" => CommunicationType::remove_community,
             "getcommunities" => CommunicationType::get_communities,
-            "challenge" => CommunicationType::challenge,
-            "challengeresponse" => CommunicationType::challenge_response,
             "register" => CommunicationType::register,
             "registerresponse" => CommunicationType::register_response,
             "identification" => CommunicationType::identification,
+            "challenge" => CommunicationType::challenge,
+            "challengeresponse" => CommunicationType::challenge_response,
             "identificationresponse" => CommunicationType::identification_response,
             "ping" => CommunicationType::ping,
             "pong" => CommunicationType::pong,