remoting: Edit dev server (#11344)

This PR allows configuring existing dev server, right now you can:
- Change the dev servers name
- Generate a new token (and invalidate the old one)

<img width="563" alt="image"
src="https://github.com/zed-industries/zed/assets/53836821/9bc95042-c969-4293-90fd-0848d021b664">


Release Notes:

- N/A

crates/collab/src/db/queries/dev_servers.rs

@@ -77,10 +77,14 @@ impl Database {
         user_id: UserId,
     ) -> crate::Result<(dev_server::Model, proto::DevServerProjectsUpdate)> {
         self.transaction(|tx| async move {
+            if name.trim().is_empty() {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
             let dev_server = dev_server::Entity::insert(dev_server::ActiveModel {
                 id: ActiveValue::NotSet,
                 hashed_token: ActiveValue::Set(hashed_access_token.to_string()),
-                name: ActiveValue::Set(name.to_string()),
+                name: ActiveValue::Set(name.trim().to_string()),
                 user_id: ActiveValue::Set(user_id),
             })
             .exec_with_returning(&*tx)
@@ -95,6 +99,66 @@ impl Database {
         .await
     }
 
+    pub async fn update_dev_server_token(
+        &self,
+        id: DevServerId,
+        hashed_token: &str,
+        user_id: UserId,
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        self.transaction(|tx| async move {
+            let Some(dev_server) = dev_server::Entity::find_by_id(id).one(&*tx).await? else {
+                return Err(anyhow::anyhow!("no dev server with id {}", id))?;
+            };
+            if dev_server.user_id != user_id {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
+            dev_server::Entity::update(dev_server::ActiveModel {
+                hashed_token: ActiveValue::Set(hashed_token.to_string()),
+                ..dev_server.clone().into_active_model()
+            })
+            .exec(&*tx)
+            .await?;
+
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok(dev_server_projects)
+        })
+        .await
+    }
+
+    pub async fn rename_dev_server(
+        &self,
+        id: DevServerId,
+        name: &str,
+        user_id: UserId,
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        self.transaction(|tx| async move {
+            let Some(dev_server) = dev_server::Entity::find_by_id(id).one(&*tx).await? else {
+                return Err(anyhow::anyhow!("no dev server with id {}", id))?;
+            };
+            if dev_server.user_id != user_id || name.trim().is_empty() {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
+            dev_server::Entity::update(dev_server::ActiveModel {
+                name: ActiveValue::Set(name.trim().to_string()),
+                ..dev_server.clone().into_active_model()
+            })
+            .exec(&*tx)
+            .await?;
+
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok(dev_server_projects)
+        })
+        .await
+    }
+
     pub async fn delete_dev_server(
         &self,
         id: DevServerId,

crates/collab/src/rpc.rs

@@ -433,6 +433,8 @@ impl Server {
             .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(regenerate_dev_server_token))
+            .add_request_handler(user_handler(rename_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(shutdown_dev_server))
@@ -2343,6 +2345,12 @@ async fn create_dev_server(
     let access_token = auth::random_token();
     let hashed_access_token = auth::hash_access_token(&access_token);
 
+    if request.name.is_empty() {
+        return Err(proto::ErrorCode::Forbidden
+            .message("Dev server name cannot be empty".to_string())
+            .anyhow())?;
+    }
+
     let (dev_server, status) = session
         .db()
         .await
@@ -2359,6 +2367,71 @@ async fn create_dev_server(
     Ok(())
 }
 
+async fn regenerate_dev_server_token(
+    request: proto::RegenerateDevServerToken,
+    response: Response<proto::RegenerateDevServerToken>,
+    session: UserSession,
+) -> Result<()> {
+    let dev_server_id = DevServerId(request.dev_server_id as i32);
+    let access_token = auth::random_token();
+    let hashed_access_token = auth::hash_access_token(&access_token);
+
+    let connection_id = session
+        .connection_pool()
+        .await
+        .dev_server_connection_id(dev_server_id);
+    if let Some(connection_id) = connection_id {
+        shutdown_dev_server_internal(dev_server_id, connection_id, &session).await?;
+        session
+            .peer
+            .send(connection_id, proto::ShutdownDevServer {})?;
+        let _ = remove_dev_server_connection(dev_server_id, &session).await;
+    }
+
+    let status = session
+        .db()
+        .await
+        .update_dev_server_token(dev_server_id, &hashed_access_token, session.user_id())
+        .await?;
+
+    send_dev_server_projects_update(session.user_id(), status, &session).await;
+
+    response.send(proto::RegenerateDevServerTokenResponse {
+        dev_server_id: dev_server_id.to_proto(),
+        access_token: auth::generate_dev_server_token(dev_server_id.0 as usize, access_token),
+    })?;
+    Ok(())
+}
+
+async fn rename_dev_server(
+    request: proto::RenameDevServer,
+    response: Response<proto::RenameDevServer>,
+    session: UserSession,
+) -> Result<()> {
+    if request.name.trim().is_empty() {
+        return Err(proto::ErrorCode::Forbidden
+            .message("Dev server name cannot be empty".to_string())
+            .anyhow())?;
+    }
+
+    let dev_server_id = DevServerId(request.dev_server_id as i32);
+    let dev_server = session.db().await.get_dev_server(dev_server_id).await?;
+    if dev_server.user_id != session.user_id() {
+        return Err(anyhow!(ErrorCode::Forbidden))?;
+    }
+
+    let status = session
+        .db()
+        .await
+        .rename_dev_server(dev_server_id, &request.name, session.user_id())
+        .await?;
+
+    send_dev_server_projects_update(session.user_id(), status, &session).await;
+
+    response.send(proto::Ack {})?;
+    Ok(())
+}
+
 async fn delete_dev_server(
     request: proto::DeleteDevServer,
     response: Response<proto::DeleteDevServer>,
@@ -2379,6 +2452,7 @@ async fn delete_dev_server(
         session
             .peer
             .send(connection_id, proto::ShutdownDevServer {})?;
+        let _ = remove_dev_server_connection(dev_server_id, &session).await;
     }
 
     let status = session
@@ -2551,7 +2625,8 @@ async fn shutdown_dev_server(
     session: DevServerSession,
 ) -> Result<()> {
     response.send(proto::Ack {})?;
-    shutdown_dev_server_internal(session.dev_server_id(), session.connection_id, &session).await
+    shutdown_dev_server_internal(session.dev_server_id(), session.connection_id, &session).await?;
+    remove_dev_server_connection(session.dev_server_id(), &session).await
 }
 
 async fn shutdown_dev_server_internal(
@@ -2591,6 +2666,21 @@ async fn shutdown_dev_server_internal(
     Ok(())
 }
 
+async fn remove_dev_server_connection(dev_server_id: DevServerId, session: &Session) -> Result<()> {
+    let dev_server_connection = session
+        .connection_pool()
+        .await
+        .dev_server_connection_id(dev_server_id);
+
+    if let Some(dev_server_connection) = dev_server_connection {
+        session
+            .connection_pool()
+            .await
+            .remove_connection(dev_server_connection)?;
+    }
+    Ok(())
+}
+
 /// Updates other participants with changes to the project
 async fn update_project(
     request: proto::UpdateProject,

crates/collab/src/tests/dev_server_tests.rs

@@ -315,6 +315,139 @@ async fn test_dev_server_delete(
     })
 }
 
+#[gpui::test]
+async fn test_dev_server_rename(
+    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.rename_dev_server(
+                store.dev_servers().first().unwrap().id,
+                "name-edited".to_string(),
+                cx,
+            )
+        })
+    })
+    .await
+    .unwrap();
+
+    cx1.executor().run_until_parked();
+
+    cx1.update(|cx| {
+        dev_server_projects::Store::global(cx).update(cx, |store, _| {
+            assert_eq!(store.dev_servers().first().unwrap().name, "name-edited");
+        })
+    })
+}
+
+#[gpui::test]
+async fn test_dev_server_refresh_access_token(
+    cx1: &mut gpui::TestAppContext,
+    cx2: &mut gpui::TestAppContext,
+    cx3: &mut gpui::TestAppContext,
+    cx4: &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();
+
+    // Regenerate the access token
+    let new_token_response = cx1
+        .update(|cx| {
+            dev_server_projects::Store::global(cx).update(cx, |store, cx| {
+                store.regenerate_dev_server_token(store.dev_servers().first().unwrap().id, cx)
+            })
+        })
+        .await
+        .unwrap();
+
+    cx1.executor().run_until_parked();
+
+    // Assert that the other client was disconnected
+    let (workspace, cx2) = client2.active_workspace(cx2);
+    cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected()));
+
+    // Assert that the owner of the dev server does not see the dev server as online anymore
+    let (workspace, cx1) = client1.active_workspace(cx1);
+    cx1.update(|cx| {
+        assert!(workspace.read(cx).project().read(cx).is_disconnected());
+        dev_server_projects::Store::global(cx).update(cx, |store, _| {
+            assert_eq!(
+                store.dev_servers().first().unwrap().status,
+                DevServerStatus::Offline
+            );
+        })
+    });
+
+    // Reconnect the dev server with the new token
+    let _dev_server = server
+        .create_dev_server(new_token_response.access_token, cx4)
+        .await;
+
+    cx1.executor().run_until_parked();
+
+    // Assert that the dev server is online again
+    cx1.update(|cx| {
+        dev_server_projects::Store::global(cx).update(cx, |store, _| {
+            assert_eq!(store.dev_servers().len(), 1);
+            assert_eq!(
+                store.dev_servers().first().unwrap().status,
+                DevServerStatus::Online
+            );
+        })
+    });
+}
+
 #[gpui::test]
 async fn test_dev_server_reconnect(
     cx1: &mut gpui::TestAppContext,