diff --git a/client/src/app.rs b/client/src/app.rs index 75e4fba..45ef9b9 100644 --- a/client/src/app.rs +++ b/client/src/app.rs @@ -1,4 +1,3 @@ -use tarpc::client::RpcError; use tarpc::context; use tarpc::tokio_serde::formats::Json; use tokio::sync::broadcast; @@ -77,7 +76,11 @@ pub struct RealmApp { #[serde(skip)] pub add_server_channel: (Sender>, Receiver>), #[serde(skip)] + pub remove_server_channel: (Sender>, Receiver>), + #[serde(skip)] pub join_server_channel: (Sender>, Receiver>), + #[serde(skip)] + pub leave_server_channel: (Sender>, Receiver>), #[serde(skip)] pub fetching_servers_channel: (Sender>, Receiver>), @@ -122,7 +125,9 @@ impl Default for RealmApp { fetching_user_data_channel: broadcast::channel(10), add_server_channel: broadcast::channel(10), + remove_server_channel: broadcast::channel(10), join_server_channel: broadcast::channel(10), + leave_server_channel: broadcast::channel(10), fetching_servers_channel: broadcast::channel(10), add_room_channel: broadcast::channel(10), room_changes_channel: broadcast::channel(10), @@ -187,7 +192,7 @@ pub fn fetch_user_data(send_channel: Sender>, server_ad }); } -pub fn fetch_server_data(channel: Sender>, addresses: Vec, token: String, username: String) { +pub fn fetch_server_data(channel: Sender>, addresses: Vec, token: String, username: String){ for server_address in addresses { let send_channel = channel.clone(); let token = token.clone(); @@ -316,13 +321,13 @@ impl eframe::App for RealmApp { match result { Ok(client_user) => { info!("Got data! User: {:?}", client_user); - self.current_user = Some(client_user); + self.current_user.replace(client_user); } Err(e) => error!("Error fetching data: {:?}", e), } } - // Adding a server + // Adding a server (auth) while let Ok(result) = self.add_server_channel.1.try_recv() { match result { Ok(address) => { @@ -396,6 +401,61 @@ impl eframe::App for RealmApp { } } } + + // Leaving a server + while let Ok(result) = self.leave_server_channel.1.try_recv() { + match result { + Ok((serverid, domain, port)) => { + info!("Successfully left a server"); + self.active_servers.as_mut().unwrap().retain(|s| !s.server_id.eq(&serverid)); + let send_channel = self.remove_server_channel.0.clone(); + let auth_address = self.current_user.clone().unwrap().auth_address; + let username = self.current_user.clone().unwrap().username; + let token = self.current_user.clone().unwrap().token; + let _handle = tokio::spawn(async move { + let mut transport = tarpc::serde_transport::tcp::connect(&auth_address, Json::default); + transport.config_mut().max_frame_length(usize::MAX); + + let result = transport.await; + let connection = match result { + Ok(connection) => connection, + Err(_) => { + send_channel.clone().send(Err(UnableToConnectToServer)).unwrap(); + return; + } + }; + + let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn(); + + let result = client.remove_server(context::current(), username, token, domain, port).await; + match result { + Ok(r) => { send_channel.send(r).unwrap(); }, + Err(_) => { send_channel.send(Err(RPCError)).unwrap(); }, + } + }); + }, + Err(code) => { + error!("Error leaving server: {:?}", code); + } + } + } + + // Removing a server (auth) + while let Ok(result) = self.remove_server_channel.1.try_recv() { + match result { + Ok(_) => { + let send_channel = self.fetching_user_data_channel.0.clone(); + let server_address = self.saved_auth_address.clone().unwrap(); + let username = self.saved_username.clone().unwrap(); + let token = self.saved_token.clone().unwrap(); + fetch_user_data(send_channel, server_address, username, token); + info!("Successfully removed a server"); + } + Err(code) => { + error!("Error removing server: {:?}", code); + } + } + } // Fetching servers while let Ok(result) = self.fetching_servers_channel.1.try_recv() { diff --git a/client/src/main.rs b/client/src/main.rs index ddf0040..4c44843 100644 --- a/client/src/main.rs +++ b/client/src/main.rs @@ -7,7 +7,7 @@ async fn main() -> eframe::Result { .with_file(true) .with_line_number(true) .with_thread_ids(true) - .with_target(true) + .with_target(false) .finish(); subscriber::set_global_default(subscriber).unwrap(); diff --git a/client/src/ui/gui.rs b/client/src/ui/gui.rs index 7daa653..5903090 100644 --- a/client/src/ui/gui.rs +++ b/client/src/ui/gui.rs @@ -5,8 +5,9 @@ use realm_auth::types::RealmAuthClient; use realm_shared::types::ErrorCode::RPCError; use regex::Regex; use tracing::log::*; -use realm_server::types::Room; +use realm_server::types::{RealmChatClient, Room}; use realm_shared::stoken; +use realm_shared::types::ErrorCode; use crate::app::RealmApp; use crate::types::CServer; @@ -76,6 +77,29 @@ pub fn servers(app: &mut RealmApp, ctx: &Context) { if app.current_user.is_some() && ui.button("+").clicked() { app.server_window_open = true; } + if !app.selected_serverid.is_empty() && ui.button("-").clicked() { + let server = app.active_servers.clone().unwrap().into_iter().find(|s| s.server_id.eq(&app.selected_serverid)).unwrap(); + let token = app.current_user.as_ref().unwrap().token.clone(); + let userid = app.current_user.as_ref().unwrap().username.clone(); + let send_channel = app.leave_server_channel.0.clone(); + let _handle = tokio::spawn(async move { + let result = server.tarpc_conn.leave_server( + context::current(), + stoken(&token, &server.server_id, &server.domain, server.port), + userid + ).await; + + match result { + Ok(r) => { + match r { + Ok(_) => send_channel.send(Ok((server.server_id.clone(), server.domain.clone(), server.port))).unwrap(), + Err(e) => send_channel.send(Err(e)).unwrap() + } + }, + Err(_) => send_channel.send(Err(RPCError)).unwrap(), + } + }); + } }); ui.separator(); diff --git a/server/src/main.rs b/server/src/main.rs index 5c308c7..1f37aaa 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -61,7 +61,7 @@ async fn main() -> anyhow::Result<()> { // let (handler, listener) = node::split::<()>(); // handler.network().listen(Transport::FramedTcp, "0.0.0.0:"+(port-1))?; // info!("Listening on port {}", port-1); - // + // // // Read incoming network events. // listener.for_each(|event| match event.network() { // NetEvent::Connected(_, _) => unreachable!(), // Used for explicit connections. @@ -72,12 +72,12 @@ async fn main() -> anyhow::Result<()> { // }, // NetEvent::Disconnected(_endpoint) => println!("Client disconnected"), //Tcp or Ws // }); - // + // // inner_manager.init_server( // ServerConfig::new( // SocketAddr::from((IpAddr::V4("0.0.0.0".parse()?), port-1)).to_string(), // 0, None, 8, 8))?; - // + // // let manager = Arc::new(Mutex::new(NetIO { // handler, // listener,