Remove environment guards (#7741)

Release Notes: - N/A
2024-09-19 10:29:35 +03:00 · 2024-02-13 13:20:14 -07:00 · 2024-02-13 13:20:14 -07:00 · a2144faf9c
commit a2144faf9c
parent d744aa896f
9 changed files with 22 additions and 157 deletions
--- a/crates/collab/src/db/queries/channels.rs
+++ b/crates/collab/src/db/queries/channels.rs
@ -103,7 +103,6 @@ impl Database {
        channel_id: ChannelId,
        user_id: UserId,
        connection: ConnectionId,
-        environment: &str,
    ) -> Result<(JoinRoom, Option<MembershipUpdated>, ChannelRole)> {
        self.transaction(move |tx| async move {
            let channel = self.get_channel_internal(channel_id, &*tx).await?;
@ -163,7 +162,7 @@ impl Database {

            let live_kit_room = format!("channel-{}", nanoid::nanoid!(30));
            let room_id = self
-                .get_or_create_channel_room(channel_id, &live_kit_room, environment, &*tx)
+                .get_or_create_channel_room(channel_id, &live_kit_room, &*tx)
                .await?;

            self.join_channel_room_internal(room_id, user_id, connection, role, &*tx)
@ -933,7 +932,6 @@ impl Database {
        &self,
        channel_id: ChannelId,
        live_kit_room: &str,
-        environment: &str,
        tx: &DatabaseTransaction,
    ) -> Result<RoomId> {
        let room = room::Entity::find()
@ -942,19 +940,11 @@ impl Database {
            .await?;

        let room_id = if let Some(room) = room {
-            if let Some(env) = room.environment {
-                if &env != environment {
-                    Err(ErrorCode::WrongReleaseChannel
-                        .with_tag("required", &env)
-                        .anyhow())?;
-                }
-            }
            room.id
        } else {
            let result = room::Entity::insert(room::ActiveModel {
                channel_id: ActiveValue::Set(Some(channel_id)),
                live_kit_room: ActiveValue::Set(live_kit_room.to_string()),
-                environment: ActiveValue::Set(Some(environment.to_string())),
                ..Default::default()
            })
            .exec(&*tx)
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@ -110,12 +110,10 @@ impl Database {
        user_id: UserId,
        connection: ConnectionId,
        live_kit_room: &str,
-        release_channel: &str,
    ) -> Result<proto::Room> {
        self.transaction(|tx| async move {
            let room = room::ActiveModel {
                live_kit_room: ActiveValue::set(live_kit_room.into()),
-                environment: ActiveValue::set(Some(release_channel.to_string())),
                ..Default::default()
            }
            .insert(&*tx)
@ -302,31 +300,21 @@ impl Database {
        room_id: RoomId,
        user_id: UserId,
        connection: ConnectionId,
-        environment: &str,
    ) -> Result<RoomGuard<JoinRoom>> {
        self.room_transaction(room_id, |tx| async move {
            #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
-            enum QueryChannelIdAndEnvironment {
+            enum QueryChannelId {
                ChannelId,
-                Environment,
            }

-            let (channel_id, release_channel): (Option<ChannelId>, Option<String>) =
-                room::Entity::find()
-                    .select_only()
-                    .column(room::Column::ChannelId)
-                    .column(room::Column::Environment)
-                    .filter(room::Column::Id.eq(room_id))
-                    .into_values::<_, QueryChannelIdAndEnvironment>()
-                    .one(&*tx)
-                    .await?
-                    .ok_or_else(|| anyhow!("no such room"))?;
-
-            if let Some(release_channel) = release_channel {
-                if &release_channel != environment {
-                    Err(anyhow!("must join using the {} release", release_channel))?;
-                }
-            }
+            let channel_id: Option<ChannelId> = room::Entity::find()
+                .select_only()
+                .column(room::Column::ChannelId)
+                .filter(room::Column::Id.eq(room_id))
+                .into_values::<_, QueryChannelId>()
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such room"))?;

            if channel_id.is_some() {
                Err(anyhow!("tried to join channel call directly"))?
--- a/crates/collab/src/db/tables/room.rs
+++ b/crates/collab/src/db/tables/room.rs
@ -8,7 +8,6 @@ pub struct Model {
    pub id: RoomId,
    pub live_kit_room: String,
    pub channel_id: Option<ChannelId>,
-    pub environment: Option<String>,
 }

 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
--- a/crates/collab/src/db/tests.rs
+++ b/crates/collab/src/db/tests.rs
@ -15,8 +15,6 @@ use std::sync::{
    Arc,
 };

-const TEST_RELEASE_CHANNEL: &'static str = "test";
-
 pub struct TestDb {
    pub db: Option<Arc<Database>>,
    pub connection: Option<sqlx::AnyConnection>,
--- a/crates/collab/src/db/tests/channel_tests.rs
+++ b/crates/collab/src/db/tests/channel_tests.rs
@ -1,6 +1,6 @@
 use crate::{
    db::{
-        tests::{channel_tree, new_test_connection, new_test_user, TEST_RELEASE_CHANNEL},
+        tests::{channel_tree, new_test_connection, new_test_user},
        Channel, ChannelId, ChannelRole, Database, NewUserParams, RoomId,
    },
    test_both_dbs,
@ -135,12 +135,7 @@ async fn test_joining_channels(db: &Arc<Database>) {

    // can join a room with membership to its channel
    let (joined_room, _, _) = db
-        .join_channel(
-            channel_1,
-            user_1,
-            ConnectionId { owner_id, id: 1 },
-            TEST_RELEASE_CHANNEL,
-        )
+        .join_channel(channel_1, user_1, ConnectionId { owner_id, id: 1 })
        .await
        .unwrap();
    assert_eq!(joined_room.room.participants.len(), 1);
@ -149,12 +144,7 @@ async fn test_joining_channels(db: &Arc<Database>) {
    drop(joined_room);
    // cannot join a room without membership to its channel
    assert!(db
-        .join_room(
-            room_id,
-            user_2,
-            ConnectionId { owner_id, id: 1 },
-            TEST_RELEASE_CHANNEL
-        )
+        .join_room(room_id, user_2, ConnectionId { owner_id, id: 1 },)
        .await
        .is_err());
 }
@ -732,7 +722,7 @@ async fn test_guest_access(db: &Arc<Database>) {
        .await
        .is_err());

-    db.join_channel(zed_channel, guest, guest_connection, TEST_RELEASE_CHANNEL)
+    db.join_channel(zed_channel, guest, guest_connection)
        .await
        .unwrap();

--- a/crates/collab/src/db/tests/db_tests.rs
+++ b/crates/collab/src/db/tests/db_tests.rs
@ -517,7 +517,7 @@ async fn test_project_count(db: &Arc<Database>) {
        .unwrap();

    let room_id = RoomId::from_proto(
-        db.create_room(user1.user_id, ConnectionId { owner_id, id: 0 }, "", "test")
+        db.create_room(user1.user_id, ConnectionId { owner_id, id: 0 }, "")
            .await
            .unwrap()
            .id,
@ -531,14 +531,9 @@ async fn test_project_count(db: &Arc<Database>) {
    )
    .await
    .unwrap();
-    db.join_room(
-        room_id,
-        user2.user_id,
-        ConnectionId { owner_id, id: 1 },
-        "test",
-    )
-    .await
-    .unwrap();
+    db.join_room(room_id, user2.user_id, ConnectionId { owner_id, id: 1 })
+        .await
+        .unwrap();
    assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);

    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[])
@ -616,80 +611,3 @@ async fn test_fuzzy_search_users(cx: &mut TestAppContext) {
            .collect::<Vec<_>>()
    }
 }
-
-test_both_dbs!(
-    test_non_matching_release_channels,
-    test_non_matching_release_channels_postgres,
-    test_non_matching_release_channels_sqlite
-);
-
-async fn test_non_matching_release_channels(db: &Arc<Database>) {
-    let owner_id = db.create_server("test").await.unwrap().0 as u32;
-
-    let user1 = db
-        .create_user(
-            &format!("admin@example.com"),
-            true,
-            NewUserParams {
-                github_login: "admin".into(),
-                github_user_id: 0,
-            },
-        )
-        .await
-        .unwrap();
-    let user2 = db
-        .create_user(
-            &format!("user@example.com"),
-            false,
-            NewUserParams {
-                github_login: "user".into(),
-                github_user_id: 1,
-            },
-        )
-        .await
-        .unwrap();
-
-    let room = db
-        .create_room(
-            user1.user_id,
-            ConnectionId { owner_id, id: 0 },
-            "",
-            "stable",
-        )
-        .await
-        .unwrap();
-
-    db.call(
-        RoomId::from_proto(room.id),
-        user1.user_id,
-        ConnectionId { owner_id, id: 0 },
-        user2.user_id,
-        None,
-    )
-    .await
-    .unwrap();
-
-    // User attempts to join from preview
-    let result = db
-        .join_room(
-            RoomId::from_proto(room.id),
-            user2.user_id,
-            ConnectionId { owner_id, id: 1 },
-            "preview",
-        )
-        .await;
-
-    assert!(result.is_err());
-
-    // User switches to stable
-    let result = db
-        .join_room(
-            RoomId::from_proto(room.id),
-            user2.user_id,
-            ConnectionId { owner_id, id: 1 },
-            "stable",
-        )
-        .await;
-
-    assert!(result.is_ok())
-}
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@ -102,7 +102,6 @@ impl<R: RequestMessage> Response<R> {

 #[derive(Clone)]
 struct Session {
-    zed_environment: Arc<str>,
    user_id: UserId,
    connection_id: ConnectionId,
    db: Arc<tokio::sync::Mutex<DbHandle>>,
@ -617,7 +616,6 @@ impl Server {
                user_id,
                connection_id,
                db: Arc::new(tokio::sync::Mutex::new(DbHandle(this.app_state.db.clone()))),
-                zed_environment: this.app_state.config.zed_environment.clone(),
                peer: this.peer.clone(),
                connection_pool: this.connection_pool.clone(),
                live_kit_client: this.app_state.live_kit_client.clone(),
@ -1009,12 +1007,7 @@ async fn create_room(
    let room = session
        .db()
        .await
-        .create_room(
-            session.user_id,
-            session.connection_id,
-            &live_kit_room,
-            &session.zed_environment,
-        )
+        .create_room(session.user_id, session.connection_id, &live_kit_room)
        .await?;

    response.send(proto::CreateRoomResponse {
@ -1044,12 +1037,7 @@ async fn join_room(
        let room = session
            .db()
            .await
-            .join_room(
-                room_id,
-                session.user_id,
-                session.connection_id,
-                session.zed_environment.as_ref(),
-            )
+            .join_room(room_id, session.user_id, session.connection_id)
            .await?;
        room_updated(&room.room, &session.peer);
        room.into_inner()
@ -2734,12 +2722,7 @@ async fn join_channel_internal(
        let db = session.db().await;

        let (joined_room, membership_updated, role) = db
-            .join_channel(
-                channel_id,
-                session.user_id,
-                session.connection_id,
-                session.zed_environment.as_ref(),
-            )
+            .join_channel(channel_id, session.user_id, session.connection_id)
            .await?;

        let live_kit_connection_info = session.live_kit_client.as_ref().and_then(|live_kit| {
--- a/crates/rpc/proto/zed.proto
+++ b/crates/rpc/proto/zed.proto
@ -212,13 +212,13 @@ enum ErrorCode {
    SignedOut = 3;
    UpgradeRequired = 4;
    Forbidden = 5;
-    WrongReleaseChannel = 6;
    NeedsCla = 7;
    NotARootChannel = 8;
    BadPublicNesting = 9;
    CircularNesting = 10;
    WrongMoveTarget = 11;
    UnsharedItem = 12;
+    reserved 6;
 }

 message Test {
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@ -4201,7 +4201,6 @@ pub fn join_channel(
                                "This channel is private, and you do not have access. Please ask someone to add you and try again.".into()
                            },
                            ErrorCode::Disconnected => "Please check your internet connection and try again.".into(),
-                            ErrorCode::WrongReleaseChannel => format!("Others in the channel are using the {} release of Zed. Please switch to join this call.", err.error_tag("required").unwrap_or("other")).into(),
                            _ => format!("{}\n\nPlease try again.", err).into(),
                        };
                        cx.prompt(