2022-10-19 12:58:50 +00:00
|
|
|
use anyhow::{anyhow, Result};
|
2022-10-19 14:35:34 +00:00
|
|
|
use async_trait::async_trait;
|
2022-10-19 12:58:50 +00:00
|
|
|
use collections::HashMap;
|
2022-10-20 07:51:55 +00:00
|
|
|
use futures::Stream;
|
|
|
|
use gpui::executor::Background;
|
2022-10-19 12:58:50 +00:00
|
|
|
use lazy_static::lazy_static;
|
2022-10-19 14:35:34 +00:00
|
|
|
use live_kit_server::token;
|
2022-10-19 11:53:40 +00:00
|
|
|
use media::core_video::CVImageBuffer;
|
2022-10-19 12:58:50 +00:00
|
|
|
use parking_lot::Mutex;
|
2022-10-21 12:21:45 +00:00
|
|
|
use postage::watch;
|
|
|
|
use std::{future::Future, mem, sync::Arc};
|
2022-10-19 11:53:40 +00:00
|
|
|
|
2022-10-19 12:58:50 +00:00
|
|
|
lazy_static! {
|
2022-10-19 14:35:34 +00:00
|
|
|
static ref SERVERS: Mutex<HashMap<String, Arc<TestServer>>> = Default::default();
|
2022-10-19 12:58:50 +00:00
|
|
|
}
|
|
|
|
|
2022-10-19 14:35:34 +00:00
|
|
|
pub struct TestServer {
|
|
|
|
pub url: String,
|
|
|
|
pub api_key: String,
|
|
|
|
pub secret_key: String,
|
|
|
|
rooms: Mutex<HashMap<String, TestServerRoom>>,
|
2022-10-19 12:58:50 +00:00
|
|
|
background: Arc<Background>,
|
|
|
|
}
|
|
|
|
|
2022-10-19 14:35:34 +00:00
|
|
|
impl TestServer {
|
2022-10-19 12:58:50 +00:00
|
|
|
pub fn create(
|
|
|
|
url: String,
|
2022-10-19 14:35:34 +00:00
|
|
|
api_key: String,
|
2022-10-19 12:58:50 +00:00
|
|
|
secret_key: String,
|
|
|
|
background: Arc<Background>,
|
2022-10-19 14:35:34 +00:00
|
|
|
) -> Result<Arc<TestServer>> {
|
2022-10-19 12:58:50 +00:00
|
|
|
let mut servers = SERVERS.lock();
|
|
|
|
if servers.contains_key(&url) {
|
|
|
|
Err(anyhow!("a server with url {:?} already exists", url))
|
|
|
|
} else {
|
2022-10-19 14:35:34 +00:00
|
|
|
let server = Arc::new(TestServer {
|
2022-10-19 12:58:50 +00:00
|
|
|
url: url.clone(),
|
2022-10-19 14:35:34 +00:00
|
|
|
api_key,
|
2022-10-19 12:58:50 +00:00
|
|
|
secret_key,
|
|
|
|
rooms: Default::default(),
|
|
|
|
background,
|
|
|
|
});
|
|
|
|
servers.insert(url, server.clone());
|
|
|
|
Ok(server)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-19 14:35:34 +00:00
|
|
|
fn get(url: &str) -> Result<Arc<TestServer>> {
|
2022-10-19 12:58:50 +00:00
|
|
|
Ok(SERVERS
|
|
|
|
.lock()
|
|
|
|
.get(url)
|
|
|
|
.ok_or_else(|| anyhow!("no server found for url"))?
|
|
|
|
.clone())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn teardown(&self) -> Result<()> {
|
|
|
|
SERVERS
|
|
|
|
.lock()
|
|
|
|
.remove(&self.url)
|
|
|
|
.ok_or_else(|| anyhow!("server with url {:?} does not exist", self.url))?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-10-19 14:35:34 +00:00
|
|
|
pub fn create_api_client(&self) -> TestApiClient {
|
|
|
|
TestApiClient {
|
|
|
|
url: self.url.clone(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn create_room(&self, room: String) -> Result<()> {
|
|
|
|
self.background.simulate_random_delay().await;
|
|
|
|
let mut server_rooms = self.rooms.lock();
|
|
|
|
if server_rooms.contains_key(&room) {
|
|
|
|
Err(anyhow!("room {:?} already exists", room))
|
|
|
|
} else {
|
|
|
|
server_rooms.insert(room, Default::default());
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn delete_room(&self, room: String) -> Result<()> {
|
|
|
|
// TODO: clear state associated with all `Room`s.
|
|
|
|
self.background.simulate_random_delay().await;
|
|
|
|
let mut server_rooms = self.rooms.lock();
|
|
|
|
server_rooms
|
|
|
|
.remove(&room)
|
|
|
|
.ok_or_else(|| anyhow!("room {:?} does not exist", room))?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-10-19 12:58:50 +00:00
|
|
|
async fn join_room(&self, token: String, client_room: Arc<Room>) -> Result<()> {
|
|
|
|
self.background.simulate_random_delay().await;
|
|
|
|
let claims = live_kit_server::token::validate(&token, &self.secret_key)?;
|
|
|
|
let identity = claims.sub.unwrap().to_string();
|
2022-10-19 14:35:34 +00:00
|
|
|
let room_name = claims.video.room.unwrap();
|
|
|
|
let mut server_rooms = self.rooms.lock();
|
|
|
|
let room = server_rooms
|
|
|
|
.get_mut(&*room_name)
|
|
|
|
.ok_or_else(|| anyhow!("room {:?} does not exist", room_name))?;
|
2022-10-19 17:20:31 +00:00
|
|
|
if room.client_rooms.contains_key(&identity) {
|
2022-10-19 14:35:34 +00:00
|
|
|
Err(anyhow!(
|
|
|
|
"{:?} attempted to join room {:?} twice",
|
|
|
|
identity,
|
|
|
|
room_name
|
|
|
|
))
|
|
|
|
} else {
|
2022-10-19 17:20:31 +00:00
|
|
|
room.client_rooms.insert(identity, client_room);
|
2022-10-19 14:35:34 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn leave_room(&self, token: String) -> Result<()> {
|
|
|
|
self.background.simulate_random_delay().await;
|
|
|
|
let claims = live_kit_server::token::validate(&token, &self.secret_key)?;
|
|
|
|
let identity = claims.sub.unwrap().to_string();
|
|
|
|
let room_name = claims.video.room.unwrap();
|
|
|
|
let mut server_rooms = self.rooms.lock();
|
|
|
|
let room = server_rooms
|
|
|
|
.get_mut(&*room_name)
|
|
|
|
.ok_or_else(|| anyhow!("room {} does not exist", room_name))?;
|
2022-10-19 17:20:31 +00:00
|
|
|
room.client_rooms.remove(&identity).ok_or_else(|| {
|
2022-10-19 14:35:34 +00:00
|
|
|
anyhow!(
|
|
|
|
"{:?} attempted to leave room {:?} before joining it",
|
|
|
|
identity,
|
|
|
|
room_name
|
|
|
|
)
|
|
|
|
})?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn remove_participant(&self, room_name: String, identity: String) -> Result<()> {
|
|
|
|
// TODO: clear state associated with the `Room`.
|
|
|
|
|
|
|
|
self.background.simulate_random_delay().await;
|
2022-10-19 12:58:50 +00:00
|
|
|
let mut server_rooms = self.rooms.lock();
|
|
|
|
let room = server_rooms
|
2022-10-19 14:35:34 +00:00
|
|
|
.get_mut(&room_name)
|
|
|
|
.ok_or_else(|| anyhow!("room {} does not exist", room_name))?;
|
2022-10-19 17:20:31 +00:00
|
|
|
room.client_rooms.remove(&identity).ok_or_else(|| {
|
2022-10-19 14:35:34 +00:00
|
|
|
anyhow!(
|
|
|
|
"participant {:?} did not join room {:?}",
|
|
|
|
identity,
|
|
|
|
room_name
|
|
|
|
)
|
|
|
|
})?;
|
2022-10-19 12:58:50 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
2022-10-19 17:20:31 +00:00
|
|
|
|
2022-10-21 12:21:45 +00:00
|
|
|
pub async fn disconnect_client(&self, client_identity: String) {
|
|
|
|
self.background.simulate_random_delay().await;
|
|
|
|
let mut server_rooms = self.rooms.lock();
|
|
|
|
for room in server_rooms.values_mut() {
|
|
|
|
if let Some(room) = room.client_rooms.remove(&client_identity) {
|
|
|
|
*room.0.lock().connection.0.borrow_mut() = ConnectionState::Disconnected;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
async fn publish_video_track(&self, token: String, local_track: LocalVideoTrack) -> Result<()> {
|
|
|
|
self.background.simulate_random_delay().await;
|
|
|
|
let claims = live_kit_server::token::validate(&token, &self.secret_key)?;
|
|
|
|
let identity = claims.sub.unwrap().to_string();
|
|
|
|
let room_name = claims.video.room.unwrap();
|
|
|
|
|
|
|
|
let mut server_rooms = self.rooms.lock();
|
|
|
|
let room = server_rooms
|
|
|
|
.get_mut(&*room_name)
|
|
|
|
.ok_or_else(|| anyhow!("room {} does not exist", room_name))?;
|
|
|
|
|
|
|
|
let update = RemoteVideoTrackUpdate::Subscribed(Arc::new(RemoteVideoTrack {
|
|
|
|
sid: nanoid::nanoid!(17),
|
|
|
|
publisher_id: identity.clone(),
|
|
|
|
frames_rx: local_track.frames_rx.clone(),
|
|
|
|
}));
|
|
|
|
|
|
|
|
for (id, client_room) in &room.client_rooms {
|
|
|
|
if *id != identity {
|
|
|
|
let _ = client_room
|
|
|
|
.0
|
|
|
|
.lock()
|
|
|
|
.video_track_updates
|
|
|
|
.0
|
|
|
|
.try_broadcast(update.clone())
|
|
|
|
.unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
2022-10-19 12:58:50 +00:00
|
|
|
}
|
|
|
|
|
2022-10-19 14:35:34 +00:00
|
|
|
#[derive(Default)]
|
|
|
|
struct TestServerRoom {
|
2022-10-19 17:20:31 +00:00
|
|
|
client_rooms: HashMap<Sid, Arc<Room>>,
|
2022-10-19 12:58:50 +00:00
|
|
|
}
|
|
|
|
|
2022-10-19 14:35:34 +00:00
|
|
|
impl TestServerRoom {}
|
|
|
|
|
|
|
|
pub struct TestApiClient {
|
|
|
|
url: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[async_trait]
|
|
|
|
impl live_kit_server::api::Client for TestApiClient {
|
|
|
|
fn url(&self) -> &str {
|
|
|
|
&self.url
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn create_room(&self, name: String) -> Result<()> {
|
|
|
|
let server = TestServer::get(&self.url)?;
|
|
|
|
server.create_room(name).await?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn delete_room(&self, name: String) -> Result<()> {
|
|
|
|
let server = TestServer::get(&self.url)?;
|
|
|
|
server.delete_room(name).await?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn remove_participant(&self, room: String, identity: String) -> Result<()> {
|
|
|
|
let server = TestServer::get(&self.url)?;
|
|
|
|
server.remove_participant(room, identity).await?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn room_token(&self, room: &str, identity: &str) -> Result<String> {
|
|
|
|
let server = TestServer::get(&self.url)?;
|
|
|
|
token::create(
|
|
|
|
&server.api_key,
|
|
|
|
&server.secret_key,
|
|
|
|
Some(identity),
|
|
|
|
token::VideoGrant::to_join(room),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
2022-10-19 12:58:50 +00:00
|
|
|
|
2022-10-19 11:53:40 +00:00
|
|
|
pub type Sid = String;
|
|
|
|
|
2022-10-19 14:35:34 +00:00
|
|
|
struct RoomState {
|
2022-10-21 12:21:45 +00:00
|
|
|
connection: (
|
|
|
|
watch::Sender<ConnectionState>,
|
|
|
|
watch::Receiver<ConnectionState>,
|
|
|
|
),
|
2022-10-19 17:20:31 +00:00
|
|
|
display_sources: Vec<MacOSDisplay>,
|
|
|
|
video_track_updates: (
|
|
|
|
async_broadcast::Sender<RemoteVideoTrackUpdate>,
|
|
|
|
async_broadcast::Receiver<RemoteVideoTrackUpdate>,
|
|
|
|
),
|
|
|
|
}
|
|
|
|
|
2022-10-21 12:21:45 +00:00
|
|
|
#[derive(Clone, Eq, PartialEq)]
|
|
|
|
pub enum ConnectionState {
|
|
|
|
Disconnected,
|
|
|
|
Connected { url: String, token: String },
|
2022-10-19 14:35:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Room(Mutex<RoomState>);
|
2022-10-19 11:53:40 +00:00
|
|
|
|
|
|
|
impl Room {
|
|
|
|
pub fn new() -> Arc<Self> {
|
2022-10-19 17:20:31 +00:00
|
|
|
Arc::new(Self(Mutex::new(RoomState {
|
2022-10-21 12:21:45 +00:00
|
|
|
connection: watch::channel_with(ConnectionState::Disconnected),
|
2022-10-19 17:20:31 +00:00
|
|
|
display_sources: Default::default(),
|
|
|
|
video_track_updates: async_broadcast::broadcast(128),
|
|
|
|
})))
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|
|
|
|
|
2022-10-21 12:21:45 +00:00
|
|
|
pub fn status(&self) -> watch::Receiver<ConnectionState> {
|
|
|
|
self.0.lock().connection.1.clone()
|
|
|
|
}
|
|
|
|
|
2022-10-19 12:58:50 +00:00
|
|
|
pub fn connect(self: &Arc<Self>, url: &str, token: &str) -> impl Future<Output = Result<()>> {
|
|
|
|
let this = self.clone();
|
|
|
|
let url = url.to_string();
|
|
|
|
let token = token.to_string();
|
|
|
|
async move {
|
2022-10-19 14:35:34 +00:00
|
|
|
let server = TestServer::get(&url)?;
|
|
|
|
server.join_room(token.clone(), this.clone()).await?;
|
2022-10-21 12:21:45 +00:00
|
|
|
*this.0.lock().connection.0.borrow_mut() = ConnectionState::Connected { url, token };
|
2022-10-19 12:58:50 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
pub fn display_sources(self: &Arc<Self>) -> impl Future<Output = Result<Vec<MacOSDisplay>>> {
|
|
|
|
let this = self.clone();
|
|
|
|
async move {
|
|
|
|
let server = this.test_server();
|
|
|
|
server.background.simulate_random_delay().await;
|
|
|
|
Ok(this.0.lock().display_sources.clone())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-19 11:53:40 +00:00
|
|
|
pub fn publish_video_track(
|
2022-10-19 17:20:31 +00:00
|
|
|
self: &Arc<Self>,
|
2022-10-19 11:53:40 +00:00
|
|
|
track: &LocalVideoTrack,
|
|
|
|
) -> impl Future<Output = Result<LocalTrackPublication>> {
|
2022-10-19 17:20:31 +00:00
|
|
|
let this = self.clone();
|
|
|
|
let track = track.clone();
|
|
|
|
async move {
|
|
|
|
this.test_server()
|
|
|
|
.publish_video_track(this.token(), track)
|
|
|
|
.await?;
|
|
|
|
Ok(LocalTrackPublication)
|
|
|
|
}
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
pub fn unpublish_track(&self, _: LocalTrackPublication) {}
|
2022-10-19 11:53:40 +00:00
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
pub fn remote_video_tracks(&self, _: &str) -> Vec<Arc<RemoteVideoTrack>> {
|
2022-10-19 11:53:40 +00:00
|
|
|
Default::default()
|
|
|
|
}
|
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
pub fn remote_video_track_updates(&self) -> impl Stream<Item = RemoteVideoTrackUpdate> {
|
|
|
|
self.0.lock().video_track_updates.1.clone()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn set_display_sources(&self, sources: Vec<MacOSDisplay>) {
|
|
|
|
self.0.lock().display_sources = sources;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_server(&self) -> Arc<TestServer> {
|
2022-10-21 12:21:45 +00:00
|
|
|
match self.0.lock().connection.1.borrow().clone() {
|
|
|
|
ConnectionState::Disconnected => panic!("must be connected to call this method"),
|
|
|
|
ConnectionState::Connected { url, .. } => TestServer::get(&url).unwrap(),
|
|
|
|
}
|
2022-10-19 17:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn token(&self) -> String {
|
2022-10-21 12:21:45 +00:00
|
|
|
match self.0.lock().connection.1.borrow().clone() {
|
|
|
|
ConnectionState::Disconnected => panic!("must be connected to call this method"),
|
|
|
|
ConnectionState::Connected { token, .. } => token,
|
|
|
|
}
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-19 12:58:50 +00:00
|
|
|
impl Drop for Room {
|
|
|
|
fn drop(&mut self) {
|
2022-10-21 12:21:45 +00:00
|
|
|
if let ConnectionState::Connected { token, .. } = mem::replace(
|
|
|
|
&mut *self.0.lock().connection.0.borrow_mut(),
|
|
|
|
ConnectionState::Disconnected,
|
|
|
|
) {
|
|
|
|
if let Ok(server) = TestServer::get(&token) {
|
2022-10-19 14:35:34 +00:00
|
|
|
let background = server.background.clone();
|
|
|
|
background
|
2022-10-21 12:21:45 +00:00
|
|
|
.spawn(async move { server.leave_room(token).await.unwrap() })
|
2022-10-19 14:35:34 +00:00
|
|
|
.detach();
|
|
|
|
}
|
|
|
|
}
|
2022-10-19 12:58:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-19 11:53:40 +00:00
|
|
|
pub struct LocalTrackPublication;
|
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct LocalVideoTrack {
|
|
|
|
frames_rx: async_broadcast::Receiver<Frame>,
|
|
|
|
}
|
2022-10-19 11:53:40 +00:00
|
|
|
|
|
|
|
impl LocalVideoTrack {
|
|
|
|
pub fn screen_share_for_display(display: &MacOSDisplay) -> Self {
|
2022-10-19 17:20:31 +00:00
|
|
|
Self {
|
|
|
|
frames_rx: display.frames.1.clone(),
|
|
|
|
}
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct RemoteVideoTrack {
|
|
|
|
sid: Sid,
|
|
|
|
publisher_id: Sid,
|
2022-10-19 17:20:31 +00:00
|
|
|
frames_rx: async_broadcast::Receiver<Frame>,
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl RemoteVideoTrack {
|
|
|
|
pub fn sid(&self) -> &str {
|
|
|
|
&self.sid
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn publisher_id(&self) -> &str {
|
|
|
|
&self.publisher_id
|
|
|
|
}
|
|
|
|
|
2022-10-20 07:51:55 +00:00
|
|
|
pub fn frames(&self) -> async_broadcast::Receiver<Frame> {
|
|
|
|
self.frames_rx.clone()
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
#[derive(Clone)]
|
2022-10-19 11:53:40 +00:00
|
|
|
pub enum RemoteVideoTrackUpdate {
|
|
|
|
Subscribed(Arc<RemoteVideoTrack>),
|
|
|
|
Unsubscribed { publisher_id: Sid, track_id: Sid },
|
|
|
|
}
|
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct MacOSDisplay {
|
|
|
|
frames: (
|
|
|
|
async_broadcast::Sender<Frame>,
|
|
|
|
async_broadcast::Receiver<Frame>,
|
|
|
|
),
|
|
|
|
}
|
|
|
|
|
|
|
|
impl MacOSDisplay {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
frames: async_broadcast::broadcast(128),
|
|
|
|
}
|
|
|
|
}
|
2022-10-19 11:53:40 +00:00
|
|
|
|
2022-10-19 17:20:31 +00:00
|
|
|
pub fn send_frame(&self, frame: Frame) {
|
|
|
|
self.frames.0.try_broadcast(frame).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
|
|
pub struct Frame {
|
|
|
|
pub label: String,
|
|
|
|
pub width: usize,
|
|
|
|
pub height: usize,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Frame {
|
|
|
|
pub fn width(&self) -> usize {
|
|
|
|
self.width
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn height(&self) -> usize {
|
|
|
|
self.height
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn image(&self) -> CVImageBuffer {
|
|
|
|
unimplemented!("you can't call this in test mode")
|
|
|
|
}
|
2022-10-19 11:53:40 +00:00
|
|
|
}
|