Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
livekit_api: Fix LiveKit token revocation timestamps (#60157)
Richard Feldman59185f5a70b4
diff --git a/crates/collab/tests/integration/channel_tests.rs b/crates/collab/tests/integration/channel_tests.rsindex 329478819e4..7b20620082d 100644--- a/crates/collab/tests/integration/channel_tests.rs+++ b/crates/collab/tests/integration/channel_tests.rs@@ -589,6 +589,95 @@ async fn test_channel_room();}+#[gpui::test]+async fn test_rejoining_channel_after_stale_connection_cleanup_connects_livekit(+ executor: BackgroundExecutor,+ cx_a: &mut TestAppContext,+ cx_a2: &mut TestAppContext,+ cx_b: &mut TestAppContext,+) {+ let mut server = TestServer::start(executor.clone()).await;+ let client_a = server.create_client(cx_a, "user_a").await;+ let client_b = server.create_client(cx_b, "user_b").await;++ let channel_id = server+ .make_channel("zed", None, (&client_a, cx_a), &mut [(&client_b, cx_b)])+ .await;++ let active_call_a = cx_a.read(ActiveCall::global);+ active_call_a+ .update(cx_a, |active_call, cx| {+ active_call.join_channel(channel_id, cx)+ })+ .await+ .unwrap();++ let active_call_b = cx_b.read(ActiveCall::global);+ active_call_b+ .update(cx_b, |active_call, cx| {+ active_call.join_channel(channel_id, cx)+ })+ .await+ .unwrap();++ executor.run_until_parked();++ let old_room_a =+ cx_a.read(|cx| active_call_a.read_with(cx, |call, _| call.room().unwrap().clone()));+ cx_a.read(|cx| old_room_a.read_with(cx, |room, cx| assert!(room.is_connected(cx))));++ server.disconnect_client(client_a.peer_id().unwrap());+ executor.run_until_parked();+ server.advance_livekit_timestamp();++ let client_a2 = server.create_client(cx_a2, "user_a").await;+ let active_call_a2 = cx_a2.read(ActiveCall::global);+ active_call_a2+ .update(cx_a2, |active_call, cx| {+ active_call.join_channel(channel_id, cx)+ })+ .await+ .unwrap();++ executor.run_until_parked();++ let room_a2 =+ cx_a2.read(|cx| active_call_a2.read_with(cx, |call, _| call.room().unwrap().clone()));+ cx_a2.read(|cx| room_a2.read_with(cx, |room, cx| assert!(room.is_connected(cx))));+ assert_eq!(+ room_participants(&room_a2, cx_a2),+ RoomParticipants {+ remote: vec!["user_b".to_string()],+ pending: vec![]+ }+ );++ let room_b =+ cx_b.read(|cx| active_call_b.read_with(cx, |call, _| call.room().unwrap().clone()));+ cx_b.read(|cx| room_b.read_with(cx, |room, cx| assert!(room.is_connected(cx))));+ assert_eq!(+ room_participants(&room_b, cx_b),+ RoomParticipants {+ remote: vec!["user_a".to_string()],+ pending: vec![]+ }+ );++ cx_a2.read(|cx| {+ client_a2.channel_store().read_with(cx, |channels, _| {+ let mut participant_ids = channels+ .channel_participants(channel_id)+ .iter()+ .map(|participant| participant.legacy_id)+ .collect::<Vec<_>>();+ participant_ids.sort_unstable();+ let mut expected_ids = vec![client_a2.user_id().unwrap(), client_b.user_id().unwrap()];+ expected_ids.sort_unstable();+ assert_eq!(participant_ids, expected_ids);+ })+ });+}+#[gpui::test]async fn test_channel_jumping(executor: BackgroundExecutor, cx_a: &mut TestAppContext) {let mut server = TestServer::start(executor.clone()).await;diff --git a/crates/collab/tests/integration/test_server.rs b/crates/collab/tests/integration/test_server.rsindex 62169c9a938..3434674e630 100644--- a/crates/collab/tests/integration/test_server.rs+++ b/crates/collab/tests/integration/test_server.rs@@ -48,7 +48,7 @@ use std::{use util::path;use workspace::{MultiWorkspace, Workspace, WorkspaceStore};-use livekit_client::test::TestServer as LivekitTestServer;+use livekit_client::test::{ManualUnixTimestampSource, TestServer as LivekitTestServer};use crate::db_tests::TestDb;@@ -56,6 +56,7 @@ pub struct TestServer {pub app_state: Arc<AppState>,pub test_livekit_server: Arc<LivekitTestServer>,pub test_db: TestDb,+ livekit_timestamp_source: Arc<ManualUnixTimestampSource>,server: Arc<Server>,next_github_user_id: i32,connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,@@ -96,11 +97,13 @@ impl TestServer {TestDb::sqlite(deterministic.clone())};let livekit_server_id = NEXT_LIVEKIT_SERVER_ID.fetch_add(1, SeqCst);- let livekit_server = LivekitTestServer::create(+ let livekit_timestamp_source = Arc::new(ManualUnixTimestampSource::new(1_234_567));+ let livekit_server = LivekitTestServer::create_with_timestamp_source(format!("http://livekit.{}.test", livekit_server_id),format!("devkey-{}", livekit_server_id),format!("secret-{}", livekit_server_id),deterministic.clone(),+ livekit_timestamp_source.clone(),).unwrap();let executor = Executor::Deterministic(deterministic.clone());@@ -121,10 +124,15 @@ impl TestServer {forbid_connections: Default::default(),next_github_user_id: 0,test_db,+ livekit_timestamp_source,test_livekit_server: livekit_server,}}+ pub fn advance_livekit_timestamp(&self) {+ self.livekit_timestamp_source.advance();+ }+pub async fn start2(cx_a: &mut TestAppContext,cx_b: &mut TestAppContext,diff --git a/crates/livekit_api/Cargo.toml b/crates/livekit_api/Cargo.tomlindex 2b2438c25e6..80ba67d9941 100644--- a/crates/livekit_api/Cargo.toml+++ b/crates/livekit_api/Cargo.toml@@ -13,6 +13,9 @@ workspace = truepath = "src/livekit_api.rs"doctest = false+[features]+test-support = []+[dependencies]anyhow.workspace = trueasync-trait.workspace = truediff --git a/crates/livekit_api/src/livekit_api.rs b/crates/livekit_api/src/livekit_api.rsindex 745f511b12e..250f56b3fd9 100644--- a/crates/livekit_api/src/livekit_api.rs+++ b/crates/livekit_api/src/livekit_api.rs@@ -31,10 +31,25 @@ pub struct LiveKitClient {url: Arc<str>,key: Arc<str>,secret: Arc<str>,+ timestamp_source: Arc<dyn token::UnixTimestampSource>,}impl LiveKitClient {- pub fn new(mut url: String, key: String, secret: String) -> Self {+ pub fn new(url: String, key: String, secret: String) -> Self {+ Self::new_with_timestamp_source(+ url,+ key,+ secret,+ Arc::new(token::SystemUnixTimestampSource),+ )+ }++ pub(crate) fn new_with_timestamp_source(+ mut url: String,+ key: String,+ secret: String,+ timestamp_source: Arc<dyn token::UnixTimestampSource>,+ ) -> Self {if url.ends_with('/') {url.pop();}@@ -47,6 +62,7 @@ impl LiveKitClient {url: url.into(),key: key.into(),secret: secret.into(),+ timestamp_source,}}@@ -61,7 +77,13 @@ impl LiveKitClient {Res: Default + Message,{let client = self.http.clone();- let token = token::create(&self.key, &self.secret, None, grant);+ let token = token::create_with_timestamp_source(+ &self.key,+ &self.secret,+ None,+ grant,+ self.timestamp_source.as_ref(),+ );let url = format!("{}/{}", self.url, path);log::info!("Request {}: {:?}", url, body);async move {@@ -163,20 +185,22 @@ impl Client for LiveKitClient {}fn room_token(&self, room: &str, identity: &str) -> Result<String> {- token::create(+ token::create_with_timestamp_source(&self.key,&self.secret,Some(identity),token::VideoGrant::to_join(room),+ self.timestamp_source.as_ref(),)}fn guest_token(&self, room: &str, identity: &str) -> Result<String> {- token::create(+ token::create_with_timestamp_source(&self.key,&self.secret,Some(identity),token::VideoGrant::for_guest(room),+ self.timestamp_source.as_ref(),)}}diff --git a/crates/livekit_api/src/token.rs b/crates/livekit_api/src/token.rsindex 6f12d788551..5229a83bb6e 100644--- a/crates/livekit_api/src/token.rs+++ b/crates/livekit_api/src/token.rs@@ -1,14 +1,25 @@-use anyhow::Result;+use anyhow::{Context as _, Result};use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation};use serde::{Deserialize, Serialize};use std::{borrow::Cow,- ops::Add,time::{Duration, SystemTime, UNIX_EPOCH},};const DEFAULT_TTL: Duration = Duration::from_secs(6 * 60 * 60); // 6 hours+pub trait UnixTimestampSource: Send + Sync {+ fn unix_timestamp(&self) -> Result<u64>;+}++pub struct SystemUnixTimestampSource;++impl UnixTimestampSource for SystemUnixTimestampSource {+ fn unix_timestamp(&self) -> Result<u64> {+ Ok(SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs())+ }+}+#[derive(Default, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct ClaimGrants<'a> {@@ -73,22 +84,55 @@ pub fn create(identity: Option<&str>,video_grant: VideoGrant,) -> Result<String> {- if video_grant.room_join.is_some() && identity.is_none() {+ create_with_timestamp_source(+ api_key,+ secret_key,+ identity,+ video_grant,+ &SystemUnixTimestampSource,+ )+}++pub fn create_with_timestamp_source(+ api_key: &str,+ secret_key: &str,+ identity: Option<&str>,+ video_grant: VideoGrant,+ timestamp_source: &dyn UnixTimestampSource,+) -> Result<String> {+ let issued_at = timestamp_source.unix_timestamp()?;+ create_with_issued_at(api_key, secret_key, identity, video_grant, issued_at)+}++fn create_with_issued_at(+ api_key: &str,+ secret_key: &str,+ identity: Option<&str>,+ video_grant: VideoGrant,+ issued_at: u64,+) -> Result<String> {+ let room_join = video_grant.room_join.unwrap_or(false);+ if room_join && identity.is_none() {anyhow::bail!("identity is required for room_join grant, but it is none");}- let now = SystemTime::now();+ let expires_at = issued_at+ .checked_add(DEFAULT_TTL.as_secs())+ .context("token expiration overflow")?;+ let not_before = if room_join {+ // LiveKit Cloud applies participant revocations by comparing the+ // revocation timestamp to room-join token `nbf`.+ issued_at+ } else {+ 0+ };let claims = ClaimGrants {iss: Cow::Borrowed(api_key),sub: identity.map(Cow::Borrowed),- iat: now.duration_since(UNIX_EPOCH).unwrap().as_secs(),- exp: now- .add(DEFAULT_TTL)- .duration_since(UNIX_EPOCH)- .unwrap()- .as_secs(),- nbf: 0,+ iat: issued_at,+ exp: expires_at,+ nbf: not_before,jwtid: identity.map(Cow::Borrowed),video: video_grant,};@@ -108,3 +152,127 @@ pub fn validate<'a>(token: &'a str, secret_key: &str) -> Result<ClaimGrants<'a>>Ok(token.claims)}++#[cfg(any(test, feature = "test-support"))]+pub fn validate_with_timestamp_source<'a>(+ token: &'a str,+ secret_key: &str,+ timestamp_source: &dyn UnixTimestampSource,+) -> Result<ClaimGrants<'a>> {+ let mut validation = Validation::default();+ validation.validate_exp = false;+ validation.validate_nbf = false;+ let token: jsonwebtoken::TokenData<ClaimGrants<'_>> = jsonwebtoken::decode(+ token,+ &DecodingKey::from_secret(secret_key.as_ref()),+ &validation,+ )?;+ let claims = token.claims;+ let timestamp = timestamp_source.unix_timestamp()?;++ anyhow::ensure!(claims.nbf <= timestamp, "token is not yet valid");+ anyhow::ensure!(claims.exp > timestamp, "token has expired");++ Ok(claims)+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{Client as _, LiveKitClient};+ use std::sync::Arc;++ const ISSUED_AT: u64 = 1_234_567;++ struct FixedUnixTimestampSource(u64);++ impl UnixTimestampSource for FixedUnixTimestampSource {+ fn unix_timestamp(&self) -> Result<u64> {+ Ok(self.0)+ }+ }++ #[test]+ fn token_not_before_matches_issue_time() -> Result<()> {+ let token = create_with_timestamp_source(+ "api-key",+ "secret-key",+ Some("participant"),+ VideoGrant::to_join("room"),+ &FixedUnixTimestampSource(ISSUED_AT),+ )?;++ assert_claims_timestamp(&token, ISSUED_AT, ISSUED_AT)?;+ Ok(())+ }++ #[test]+ fn room_token_not_before_matches_issue_time() -> Result<()> {+ let client = LiveKitClient::new_with_timestamp_source(+ "http://livekit.test".into(),+ "api-key".into(),+ "secret-key".into(),+ Arc::new(FixedUnixTimestampSource(ISSUED_AT)),+ );+ let token = client.room_token("room", "participant")?;++ let claims = assert_claims_timestamp(&token, ISSUED_AT, ISSUED_AT)?;+ assert_eq!(claims.video.room_join, Some(true));+ assert_eq!(claims.video.can_publish, Some(true));+ assert_eq!(claims.video.can_subscribe, Some(true));++ Ok(())+ }++ #[test]+ fn guest_token_not_before_matches_issue_time() -> Result<()> {+ let client = LiveKitClient::new_with_timestamp_source(+ "http://livekit.test".into(),+ "api-key".into(),+ "secret-key".into(),+ Arc::new(FixedUnixTimestampSource(ISSUED_AT)),+ );+ let token = client.guest_token("room", "participant")?;++ let claims = assert_claims_timestamp(&token, ISSUED_AT, ISSUED_AT)?;+ assert_eq!(claims.video.room_join, Some(true));+ assert_eq!(claims.video.can_publish, Some(false));+ assert_eq!(claims.video.can_subscribe, Some(true));++ Ok(())+ }++ #[test]+ fn admin_token_not_before_remains_unset() -> Result<()> {+ let token = create_with_timestamp_source(+ "api-key",+ "secret-key",+ None,+ VideoGrant::to_admin("room"),+ &FixedUnixTimestampSource(ISSUED_AT),+ )?;++ let claims = assert_claims_timestamp(&token, ISSUED_AT, 0)?;+ assert_eq!(claims.video.room_admin, Some(true));++ Ok(())+ }++ fn assert_claims_timestamp(+ token: &str,+ issued_at: u64,+ expected_not_before: u64,+ ) -> Result<ClaimGrants<'_>> {+ let claims = validate_with_timestamp_source(+ token,+ "secret-key",+ &FixedUnixTimestampSource(issued_at),+ )?;++ assert_eq!(claims.iat, issued_at);+ assert_eq!(claims.nbf, expected_not_before);+ assert_eq!(claims.exp, issued_at + DEFAULT_TTL.as_secs());++ Ok(claims)+ }+}diff --git a/crates/livekit_client/Cargo.toml b/crates/livekit_client/Cargo.tomlindex 42c13f094c1..a229d39ca8c 100644--- a/crates/livekit_client/Cargo.toml+++ b/crates/livekit_client/Cargo.toml@@ -17,7 +17,7 @@ doctest = falsename = "test_app"[features]-test-support = ["collections/test-support", "gpui/test-support"]+test-support = ["collections/test-support", "gpui/test-support", "livekit_api/test-support"][dependencies]anyhow.workspace = true@@ -65,6 +65,7 @@ objc.workspace = truecollections = { workspace = true, features = ["test-support"] }gpui = { workspace = true, features = ["test-support"] }gpui_platform.workspace = true+livekit_api = { workspace = true, features = ["test-support"] }simplelog.workspace = true[build-dependencies]diff --git a/crates/livekit_client/src/test.rs b/crates/livekit_client/src/test.rsindex 955f92dc19d..d742dd06617 100644--- a/crates/livekit_client/src/test.rs+++ b/crates/livekit_client/src/test.rs@@ -57,6 +57,25 @@ pub struct TestServer {pub secret_key: String,rooms: Mutex<HashMap<String, TestServerRoom>>,executor: BackgroundExecutor,+ timestamp_source: Arc<dyn token::UnixTimestampSource>,+}++pub struct ManualUnixTimestampSource(AtomicU64);++impl ManualUnixTimestampSource {+ pub fn new(timestamp: u64) -> Self {+ Self(AtomicU64::new(timestamp))+ }++ pub fn advance(&self) {+ self.0.fetch_add(1, SeqCst);+ }+}++impl token::UnixTimestampSource for ManualUnixTimestampSource {+ fn unix_timestamp(&self) -> Result<u64> {+ Ok(self.0.load(SeqCst))+ }}impl TestServer {@@ -65,6 +84,22 @@ impl TestServer {api_key: String,secret_key: String,executor: BackgroundExecutor,+ ) -> Result<Arc<TestServer>> {+ Self::create_with_timestamp_source(+ url,+ api_key,+ secret_key,+ executor,+ Arc::new(token::SystemUnixTimestampSource),+ )+ }++ pub fn create_with_timestamp_source(+ url: String,+ api_key: String,+ secret_key: String,+ executor: BackgroundExecutor,+ timestamp_source: Arc<dyn token::UnixTimestampSource>,) -> Result<Arc<TestServer>> {let mut servers = SERVERS.lock();if let BTreeEntry::Vacant(e) = servers.entry(url.clone()) {@@ -74,6 +109,7 @@ impl TestServer {secret_key,rooms: Default::default(),executor,+ timestamp_source,});e.insert(server.clone());Ok(server)@@ -104,6 +140,20 @@ impl TestServer {}}+ #[cfg(any(test, feature = "test-support"))]+ fn validate_token<'a>(&self, token: &'a str) -> Result<token::ClaimGrants<'a>> {+ token::validate_with_timestamp_source(+ token,+ &self.secret_key,+ self.timestamp_source.as_ref(),+ )+ }++ #[cfg(not(any(test, feature = "test-support")))]+ fn validate_token<'a>(&self, token: &'a str) -> Result<token::ClaimGrants<'a>> {+ token::validate(token, &self.secret_key)+ }+pub async fn create_room(&self, room: String) -> Result<()> {self.simulate_random_delay().await;@@ -129,11 +179,19 @@ impl TestServer {async fn join_room(&self, token: String, client_room: Room) -> Result<ParticipantIdentity> {self.simulate_random_delay().await;- let claims = livekit_api::token::validate(&token, &self.secret_key)?;- let identity = ParticipantIdentity(claims.sub.unwrap().to_string());- let room_name = claims.video.room.unwrap();+ let claims = self.validate_token(&token)?;+ let identity = ParticipantIdentity(+ claims+ .sub+ .context("missing participant identity")?+ .to_string(),+ );+ let room_name = claims.video.room.context("missing room name")?.to_string();let mut server_rooms = self.rooms.lock();- let room = (*server_rooms).entry(room_name.to_string()).or_default();+ let room = (*server_rooms).entry(room_name.clone()).or_default();+ if let Some(revoked_before) = room.token_revocations.get(&identity) {+ anyhow::ensure!(claims.nbf >= *revoked_before, "invalid token: revoked");+ }if let Entry::Vacant(e) = room.client_rooms.entry(identity.clone()) {for server_track in &room.video_tracks {@@ -192,7 +250,7 @@ impl TestServer {async fn leave_room(&self, token: String) -> Result<()> {self.simulate_random_delay().await;- let claims = livekit_api::token::validate(&token, &self.secret_key)?;+ let claims = self.validate_token(&token)?;let identity = ParticipantIdentity(claims.sub.unwrap().to_string());let room_name = claims.video.room.unwrap();let mut server_rooms = self.rooms.lock();@@ -209,7 +267,7 @@ impl TestServer {&self,token: String,) -> Result<HashMap<ParticipantIdentity, RemoteParticipant>> {- let claims = livekit_api::token::validate(&token, &self.secret_key)?;+ let claims = self.validate_token(&token)?;let local_identity = ParticipantIdentity(claims.sub.unwrap().to_string());let room_name = claims.video.room.unwrap().to_string();@@ -244,14 +302,25 @@ impl TestServer {identity: ParticipantIdentity,) -> Result<()> {self.simulate_random_delay().await;+ let revoked_before = self.timestamp_source.unix_timestamp()?;let mut server_rooms = self.rooms.lock();let room = server_rooms.get_mut(&room_name).with_context(|| format!("room {room_name} does not exist"))?;- room.client_rooms+ let removed_room = room+ .client_rooms.remove(&identity).with_context(|| format!("participant {identity:?} did not join room {room_name:?}"))?;+ room.token_revocations.insert(identity, revoked_before);+ let mut removed_room = removed_room.0.lock();+ removed_room.connection_state = ConnectionState::Disconnected;+ removed_room+ .updates_tx+ .blocking_send(RoomEvent::Disconnected {+ reason: "PARTICIPANT_REMOVED",+ })+ .ok();Ok(())}@@ -262,13 +331,18 @@ impl TestServer {permission: proto::ParticipantPermission,) -> Result<()> {self.simulate_random_delay().await;+ let revoked_before = self.timestamp_source.unix_timestamp()?;let mut server_rooms = self.rooms.lock();let room = server_rooms.get_mut(&room_name).with_context(|| format!("room {room_name} does not exist"))?;+ let identity = ParticipantIdentity(identity);room.participant_permissions- .insert(ParticipantIdentity(identity), permission);+ .insert(identity.clone(), permission);+ // Permission changes in LiveKit Cloud invalidate existing participant+ // tokens, so the mock needs to reject tokens minted before the update.+ room.token_revocations.insert(identity, revoked_before);Ok(())}@@ -298,7 +372,7 @@ impl TestServer {) -> Result<TrackSid> {self.simulate_random_delay().await;- let claims = livekit_api::token::validate(&token, &self.secret_key)?;+ let claims = self.validate_token(&token)?;let identity = ParticipantIdentity(claims.sub.unwrap().to_string());let room_name = claims.video.room.unwrap();@@ -362,7 +436,7 @@ impl TestServer {) -> Result<TrackSid> {self.simulate_random_delay().await;- let claims = livekit_api::token::validate(&token, &self.secret_key)?;+ let claims = self.validate_token(&token)?;let identity = ParticipantIdentity(claims.sub.unwrap().to_string());let room_name = claims.video.room.unwrap();@@ -421,7 +495,7 @@ impl TestServer {}pub(crate) async fn unpublish_track(&self, token: String, track_sid: &TrackSid) -> Result<()> {- let claims = livekit_api::token::validate(&token, &self.secret_key)?;+ let claims = self.validate_token(&token)?;let identity = ParticipantIdentity(claims.sub.unwrap().to_string());let room_name = claims.video.room.unwrap();@@ -503,7 +577,7 @@ impl TestServer {track_sid: &TrackSid,muted: bool,) -> Result<()> {- let claims = livekit_api::token::validate(token, &self.secret_key)?;+ let claims = self.validate_token(token)?;let room_name = claims.video.room.unwrap();let identity = ParticipantIdentity(claims.sub.unwrap().to_string());let mut server_rooms = self.rooms.lock();@@ -557,7 +631,7 @@ impl TestServer {}pub(crate) fn is_track_muted(&self, token: &str, track_sid: &TrackSid) -> Option<bool> {- let claims = livekit_api::token::validate(token, &self.secret_key).ok()?;+ let claims = self.validate_token(token).ok()?;let room_name = claims.video.room.unwrap();let mut server_rooms = self.rooms.lock();@@ -572,7 +646,7 @@ impl TestServer {}pub(crate) fn video_tracks(&self, token: String) -> Result<Vec<RemoteVideoTrack>> {- let claims = livekit_api::token::validate(&token, &self.secret_key)?;+ let claims = self.validate_token(&token)?;let room_name = claims.video.room.unwrap();let identity = ParticipantIdentity(claims.sub.unwrap().to_string());@@ -595,7 +669,7 @@ impl TestServer {}pub(crate) fn audio_tracks(&self, token: String) -> Result<Vec<RemoteAudioTrack>> {- let claims = livekit_api::token::validate(&token, &self.secret_key)?;+ let claims = self.validate_token(&token)?;let room_name = claims.video.room.unwrap();let identity = ParticipantIdentity(claims.sub.unwrap().to_string());@@ -629,6 +703,7 @@ struct TestServerRoom {video_tracks: Vec<Arc<TestServerVideoTrack>>,audio_tracks: Vec<Arc<TestServerAudioTrack>>,participant_permissions: HashMap<ParticipantIdentity, proto::ParticipantPermission>,+ token_revocations: HashMap<ParticipantIdentity, u64>,}#[derive(Debug)]@@ -690,21 +765,23 @@ impl livekit_api::Client for TestApiClient {fn room_token(&self, room: &str, identity: &str) -> Result<String> {let server = TestServer::get(&self.url)?;- token::create(+ token::create_with_timestamp_source(&server.api_key,&server.secret_key,Some(identity),token::VideoGrant::to_join(room),+ server.timestamp_source.as_ref(),)}fn guest_token(&self, room: &str, identity: &str) -> Result<String> {let server = TestServer::get(&self.url)?;- token::create(+ token::create_with_timestamp_source(&server.api_key,&server.secret_key,Some(identity),token::VideoGrant::for_guest(room),+ server.timestamp_source.as_ref(),)}}@@ -853,3 +930,168 @@ impl WeakRoom {self.0.upgrade().map(Room)}}++#[cfg(test)]+mod tests {+ use super::*;+ use gpui::TestAppContext;+ use livekit_api::Client as _;+ use std::{ops::Deref, sync::atomic::AtomicUsize};++ struct TestServerGuard {+ server: Arc<TestServer>,+ timestamp_source: Arc<ManualUnixTimestampSource>,+ }++ impl TestServerGuard {+ fn advance_timestamp(&self) {+ self.timestamp_source.advance();+ }+ }++ impl Deref for TestServerGuard {+ type Target = TestServer;++ fn deref(&self) -> &Self::Target {+ self.server.as_ref()+ }+ }++ impl Drop for TestServerGuard {+ fn drop(&mut self) {+ self.server.teardown().ok();+ }+ }++ fn create_test_server(name: &str, executor: BackgroundExecutor) -> TestServerGuard {+ static NEXT_SERVER_ID: AtomicUsize = AtomicUsize::new(0);+ let server_id = NEXT_SERVER_ID.fetch_add(1, SeqCst);+ let timestamp_source = Arc::new(ManualUnixTimestampSource::new(1_234_567));+ let server = TestServer::create_with_timestamp_source(+ format!("http://livekit-{name}-{server_id}.test"),+ format!("api-key-{server_id}"),+ format!("secret-key-{server_id}"),+ executor,+ timestamp_source.clone(),+ )+ .expect("create LiveKit test server");+ TestServerGuard {+ server,+ timestamp_source,+ }+ }++ async fn assert_token_was_revoked(server: &TestServer, token: String, cx: &mut TestAppContext) {+ match Room::connect(server.url.clone(), token, &mut cx.to_async()).await {+ Ok(_) => panic!("revoked token unexpectedly connected"),+ Err(error) => {+ let error = format!("{error:#}");+ assert!(+ error.contains("invalid token: revoked"),+ "expected revoked token error, got {error}"+ );+ }+ }+ }++ #[gpui::test]+ async fn token_created_after_participant_removal_can_join(+ executor: BackgroundExecutor,+ cx: &mut TestAppContext,+ ) {+ let server = create_test_server("room-token", executor);+ server+ .create_room("room".into())+ .await+ .expect("create LiveKit test room");+ let api_client = server.create_api_client();++ let initial_token = api_client+ .room_token("room", "participant")+ .expect("create initial room token");+ let (initial_room, _) = Room::connect(+ server.url.clone(),+ initial_token.clone(),+ &mut cx.to_async(),+ )+ .await+ .expect("connect with initial room token");++ server.advance_timestamp();+ api_client+ .remove_participant("room".into(), "participant".into())+ .await+ .expect("remove participant");++ assert_eq!(+ initial_room.connection_state(),+ ConnectionState::Disconnected+ );+ assert_token_was_revoked(&server, initial_token, cx).await;++ let fresh_token = api_client+ .room_token("room", "participant")+ .expect("create fresh room token");+ let (fresh_room, _) = Room::connect(server.url.clone(), fresh_token, &mut cx.to_async())+ .await+ .expect("connect with fresh room token");++ assert_eq!(fresh_room.connection_state(), ConnectionState::Connected);+ }++ #[gpui::test]+ async fn guest_token_created_after_permission_update_can_join(+ executor: BackgroundExecutor,+ cx: &mut TestAppContext,+ ) {+ let server = create_test_server("guest-token", executor);+ server+ .create_room("room".into())+ .await+ .expect("create LiveKit test room");+ let api_client = server.create_api_client();++ let initial_token = api_client+ .guest_token("room", "participant")+ .expect("create initial guest token");+ let (initial_room, _) = Room::connect(+ server.url.clone(),+ initial_token.clone(),+ &mut cx.to_async(),+ )+ .await+ .expect("connect with initial guest token");++ server.advance_timestamp();+ api_client+ .update_participant(+ "room".into(),+ "participant".into(),+ proto::ParticipantPermission {+ can_subscribe: true,+ can_publish: true,+ can_publish_data: true,+ hidden: false,+ recorder: false,+ },+ )+ .await+ .expect("update participant permissions");+ assert_token_was_revoked(&server, initial_token, cx).await;++ server.disconnect_client("participant".into()).await;+ assert_eq!(+ initial_room.connection_state(),+ ConnectionState::Disconnected+ );++ let fresh_token = api_client+ .guest_token("room", "participant")+ .expect("create fresh guest token");+ let (fresh_room, _) = Room::connect(server.url.clone(), fresh_token, &mut cx.to_async())+ .await+ .expect("connect with fresh guest token");++ assert_eq!(fresh_room.connection_state(), ConnectionState::Connected);+ }+}