joshuafhiggins/realm-chat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

joining server works but...

Browse Source 
durian is POS
This commit is contained in:
Joshua Higgins
2024-10-13 11:56:01 -04:00
Unverified
parent 87b3125f8e
commit 3d2445c94c
12 changed files with 243 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
client/src/app.rs
View File

@@ -4,9 +4,11 @@ use tokio::sync::broadcast;
use tokio::sync::broadcast::{Receiver, Sender};
use tracing::log::*;
use realm_auth::types::RealmAuthClient;
use realm_server::types::{RealmChatClient, User};
use realm_shared::stoken;
use realm_shared::types::ErrorCode::*;
use realm_shared::types::ErrorCode;
use crate::types::ClientUser;
use crate::types::{CServer, CUser};
use crate::ui::gui;
/// We derive Deserialize/Serialize so we can persist app state on shutdown.
@@ -16,15 +18,20 @@ pub struct RealmApp {
// Example stuff:
pub label: String,
pub selected: bool,
pub selected_serverid: Option<String>,
pub selected_roomid: Option<String>,
#[serde(skip)]
pub selected_serverid: String,
#[serde(skip)]
pub selected_roomid: String,
#[serde(skip)]
pub current_user: Option<ClientUser>,
pub current_user: Option<CUser>,
pub saved_username: Option<String>,
pub saved_token: Option<String>,
pub saved_auth_address: Option<String>,
#[serde(skip)]
pub active_servers: Option<Vec<CServer>>,
#[serde(skip)]
pub value: f32,
@@ -58,10 +65,15 @@ pub struct RealmApp {
pub login_ending_channel: (Sender<Result<String, ErrorCode>>, Receiver<Result<String, ErrorCode>>),
#[serde(skip)]
pub fetching_user_data_channel: (Sender<Result<ClientUser, ErrorCode>>, Receiver<Result<ClientUser, ErrorCode>>),
pub fetching_user_data_channel: (Sender<Result<CUser, ErrorCode>>, Receiver<Result<CUser, ErrorCode>>),
#[serde(skip)]
pub added_server_channel: (Sender<Result<String, ErrorCode>>, Receiver<Result<String, ErrorCode>>),
pub add_server_channel: (Sender<Result<String, ErrorCode>>, Receiver<Result<String, ErrorCode>>),
#[serde(skip)]
pub join_server_channel: (Sender<Result<(), ErrorCode>>, Receiver<Result<(), ErrorCode>>),
#[serde(skip)]
pub fetching_servers_channel: (Sender<Result<CServer, ErrorCode>>, Receiver<Result<CServer, ErrorCode>>),
}
impl Default for RealmApp {
@@ -70,12 +82,13 @@ impl Default for RealmApp {
// Example stuff:
label: "Hello World!".to_owned(),
selected: false,
selected_serverid: None,
selected_roomid: None,
selected_serverid: String::new(),
selected_roomid: String::new(),
current_user: None,
saved_username: None,
saved_token: None,
saved_auth_address: None,
active_servers: None,
value: 2.7,
login_window_open: false,
@@ -94,8 +107,9 @@ impl Default for RealmApp {
server_window_port: "5051".to_string(),
fetching_user_data_channel: broadcast::channel(10),
added_server_channel: broadcast::channel(10),
add_server_channel: broadcast::channel(10),
join_server_channel: broadcast::channel(10),
fetching_servers_channel: broadcast::channel(10),
}
}
}
@@ -116,21 +130,21 @@ impl RealmApp {
}
}
pub fn fetch_user_data(send_channel: Sender<Result<ClientUser, ErrorCode>>, server_address: String, username: String, token: String) {
pub fn fetch_user_data(send_channel: Sender<Result<CUser, ErrorCode>>, server_address: String, username: String, token: String) {
let _handle = tokio::spawn(async move {
let mut transport = tarpc::serde_transport::tcp::connect(&server_address, Json::default);
transport.config_mut().max_frame_length(usize::MAX);
let result = transport.await;
let connection = match result {
let auth_connection = match result {
Ok(connection) => connection,
Err(e) => {
tracing::error!("Failed to connect to server: {}", e);
Err(_) => {
send_channel.send(Err(UnableToConnectToServer)).unwrap();
return;
}
};
let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn();
let client = RealmAuthClient::new(tarpc::client::Config::default(), auth_connection).spawn();
let result = client.get_all_data(context::current(), username, token.clone()).await;
match result {
@@ -139,20 +153,13 @@ pub fn fetch_user_data(send_channel: Sender<Result<ClientUser, ErrorCode>>, serv
send_channel.send(Err(code)).unwrap();
} else {
let auth_user = r.unwrap();
let servers: Vec<String> = {
if auth_user.servers.eq("") {
Vec::new()
} else {
auth_user.servers.split('|').map(|s| s.to_string()).collect()
}
};
send_channel.send(Ok(ClientUser {
send_channel.send(Ok(CUser {
id: auth_user.id,
server_address,
auth_address: server_address,
username: auth_user.username,
email: auth_user.email,
//avatar: auth_user.avatar,
servers,
server_addresses: auth_user.servers.split('|').map(|s| s.to_string()).collect(),
token,
})).unwrap();
}
@@ -164,6 +171,38 @@ pub fn fetch_user_data(send_channel: Sender<Result<ClientUser, ErrorCode>>, serv
});
}
pub fn fetch_server_data(addresses: Vec<String>, channel: Sender<Result<CServer, ErrorCode>>) {
for server_address in addresses {
let send_channel = channel.clone();
let _handle = tokio::spawn(async move {
let mut transport = tarpc::serde_transport::tcp::connect(&server_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.send(Err(UnableToConnectToServer)).unwrap();
return;
}
};
let client = RealmChatClient::new(tarpc::client::Config::default(), connection).spawn();
let info = client.get_info(context::current()).await.unwrap();
let is_admin = client.is_user_admin(context::current(), info.server_id.clone()).await.unwrap();
let is_owner = client.is_user_owner(context::current(), info.server_id.clone()).await.unwrap();
send_channel.send(Ok(CServer {
server_id: info.server_id,
domain: server_address.split(':').collect::<Vec<&str>>()[0].to_string(),
port: server_address.split(':').collect::<Vec<&str>>()[1].to_string().parse::<u16>().unwrap(),
is_admin,
is_owner,
})).unwrap();
});
}
}
impl eframe::App for RealmApp {
/// Called each time the UI needs repainting, which may be many times per second.
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
@@ -174,7 +213,7 @@ impl eframe::App for RealmApp {
if self.current_user.is_none() &&
self.saved_token.is_some() &&
self.saved_auth_address.is_some() &&
self.saved_username.is_some()
self.saved_username.is_some()
{
let send_channel = self.fetching_user_data_channel.0.clone();
let server_address = self.saved_auth_address.clone().unwrap();
@@ -183,6 +222,13 @@ impl eframe::App for RealmApp {
fetch_user_data(send_channel, server_address, username, token);
}
// Fetching servers
if self.active_servers.is_none() && self.current_user.is_some() {
self.active_servers = Some(Vec::new());
fetch_server_data(self.current_user.clone().unwrap().server_addresses.clone(), self.fetching_servers_channel.0.clone());
}
// Starting the login flow
while let Ok(result) = self.login_start_channel.1.try_recv() {
match result {
Ok(_) => self.login_ready_for_code_input = true,
@@ -190,6 +236,7 @@ impl eframe::App for RealmApp {
}
}
// End of the login flow
while let Ok(result) = self.login_ending_channel.1.try_recv() {
match result {
Ok(token) => {
@@ -214,6 +261,7 @@ impl eframe::App for RealmApp {
}
}
// Fetching user data
while let Ok(result) = self.fetching_user_data_channel.1.try_recv() {
match result {
Ok(client_user) => {
@@ -224,21 +272,81 @@ impl eframe::App for RealmApp {
}
}
while let Ok(result) = self.added_server_channel.1.try_recv() {
// Adding a server
while let Ok(result) = self.add_server_channel.1.try_recv() {
match result {
Ok(address) => {
info!("New server added at: {:?}", address);
self.server_window_open = false;
let send_channel = self.fetching_user_data_channel.0.clone();
let server_address = self.saved_auth_address.clone().unwrap();
let send_channel = self.join_server_channel.0.clone();
let auth_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);
let thread_username = username.clone();
let thread_token = token.clone();
let _handle = tokio::spawn(async move {
let mut transport = tarpc::serde_transport::tcp::connect(&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 = RealmChatClient::new(tarpc::client::Config::default(), connection).spawn();
let domain = address.split(':').collect::<Vec<&str>>()[0].to_string();
let port = address.split(':').collect::<Vec<&str>>()[1].to_string().parse::<u16>().unwrap();
let info = client.get_info(context::current()).await.unwrap();
let result = client.join_server(context::current(), stoken(&thread_token, &info.server_id, &domain, port), thread_username).await;
match result {
Ok(_) => {
info!("Joined server!");
},
Err(e) => error!("Error joining server: {:?}", e),
}
});
fetch_user_data(self.fetching_user_data_channel.0.clone(), auth_address, username, token);
}
Err(e) => error!("Error in adding a server: {:?}", e),
}
}
// Joining a server
while let Ok(result) = self.join_server_channel.1.try_recv() {
match result {
Ok(_) => {
info!("Successfully joined a server");
fetch_server_data(self.current_user.clone().unwrap().server_addresses.clone(), self.fetching_servers_channel.0.clone());
},
Err(code) => {
error!("Error joining server: {:?}", code);
}
}
}
// Fetching servers
while let Ok(result) = self.fetching_servers_channel.1.try_recv() {
match result {
Ok(server) => {
info!("Got server data! Server: {:?}", server);
if let Some(active_servers) = &mut self.active_servers {
active_servers.push(server);
}
}
Err(e) => error!("Error fetching server data: {:?}", e),
}
}
// File -> Quit
gui::top_panel(self, ctx);