Leaving servers

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<Result<String, ErrorCode>>, Receiver<Result<String, ErrorCode>>),
 	#[serde(skip)]
+	pub remove_server_channel: (Sender<Result<(), ErrorCode>>, Receiver<Result<(), ErrorCode>>),
+	#[serde(skip)]
 	pub join_server_channel: (Sender<Result<(), ErrorCode>>, Receiver<Result<(), ErrorCode>>),
+	#[serde(skip)]
+	pub leave_server_channel: (Sender<Result<(String, String, u16), ErrorCode>>, Receiver<Result<(String, String, u16), ErrorCode>>),
 
 	#[serde(skip)]
 	pub fetching_servers_channel: (Sender<Result<CServer, ErrorCode>>, Receiver<Result<CServer, ErrorCode>>),
@@ -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<Result<CUser, ErrorCode>>, server_ad
 	});
 }
 
-pub fn fetch_server_data(channel: Sender<Result<CServer, ErrorCode>>, addresses: Vec<String>, token: String, username: String) {
+pub fn fetch_server_data(channel: Sender<Result<CServer, ErrorCode>>, addresses: Vec<String>, 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) => {
@@ -397,6 +402,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() {
 			match result {

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();

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();