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

Slicker remote project creation (#11309)

Browse source 
Inline the editor into the modal

Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennetbo@gmx.de>
This commit is contained in:
Conrad Irwin 2024-05-02 12:46:52 -06:00 • committed by GitHub
parent 78a8a58ee2
commit 1abd58070b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 500 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/collab/migrations/20240502180204_remove_old_remote_projects.sql Normal file
View file

@ -0,0 +1,2 @@
ALTER TABLE projects DROP COLUMN remote_project_id;
DROP TABLE remote_projects;

75
crates/collab/src/db/queries/dev_server_projects.rs
View file

@ -1,5 +1,8 @@
use anyhow::anyhow; use anyhow::anyhow;
use rpc::{proto, ConnectionId}; use rpc::{
proto::{self},
ConnectionId,
};
use sea_orm::{ use sea_orm::{
ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, EntityTrait, ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, EntityTrait,
ModelTrait, QueryFilter, ModelTrait, QueryFilter,
@ -35,24 +38,33 @@ impl Database {
dev_server_id: DevServerId, dev_server_id: DevServerId,
) -> crate::Result<Vec<proto::DevServerProject>> { ) -> crate::Result<Vec<proto::DevServerProject>> {
self.transaction(|tx| async move { self.transaction(|tx| async move {
let servers = dev_server_project::Entity::find() self.get_projects_for_dev_server_internal(dev_server_id, &tx)
.filter(dev_server_project::Column::DevServerId.eq(dev_server_id)) .await
.find_also_related(project::Entity)
.all(&*tx)
.await?;
Ok(servers
.into_iter()
.map(|(dev_server_project, project)| proto::DevServerProject {
id: dev_server_project.id.to_proto(),
project_id: project.map(|p| p.id.to_proto()),
dev_server_id: dev_server_project.dev_server_id.to_proto(),
path: dev_server_project.path,
})
.collect())
}) })
.await .await
} }
pub async fn get_projects_for_dev_server_internal(
&self,
dev_server_id: DevServerId,
tx: &DatabaseTransaction,
) -> crate::Result<Vec<proto::DevServerProject>> {
let servers = dev_server_project::Entity::find()
.filter(dev_server_project::Column::DevServerId.eq(dev_server_id))
.find_also_related(project::Entity)
.all(tx)
.await?;
Ok(servers
.into_iter()
.map(|(dev_server_project, project)| proto::DevServerProject {
id: dev_server_project.id.to_proto(),
project_id: project.map(|p| p.id.to_proto()),
dev_server_id: dev_server_project.dev_server_id.to_proto(),
path: dev_server_project.path,
})
.collect())
}
pub async fn dev_server_project_ids_for_user( pub async fn dev_server_project_ids_for_user(
&self, &self,
user_id: UserId, user_id: UserId,
@ -136,6 +148,39 @@ impl Database {
.await .await
} }
pub async fn delete_dev_server_project(
&self,
dev_server_project_id: DevServerProjectId,
dev_server_id: DevServerId,
user_id: UserId,
) -> crate::Result<(Vec<proto::DevServerProject>, proto::DevServerProjectsUpdate)> {
self.transaction(|tx| async move {
project::Entity::delete_many()
.filter(project::Column::DevServerProjectId.eq(dev_server_project_id))
.exec(&*tx)
.await?;
let result = dev_server_project::Entity::delete_by_id(dev_server_project_id)
.exec(&*tx)
.await?;
if result.rows_affected != 1 {
return Err(anyhow!(
"no dev server project with id {}",
dev_server_project_id
))?;
}
let status = self
.dev_server_projects_update_internal(user_id, &tx)
.await?;
let projects = self
.get_projects_for_dev_server_internal(dev_server_id, &tx)
.await?;
Ok((projects, status))
})
.await
}
pub async fn share_dev_server_project( pub async fn share_dev_server_project(
&self, &self,
dev_server_project_id: DevServerProjectId, dev_server_project_id: DevServerProjectId,

11
crates/collab/src/db/queries/projects.rs
View file

@ -598,6 +598,17 @@ impl Database {
.await .await
} }
pub async fn find_dev_server_project(&self, id: DevServerProjectId) -> Result<project::Model> {
self.transaction(|tx| async move {
Ok(project::Entity::find()
.filter(project::Column::DevServerProjectId.eq(id))
.one(&*tx)
.await?
.ok_or_else(|| anyhow!("no such project"))?)
})
.await
}
/// Adds the given connection to the specified project /// Adds the given connection to the specified project
/// in the current room. /// in the current room.
pub async fn join_project( pub async fn join_project(

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

@ -413,6 +413,7 @@ impl Server {
.add_request_handler(user_handler(join_hosted_project)) .add_request_handler(user_handler(join_hosted_project))
.add_request_handler(user_handler(rejoin_dev_server_projects)) .add_request_handler(user_handler(rejoin_dev_server_projects))
.add_request_handler(user_handler(create_dev_server_project)) .add_request_handler(user_handler(create_dev_server_project))
.add_request_handler(user_handler(delete_dev_server_project))
.add_request_handler(user_handler(create_dev_server)) .add_request_handler(user_handler(create_dev_server))
.add_request_handler(user_handler(delete_dev_server)) .add_request_handler(user_handler(delete_dev_server))
.add_request_handler(dev_server_handler(share_dev_server_project)) .add_request_handler(dev_server_handler(share_dev_server_project))
@ -2363,6 +2364,68 @@ async fn delete_dev_server(
Ok(()) Ok(())
} }
async fn delete_dev_server_project(
request: proto::DeleteDevServerProject,
response: Response<proto::DeleteDevServerProject>,
session: UserSession,
) -> Result<()> {
let dev_server_project_id = DevServerProjectId(request.dev_server_project_id as i32);
let dev_server_project = session
.db()
.await
.get_dev_server_project(dev_server_project_id)
.await?;
let dev_server = session
.db()
.await
.get_dev_server(dev_server_project.dev_server_id)
.await?;
if dev_server.user_id != session.user_id() {
return Err(anyhow!(ErrorCode::Forbidden))?;
}
let dev_server_connection_id = session
.connection_pool()
.await
.dev_server_connection_id(dev_server.id);
if let Some(dev_server_connection_id) = dev_server_connection_id {
let project = session
.db()
.await
.find_dev_server_project(dev_server_project_id)
.await;
if let Ok(project) = project {
unshare_project_internal(
project.id,
dev_server_connection_id,
Some(session.user_id()),
&session,
)
.await?;
}
}
let (projects, status) = session
.db()
.await
.delete_dev_server_project(dev_server_project_id, dev_server.id, session.user_id())
.await?;
if let Some(dev_server_connection_id) = dev_server_connection_id {
session.peer.send(
dev_server_connection_id,
proto::DevServerInstructions { projects },
)?;
}
send_dev_server_projects_update(session.user_id(), status, &session).await;
response.send(proto::Ack {})?;
Ok(())
}
async fn rejoin_dev_server_projects( async fn rejoin_dev_server_projects(
request: proto::RejoinRemoteProjects, request: proto::RejoinRemoteProjects,
response: Response<proto::RejoinRemoteProjects>, response: Response<proto::RejoinRemoteProjects>,

52
crates/collab/src/tests/dev_server_tests.rs
View file

@ -263,6 +263,58 @@ async fn test_dev_server_leave_room(
cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected())); cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected()));
} }
#[gpui::test]
async fn test_dev_server_delete(
cx1: &mut gpui::TestAppContext,
cx2: &mut gpui::TestAppContext,
cx3: &mut gpui::TestAppContext,
) {
let (server, client1, client2, channel_id) = TestServer::start2(cx1, cx2).await;
let (_dev_server, remote_workspace) =
create_dev_server_project(&server, client1.app_state.clone(), cx1, cx3).await;
cx1.update(|cx| {
workspace::join_channel(
channel_id,
client1.app_state.clone(),
Some(remote_workspace),
cx,
)
})
.await
.unwrap();
cx1.executor().run_until_parked();
remote_workspace
.update(cx1, |ws, cx| {
assert!(ws.project().read(cx).is_shared());
})
.unwrap();
join_channel(channel_id, &client2, cx2).await.unwrap();
cx2.executor().run_until_parked();
cx1.update(|cx| {
dev_server_projects::Store::global(cx).update(cx, |store, cx| {
store.delete_dev_server_project(store.dev_server_projects().first().unwrap().id, cx)
})
})
.await
.unwrap();
cx1.executor().run_until_parked();
let (workspace, cx2) = client2.active_workspace(cx2);
cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected()));
cx1.update(|cx| {
dev_server_projects::Store::global(cx).update(cx, |store, _| {
assert_eq!(store.dev_server_projects().len(), 0);
})
})
}
#[gpui::test] #[gpui::test]
async fn test_dev_server_reconnect( async fn test_dev_server_reconnect(
cx1: &mut gpui::TestAppContext, cx1: &mut gpui::TestAppContext,

16
crates/dev_server_projects/src/dev_server_projects.rs
View file

@ -188,4 +188,20 @@ impl Store {
Ok(()) Ok(())
}) })
} }
pub fn delete_dev_server_project(
&mut self,
id: DevServerProjectId,
cx: &mut ModelContext<Self>,
) -> Task<Result<()>> {
let client = self.client.clone();
cx.background_executor().spawn(async move {
client
.request(proto::DeleteDevServerProject {
dev_server_project_id: id.0,
})
.await?;
Ok(())
})
}
} }

1
crates/recent_projects/Cargo.toml
View file

@ -14,6 +14,7 @@ doctest = false
[dependencies] [dependencies]
anyhow.workspace = true anyhow.workspace = true
editor.workspace = true
feature_flags.workspace = true feature_flags.workspace = true
fuzzy.workspace = true fuzzy.workspace = true
gpui.workspace = true gpui.workspace = true

444
crates/recent_projects/src/dev_servers.rs
View file

@ -1,14 +1,15 @@
use std::time::Duration; use std::time::Duration;
use dev_server_projects::{DevServer, DevServerId, DevServerProject, DevServerProjectId}; use dev_server_projects::{DevServer, DevServerId, DevServerProject, DevServerProjectId};
use editor::Editor;
use feature_flags::FeatureFlagViewExt; use feature_flags::FeatureFlagViewExt;
use gpui::{ use gpui::{
percentage, Action, Animation, AnimationExt, AppContext, ClipboardItem, DismissEvent, percentage, Action, Animation, AnimationExt, AnyElement, AppContext, ClipboardItem,
EventEmitter, FocusHandle, FocusableView, Model, ScrollHandle, Transformation, View, DismissEvent, EventEmitter, FocusHandle, FocusableView, Model, ScrollHandle, Transformation,
ViewContext, View, ViewContext,
}; };
use rpc::{ use rpc::{
proto::{self, CreateDevServerResponse, DevServerStatus}, proto::{CreateDevServerResponse, DevServerStatus},
ErrorCode, ErrorExt, ErrorCode, ErrorExt,
}; };
use settings::Settings; use settings::Settings;
@ -16,7 +17,7 @@ use theme::ThemeSettings;
use ui::{prelude::*, Indicator, List, ListHeader, ListItem, ModalContent, ModalHeader, Tooltip}; use ui::{prelude::*, Indicator, List, ListHeader, ListItem, ModalContent, ModalHeader, Tooltip};
use ui_text_field::{FieldLabelLayout, TextField}; use ui_text_field::{FieldLabelLayout, TextField};
use util::ResultExt; use util::ResultExt;
use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspace}; use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspace, WORKSPACE_DB};
use crate::OpenRemote; use crate::OpenRemote;
@ -25,7 +26,7 @@ pub struct DevServerProjects {
focus_handle: FocusHandle, focus_handle: FocusHandle,
scroll_handle: ScrollHandle, scroll_handle: ScrollHandle,
dev_server_store: Model<dev_server_projects::Store>, dev_server_store: Model<dev_server_projects::Store>,
project_path_input: View<TextField>, project_path_input: View<Editor>,
dev_server_name_input: View<TextField>, dev_server_name_input: View<TextField>,
_subscription: gpui::Subscription, _subscription: gpui::Subscription,
} }
@ -36,15 +37,14 @@ struct CreateDevServer {
dev_server: Option<CreateDevServerResponse>, dev_server: Option<CreateDevServerResponse>,
} }
#[derive(Clone)]
struct CreateDevServerProject { struct CreateDevServerProject {
dev_server_id: DevServerId, dev_server_id: DevServerId,
creating: bool, creating: bool,
dev_server_project: Option<proto::DevServerProject>,
} }
enum Mode { enum Mode {
Default, Default(Option<CreateDevServerProject>),
CreateDevServerProject(CreateDevServerProject),
CreateDevServer(CreateDevServer), CreateDevServer(CreateDevServer),
} }
@ -67,7 +67,11 @@ impl DevServerProjects {
} }
pub fn new(cx: &mut ViewContext<Self>) -> Self { pub fn new(cx: &mut ViewContext<Self>) -> Self {
let project_path_input = cx.new_view(|cx| TextField::new(cx, "", "Project path")); let project_path_input = cx.new_view(|cx| {
let mut editor = Editor::single_line(cx);
editor.set_placeholder_text("Project path", cx);
editor
});
let dev_server_name_input = let dev_server_name_input =
cx.new_view(|cx| TextField::new(cx, "Name", "").with_label(FieldLabelLayout::Stacked)); cx.new_view(|cx| TextField::new(cx, "Name", "").with_label(FieldLabelLayout::Stacked));
@ -79,7 +83,7 @@ impl DevServerProjects {
}); });
Self { Self {
mode: Mode::Default, mode: Mode::Default(None),
focus_handle, focus_handle,
scroll_handle: ScrollHandle::new(), scroll_handle: ScrollHandle::new(),
dev_server_store, dev_server_store,
@ -94,14 +98,7 @@ impl DevServerProjects {
dev_server_id: DevServerId, dev_server_id: DevServerId,
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) { ) {
let path = self let path = self.project_path_input.read(cx).text(cx).trim().to_string();
.project_path_input
.read(cx)
.editor()
.read(cx)
.text(cx)
.trim()
.to_string();
if path == "" { if path == "" {
return; return;
@ -139,16 +136,18 @@ impl DevServerProjects {
cx.spawn(|this, mut cx| async move { cx.spawn(|this, mut cx| async move {
let result = create.await; let result = create.await;
let dev_server_project = result this.update(&mut cx, |this, cx| {
.as_ref() if result.is_ok() {
.ok() this.project_path_input.update(cx, |editor, cx| {
.and_then(|r| r.dev_server_project.clone()); editor.set_text("", cx);
this.update(&mut cx, |this, _| { });
this.mode = Mode::CreateDevServerProject(CreateDevServerProject { this.mode = Mode::Default(None);
dev_server_id, } else {
creating: false, this.mode = Mode::Default(Some(CreateDevServerProject {
dev_server_project, dev_server_id,
}); creating: false,
}));
}
}) })
.log_err(); .log_err();
result result
@ -166,17 +165,10 @@ impl DevServerProjects {
} }
}); });
self.project_path_input.update(cx, |input, cx| { self.mode = Mode::Default(Some(CreateDevServerProject {
input.editor().update(cx, |editor, cx| {
editor.set_text("", cx);
});
});
self.mode = Mode::CreateDevServerProject(CreateDevServerProject {
dev_server_id, dev_server_id,
creating: true, creating: true,
dev_server_project: None, }));
});
} }
pub fn create_dev_server(&mut self, cx: &mut ViewContext<Self>) { pub fn create_dev_server(&mut self, cx: &mut ViewContext<Self>) {
@ -238,20 +230,74 @@ impl DevServerProjects {
return Ok(()); return Ok(());
} }
let project_ids: Vec<DevServerProjectId> = this.update(&mut cx, |this, cx| {
this.dev_server_store.update(cx, |store, _| {
store
.projects_for_server(id)
.into_iter()
.map(|project| project.id)
.collect()
})
})?;
this.update(&mut cx, |this, cx| { this.update(&mut cx, |this, cx| {
this.dev_server_store this.dev_server_store
.update(cx, |store, cx| store.delete_dev_server(id, cx)) .update(cx, |store, cx| store.delete_dev_server(id, cx))
})? })?
.await .await?;
for id in project_ids {
WORKSPACE_DB
.delete_workspace_by_dev_server_project_id(id)
.await
.log_err();
}
Ok(())
}) })
.detach_and_prompt_err("Failed to delete dev server", cx, |_, _| None); .detach_and_prompt_err("Failed to delete dev server", cx, |_, _| None);
} }
fn delete_dev_server_project(
&mut self,
id: DevServerProjectId,
path: &str,
cx: &mut ViewContext<Self>,
) {
let answer = cx.prompt(
gpui::PromptLevel::Destructive,
format!("Delete \"{}\"?", path).as_str(),
Some("This will delete the remote project. You can always re-add it later."),
&["Delete", "Cancel"],
);
cx.spawn(|this, mut cx| async move {
let answer = answer.await?;
if answer != 0 {
return Ok(());
}
this.update(&mut cx, |this, cx| {
this.dev_server_store
.update(cx, |store, cx| store.delete_dev_server_project(id, cx))
})?
.await?;
WORKSPACE_DB
.delete_workspace_by_dev_server_project_id(id)
.await
.log_err();
Ok(())
})
.detach_and_prompt_err("Failed to delete dev server project", cx, |_, _| None);
}
fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) { fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
match self.mode { match &self.mode {
Mode::Default => {} Mode::Default(None) => {}
Mode::CreateDevServerProject(CreateDevServerProject { dev_server_id, .. }) => { Mode::Default(Some(create_project)) => {
self.create_dev_server_project(dev_server_id, cx); self.create_dev_server_project(create_project.dev_server_id, cx);
} }
Mode::CreateDevServer(_) => { Mode::CreateDevServer(_) => {
self.create_dev_server(cx); self.create_dev_server(cx);
@ -261,9 +307,9 @@ impl DevServerProjects {
fn cancel(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) { fn cancel(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
match self.mode { match self.mode {
Mode::Default => cx.emit(DismissEvent), Mode::Default(None) => cx.emit(DismissEvent),
Mode::CreateDevServerProject(_) | Mode::CreateDevServer(_) => { _ => {
self.mode = Mode::Default; self.mode = Mode::Default(None);
self.focus_handle(cx).focus(cx); self.focus_handle(cx).focus(cx);
cx.notify(); cx.notify();
} }
@ -273,10 +319,17 @@ impl DevServerProjects {
fn render_dev_server( fn render_dev_server(
&mut self, &mut self,
dev_server: &DevServer, dev_server: &DevServer,
mut create_project: Option<CreateDevServerProject>,
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) -> impl IntoElement { ) -> impl IntoElement {
let dev_server_id = dev_server.id; let dev_server_id = dev_server.id;
let status = dev_server.status; let status = dev_server.status;
if create_project
.as_ref()
.is_some_and(|cp| cp.dev_server_id != dev_server.id)
{
create_project = None;
}
v_flex() v_flex()
.w_full() .w_full()
@ -341,12 +394,12 @@ impl DevServerProjects {
.tooltip(|cx| Tooltip::text("Add a remote project", cx)) .tooltip(|cx| Tooltip::text("Add a remote project", cx))
.on_click(cx.listener( .on_click(cx.listener(
move |this, _, cx| { move |this, _, cx| {
this.mode = if let Mode::Default(project) = &mut this.mode {
Mode::CreateDevServerProject(CreateDevServerProject { *project = Some(CreateDevServerProject {
dev_server_id, dev_server_id,
creating: false, creating: false,
dev_server_project: None,
}); });
}
this.project_path_input.read(cx).focus_handle(cx).focus(cx); this.project_path_input.read(cx).focus_handle(cx).focus(cx);
cx.notify(); cx.notify();
}, },
@ -365,17 +418,49 @@ impl DevServerProjects {
.py_0p5() .py_0p5()
.px_3() .px_3()
.child( .child(
List::new().empty_message("No projects.").children( List::new()
self.dev_server_store .empty_message("No projects.")
.read(cx) .children(
.projects_for_server(dev_server.id) self.dev_server_store
.iter() .read(cx)
.map(|p| self.render_dev_server_project(p, cx)), .projects_for_server(dev_server.id)
), .iter()
.map(|p| self.render_dev_server_project(p, cx)),
)
.when_some(create_project, |el, create_project| {
el.child(self.render_create_new_project(&create_project, cx))
}),
), ),
) )
} }
fn render_create_new_project(
&mut self,
create_project: &CreateDevServerProject,
_: &mut ViewContext<Self>,
) -> impl IntoElement {
ListItem::new("create-remote-project")
.start_slot(Icon::new(IconName::FileTree).color(Color::Muted))
.child(self.project_path_input.clone())
.child(
div()
.w(IconSize::Medium.rems())
.when(create_project.creating, |el| {
el.child(
Icon::new(IconName::ArrowCircle)
.size(IconSize::Medium)
.with_animation(
"arrow-circle",
Animation::new(Duration::from_secs(2)).repeat(),
|icon, delta| {
icon.transform(Transformation::rotate(percentage(delta)))
},
),
)
}),
)
}
fn render_dev_server_project( fn render_dev_server_project(
&mut self, &mut self,
project: &DevServerProject, project: &DevServerProject,
@ -384,6 +469,7 @@ impl DevServerProjects {
let dev_server_project_id = project.id; let dev_server_project_id = project.id;
let project_id = project.project_id; let project_id = project.project_id;
let is_online = project_id.is_some(); let is_online = project_id.is_some();
let project_path = project.path.clone();
ListItem::new(("remote-project", dev_server_project_id.0)) ListItem::new(("remote-project", dev_server_project_id.0))
.start_slot(Icon::new(IconName::FileTree).when(!is_online, |icon| icon.color(Color::Muted))) .start_slot(Icon::new(IconName::FileTree).when(!is_online, |icon| icon.color(Color::Muted)))
@ -402,6 +488,11 @@ impl DevServerProjects {
}).detach(); }).detach();
} }
})) }))
.end_hover_slot::<AnyElement>(Some(IconButton::new("remove-remote-project", IconName::Trash)
.on_click(cx.listener(move |this, _, cx| {
this.delete_dev_server_project(dev_server_project_id, &project_path, cx)
}))
.tooltip(|cx| Tooltip::text("Delete remote project", cx)).into_any_element()))
} }
fn render_create_dev_server(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement { fn render_create_dev_server(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
@ -559,6 +650,11 @@ impl DevServerProjects {
fn render_default(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement { fn render_default(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
let dev_servers = self.dev_server_store.read(cx).dev_servers(); let dev_servers = self.dev_server_store.read(cx).dev_servers();
let Mode::Default(create_dev_server_project) = &self.mode else {
unreachable!()
};
let create_dev_server_project = create_dev_server_project.clone();
v_flex() v_flex()
.id("scroll-container") .id("scroll-container")
.h_full() .h_full()
@ -597,126 +693,131 @@ impl DevServerProjects {
), ),
)) ))
.children(dev_servers.iter().map(|dev_server| { .children(dev_servers.iter().map(|dev_server| {
self.render_dev_server(dev_server, cx).into_any_element() self.render_dev_server(
dev_server,
create_dev_server_project.clone(),
cx,
)
.into_any_element()
})), })),
), ),
) )
} }
fn render_create_dev_server_project(&self, cx: &mut ViewContext<Self>) -> impl IntoElement { // fn render_create_dev_server_project(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
let Mode::CreateDevServerProject(CreateDevServerProject { // let Mode::CreateDevServerProject(CreateDevServerProject {
dev_server_id, // dev_server_id,
creating, // creating,
dev_server_project, // dev_server_project,
}) = &self.mode // }) = &self.mode
else { // else {
unreachable!() // unreachable!()
}; // };
let dev_server = self // let dev_server = self
.dev_server_store // .dev_server_store
.read(cx) // .read(cx)
.dev_server(*dev_server_id) // .dev_server(*dev_server_id)
.cloned(); // .cloned();
let (dev_server_name, dev_server_status) = dev_server // let (dev_server_name, dev_server_status) = dev_server
.map(|server| (server.name, server.status)) // .map(|server| (server.name, server.status))
.unwrap_or((SharedString::from(""), DevServerStatus::Offline)); // .unwrap_or((SharedString::from(""), DevServerStatus::Offline));
v_flex() // v_flex()
.px_1() // .px_1()
.pt_0p5() // .pt_0p5()
.gap_px() // .gap_px()
.child( // .child(
v_flex().py_0p5().px_1().child( // v_flex().py_0p5().px_1().child(
h_flex() // h_flex()
.px_1() // .px_1()
.py_0p5() // .py_0p5()
.child( // .child(
IconButton::new("back", IconName::ArrowLeft) // IconButton::new("back", IconName::ArrowLeft)
.style(ButtonStyle::Transparent) // .style(ButtonStyle::Transparent)
.on_click(cx.listener(|_, _: &gpui::ClickEvent, cx| { // .on_click(cx.listener(|_, _: &gpui::ClickEvent, cx| {
cx.dispatch_action(menu::Cancel.boxed_clone()) // cx.dispatch_action(menu::Cancel.boxed_clone())
})), // })),
) // )
.child(Headline::new("Add remote project").size(HeadlineSize::Small)), // .child(Headline::new("Add remote project").size(HeadlineSize::Small)),
), // ),
) // )
.child( // .child(
h_flex() // h_flex()
.ml_5() // .ml_5()
.gap_2() // .gap_2()
.child( // .child(
div() // div()
.id(("status", dev_server_id.0)) // .id(("status", dev_server_id.0))
.relative() // .relative()
.child(Icon::new(IconName::Server)) // .child(Icon::new(IconName::Server))
.child(div().absolute().bottom_0().left(rems_from_px(12.0)).child( // .child(div().absolute().bottom_0().left(rems_from_px(12.0)).child(
Indicator::dot().color(match dev_server_status { // Indicator::dot().color(match dev_server_status {
DevServerStatus::Online => Color::Created, // DevServerStatus::Online => Color::Created,
DevServerStatus::Offline => Color::Hidden, // DevServerStatus::Offline => Color::Hidden,
}), // }),
)) // ))
.tooltip(move |cx| { // .tooltip(move |cx| {
Tooltip::text( // Tooltip::text(
match dev_server_status { // match dev_server_status {
DevServerStatus::Online => "Online", // DevServerStatus::Online => "Online",
DevServerStatus::Offline => "Offline", // DevServerStatus::Offline => "Offline",
}, // },
cx, // cx,
) // )
}), // }),
) // )
.child(dev_server_name.clone()), // .child(dev_server_name.clone()),
) // )
.child( // .child(
h_flex() // h_flex()
.ml_5() // .ml_5()
.gap_2() // .gap_2()
.child(self.project_path_input.clone()) // .child(self.project_path_input.clone())
.when(!*creating && dev_server_project.is_none(), |div| { // .when(!*creating && dev_server_project.is_none(), |div| {
div.child(Button::new("create-remote-server", "Create").on_click({ // div.child(Button::new("create-remote-server", "Create").on_click({
let dev_server_id = *dev_server_id; // let dev_server_id = *dev_server_id;
cx.listener(move |this, _, cx| { // cx.listener(move |this, _, cx| {
this.create_dev_server_project(dev_server_id, cx) // this.create_dev_server_project(dev_server_id, cx)
}) // })
})) // }))
}) // })
.when(*creating, |div| { // .when(*creating, |div| {
div.child(Button::new("create-dev-server", "Creating...").disabled(true)) // div.child(Button::new("create-dev-server", "Creating...").disabled(true))
}), // }),
) // )
.when_some(dev_server_project.clone(), |div, dev_server_project| { // .when_some(dev_server_project.clone(), |div, dev_server_project| {
let status = self // let status = self
.dev_server_store // .dev_server_store
.read(cx) // .read(cx)
.dev_server_project(DevServerProjectId(dev_server_project.id)) // .dev_server_project(DevServerProjectId(dev_server_project.id))
.map(|project| { // .map(|project| {
if project.project_id.is_some() { // if project.project_id.is_some() {
DevServerStatus::Online // DevServerStatus::Online
} else { // } else {
DevServerStatus::Offline // DevServerStatus::Offline
} // }
}) // })
.unwrap_or(DevServerStatus::Offline); // .unwrap_or(DevServerStatus::Offline);
div.child( // div.child(
v_flex() // v_flex()
.ml_5() // .ml_5()
.ml_8() // .ml_8()
.gap_2() // .gap_2()
.when(status == DevServerStatus::Offline, |this| { // .when(status == DevServerStatus::Offline, |this| {
this.child(Label::new("Waiting for project...")) // this.child(Label::new("Waiting for project..."))
}) // })
.when(status == DevServerStatus::Online, |this| { // .when(status == DevServerStatus::Online, |this| {
this.child(Label::new("Project online! 🎊")).child( // this.child(Label::new("Project online! 🎊")).child(
Button::new("done", "Done").on_click(cx.listener(|_, _, cx| { // Button::new("done", "Done").on_click(cx.listener(|_, _, cx| {
cx.dispatch_action(menu::Cancel.boxed_clone()) // cx.dispatch_action(menu::Cancel.boxed_clone())
})), // })),
) // )
}), // }),
) // )
}) // })
} // }
} }
impl ModalView for DevServerProjects {} impl ModalView for DevServerProjects {}
@ -737,7 +838,7 @@ impl Render for DevServerProjects {
.on_action(cx.listener(Self::cancel)) .on_action(cx.listener(Self::cancel))
.on_action(cx.listener(Self::confirm)) .on_action(cx.listener(Self::confirm))
.on_mouse_down_out(cx.listener(|this, _, cx| { .on_mouse_down_out(cx.listener(|this, _, cx| {
if matches!(this.mode, Mode::Default) { if matches!(this.mode, Mode::Default(None)) {
cx.emit(DismissEvent) cx.emit(DismissEvent)
} }
})) }))
@ -746,10 +847,7 @@ impl Render for DevServerProjects {
.min_h(rems(20.)) .min_h(rems(20.))
.max_h(rems(40.)) .max_h(rems(40.))
.child(match &self.mode { .child(match &self.mode {
Mode::Default => self.render_default(cx).into_any_element(), Mode::Default(_) => self.render_default(cx).into_any_element(),
Mode::CreateDevServerProject(_) => {
self.render_create_dev_server_project(cx).into_any_element()
}
Mode::CreateDevServer(_) => self.render_create_dev_server(cx).into_any_element(), Mode::CreateDevServer(_) => self.render_create_dev_server(cx).into_any_element(),
}) })
} }

7
crates/rpc/proto/zed.proto
View file

@ -237,7 +237,8 @@ message Envelope {
DevServerProjectsUpdate dev_server_projects_update = 193; DevServerProjectsUpdate dev_server_projects_update = 193;
ValidateDevServerProjectRequest validate_dev_server_project_request = 194; ValidateDevServerProjectRequest validate_dev_server_project_request = 194;
DeleteDevServer delete_dev_server = 195; DeleteDevServer delete_dev_server = 195;
OpenNewBuffer open_new_buffer = 196; // Current max OpenNewBuffer open_new_buffer = 196;
DeleteDevServerProject delete_dev_server_project = 197; // Current max
} }
reserved 158 to 161; reserved 158 to 161;
@ -498,6 +499,10 @@ message DeleteDevServer {
uint64 dev_server_id = 1; uint64 dev_server_id = 1;
} }
message DeleteDevServerProject {
uint64 dev_server_project_id = 1;
}
message ReconnectDevServer { message ReconnectDevServer {
repeated UpdateProject reshared_projects = 1; repeated UpdateProject reshared_projects = 1;
} }

2
crates/rpc/src/proto.rs
View file

@ -320,6 +320,7 @@ messages!(
(DevServerProjectsUpdate, Foreground), (DevServerProjectsUpdate, Foreground),
(ValidateDevServerProjectRequest, Background), (ValidateDevServerProjectRequest, Background),
(DeleteDevServer, Foreground), (DeleteDevServer, Foreground),
(DeleteDevServerProject, Foreground),
(OpenNewBuffer, Foreground) (OpenNewBuffer, Foreground)
); );
@ -425,6 +426,7 @@ request_messages!(
(ValidateDevServerProjectRequest, Ack), (ValidateDevServerProjectRequest, Ack),
(MultiLspQuery, MultiLspQueryResponse), (MultiLspQuery, MultiLspQueryResponse),
(DeleteDevServer, Ack), (DeleteDevServer, Ack),
(DeleteDevServerProject, Ack),
); );
entity_messages!( entity_messages!(

16
crates/workspace/src/persistence.rs
View file

@ -576,6 +576,22 @@ impl WorkspaceDb {
} }
} }
pub async fn delete_workspace_by_dev_server_project_id(
&self,
id: DevServerProjectId,
) -> Result<()> {
self.write(move |conn| {
conn.exec_bound(sql!(
DELETE FROM dev_server_projects WHERE id = ?
))?(id.0)?;
conn.exec_bound(sql!(
DELETE FROM workspaces
WHERE dev_server_project_id IS ?
))?(id.0)
})
.await
}
// Returns the recent locations which are still valid on disk and deletes ones which no longer // Returns the recent locations which are still valid on disk and deletes ones which no longer
// exist. // exist.
pub async fn recent_workspaces_on_disk( pub async fn recent_workspaces_on_disk(