Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rip out project registration and use sharing/unsharing instead

Browse source
This commit is contained in:
Antonio Scandurra 2022-09-30 12:23:57 +02:00
parent be8990ea78
commit 074b8f18d1
7 changed files with 333 additions and 525 deletions
Download patch file Download diff file Expand all files Collapse all files

306
crates/collab/src/integration_tests.rs
View file

@ -314,11 +314,14 @@ async fn test_share_project(
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_id = project_a.read_with(cx_a, |project, _| project.remote_id().unwrap());
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
// Join that project as client B
let client_b_peer_id = client_b.peer_id;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let replica_id_b = project_b.read_with(cx_b, |project, _| {
assert_eq!(
project
@ -390,17 +393,7 @@ async fn test_share_project(
// Client B can join again on a different window because they are already a participant.
let client_b2 = server.create_client(cx_b2, "user_b").await;
let project_b2 = Project::remote(
project_id,
client_b2.client.clone(),
client_b2.user_store.clone(),
client_b2.project_store.clone(),
client_b2.language_registry.clone(),
FakeFs::new(cx_b2.background()),
cx_b2.to_async(),
)
.await
.unwrap();
let project_b2 = client_b2.build_remote_project(project_id, cx_b2).await;
deterministic.run_until_parked();
project_a.read_with(cx_a, |project, _| {
assert_eq!(project.collaborators().len(), 2);
@ -449,8 +442,12 @@ async fn test_unshare_project(
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let worktree_a = project_a.read_with(cx_a, |project, cx| project.worktrees(cx).next().unwrap());
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
project_b
@ -467,7 +464,11 @@ async fn test_unshare_project(
assert!(project_b.read_with(cx_b, |project, _| project.is_read_only()));
// Client B can join again after client A re-shares.
let project_b2 = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b2 = client_b.build_remote_project(project_id, cx_b).await;
assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
project_b2
.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
@ -517,9 +518,12 @@ async fn test_host_disconnect(
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let worktree_a = project_a.read_with(cx_a, |project, cx| project.worktrees(cx).next().unwrap());
project_a.read_with(cx_a, |project, _| project.remote_id().unwrap());
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
let (_, workspace_b) =
@ -574,7 +578,11 @@ async fn test_host_disconnect(
});
// Ensure guests can still join.
let project_b2 = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b2 = client_b.build_remote_project(project_id, cx_b).await;
assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
project_b2
.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
@ -613,10 +621,14 @@ async fn test_propagate_saves_and_fs_changes(
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let worktree_a = project_a.read_with(cx_a, |p, cx| p.worktrees(cx).next().unwrap());
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
// Join that worktree as clients B and C.
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_c = client_c.build_remote_project(&project_a, cx_a, cx_c).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let project_c = client_c.build_remote_project(project_id, cx_c).await;
let worktree_b = project_b.read_with(cx_b, |p, cx| p.worktrees(cx).next().unwrap());
let worktree_c = project_c.read_with(cx_c, |p, cx| p.worktrees(cx).next().unwrap());
@ -756,7 +768,11 @@ async fn test_fs_operations(
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let worktree_a = project_a.read_with(cx_a, |project, cx| project.worktrees(cx).next().unwrap());
let worktree_b = project_b.read_with(cx_b, |project, cx| project.worktrees(cx).next().unwrap());
@ -1016,7 +1032,11 @@ async fn test_buffer_conflict_after_save(cx_a: &mut TestAppContext, cx_b: &mut T
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open a buffer as client B
let buffer_b = project_b
@ -1065,7 +1085,11 @@ async fn test_buffer_reloading(cx_a: &mut TestAppContext, cx_b: &mut TestAppCont
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open a buffer as client B
let buffer_b = project_b
@ -1114,7 +1138,11 @@ async fn test_editing_while_guest_opens_buffer(
.insert_tree("/dir", json!({ "a.txt": "a-contents" }))
.await;
let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open a buffer as client A
let buffer_a = project_a
@ -1156,7 +1184,11 @@ async fn test_leaving_worktree_while_opening_buffer(
.insert_tree("/dir", json!({ "a.txt": "a-contents" }))
.await;
let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// See that a guest has joined as client A.
project_a
@ -1201,7 +1233,11 @@ async fn test_canceling_buffer_opening(
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let buffer_a = project_a
.update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
@ -1243,7 +1279,11 @@ async fn test_leaving_project(cx_a: &mut TestAppContext, cx_b: &mut TestAppConte
)
.await;
let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
let _project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let _project_b = client_b.build_remote_project(project_id, cx_b).await;
// Client A sees that a guest has joined.
project_a
@ -1257,7 +1297,7 @@ async fn test_leaving_project(cx_a: &mut TestAppContext, cx_b: &mut TestAppConte
.await;
// Rejoin the project as client B
let _project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let _project_b = client_b.build_remote_project(project_id, cx_b).await;
// Client A sees that a guest has re-joined.
project_a
@ -1317,7 +1357,10 @@ async fn test_collaborating_with_diagnostics(
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_id = project_a.update(cx_a, |p, _| p.next_remote_id()).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
// Cause the language server to start.
let _buffer = cx_a
@ -1335,7 +1378,7 @@ async fn test_collaborating_with_diagnostics(
.unwrap();
// Join the worktree as client B.
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Simulate a language server reporting errors for a file.
let mut fake_language_server = fake_language_servers.next().await.unwrap();
@ -1383,7 +1426,7 @@ async fn test_collaborating_with_diagnostics(
});
// Join project as client C and observe the diagnostics.
let project_c = client_c.build_remote_project(&project_a, cx_a, cx_c).await;
let project_c = client_c.build_remote_project(project_id, cx_c).await;
deterministic.run_until_parked();
project_c.read_with(cx_c, |project, cx| {
assert_eq!(
@ -1561,7 +1604,11 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open a file in an editor as the guest.
let buffer_b = project_b
@ -1705,8 +1752,12 @@ async fn test_reloading_buffer_manually(cx_a: &mut TestAppContext, cx_b: &mut Te
.update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx))
.await
.unwrap();
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let buffer_b = cx_b
.background()
@ -1805,7 +1856,11 @@ async fn test_formatting_buffer(cx_a: &mut TestAppContext, cx_b: &mut TestAppCon
.insert_tree(&directory, json!({ "a.rs": "let one = \"two\"" }))
.await;
let (project_a, worktree_id) = client_a.build_local_project(&directory, cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let buffer_b = cx_b
.background()
@ -1908,7 +1963,11 @@ async fn test_definition(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/root/dir-1", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open the file on client B.
let buffer_b = cx_b
@ -2047,7 +2106,11 @@ async fn test_references(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/root/dir-1", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open the file on client B.
let buffer_b = cx_b
@ -2142,8 +2205,12 @@ async fn test_project_search(cx_a: &mut TestAppContext, cx_b: &mut TestAppContex
worktree_2
.read_with(cx_a, |tree, _| tree.as_local().unwrap().scan_complete())
.await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Perform a search as the guest.
let results = project_b
@ -2212,7 +2279,11 @@ async fn test_document_highlights(cx_a: &mut TestAppContext, cx_b: &mut TestAppC
client_a.language_registry.add(Arc::new(language));
let (project_a, worktree_id) = client_a.build_local_project("/root-1", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open the file on client B.
let buffer_b = cx_b
@ -2309,7 +2380,11 @@ async fn test_lsp_hover(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
client_a.language_registry.add(Arc::new(language));
let (project_a, worktree_id) = client_a.build_local_project("/root-1", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Open the file as the guest
let buffer_b = cx_b
@ -2414,7 +2489,11 @@ async fn test_project_symbols(cx_a: &mut TestAppContext, cx_b: &mut TestAppConte
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/code/crate-1", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Cause the language server to start.
let _buffer = cx_b
@ -2510,7 +2589,11 @@ async fn test_open_buffer_while_getting_definition_pointing_to_it(
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/root", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let buffer_b1 = cx_b
.background()
@ -2581,9 +2664,13 @@ async fn test_collaborating_with_code_actions(
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
// Join the project as client B.
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let (_window_b, workspace_b) =
cx_b.add_window(|cx| Workspace::new(project_b.clone(), |_, _| unimplemented!(), cx));
let editor_b = workspace_b
@ -2798,7 +2885,11 @@ async fn test_collaborating_with_renames(cx_a: &mut TestAppContext, cx_b: &mut T
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let (_window_b, workspace_b) =
cx_b.add_window(|cx| Workspace::new(project_b.clone(), |_, _| unimplemented!(), cx));
@ -3006,7 +3097,11 @@ async fn test_language_server_statuses(
);
});
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
project_b.read_with(cx_b, |project, _| {
let status = project.language_server_statuses().next().unwrap();
assert_eq!(status.name, "the-language-server");
@ -3485,79 +3580,6 @@ async fn test_contacts(
[("user_a".to_string(), true), ("user_b".to_string(), true)]
);
// Share a project as client A.
client_a.fs.create_dir(Path::new("/a")).await.unwrap();
let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
deterministic.run_until_parked();
assert_eq!(
contacts(&client_a, cx_a),
[("user_b".to_string(), true), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_b, cx_b),
[("user_a".to_string(), true), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_c, cx_c),
[("user_a".to_string(), true), ("user_b".to_string(), true)]
);
let _project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
deterministic.run_until_parked();
assert_eq!(
contacts(&client_a, cx_a),
[("user_b".to_string(), true), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_b, cx_b),
[("user_a".to_string(), true,), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_c, cx_c),
[("user_a".to_string(), true,), ("user_b".to_string(), true)]
);
// Add a local project as client B
client_a.fs.create_dir("/b".as_ref()).await.unwrap();
let (_project_b, _) = client_b.build_local_project("/b", cx_b).await;
deterministic.run_until_parked();
assert_eq!(
contacts(&client_a, cx_a),
[("user_b".to_string(), true), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_b, cx_b),
[("user_a".to_string(), true), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_c, cx_c),
[("user_a".to_string(), true,), ("user_b".to_string(), true)]
);
project_a
.condition(cx_a, |project, _| {
project.collaborators().contains_key(&client_b.peer_id)
})
.await;
cx_a.update(move |_| drop(project_a));
deterministic.run_until_parked();
assert_eq!(
contacts(&client_a, cx_a),
[("user_b".to_string(), true), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_b, cx_b),
[("user_a".to_string(), true), ("user_c".to_string(), true)]
);
assert_eq!(
contacts(&client_c, cx_c),
[("user_a".to_string(), true), ("user_b".to_string(), true)]
);
server.disconnect_client(client_c.current_user_id(cx_c));
server.forbid_connections();
deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
@ -3811,8 +3833,11 @@ async fn test_following(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Client A opens some editors.
let workspace_a = client_a.build_workspace(&project_a, cx_a);
@ -4019,9 +4044,13 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
// Client B joins the project.
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Client A opens some editors.
let workspace_a = client_a.build_workspace(&project_a, cx_a);
@ -4182,7 +4211,11 @@ async fn test_auto_unfollowing(cx_a: &mut TestAppContext, cx_b: &mut TestAppCont
)
.await;
let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
// Client A opens some editors.
let workspace_a = client_a.build_workspace(&project_a, cx_a);
@ -4331,8 +4364,12 @@ async fn test_peers_simultaneously_following_each_other(
client_a.fs.insert_tree("/a", json!({})).await;
let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
let workspace_a = client_a.build_workspace(&project_a, cx_a);
let project_id = project_a
.update(cx_a, |project, cx| project.share(cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(&project_a, cx_a, cx_b).await;
let project_b = client_b.build_remote_project(project_id, cx_b).await;
let workspace_b = client_b.build_workspace(&project_b, cx_b);
deterministic.run_until_parked();
@ -4445,9 +4482,6 @@ async fn test_random_collaboration(
cx,
)
});
let host_project_id = host_project
.update(&mut host_cx, |p, _| p.next_remote_id())
.await;
let (collab_worktree, _) = host_project
.update(&mut host_cx, |project, cx| {
@ -4588,7 +4622,7 @@ async fn test_random_collaboration(
.await;
host_language_registry.add(Arc::new(language));
host_project
let host_project_id = host_project
.update(&mut host_cx, |project, cx| project.share(cx))
.await
.unwrap();
@ -5155,40 +5189,26 @@ impl TestClient {
worktree
.read_with(cx, |tree, _| tree.as_local().unwrap().scan_complete())
.await;
project
.update(cx, |project, _| project.next_remote_id())
.await;
(project, worktree.read_with(cx, |tree, _| tree.id()))
}
async fn build_remote_project(
&self,
host_project: &ModelHandle<Project>,
host_cx: &mut TestAppContext,
host_project_id: u64,
guest_cx: &mut TestAppContext,
) -> ModelHandle<Project> {
let host_project_id = host_project
.read_with(host_cx, |project, _| project.next_remote_id())
.await;
host_project
.update(host_cx, |project, cx| project.share(cx))
.await
.unwrap();
let languages = host_project.read_with(host_cx, |project, _| project.languages().clone());
let project_b = guest_cx.spawn(|cx| {
Project::remote(
host_project_id,
self.client.clone(),
self.user_store.clone(),
self.project_store.clone(),
languages,
self.language_registry.clone(),
FakeFs::new(cx.background()),
cx,
)
});
let project = project_b.await.unwrap();
project
project_b.await.unwrap()
}
fn build_workspace(

60
crates/collab/src/rpc.rs
View file

@ -151,11 +151,10 @@ impl Server {
.add_message_handler(Server::leave_room)
.add_request_handler(Server::call)
.add_message_handler(Server::decline_call)
.add_request_handler(Server::register_project)
.add_request_handler(Server::unregister_project)
.add_request_handler(Server::share_project)
.add_message_handler(Server::unshare_project)
.add_request_handler(Server::join_project)
.add_message_handler(Server::leave_project)
.add_message_handler(Server::unshare_project)
.add_message_handler(Server::update_project)
.add_message_handler(Server::register_project_activity)
.add_request_handler(Server::update_worktree)
@ -470,18 +469,18 @@ impl Server {
async fn sign_out(self: &mut Arc<Self>, connection_id: ConnectionId) -> Result<()> {
self.peer.disconnect(connection_id);
let mut projects_to_unregister = Vec::new();
let mut projects_to_unshare = Vec::new();
let removed_user_id;
{
let mut store = self.store().await;
let removed_connection = store.remove_connection(connection_id)?;
for (project_id, project) in removed_connection.hosted_projects {
projects_to_unregister.push(project_id);
projects_to_unshare.push(project_id);
broadcast(connection_id, project.guests.keys().copied(), |conn_id| {
self.peer.send(
conn_id,
proto::UnregisterProject {
proto::UnshareProject {
project_id: project_id.to_proto(),
},
)
@ -514,7 +513,7 @@ impl Server {
self.update_user_contacts(removed_user_id).await.trace_err();
for project_id in projects_to_unregister {
for project_id in projects_to_unshare {
self.app_state
.db
.unregister_project(project_id)
@ -687,10 +686,10 @@ impl Server {
}
}
async fn register_project(
async fn share_project(
self: Arc<Server>,
request: TypedEnvelope<proto::RegisterProject>,
response: Response<proto::RegisterProject>,
request: TypedEnvelope<proto::ShareProject>,
response: Response<proto::ShareProject>,
) -> Result<()> {
let user_id = self
.store()
@ -699,44 +698,15 @@ impl Server {
let project_id = self.app_state.db.register_project(user_id).await?;
self.store()
.await
.register_project(request.sender_id, project_id)?;
.share_project(request.sender_id, project_id)?;
response.send(proto::RegisterProjectResponse {
response.send(proto::ShareProjectResponse {
project_id: project_id.to_proto(),
})?;
Ok(())
}
async fn unregister_project(
self: Arc<Server>,
request: TypedEnvelope<proto::UnregisterProject>,
response: Response<proto::UnregisterProject>,
) -> Result<()> {
let project_id = ProjectId::from_proto(request.payload.project_id);
let project = self
.store()
.await
.unregister_project(project_id, request.sender_id)?;
self.app_state.db.unregister_project(project_id).await?;
broadcast(
request.sender_id,
project.guests.keys().copied(),
|conn_id| {
self.peer.send(
conn_id,
proto::UnregisterProject {
project_id: project_id.to_proto(),
},
)
},
);
response.send(proto::Ack {})?;
Ok(())
}
async fn unshare_project(
self: Arc<Server>,
message: TypedEnvelope<proto::UnshareProject>,
@ -746,9 +716,11 @@ impl Server {
.store()
.await
.unshare_project(project_id, message.sender_id)?;
broadcast(message.sender_id, project.guest_connection_ids, |conn_id| {
self.peer.send(conn_id, message.payload.clone())
});
broadcast(
message.sender_id,
project.guest_connection_ids(),
|conn_id| self.peer.send(conn_id, message.payload.clone()),
);
Ok(())
}

99
crates/collab/src/rpc/store.rs
View file

@ -96,10 +96,6 @@ pub struct LeftProject {
pub remove_collaborator: bool,
}
pub struct UnsharedProject {
pub guest_connection_ids: Vec<ConnectionId>,
}
#[derive(Copy, Clone)]
pub struct Metrics {
pub connections: usize,
@ -201,9 +197,9 @@ impl Store {
self.leave_channel(connection_id, channel_id);
}
// Unregister and leave all projects.
// Unshare and leave all projects.
for project_id in connection_projects {
if let Ok(project) = self.unregister_project(project_id, connection_id) {
if let Ok(project) = self.unshare_project(project_id, connection_id) {
result.hosted_projects.insert(project_id, project);
} else if self.leave_project(connection_id, project_id).is_ok() {
result.guest_project_ids.insert(project_id);
@ -566,7 +562,7 @@ impl Store {
}
}
pub fn register_project(
pub fn share_project(
&mut self,
host_connection_id: ConnectionId,
project_id: ProjectId,
@ -595,6 +591,35 @@ impl Store {
Ok(())
}
pub fn unshare_project(
&mut self,
project_id: ProjectId,
connection_id: ConnectionId,
) -> Result<Project> {
match self.projects.entry(project_id) {
btree_map::Entry::Occupied(e) => {
if e.get().host_connection_id == connection_id {
let project = e.remove();
if let Some(host_connection) = self.connections.get_mut(&connection_id) {
host_connection.projects.remove(&project_id);
}
for guest_connection in project.guests.keys() {
if let Some(connection) = self.connections.get_mut(guest_connection) {
connection.projects.remove(&project_id);
}
}
Ok(project)
} else {
Err(anyhow!("no such project"))?
}
}
btree_map::Entry::Vacant(_) => Err(anyhow!("no such project"))?,
}
}
pub fn update_project(
&mut self,
project_id: ProjectId,
@ -628,66 +653,6 @@ impl Store {
}
}
pub fn unregister_project(
&mut self,
project_id: ProjectId,
connection_id: ConnectionId,
) -> Result<Project> {
match self.projects.entry(project_id) {
btree_map::Entry::Occupied(e) => {
if e.get().host_connection_id == connection_id {
let project = e.remove();
if let Some(host_connection) = self.connections.get_mut(&connection_id) {
host_connection.projects.remove(&project_id);
}
for guest_connection in project.guests.keys() {
if let Some(connection) = self.connections.get_mut(guest_connection) {
connection.projects.remove(&project_id);
}
}
Ok(project)
} else {
Err(anyhow!("no such project"))?
}
}
btree_map::Entry::Vacant(_) => Err(anyhow!("no such project"))?,
}
}
pub fn unshare_project(
&mut self,
project_id: ProjectId,
connection_id: ConnectionId,
) -> Result<UnsharedProject> {
let project = self
.projects
.get_mut(&project_id)
.ok_or_else(|| anyhow!("no such project"))?;
anyhow::ensure!(
project.host_connection_id == connection_id,
"no such project"
);
let guest_connection_ids = project.guest_connection_ids();
project.active_replica_ids.clear();
project.guests.clear();
project.language_servers.clear();
project.worktrees.clear();
for connection_id in &guest_connection_ids {
if let Some(connection) = self.connections.get_mut(connection_id) {
connection.projects.remove(&project_id);
}
}
Ok(UnsharedProject {
guest_connection_ids,
})
}
pub fn update_diagnostic_summary(
&mut self,
project_id: ProjectId,