Detailed changes
@@ -1,13 +1,17 @@
use crate::{Client, Subscription, User, UserStore};
use anyhow::Result;
+use collections::HashMap;
use futures::Future;
use gpui::{AsyncAppContext, Entity, ModelContext, ModelHandle, Task};
use rpc::{proto, TypedEnvelope};
use std::sync::Arc;
+type ChannelId = u64;
+
pub struct ChannelStore {
channels: Vec<Arc<Channel>>,
channel_invitations: Vec<Arc<Channel>>,
+ channel_participants: HashMap<ChannelId, Vec<ChannelId>>,
client: Arc<Client>,
user_store: ModelHandle<UserStore>,
_rpc_subscription: Subscription,
@@ -15,9 +19,9 @@ pub struct ChannelStore {
#[derive(Clone, Debug, PartialEq)]
pub struct Channel {
- pub id: u64,
+ pub id: ChannelId,
pub name: String,
- pub parent_id: Option<u64>,
+ pub parent_id: Option<ChannelId>,
pub depth: usize,
}
@@ -37,6 +41,7 @@ impl ChannelStore {
Self {
channels: vec![],
channel_invitations: vec![],
+ channel_participants: Default::default(),
client,
user_store,
_rpc_subscription: rpc_subscription,
@@ -51,15 +56,15 @@ impl ChannelStore {
&self.channel_invitations
}
- pub fn channel_for_id(&self, channel_id: u64) -> Option<Arc<Channel>> {
+ pub fn channel_for_id(&self, channel_id: ChannelId) -> Option<Arc<Channel>> {
self.channels.iter().find(|c| c.id == channel_id).cloned()
}
pub fn create_channel(
&self,
name: &str,
- parent_id: Option<u64>,
- ) -> impl Future<Output = Result<u64>> {
+ parent_id: Option<ChannelId>,
+ ) -> impl Future<Output = Result<ChannelId>> {
let client = self.client.clone();
let name = name.to_owned();
async move {
@@ -72,7 +77,7 @@ impl ChannelStore {
pub fn invite_member(
&self,
- channel_id: u64,
+ channel_id: ChannelId,
user_id: u64,
admin: bool,
) -> impl Future<Output = Result<()>> {
@@ -91,7 +96,7 @@ impl ChannelStore {
pub fn respond_to_channel_invite(
&mut self,
- channel_id: u64,
+ channel_id: ChannelId,
accept: bool,
) -> impl Future<Output = Result<()>> {
let client = self.client.clone();
@@ -107,7 +112,7 @@ impl ChannelStore {
false
}
- pub fn remove_channel(&self, channel_id: u64) -> impl Future<Output = Result<()>> {
+ pub fn remove_channel(&self, channel_id: ChannelId) -> impl Future<Output = Result<()>> {
let client = self.client.clone();
async move {
client.request(proto::RemoveChannel { channel_id }).await?;
@@ -117,7 +122,7 @@ impl ChannelStore {
pub fn remove_member(
&self,
- channel_id: u64,
+ channel_id: ChannelId,
user_id: u64,
cx: &mut ModelContext<Self>,
) -> Task<Result<()>> {
@@ -126,13 +131,13 @@ impl ChannelStore {
pub fn channel_members(
&self,
- channel_id: u64,
+ channel_id: ChannelId,
cx: &mut ModelContext<Self>,
) -> Task<Result<Vec<Arc<User>>>> {
todo!()
}
- pub fn add_guest_channel(&self, channel_id: u64) -> Task<Result<()>> {
+ pub fn add_guest_channel(&self, channel_id: ChannelId) -> Task<Result<()>> {
todo!()
}
@@ -212,7 +212,13 @@ impl Database {
.map(|participant| participant.user_id),
);
- let room = self.get_room(room_id, &tx).await?;
+ let (channel_id, room) = self.get_channel_room(room_id, &tx).await?;
+ let channel_members = if let Some(channel_id) = channel_id {
+ self.get_channel_members_internal(channel_id, &tx).await?
+ } else {
+ Vec::new()
+ };
+
// Delete the room if it becomes empty.
if room.participants.is_empty() {
project::Entity::delete_many()
@@ -224,6 +230,8 @@ impl Database {
Ok(RefreshedRoom {
room,
+ channel_id,
+ channel_members,
stale_participant_user_ids,
canceled_calls_to_user_ids,
})
@@ -1178,7 +1186,7 @@ impl Database {
user_id: UserId,
connection: ConnectionId,
live_kit_room: &str,
- ) -> Result<ChannelRoom> {
+ ) -> Result<proto::Room> {
self.transaction(|tx| async move {
let room = room::ActiveModel {
live_kit_room: ActiveValue::set(live_kit_room.into()),
@@ -1217,7 +1225,7 @@ impl Database {
calling_connection: ConnectionId,
called_user_id: UserId,
initial_project_id: Option<ProjectId>,
- ) -> Result<RoomGuard<(ChannelRoom, proto::IncomingCall)>> {
+ ) -> Result<RoomGuard<(proto::Room, proto::IncomingCall)>> {
self.room_transaction(room_id, |tx| async move {
room_participant::ActiveModel {
room_id: ActiveValue::set(room_id),
@@ -1246,7 +1254,7 @@ impl Database {
&self,
room_id: RoomId,
called_user_id: UserId,
- ) -> Result<RoomGuard<ChannelRoom>> {
+ ) -> Result<RoomGuard<proto::Room>> {
self.room_transaction(room_id, |tx| async move {
room_participant::Entity::delete_many()
.filter(
@@ -1266,7 +1274,7 @@ impl Database {
&self,
expected_room_id: Option<RoomId>,
user_id: UserId,
- ) -> Result<Option<RoomGuard<ChannelRoom>>> {
+ ) -> Result<Option<RoomGuard<proto::Room>>> {
self.optional_room_transaction(|tx| async move {
let mut filter = Condition::all()
.add(room_participant::Column::UserId.eq(user_id))
@@ -1303,7 +1311,7 @@ impl Database {
room_id: RoomId,
calling_connection: ConnectionId,
called_user_id: UserId,
- ) -> Result<RoomGuard<ChannelRoom>> {
+ ) -> Result<RoomGuard<proto::Room>> {
self.room_transaction(room_id, |tx| async move {
let participant = room_participant::Entity::find()
.filter(
@@ -1340,7 +1348,7 @@ impl Database {
user_id: UserId,
channel_id: Option<ChannelId>,
connection: ConnectionId,
- ) -> Result<RoomGuard<ChannelRoom>> {
+ ) -> Result<RoomGuard<JoinRoom>> {
self.room_transaction(room_id, |tx| async move {
if let Some(channel_id) = channel_id {
channel_member::Entity::find()
@@ -1396,7 +1404,16 @@ impl Database {
}
let room = self.get_room(room_id, &tx).await?;
- Ok(room)
+ let channel_members = if let Some(channel_id) = channel_id {
+ self.get_channel_members_internal(channel_id, &tx).await?
+ } else {
+ Vec::new()
+ };
+ Ok(JoinRoom {
+ room,
+ channel_id,
+ channel_members,
+ })
})
.await
}
@@ -1690,9 +1707,18 @@ impl Database {
});
}
- let room = self.get_room(room_id, &tx).await?;
+ let (channel_id, room) = self.get_channel_room(room_id, &tx).await?;
+
+ let channel_members = if let Some(channel_id) = channel_id {
+ self.get_channel_members_internal(channel_id, &tx).await?
+ } else {
+ Vec::new()
+ };
+
Ok(RejoinedRoom {
room,
+ channel_id,
+ channel_members,
rejoined_projects,
reshared_projects,
})
@@ -1833,7 +1859,7 @@ impl Database {
.exec(&*tx)
.await?;
- let room = self.get_room(room_id, &tx).await?;
+ let (channel_id, room) = self.get_channel_room(room_id, &tx).await?;
let deleted = if room.participants.is_empty() {
let result = room::Entity::delete_by_id(room_id)
.filter(room::Column::ChannelId.is_null())
@@ -1844,8 +1870,15 @@ impl Database {
false
};
+ let channel_members = if let Some(channel_id) = channel_id {
+ self.get_channel_members_internal(channel_id, &tx).await?
+ } else {
+ Vec::new()
+ };
let left_room = LeftRoom {
room,
+ channel_id,
+ channel_members,
left_projects,
canceled_calls_to_user_ids,
deleted,
@@ -1868,7 +1901,7 @@ impl Database {
project_id: ProjectId,
leader_connection: ConnectionId,
follower_connection: ConnectionId,
- ) -> Result<RoomGuard<ChannelRoom>> {
+ ) -> Result<RoomGuard<proto::Room>> {
let room_id = self.room_id_for_project(project_id).await?;
self.room_transaction(room_id, |tx| async move {
follower::ActiveModel {
@@ -1898,7 +1931,7 @@ impl Database {
project_id: ProjectId,
leader_connection: ConnectionId,
follower_connection: ConnectionId,
- ) -> Result<RoomGuard<ChannelRoom>> {
+ ) -> Result<RoomGuard<proto::Room>> {
let room_id = self.room_id_for_project(project_id).await?;
self.room_transaction(room_id, |tx| async move {
follower::Entity::delete_many()
@@ -1930,7 +1963,7 @@ impl Database {
room_id: RoomId,
connection: ConnectionId,
location: proto::ParticipantLocation,
- ) -> Result<RoomGuard<ChannelRoom>> {
+ ) -> Result<RoomGuard<proto::Room>> {
self.room_transaction(room_id, |tx| async {
let tx = tx;
let location_kind;
@@ -2042,8 +2075,16 @@ impl Database {
}),
})
}
+ async fn get_room(&self, room_id: RoomId, tx: &DatabaseTransaction) -> Result<proto::Room> {
+ let (_, room) = self.get_channel_room(room_id, tx).await?;
+ Ok(room)
+ }
- async fn get_room(&self, room_id: RoomId, tx: &DatabaseTransaction) -> Result<ChannelRoom> {
+ async fn get_channel_room(
+ &self,
+ room_id: RoomId,
+ tx: &DatabaseTransaction,
+ ) -> Result<(Option<ChannelId>, proto::Room)> {
let db_room = room::Entity::find_by_id(room_id)
.one(tx)
.await?
@@ -2147,6 +2188,28 @@ impl Database {
});
}
+ Ok((
+ db_room.channel_id,
+ proto::Room {
+ id: db_room.id.to_proto(),
+ live_kit_room: db_room.live_kit_room,
+ participants: participants.into_values().collect(),
+ pending_participants,
+ followers,
+ },
+ ))
+ }
+
+ async fn get_channel_members_for_room(
+ &self,
+ room_id: RoomId,
+ tx: &DatabaseTransaction,
+ ) -> Result<Vec<UserId>> {
+ let db_room = room::Model {
+ id: room_id,
+ ..Default::default()
+ };
+
let channel_users =
if let Some(channel) = db_room.find_related(channel::Entity).one(tx).await? {
self.get_channel_members_internal(channel.id, tx).await?
@@ -2154,16 +2217,7 @@ impl Database {
Vec::new()
};
- Ok(ChannelRoom {
- room: proto::Room {
- id: db_room.id.to_proto(),
- live_kit_room: db_room.live_kit_room,
- participants: participants.into_values().collect(),
- pending_participants,
- followers,
- },
- channel_participants: channel_users,
- })
+ Ok(channel_users)
}
// projects
@@ -2193,7 +2247,7 @@ impl Database {
room_id: RoomId,
connection: ConnectionId,
worktrees: &[proto::WorktreeMetadata],
- ) -> Result<RoomGuard<(ProjectId, ChannelRoom)>> {
+ ) -> Result<RoomGuard<(ProjectId, proto::Room)>> {
self.room_transaction(room_id, |tx| async move {
let participant = room_participant::Entity::find()
.filter(
@@ -2264,7 +2318,7 @@ impl Database {
&self,
project_id: ProjectId,
connection: ConnectionId,
- ) -> Result<RoomGuard<(ChannelRoom, Vec<ConnectionId>)>> {
+ ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
let room_id = self.room_id_for_project(project_id).await?;
self.room_transaction(room_id, |tx| async move {
let guest_connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
@@ -2291,7 +2345,7 @@ impl Database {
project_id: ProjectId,
connection: ConnectionId,
worktrees: &[proto::WorktreeMetadata],
- ) -> Result<RoomGuard<(ChannelRoom, Vec<ConnectionId>)>> {
+ ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
let room_id = self.room_id_for_project(project_id).await?;
self.room_transaction(room_id, |tx| async move {
let project = project::Entity::find_by_id(project_id)
@@ -2868,7 +2922,7 @@ impl Database {
&self,
project_id: ProjectId,
connection: ConnectionId,
- ) -> Result<RoomGuard<(ChannelRoom, LeftProject)>> {
+ ) -> Result<RoomGuard<(proto::Room, LeftProject)>> {
let room_id = self.room_id_for_project(project_id).await?;
self.room_transaction(room_id, |tx| async move {
let result = project_collaborator::Entity::delete_many()
@@ -3342,7 +3396,10 @@ impl Database {
.await
}
- pub async fn get_channels(&self, user_id: UserId) -> Result<Vec<Channel>> {
+ pub async fn get_channels(
+ &self,
+ user_id: UserId,
+ ) -> Result<(Vec<Channel>, HashMap<ChannelId, Vec<UserId>>)> {
self.transaction(|tx| async move {
let tx = tx;
@@ -3379,7 +3436,31 @@ impl Database {
drop(rows);
- Ok(channels)
+ #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
+ enum QueryUserIdsAndChannelIds {
+ ChannelId,
+ UserId,
+ }
+
+ let mut participants = room_participant::Entity::find()
+ .inner_join(room::Entity)
+ .filter(room::Column::ChannelId.is_in(channels.iter().map(|c| c.id)))
+ .select_only()
+ .column(room::Column::ChannelId)
+ .column(room_participant::Column::UserId)
+ .into_values::<_, QueryUserIdsAndChannelIds>()
+ .stream(&*tx)
+ .await?;
+
+ let mut participant_map: HashMap<ChannelId, Vec<UserId>> = HashMap::default();
+ while let Some(row) = participants.next().await {
+ let row: (ChannelId, UserId) = row?;
+ participant_map.entry(row.0).or_default().push(row.1)
+ }
+
+ drop(participants);
+
+ Ok((channels, participant_map))
})
.await
}
@@ -3523,7 +3604,7 @@ impl Database {
.await
}
- pub async fn get_channel_room(&self, channel_id: ChannelId) -> Result<RoomId> {
+ pub async fn room_id_for_channel(&self, channel_id: ChannelId) -> Result<RoomId> {
self.transaction(|tx| async move {
let tx = tx;
let room = channel::Model {
@@ -3932,29 +4013,19 @@ id_type!(ServerId);
id_type!(SignupId);
id_type!(UserId);
-pub struct ChannelRoom {
+#[derive(Clone)]
+pub struct JoinRoom {
pub room: proto::Room,
- pub channel_participants: Vec<UserId>,
-}
-
-impl Deref for ChannelRoom {
- type Target = proto::Room;
-
- fn deref(&self) -> &Self::Target {
- &self.room
- }
-}
-
-impl DerefMut for ChannelRoom {
- fn deref_mut(&mut self) -> &mut Self::Target {
- &mut self.room
- }
+ pub channel_id: Option<ChannelId>,
+ pub channel_members: Vec<UserId>,
}
pub struct RejoinedRoom {
- pub room: ChannelRoom,
+ pub room: proto::Room,
pub rejoined_projects: Vec<RejoinedProject>,
pub reshared_projects: Vec<ResharedProject>,
+ pub channel_id: Option<ChannelId>,
+ pub channel_members: Vec<UserId>,
}
pub struct ResharedProject {
@@ -3989,14 +4060,18 @@ pub struct RejoinedWorktree {
}
pub struct LeftRoom {
- pub room: ChannelRoom,
+ pub room: proto::Room,
+ pub channel_id: Option<ChannelId>,
+ pub channel_members: Vec<UserId>,
pub left_projects: HashMap<ProjectId, LeftProject>,
pub canceled_calls_to_user_ids: Vec<UserId>,
pub deleted: bool,
}
pub struct RefreshedRoom {
- pub room: ChannelRoom,
+ pub room: proto::Room,
+ pub channel_id: Option<ChannelId>,
+ pub channel_members: Vec<UserId>,
pub stale_participant_user_ids: Vec<UserId>,
pub canceled_calls_to_user_ids: Vec<UserId>,
}
@@ -1,7 +1,7 @@
use super::{ChannelId, RoomId};
use sea_orm::entity::prelude::*;
-#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[derive(Clone, Default, Debug, PartialEq, Eq, DeriveEntityModel)]
#[sea_orm(table_name = "rooms")]
pub struct Model {
#[sea_orm(primary_key)]
@@ -951,7 +951,7 @@ test_both_dbs!(test_channels_postgres, test_channels_sqlite, db, {
.await
.unwrap();
- let channels = db.get_channels(a_id).await.unwrap();
+ let (channels, _) = db.get_channels(a_id).await.unwrap();
assert_eq!(
channels,
@@ -1047,10 +1047,10 @@ test_both_dbs!(
.create_root_channel("channel_1", "1", user_1)
.await
.unwrap();
- let room_1 = db.get_channel_room(channel_1).await.unwrap();
+ let room_1 = db.room_id_for_channel(channel_1).await.unwrap();
// can join a room with membership to its channel
- let room = db
+ let joined_room = db
.join_room(
room_1,
user_1,
@@ -1059,9 +1059,9 @@ test_both_dbs!(
)
.await
.unwrap();
- assert_eq!(room.participants.len(), 1);
+ assert_eq!(joined_room.room.participants.len(), 1);
- drop(room);
+ drop(joined_room);
// cannot join a room without membership to its channel
assert!(db
.join_room(
@@ -2,7 +2,7 @@ mod connection_pool;
use crate::{
auth,
- db::{self, ChannelId, ChannelRoom, Database, ProjectId, RoomId, ServerId, User, UserId},
+ db::{self, ChannelId, Database, ProjectId, RoomId, ServerId, User, UserId},
executor::Executor,
AppState, Result,
};
@@ -296,6 +296,15 @@ impl Server {
"refreshed room"
);
room_updated(&refreshed_room.room, &peer);
+ if let Some(channel_id) = refreshed_room.channel_id {
+ channel_updated(
+ channel_id,
+ &refreshed_room.room,
+ &refreshed_room.channel_members,
+ &peer,
+ &*pool.lock(),
+ );
+ }
contacts_to_update
.extend(refreshed_room.stale_participant_user_ids.iter().copied());
contacts_to_update
@@ -517,7 +526,7 @@ impl Server {
this.app_state.db.set_user_connected_once(user_id, true).await?;
}
- let (contacts, invite_code, channels, channel_invites) = future::try_join4(
+ let (contacts, invite_code, (channels, channel_participants), channel_invites) = future::try_join4(
this.app_state.db.get_contacts(user_id),
this.app_state.db.get_invite_code_for_user(user_id),
this.app_state.db.get_channels(user_id),
@@ -528,7 +537,7 @@ impl Server {
let mut pool = this.connection_pool.lock();
pool.add_connection(connection_id, user_id, user.admin);
this.peer.send(connection_id, build_initial_contacts_update(contacts, &pool))?;
- this.peer.send(connection_id, build_initial_channels_update(channels, channel_invites))?;
+ this.peer.send(connection_id, build_initial_channels_update(channels, channel_participants, channel_invites))?;
if let Some((code, count)) = invite_code {
this.peer.send(connection_id, proto::UpdateInviteInfo {
@@ -921,8 +930,8 @@ async fn join_room(
.await
.join_room(room_id, session.user_id, None, session.connection_id)
.await?;
- room_updated(&room, &session.peer);
- room.clone()
+ room_updated(&room.room, &session.peer);
+ room.room.clone()
};
for connection_id in session
@@ -971,6 +980,9 @@ async fn rejoin_room(
response: Response<proto::RejoinRoom>,
session: Session,
) -> Result<()> {
+ let room;
+ let channel_id;
+ let channel_members;
{
let mut rejoined_room = session
.db()
@@ -1132,6 +1144,21 @@ async fn rejoin_room(
)?;
}
}
+
+ room = mem::take(&mut rejoined_room.room);
+ channel_id = rejoined_room.channel_id;
+ channel_members = mem::take(&mut rejoined_room.channel_members);
+ }
+
+ //TODO: move this into the room guard
+ if let Some(channel_id) = channel_id {
+ channel_updated(
+ channel_id,
+ &room,
+ &channel_members,
+ &session.peer,
+ &*session.connection_pool().await,
+ );
}
update_user_contacts(session.user_id, &session).await?;
@@ -2202,9 +2229,9 @@ async fn invite_channel_member(
}
async fn remove_channel_member(
- request: proto::RemoveChannelMember,
- response: Response<proto::RemoveChannelMember>,
- session: Session,
+ _request: proto::RemoveChannelMember,
+ _response: Response<proto::RemoveChannelMember>,
+ _session: Session,
) -> Result<()> {
Ok(())
}
@@ -2247,11 +2274,11 @@ async fn join_channel(
) -> Result<()> {
let channel_id = ChannelId::from_proto(request.channel_id);
- {
+ let joined_room = {
let db = session.db().await;
- let room_id = db.get_channel_room(channel_id).await?;
+ let room_id = db.room_id_for_channel(channel_id).await?;
- let room = db
+ let joined_room = db
.join_room(
room_id,
session.user_id,
@@ -2262,7 +2289,10 @@ async fn join_channel(
let live_kit_connection_info = session.live_kit_client.as_ref().and_then(|live_kit| {
let token = live_kit
- .room_token(&room.live_kit_room, &session.user_id.to_string())
+ .room_token(
+ &joined_room.room.live_kit_room,
+ &session.user_id.to_string(),
+ )
.trace_err()?;
Some(LiveKitConnectionInfo {
@@ -2272,12 +2302,25 @@ async fn join_channel(
});
response.send(proto::JoinRoomResponse {
- room: Some(room.clone()),
+ room: Some(joined_room.room.clone()),
live_kit_connection_info,
})?;
- room_updated(&room, &session.peer);
- }
+ room_updated(&joined_room.room, &session.peer);
+
+ joined_room.clone()
+ };
+
+ // TODO - do this while still holding the room guard,
+ // currently there's a possible race condition if someone joins the channel
+ // after we've dropped the lock but before we finish sending these updates
+ channel_updated(
+ channel_id,
+ &joined_room.room,
+ &joined_room.channel_members,
+ &session.peer,
+ &*session.connection_pool().await,
+ );
update_user_contacts(session.user_id, &session).await?;
@@ -2356,6 +2399,7 @@ fn to_tungstenite_message(message: AxumMessage) -> TungsteniteMessage {
fn build_initial_channels_update(
channels: Vec<db::Channel>,
+ channel_participants: HashMap<db::ChannelId, Vec<UserId>>,
channel_invites: Vec<db::Channel>,
) -> proto::UpdateChannels {
let mut update = proto::UpdateChannels::default();
@@ -2426,10 +2470,7 @@ fn contact_for_user(
}
}
-fn room_updated(room: &ChannelRoom, peer: &Peer, pool: &ConnectionPool) {
- let channel_ids = &room.channel_participants;
- let room = &room.room;
-
+fn room_updated(room: &proto::Room, peer: &Peer) {
broadcast(
None,
room.participants
@@ -2444,17 +2485,41 @@ fn room_updated(room: &ChannelRoom, peer: &Peer, pool: &ConnectionPool) {
)
},
);
+}
+
+fn channel_updated(
+ channel_id: ChannelId,
+ room: &proto::Room,
+ channel_members: &[UserId],
+ peer: &Peer,
+ pool: &ConnectionPool,
+) {
+ let participants = room
+ .participants
+ .iter()
+ .map(|p| p.user_id)
+ .collect::<Vec<_>>();
broadcast(
None,
- channel_ids
+ channel_members
.iter()
+ .filter(|user_id| {
+ !room
+ .participants
+ .iter()
+ .any(|p| p.user_id == user_id.to_proto())
+ })
.flat_map(|user_id| pool.user_connection_ids(*user_id)),
|peer_id| {
peer.send(
peer_id.into(),
- proto::RoomUpdated {
- room: Some(room.clone()),
+ proto::UpdateChannels {
+ channel_participants: vec![proto::ChannelParticipants {
+ channel_id: channel_id.to_proto(),
+ participant_user_ids: participants.clone(),
+ }],
+ ..Default::default()
},
)
},
@@ -2502,6 +2567,10 @@ async fn leave_room_for_session(session: &Session) -> Result<()> {
let canceled_calls_to_user_ids;
let live_kit_room;
let delete_live_kit_room;
+ let room;
+ let channel_members;
+ let channel_id;
+
if let Some(mut left_room) = session.db().await.leave_room(session.connection_id).await? {
contacts_to_update.insert(session.user_id);
@@ -2509,19 +2578,30 @@ async fn leave_room_for_session(session: &Session) -> Result<()> {
project_left(project, session);
}
- {
- let connection_pool = session.connection_pool().await;
- room_updated(&left_room.room, &session.peer, &connection_pool);
- }
-
room_id = RoomId::from_proto(left_room.room.id);
canceled_calls_to_user_ids = mem::take(&mut left_room.canceled_calls_to_user_ids);
live_kit_room = mem::take(&mut left_room.room.live_kit_room);
delete_live_kit_room = left_room.deleted;
+ room = mem::take(&mut left_room.room);
+ channel_members = mem::take(&mut left_room.channel_members);
+ channel_id = left_room.channel_id;
+
+ room_updated(&room, &session.peer);
} else {
return Ok(());
}
+ // TODO - do this while holding the room guard.
+ if let Some(channel_id) = channel_id {
+ channel_updated(
+ channel_id,
+ &room,
+ &channel_members,
+ &session.peer,
+ &*session.connection_pool().await,
+ );
+ }
+
{
let pool = session.connection_pool().await;
for canceled_user_id in canceled_calls_to_user_ids {
@@ -66,7 +66,7 @@ async fn test_basic_channels(
)
});
- // Client B now sees that they are in channel A.
+ // Client B now sees that they are a member channel A.
client_b
.channel_store()
.update(cx_b, |channels, _| {
@@ -110,14 +110,20 @@ async fn test_channel_room(
deterministic: Arc<Deterministic>,
cx_a: &mut TestAppContext,
cx_b: &mut TestAppContext,
+ cx_c: &mut TestAppContext,
) {
deterministic.forbid_parking();
let mut server = TestServer::start(&deterministic).await;
let client_a = server.create_client(cx_a, "user_a").await;
let client_b = server.create_client(cx_b, "user_b").await;
+ let client_c = server.create_client(cx_b, "user_c").await;
let zed_id = server
- .make_channel("zed", (&client_a, cx_a), &mut [(&client_b, cx_b)])
+ .make_channel(
+ "zed",
+ (&client_a, cx_a),
+ &mut [(&client_b, cx_b), (&client_c, cx_c)],
+ )
.await;
let active_call_a = cx_a.read(ActiveCall::global);
@@ -128,11 +134,26 @@ async fn test_channel_room(
.await
.unwrap();
+ // TODO Test that B and C sees A in the channel room
+ client_b.channel_store().read_with(cx_b, |channels, _| {
+ assert_eq!(
+ channels.channels(),
+ &[Arc::new(Channel {
+ id: zed_id,
+ name: "zed".to_string(),
+ parent_id: None,
+ depth: 0,
+ })]
+ )
+ });
+
active_call_b
.update(cx_b, |active_call, cx| active_call.join_channel(zed_id, cx))
.await
.unwrap();
+ // TODO Test that C sees A and B in the channel room
+
deterministic.run_until_parked();
let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
@@ -162,12 +183,14 @@ async fn test_channel_room(
.await
.unwrap();
+ // TODO Make sure that C sees A leave
+
active_call_b
.update(cx_b, |active_call, cx| active_call.hang_up(cx))
.await
.unwrap();
- // Make sure room exists?
+ // TODO Make sure that C sees B leave
active_call_a
.update(cx_a, |active_call, cx| active_call.join_channel(zed_id, cx))
@@ -136,8 +136,8 @@ message Envelope {
RemoveChannelMember remove_channel_member = 122;
RespondToChannelInvite respond_to_channel_invite = 123;
UpdateChannels update_channels = 124;
- JoinChannel join_channel = 125;
- RemoveChannel remove_channel = 126;
+ JoinChannel join_channel = 126;
+ RemoveChannel remove_channel = 127;
}
}
@@ -870,6 +870,12 @@ message UpdateChannels {
repeated uint64 remove_channels = 2;
repeated Channel channel_invitations = 3;
repeated uint64 remove_channel_invitations = 4;
+ repeated ChannelParticipants channel_participants = 5;
+}
+
+message ChannelParticipants {
+ uint64 channel_id = 1;
+ repeated uint64 participant_user_ids = 2;
}
message JoinChannel {
@@ -244,7 +244,7 @@ messages!(
(UpdateWorktreeSettings, Foreground),
(UpdateDiffBase, Foreground),
(GetPrivateUserInfo, Foreground),
- (GetPrivateUserInfoResponse, Foreground),
+ (GetPrivateUserInfoResponse, Foreground)
);
request_messages!(