Always include room id in protos

Antonio Scandurra created 3 years ago

This is redundant, but it futures-proof the ability to talk about
multiple rooms at any given time and feels safer in terms of race
conditions.

Change summary

crates/call/src/call.rs        | 22 +++++++++++++++++++---
crates/collab/src/rpc.rs       |  4 +++-
crates/collab/src/rpc/store.rs | 11 +++++++++--
crates/rpc/proto/zed.proto     |  7 +++++--
4 files changed, 36 insertions(+), 8 deletions(-)

Detailed changes

crates/call/src/call.rs

@@ -145,10 +145,19 @@ impl ActiveCall {
         recipient_user_id: u64,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<()>> {
+        let room_id = if let Some(room) = self.room() {
+            room.read(cx).id()
+        } else {
+            return Task::ready(Err(anyhow!("no active call")));
+        };
+
         let client = self.client.clone();
         cx.foreground().spawn(async move {
             client
-                .request(proto::CancelCall { recipient_user_id })
+                .request(proto::CancelCall {
+                    room_id,
+                    recipient_user_id,
+                })
                 .await?;
             anyhow::Ok(())
         })
@@ -178,8 +187,15 @@ impl ActiveCall {
     }
 
     pub fn decline_incoming(&mut self) -> Result<()> {
-        *self.incoming_call.0.borrow_mut() = None;
-        self.client.send(proto::DeclineCall {})?;
+        let call = self
+            .incoming_call
+            .0
+            .borrow_mut()
+            .take()
+            .ok_or_else(|| anyhow!("no incoming call"))?;
+        self.client.send(proto::DeclineCall {
+            room_id: call.room_id,
+        })?;
         Ok(())
     }
 

crates/collab/src/rpc.rs

@@ -723,6 +723,7 @@ impl Server {
     ) -> Result<()> {
         let mut store = self.store().await;
         let (room, recipient_connection_ids) = store.cancel_call(
+            request.payload.room_id,
             UserId::from_proto(request.payload.recipient_user_id),
             request.sender_id,
         )?;
@@ -741,7 +742,8 @@ impl Server {
         message: TypedEnvelope<proto::DeclineCall>,
     ) -> Result<()> {
         let mut store = self.store().await;
-        let (room, recipient_connection_ids) = store.call_declined(message.sender_id)?;
+        let (room, recipient_connection_ids) =
+            store.decline_call(message.payload.room_id, message.sender_id)?;
         for recipient_id in recipient_connection_ids {
             self.peer
                 .send(recipient_id, proto::CallCanceled {})

crates/collab/src/rpc/store.rs

@@ -587,6 +587,7 @@ impl Store {
 
     pub fn cancel_call(
         &mut self,
+        room_id: RoomId,
         recipient_user_id: UserId,
         canceller_connection_id: ConnectionId,
     ) -> Result<(&proto::Room, HashSet<ConnectionId>)> {
@@ -609,7 +610,11 @@ impl Store {
             .ok_or_else(|| anyhow!("no active call for recipient"))?;
 
         anyhow::ensure!(
-            canceller_active_call.room_id == recipient_active_call.room_id,
+            canceller_active_call.room_id == room_id,
+            "users are on different calls"
+        );
+        anyhow::ensure!(
+            recipient_active_call.room_id == room_id,
             "users are on different calls"
         );
         anyhow::ensure!(
@@ -630,8 +635,9 @@ impl Store {
         Ok((room, recipient.connection_ids.clone()))
     }
 
-    pub fn call_declined(
+    pub fn decline_call(
         &mut self,
+        room_id: RoomId,
         recipient_connection_id: ConnectionId,
     ) -> Result<(&proto::Room, Vec<ConnectionId>)> {
         let recipient_user_id = self.user_id_for_connection(recipient_connection_id)?;
@@ -640,6 +646,7 @@ impl Store {
             .get_mut(&recipient_user_id)
             .ok_or_else(|| anyhow!("no such connection"))?;
         if let Some(active_call) = recipient.active_call.take() {
+            anyhow::ensure!(active_call.room_id == room_id, "no such room");
             let recipient_connection_ids = self
                 .connection_ids_for_user(recipient_user_id)
                 .collect::<Vec<_>>();

crates/rpc/proto/zed.proto

@@ -193,10 +193,13 @@ message IncomingCall {
 message CallCanceled {}
 
 message CancelCall {
-    uint64 recipient_user_id = 1;
+    uint64 room_id = 1;
+    uint64 recipient_user_id = 2;
 }
 
-message DeclineCall {}
+message DeclineCall {
+    uint64 room_id = 1;
+}
 
 message UpdateParticipantLocation {
     uint64 room_id = 1;