Remove dev servers (#19638)

TODO:

- [ ] Check that workspace migration worked
- [ ] Add server migrations and make sure SeaORM files are in sync
(maybe?)

Release Notes:

- N/A

---------

Co-authored-by: Conrad <conrad@zed.dev>
Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>

crates/collab/src/rpc/connection_pool.rs

@@ -1,7 +1,7 @@
-use crate::db::{ChannelId, ChannelRole, DevServerId, PrincipalId, UserId};
+use crate::db::{ChannelId, ChannelRole, UserId};
 use anyhow::{anyhow, Result};
 use collections::{BTreeMap, HashMap, HashSet};
-use rpc::{proto, ConnectionId};
+use rpc::ConnectionId;
 use semantic_version::SemanticVersion;
 use serde::Serialize;
 use std::fmt;
@@ -11,9 +11,7 @@ use tracing::instrument;
 pub struct ConnectionPool {
     connections: BTreeMap<ConnectionId, Connection>,
     connected_users: BTreeMap<UserId, ConnectedPrincipal>,
-    connected_dev_servers: BTreeMap<DevServerId, ConnectionId>,
     channels: ChannelPool,
-    offline_dev_servers: HashSet<DevServerId>,
 }
 
 #[derive(Default, Serialize)]
@@ -32,13 +30,13 @@ impl fmt::Display for ZedVersion {
 
 impl ZedVersion {
     pub fn can_collaborate(&self) -> bool {
-        self.0 >= SemanticVersion::new(0, 151, 0)
+        self.0 >= SemanticVersion::new(0, 157, 0)
     }
 }
 
 #[derive(Serialize)]
 pub struct Connection {
-    pub principal_id: PrincipalId,
+    pub user_id: UserId,
     pub admin: bool,
     pub zed_version: ZedVersion,
 }
@@ -47,7 +45,6 @@ impl ConnectionPool {
     pub fn reset(&mut self) {
         self.connections.clear();
         self.connected_users.clear();
-        self.connected_dev_servers.clear();
         self.channels.clear();
     }
 
@@ -66,7 +63,7 @@ impl ConnectionPool {
         self.connections.insert(
             connection_id,
             Connection {
-                principal_id: PrincipalId::UserId(user_id),
+                user_id,
                 admin,
                 zed_version,
             },
@@ -75,25 +72,6 @@ impl ConnectionPool {
         connected_user.connection_ids.insert(connection_id);
     }
 
-    pub fn add_dev_server(
-        &mut self,
-        connection_id: ConnectionId,
-        dev_server_id: DevServerId,
-        zed_version: ZedVersion,
-    ) {
-        self.connections.insert(
-            connection_id,
-            Connection {
-                principal_id: PrincipalId::DevServerId(dev_server_id),
-                admin: false,
-                zed_version,
-            },
-        );
-
-        self.connected_dev_servers
-            .insert(dev_server_id, connection_id);
-    }
-
     #[instrument(skip(self))]
     pub fn remove_connection(&mut self, connection_id: ConnectionId) -> Result<()> {
         let connection = self
@@ -101,28 +79,18 @@ impl ConnectionPool {
             .get_mut(&connection_id)
             .ok_or_else(|| anyhow!("no such connection"))?;
 
-        match connection.principal_id {
-            PrincipalId::UserId(user_id) => {
-                let connected_user = self.connected_users.get_mut(&user_id).unwrap();
-                connected_user.connection_ids.remove(&connection_id);
-                if connected_user.connection_ids.is_empty() {
-                    self.connected_users.remove(&user_id);
-                    self.channels.remove_user(&user_id);
-                }
-            }
-            PrincipalId::DevServerId(dev_server_id) => {
-                self.connected_dev_servers.remove(&dev_server_id);
-                self.offline_dev_servers.remove(&dev_server_id);
-            }
-        }
+        let user_id = connection.user_id;
+
+        let connected_user = self.connected_users.get_mut(&user_id).unwrap();
+        connected_user.connection_ids.remove(&connection_id);
+        if connected_user.connection_ids.is_empty() {
+            self.connected_users.remove(&user_id);
+            self.channels.remove_user(&user_id);
+        };
         self.connections.remove(&connection_id).unwrap();
         Ok(())
     }
 
-    pub fn set_dev_server_offline(&mut self, dev_server_id: DevServerId) {
-        self.offline_dev_servers.insert(dev_server_id);
-    }
-
     pub fn connections(&self) -> impl Iterator<Item = &Connection> {
         self.connections.values()
     }
@@ -147,42 +115,6 @@ impl ConnectionPool {
             .copied()
     }
 
-    pub fn dev_server_status(&self, dev_server_id: DevServerId) -> proto::DevServerStatus {
-        if self.dev_server_connection_id(dev_server_id).is_some()
-            && !self.offline_dev_servers.contains(&dev_server_id)
-        {
-            proto::DevServerStatus::Online
-        } else {
-            proto::DevServerStatus::Offline
-        }
-    }
-
-    pub fn dev_server_connection_id(&self, dev_server_id: DevServerId) -> Option<ConnectionId> {
-        self.connected_dev_servers.get(&dev_server_id).copied()
-    }
-
-    pub fn online_dev_server_connection_id(
-        &self,
-        dev_server_id: DevServerId,
-    ) -> Result<ConnectionId> {
-        match self.connected_dev_servers.get(&dev_server_id) {
-            Some(cid) => Ok(*cid),
-            None => Err(anyhow!(proto::ErrorCode::DevServerOffline)),
-        }
-    }
-
-    pub fn dev_server_connection_id_supporting(
-        &self,
-        dev_server_id: DevServerId,
-        required: ZedVersion,
-    ) -> Result<ConnectionId> {
-        match self.connected_dev_servers.get(&dev_server_id) {
-            Some(cid) if self.connections[cid].zed_version >= required => Ok(*cid),
-            Some(_) => Err(anyhow!(proto::ErrorCode::RemoteUpgradeRequired)),
-            None => Err(anyhow!(proto::ErrorCode::DevServerOffline)),
-        }
-    }
-
     pub fn channel_user_ids(
         &self,
         channel_id: ChannelId,
@@ -227,39 +159,22 @@ impl ConnectionPool {
     #[cfg(test)]
     pub fn check_invariants(&self) {
         for (connection_id, connection) in &self.connections {
-            match &connection.principal_id {
-                PrincipalId::UserId(user_id) => {
-                    assert!(self
-                        .connected_users
-                        .get(user_id)
-                        .unwrap()
-                        .connection_ids
-                        .contains(connection_id));
-                }
-                PrincipalId::DevServerId(dev_server_id) => {
-                    assert_eq!(
-                        self.connected_dev_servers.get(dev_server_id).unwrap(),
-                        connection_id
-                    );
-                }
-            }
+            assert!(self
+                .connected_users
+                .get(&connection.user_id)
+                .unwrap()
+                .connection_ids
+                .contains(connection_id));
         }
 
         for (user_id, state) in &self.connected_users {
             for connection_id in &state.connection_ids {
                 assert_eq!(
-                    self.connections.get(connection_id).unwrap().principal_id,
-                    PrincipalId::UserId(*user_id)
+                    self.connections.get(connection_id).unwrap().user_id,
+                    *user_id
                 );
             }
         }
-
-        for (dev_server_id, connection_id) in &self.connected_dev_servers {
-            assert_eq!(
-                self.connections.get(connection_id).unwrap().principal_id,
-                PrincipalId::DevServerId(*dev_server_id)
-            );
-        }
     }
 }