tensamin/omikron
Watch
6
0
Fork
You've already forked omikron
 0
Code Issues Pull requests 3 Projects Releases Packages Wiki Activity Actions

Swapped Id's to be Unix Timestamps instead of UUID's

Browse source
This commit is contained in:
Alex Emmet 2025-12-07 16:11:22 +01:00
commit b9208c190e
13 changed files with 352 additions and 291 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/auth/auth_connector.rs
View file

@ -1,5 +1,7 @@
use crate::data::communication::{CommunicationType, CommunicationValue, DataTypes};
use crate::util::config_util::CONFIG;
use crate::util::print::{PrintType, line};
use json::number::Number;
use reqwest::{Client, Response};
use std::time::Duration;
use uuid::Uuid;
@ -64,7 +66,7 @@ pub async fn get_user(user_id: Uuid) -> Option<AuthUser> {
})
}
pub async fn get_iota_id(user_id: Uuid) -> Option<Uuid> {
pub async fn get_iota_id(user_id: i64) -> Option<i64> {
let url = format!("https://auth.tensamin.net/api/get/iota-id/{}", user_id);
let client = client();
@ -81,13 +83,17 @@ pub async fn get_iota_id(user_id: Uuid) -> Option<Uuid> {
let cv = CommunicationValue::from_json(&json);
if cv.comm_type != CommunicationType::success {
line(PrintType::IotaIn, &cv.to_json().to_string());
return None;
}
let iota_id_str = cv.get_data(DataTypes::iota_id)?.to_string();
Uuid::parse_str(&iota_id_str).ok()
let iota_id = cv.get_data(DataTypes::iota_id)?.as_i64().unwrap_or(0);
if iota_id == 0 {
return None;
}
Some(iota_id)
}
pub async fn is_private_key_valid(user_id: Uuid, pk_hash: &str) -> bool {
pub async fn is_private_key_valid(user_id: i64, pk_hash: &str) -> bool {
let url = format!(
"https://auth.tensamin.net/api/get/private-key-hash/{}/",
user_id
@ -120,7 +126,7 @@ pub async fn is_private_key_valid(user_id: Uuid, pk_hash: &str) -> bool {
None => false,
}
}
pub async fn get_public_key(user_id: Uuid) -> Option<String> {
pub async fn get_public_key(user_id: i64) -> Option<String> {
let url = format!("https://auth.tensamin.net/api/{}/public-key", user_id);
let client = client();
@ -141,14 +147,16 @@ pub async fn get_public_key(user_id: Uuid) -> Option<String> {
Some(cv.get_data(DataTypes::ping_clients)?.to_string())
}
pub async fn get_register() -> Option<Uuid> {
pub async fn get_register() -> Option<i64> {
let url = "https://auth.tensamin.net/api/register/init".to_string();
let client = client();
let res = client.get(&url).send().await.ok()?;
let json = res.text().await.ok()?;
let cv = CommunicationValue::from_json(&json);
Uuid::parse_str(&*cv.get_data(DataTypes::user_id).unwrap().to_string()).ok()
cv.get_data(DataTypes::user_id)
.unwrap_or(&json::JsonValue::Number(Number::from(0)))
.as_i64()
}
async fn handle_response(resp: Response) -> bool {

7
src/calls/call_group.rs
View file

@ -8,6 +8,7 @@ use crate::calls::caller::Caller;
pub struct CallGroup {
pub call_id: Uuid,
pub members: RwLock<Vec<Arc<Caller>>>,
pub show: RwLock<bool>,
}
impl CallGroup {
@ -15,13 +16,15 @@ impl CallGroup {
CallGroup {
call_id,
members: RwLock::new(vec![user]),
show: RwLock::new(true),
}
}
pub async fn add_member(self: Arc<Self>, member: Uuid, inviter: Uuid) {
pub async fn add_member(self: Arc<Self>, member: i64, inviter: i64) {
*self.show.write().await = true;
self.members
.write()
.await
.push(Arc::new(Caller::new(member, inviter, self.call_id)));
.push(Arc::new(Caller::new(member, self.call_id, inviter)));
}
}

77
src/calls/call_manager.rs
View file

@ -1,13 +1,17 @@
use livekit_api::services::room::RoomClient;
use once_cell::sync::Lazy;
use std::sync::Arc;
use std::{str::FromStr, sync::Arc, time::Duration};
use tokio::sync::RwLock;
use uuid::Uuid;
use crate::calls::{call_group::CallGroup, caller::Caller};
use crate::{
calls::{call_group::CallGroup, caller::Caller},
util::print::{PrintType, line},
};
static CALL_GROUPS: Lazy<RwLock<Vec<Arc<CallGroup>>>> = Lazy::new(|| RwLock::new(Vec::new()));
pub async fn get_call_invites(user_id: Uuid) -> Vec<Arc<Caller>> {
pub async fn get_call_invites(user_id: i64) -> Vec<Arc<Caller>> {
let mut callers = Vec::new();
for cg in CALL_GROUPS.read().await.iter() {
let members = cg.members.read().await;
@ -20,7 +24,7 @@ pub async fn get_call_invites(user_id: Uuid) -> Vec<Arc<Caller>> {
callers
}
pub async fn get_call_groups(user_id: Uuid) -> Vec<Arc<CallGroup>> {
pub async fn get_call_groups(user_id: i64) -> Vec<Arc<CallGroup>> {
let mut call_groups = Vec::new();
for cg in CALL_GROUPS.read().await.iter() {
let is_member = {
@ -35,7 +39,7 @@ pub async fn get_call_groups(user_id: Uuid) -> Vec<Arc<CallGroup>> {
call_groups
}
pub async fn get_call_token(user_id: Uuid, call_id: Uuid) -> Option<String> {
pub async fn get_call_token(user_id: i64, call_id: Uuid) -> Option<String> {
let existing_group = {
let call_groups = CALL_GROUPS.read().await;
call_groups.iter().find(|g| g.call_id == call_id).cloned()
@ -80,11 +84,13 @@ pub async fn get_call_token(user_id: Uuid, call_id: Uuid) -> Option<String> {
Some(caller.create_token())
}
pub async fn add_invite(call_id: Uuid, inviter_id: Uuid, invitee_id: Uuid) -> bool {
let target_group = {
let call_groups = CALL_GROUPS.read().await;
call_groups.iter().find(|g| g.call_id == call_id).cloned()
};
pub async fn add_invite(call_id: Uuid, inviter_id: i64, invitee_id: i64) -> bool {
let target_group: Option<Arc<CallGroup>> = CALL_GROUPS
.read()
.await
.iter()
.find(|g| g.call_id == call_id)
.cloned();
if let Some(cg) = target_group {
let mut members = cg.members.write().await;
@ -100,18 +106,45 @@ pub async fn add_invite(call_id: Uuid, inviter_id: Uuid, invitee_id: Uuid) -> bo
}
false
}
pub async fn get_call_group_by_user(user_id: Uuid) -> Option<Arc<CallGroup>> {
let call_groups = CALL_GROUPS.read().await;
for cg in call_groups.iter() {
let is_member = {
let members = cg.members.read().await;
members.iter().any(|m| m.user_id == user_id)
};
if is_member {
return Some(cg.clone());
pub fn garbage_collect_calls() {
tokio::spawn(async move {
loop {
clean_calls().await;
tokio::time::sleep(Duration::from_secs(2)).await;
}
});
}
pub async fn clean_calls() {
let room_service = RoomClient::new("https://call.tensamin.net").unwrap();
let rooms = room_service.list_rooms(Vec::new()).await.unwrap();
let mut call_ids: Vec<Uuid> = Vec::new();
let mut no_users: Vec<Uuid> = Vec::new();
for room in rooms {
if let Ok(id) = Uuid::from_str(&room.name) {
if room.num_participants == 0 {
no_users.push(id);
}
call_ids.push(id);
}
}
None
let mut call_groups = CALL_GROUPS.write().await;
let size_pre = call_groups.len();
call_groups.retain(|cg| call_ids.contains(&cg.call_id));
for cg in call_groups.iter() {
*cg.show.write().await = !no_users.contains(&cg.call_id);
}
let size_post = call_groups.len();
drop(call_groups);
if size_pre - size_post != 0 {
line(
PrintType::CallIn,
&format!(
"Cleaned {} calls, {} remaining",
size_pre - size_post,
size_post
),
);
}
}

5
src/calls/call_util.rs
View file

@ -2,10 +2,7 @@ use livekit_api::access_token;
use std::env;
use uuid::Uuid;
pub fn create_token(
user_id: Uuid,
call_id: Uuid,
) -> Result<String, access_token::AccessTokenError> {
pub fn create_token(user_id: i64, call_id: Uuid) -> Result<String, access_token::AccessTokenError> {
let api_key = env::var("LIVEKIT_API_KEY").expect("LIVEKIT_API_KEY is not set");
let api_secret = env::var("LIVEKIT_API_SECRET").expect("LIVEKIT_API_SECRET is not set");

6
src/calls/caller.rs
View file

@ -3,13 +3,13 @@ use uuid::Uuid;
use crate::calls::call_util;
pub struct Caller {
pub user_id: Uuid,
pub user_id: i64,
pub call_id: Uuid,
pub inviters: Vec<Uuid>,
pub inviters: Vec<i64>,
}
impl Caller {
pub fn new(user_id: Uuid, call_id: Uuid, inviter_id: Uuid) -> Self {
pub fn new(user_id: i64, call_id: Uuid, inviter_id: i64) -> Self {
Caller {
user_id,
call_id,

192
src/data/communication.rs
View file

@ -1,7 +1,6 @@
use json::number::Number;
use json::{Array, JsonValue, object, parse};
use std::collections::HashMap;
use std::str::FromStr;
use std::time::{SystemTime, UNIX_EPOCH};
use uuid::Uuid;
@ -20,6 +19,7 @@ pub enum DataTypes {
user_state,
user_states,
user_pings,
call_state,
screen_share,
private_key_hash,
accepted,
@ -73,11 +73,12 @@ pub enum DataTypes {
challenge,
community_title,
communities,
user,
}
impl DataTypes {
pub fn parse(p0: String) -> DataTypes {
// normalize: lowercase + remove underscores
let normalized = p0.to_lowercase().replace('_', "");
match normalized.as_str() {
@ -92,6 +93,7 @@ impl DataTypes {
"userstate" => DataTypes::user_state,
"userstates" => DataTypes::user_states,
"userpings" => DataTypes::user_pings,
"callstate" => DataTypes::call_state,
"screenshare" => DataTypes::screen_share,
"privatekeyhash" => DataTypes::private_key_hash,
"accepted" => DataTypes::accepted,
@ -145,6 +147,8 @@ impl DataTypes {
"challenge" => DataTypes::challenge,
"communitytitle" => DataTypes::community_title,
"communities" => DataTypes::communities,
"user" => DataTypes::user,
_ => DataTypes::error_type, // fallback if unknown
}
}
@ -160,6 +164,9 @@ pub enum CommunicationType {
error_invalid_challenge,
error_invalid_secret,
error_invalid_private_key,
error_no_user_id,
error_no_call_id,
error_invalid_call_id,
success,
settings_save,
settings_load,
@ -178,11 +185,11 @@ pub enum CommunicationType {
add_community,
remove_community,
get_communities,
challenge,
challenge_response,
register,
register_response,
identification,
challenge,
challenge_response,
identification_response,
ping,
pong,
@ -203,25 +210,42 @@ pub enum CommunicationType {
watch_stream,
call_token,
call_invite,
end_call,
function,
update,
create_user,
}
impl CommunicationType {
pub fn parse(p0: String) -> CommunicationType {
let normalized = p0.to_lowercase().replace('_', "");
match normalized.as_str() {
"error" => CommunicationType::error,
"watchstream" => CommunicationType::watch_stream,
"calltoken" => CommunicationType::call_token,
"callinvite" => CommunicationType::call_invite,
"endcall" => CommunicationType::end_call,
"function" => CommunicationType::function,
"update" => CommunicationType::update,
"createuser" => CommunicationType::create_user,
"errorinvaliduserid" => CommunicationType::error_invalid_user_id,
"errornotfound" => CommunicationType::error_not_found,
"errornoiota" => CommunicationType::error_no_iota,
"errorinvalidchallenge" => CommunicationType::error_invalid_challenge,
"errorinvalidsecret" => CommunicationType::error_invalid_secret,
"errorinvalidprivatekey" => CommunicationType::error_invalid_private_key,
"errornouserid" => CommunicationType::error_no_user_id,
"errornocallid" => CommunicationType::error_no_call_id,
"errorinvalidcallid" => CommunicationType::error_invalid_call_id,
"success" => CommunicationType::success,
"settingssave" => CommunicationType::settings_save,
"settingsload" => CommunicationType::settings_load,
"settingslist" => CommunicationType::settings_list,
"success" => CommunicationType::success,
"message" => CommunicationType::message,
"messagesend" => CommunicationType::message_send,
"messagelive" => CommunicationType::message_live,
"messageotheriota" => CommunicationType::message_other_iota,
"messageother_iota" => CommunicationType::message_other_iota,
"messagechunk" => CommunicationType::message_chunk,
"messagesget" => CommunicationType::messages_get,
"messagesend" => CommunicationType::message_send,
"changeconfirm" => CommunicationType::change_confirm,
"confirmreceive" => CommunicationType::confirm_receive,
"confirmread" => CommunicationType::confirm_read,
@ -230,11 +254,11 @@ impl CommunicationType {
"addcommunity" => CommunicationType::add_community,
"removecommunity" => CommunicationType::remove_community,
"getcommunities" => CommunicationType::get_communities,
"challenge" => CommunicationType::challenge,
"challengeresponse" => CommunicationType::challenge_response,
"register" => CommunicationType::register,
"registerresponse" => CommunicationType::register_response,
"identification" => CommunicationType::identification,
"challenge" => CommunicationType::challenge,
"challengeresponse" => CommunicationType::challenge_response,
"identificationresponse" => CommunicationType::identification_response,
"ping" => CommunicationType::ping,
"pong" => CommunicationType::pong,
@ -252,11 +276,7 @@ impl CommunicationType {
"webrtcice" => CommunicationType::webrtc_ice,
"startstream" => CommunicationType::start_stream,
"endstream" => CommunicationType::end_stream,
"watchstream" => CommunicationType::watch_stream,
"calltoken" => CommunicationType::call_token,
"callinvite" => CommunicationType::call_invite,
"function" => CommunicationType::function,
"update" => CommunicationType::update,
_ => CommunicationType::error,
}
}
@ -266,8 +286,8 @@ impl CommunicationType {
pub struct CommunicationValue {
pub id: Uuid,
pub comm_type: CommunicationType,
pub sender: Uuid,
pub receiver: Uuid,
pub sender: i64,
pub receiver: i64,
pub data: HashMap<DataTypes, JsonValue>,
}
@ -277,8 +297,8 @@ impl CommunicationValue {
Self {
id: Uuid::new_v4(),
comm_type,
sender: Uuid::new_v4(),
receiver: Uuid::new_v4(),
sender: 0,
receiver: 0,
data: HashMap::new(),
}
}
@ -289,18 +309,18 @@ impl CommunicationValue {
pub fn get_id(&self) -> Uuid {
self.id.clone()
}
pub fn with_sender(mut self, sender: Uuid) -> Self {
pub fn with_sender(mut self, sender: i64) -> Self {
self.sender = sender;
self
}
pub fn get_sender(&self) -> Uuid {
pub fn get_sender(&self) -> i64 {
self.sender.clone()
}
pub fn with_receiver(mut self, receiver: Uuid) -> Self {
pub fn with_receiver(mut self, receiver: i64) -> Self {
self.receiver = receiver;
self
}
pub fn get_receiver(&self) -> Uuid {
pub fn get_receiver(&self) -> i64 {
self.receiver.clone()
}
pub fn add_data_num(mut self, key: DataTypes, value: Number) -> Self {
@ -331,72 +351,104 @@ impl CommunicationValue {
for (k, v) in &self.data {
jdata[&format!("{:?}", k)] = JsonValue::from(v.clone());
}
object! {
id: self.id.to_string(),
type: format!("{:?}", self.comm_type),
sender: self.sender.to_string(),
receiver: self.receiver.to_string(),
data: jdata
if self.sender > 0 && self.receiver > 0 {
object! {
id: self.id.to_string(),
type: format!("{:?}", self.comm_type),
sender: self.sender.to_string(),
receiver: self.receiver.to_string(),
data: jdata
}
} else if self.sender > 0 {
object! {
id: self.id.to_string(),
type: format!("{:?}", self.comm_type),
sender: self.sender.to_string(),
data: jdata
}
} else if self.receiver > 0 {
object! {
id: self.id.to_string(),
type: format!("{:?}", self.comm_type),
receiver: self.receiver.to_string(),
data: jdata
}
} else {
object! {
id: self.id.to_string(),
type: format!("{:?}", self.comm_type),
data: jdata
}
}
}
pub fn from_json(json_str: &str) -> Self {
let parsed = parse(json_str).unwrap();
let comm_type = CommunicationType::parse(parsed["type"].to_string());
let sender: Uuid = parsed["sender"]
.as_str()
.and_then(|s| Uuid::parse_str(s).ok())
.unwrap_or(Uuid::new_v4());
let receiver: Uuid = parsed["receiver"]
.as_str()
.and_then(|s| Uuid::parse_str(s).ok())
.unwrap_or(Uuid::new_v4());
let uuid = Uuid::parse_str(parsed["id"].as_str().unwrap_or("")).unwrap_or(Uuid::new_v4());
let mut data = HashMap::new();
if parsed["data"].is_object() {
for (k, v) in parsed["data"].entries() {
data.insert(DataTypes::parse(k.to_string()), v.clone());
if let Ok(parsed) = parse(json_str) {
let comm_type = CommunicationType::parse(parsed["type"].to_string());
let mut sender: i64 = 0;
if parsed.has_key("sender") {
sender = parsed["sender"].as_i64().unwrap_or(0);
}
let mut receiver: i64 = 0;
if parsed.has_key("receiver") {
receiver = parsed["receiver"].as_i64().unwrap_or(0);
}
}
Self {
id: uuid,
comm_type,
sender,
receiver,
data,
let uuid =
Uuid::parse_str(parsed["id"].as_str().unwrap_or("")).unwrap_or(Uuid::new_v4());
let mut data = HashMap::new();
if parsed["data"].is_object() {
for (k, v) in parsed["data"].entries() {
data.insert(DataTypes::parse(k.to_string()), v.clone());
}
}
Self {
id: uuid,
comm_type,
sender,
receiver,
data,
}
} else {
Self {
id: Uuid::new_v4(),
comm_type: CommunicationType::error,
sender: 0,
receiver: 0,
data: HashMap::new(),
}
}
}
pub fn forward_to_other_iota(original: &mut CommunicationValue) -> CommunicationValue {
let receiver = Uuid::from_str(
&*original
.get_data(DataTypes::receiver_id)
.unwrap()
.to_string(),
)
.ok()
.or(Option::from(Uuid::nil()));
let receiver = original
.get_data(DataTypes::receiver_id)
.unwrap_or(&JsonValue::Number(Number::from(0)))
.as_i64()
.unwrap_or(0);
let now_ms = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_millis() as i64;
let cv = CommunicationValue::new(CommunicationType::message_other_iota)
let sender = original.get_sender();
CommunicationValue::new(CommunicationType::message_other_iota)
.with_id(original.get_id())
.with_receiver(receiver.unwrap())
.with_receiver(receiver)
.add_data(
DataTypes::receiver_id,
JsonValue::Number(Number::from(receiver)),
)
.with_sender(sender)
.add_data(DataTypes::send_time, JsonValue::String(now_ms.to_string()))
.add_data(
DataTypes::sender_id,
JsonValue::Number(Number::from(sender)),
)
.add_data(
DataTypes::content,
JsonValue::String(original.get_data(DataTypes::content).unwrap().to_string()),
);
// include sender_id if the original had one
let sender = original.get_sender();
cv.add_data(DataTypes::sender_id, JsonValue::String(sender.to_string()))
)
}
}

8
src/data/user.rs
View file

@ -1,13 +1,11 @@
use uuid::Uuid;
#[derive(Clone)]
pub struct User {
pub iota_id: Uuid,
pub user_id: Uuid,
pub iota_id: i64,
pub user_id: i64,
pub status: UserStatus,
}
impl User {
pub fn new(iota_id: Uuid, user_id: Uuid, status: UserStatus) -> Self {
pub fn new(iota_id: i64, user_id: i64, status: UserStatus) -> Self {
User {
iota_id,
user_id,

3
src/main.rs
View file

@ -14,6 +14,7 @@ use tokio_util::compat::TokioAsyncReadCompatExt;
use tungstenite::handshake::server::{Request, Response};
use crate::{
calls::call_manager::garbage_collect_calls,
omega::omega_connection::OmegaConnection,
rho::{client_connection::ClientConnection, iota_connection::IotaConnection},
util::{
@ -36,6 +37,8 @@ async fn main() {
&format!("WebSocket server listening on {}", &address),
);
garbage_collect_calls();
while let Ok((stream, _)) = listener.accept().await {
tokio::spawn(async move {
let mut path: String = "/".to_string();

30
src/omega/omega_connection.rs
View file

@ -104,14 +104,16 @@ impl OmegaConnection {
// Handle CLIENT_CHANGED
if cv.is_type(CommunicationType::client_changed) {
let iota_id = Uuid::parse_str(
cv.get_data(DataTypes::iota_id).unwrap().as_str().unwrap(),
)
.unwrap();
let user_id = Uuid::parse_str(
cv.get_data(DataTypes::user_id).unwrap().as_str().unwrap(),
)
.unwrap();
let iota_id = cv
.get_data(DataTypes::iota_id)
.unwrap()
.as_i64()
.unwrap_or(0);
let user_id = cv
.get_data(DataTypes::user_id)
.unwrap()
.as_i64()
.unwrap_or(0);
let status_str = cv
.get_data(DataTypes::user_state)
.unwrap()
@ -147,7 +149,7 @@ impl OmegaConnection {
}
}
pub async fn connect_iota(iota_id: Uuid, user_ids: Vec<Uuid>) {
pub async fn connect_iota(iota_id: i64, user_ids: Vec<i64>) {
let user_ids_str = user_ids
.iter()
.map(|id| id.to_string())
@ -159,21 +161,21 @@ impl OmegaConnection {
OmegaConnection::send_global(cv).await;
}
pub async fn close_iota(iota_id: Uuid) {
pub async fn close_iota(iota_id: i64) {
let cv = CommunicationValue::new(CommunicationType::iota_closed)
.add_data(DataTypes::iota_id, JsonValue::from(iota_id.to_string()));
OmegaConnection::send_global(cv).await;
}
pub async fn client_changed(iota_id: Uuid, user_id: Uuid, state: UserStatus) {
pub async fn client_changed(iota_id: i64, user_id: i64, state: UserStatus) {
let cv = CommunicationValue::new(CommunicationType::client_changed)
.add_data(DataTypes::iota_id, JsonValue::from(iota_id.to_string()))
.add_data(DataTypes::user_id, JsonValue::from(user_id.to_string()))
.add_data(DataTypes::iota_id, JsonValue::from(iota_id))
.add_data(DataTypes::user_id, JsonValue::from(user_id))
.add_data(DataTypes::user_state, JsonValue::from(state.to_string()));
OmegaConnection::send_global(cv).await;
}
pub async fn user_states(user_id: Uuid, user_ids: Vec<Uuid>) {
pub async fn user_states(user_id: i64, user_ids: Vec<i64>) {
let user_ids_str = user_ids
.iter()
.map(|id| id.to_string())

115
src/rho/client_connection.rs
View file

@ -1,5 +1,6 @@
use async_tungstenite::tungstenite::Message;
use async_tungstenite::{WebSocketReceiver, WebSocketSender};
use json::number::Number;
use std::sync::{Arc, Weak};
use tokio::sync::RwLock;
use tokio_util::compat::Compat;
@ -27,7 +28,7 @@ pub struct ClientConnection {
pub sender: Arc<RwLock<WebSocketSender<Compat<tokio::net::TcpStream>>>>,
pub receiver: Arc<RwLock<WebSocketReceiver<Compat<tokio::net::TcpStream>>>>,
/// User ID associated with this client
pub user_id: Arc<RwLock<Option<Uuid>>>,
pub user_id: Arc<RwLock<i64>>,
/// Whether this connection has been identified/authenticated
pub identified: Arc<RwLock<bool>>,
/// Ping latency tracking
@ -35,7 +36,7 @@ pub struct ClientConnection {
/// Weak reference to RhoConnection to avoid circular references
pub rho_connection: Arc<RwLock<Option<Weak<RhoConnection>>>>,
/// List of user IDs this client is interested in receiving updates about
pub interested_users: Arc<RwLock<Vec<Uuid>>>,
pub interested_users: Arc<RwLock<Vec<i64>>>,
}
impl ClientConnection {
@ -47,7 +48,7 @@ impl ClientConnection {
Arc::new(Self {
sender: Arc::new(RwLock::new(sender)),
receiver: Arc::new(RwLock::new(receiver)),
user_id: Arc::new(RwLock::new(None)),
user_id: Arc::new(RwLock::new(0)),
identified: Arc::new(RwLock::new(false)),
ping: Arc::new(RwLock::new(-1)),
rho_connection: Arc::new(RwLock::new(None)),
@ -56,7 +57,7 @@ impl ClientConnection {
}
/// Get the user ID
pub async fn get_user_id(&self) -> Option<Uuid> {
pub async fn get_user_id(&self) -> i64 {
*self.user_id.read().await
}
@ -155,18 +156,8 @@ impl ClientConnection {
/// Handle identification message
async fn handle_identification(&self, sarc: Arc<ClientConnection>, cv: CommunicationValue) {
// Extract user ID
let user_id = match cv.get_data(DataTypes::user_id) {
Some(id_str) => match Uuid::parse_str(&id_str.to_string()) {
Ok(id) => id,
Err(_) => {
self.send_error_response(
&cv.get_id(),
CommunicationType::error_invalid_user_id,
)
.await;
return;
}
},
let user_id: i64 = match cv.get_data(DataTypes::user_id) {
Some(id_str) => id_str.as_i64().unwrap_or(0),
None => {
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_user_id)
.await;
@ -209,7 +200,7 @@ impl ClientConnection {
// Set identification data
{
let mut user_id_guard = self.user_id.write().await;
*user_id_guard = Some(user_id);
*user_id_guard = user_id;
}
{
let mut identified_guard = self.identified.write().await;
@ -253,61 +244,53 @@ impl ClientConnection {
/// Handle client status change
async fn handle_client_changed(&self, cv: CommunicationValue) {
if let Some(user_id) = self.get_user_id().await {
if let Some(_status_str) = cv.get_data(DataTypes::user_state) {
// Parse user status - this would need to be implemented properly
let user_status = UserStatus::online; // placeholder
if let Some(rho_conn) = self.get_rho_connection().await {
OmegaConnection::client_changed(
rho_conn.get_iota_id().await,
user_id,
user_status,
)
let user_id = self.get_user_id().await;
if let Some(_status_str) = cv.get_data(DataTypes::user_state) {
// Parse user status - this would need to be implemented properly
let user_status = UserStatus::online; // placeholder
if let Some(rho_conn) = self.get_rho_connection().await {
OmegaConnection::client_changed(rho_conn.get_iota_id().await, user_id, user_status)
.await;
}
}
}
}
/// Handle call invite
async fn handle_call_invite(&self, cv: CommunicationValue) {
let receiver_id = match cv.get_data(DataTypes::receiver_id) {
Some(id_str) => match Uuid::parse_str(&id_str.to_string()) {
Ok(id) => id,
Err(_) => {
self.send_error_response(&cv.get_id(), CommunicationType::error)
.await;
return;
}
},
None => {
self.send_error_response(&cv.get_id(), CommunicationType::error)
.await;
return;
}
};
let receiver_id: i64 = cv
.get_data(DataTypes::receiver_id)
.unwrap_or(&json::JsonValue::Number(Number::from(0)))
.as_i64()
.unwrap_or(0);
if receiver_id == 0 {
self.send_error_response(&cv.get_id(), CommunicationType::error_no_user_id)
.await;
return;
}
let call_id = match cv.get_data(DataTypes::call_id) {
Some(id_str) => match Uuid::parse_str(&id_str.to_string()) {
Ok(id) => id,
Err(_) => {
self.send_error_response(&cv.get_id(), CommunicationType::error)
.await;
self.send_error_response(
&cv.get_id(),
CommunicationType::error_invalid_call_id,
)
.await;
return;
}
},
None => {
self.send_error_response(&cv.get_id(), CommunicationType::error)
self.send_error_response(&cv.get_id(), CommunicationType::error_no_call_id)
.await;
return;
}
};
let invited =
call_manager::add_invite(call_id, self.user_id.read().await.unwrap(), receiver_id)
.await;
if invited {
self.send_error_response(&cv.get_id(), CommunicationType::error)
call_manager::add_invite(call_id, *self.user_id.read().await, receiver_id).await;
if !invited {
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_call_id)
.await;
return;
}
@ -323,10 +306,7 @@ impl ClientConnection {
};
// Get sender user ID
let sender_id = match self.get_user_id().await {
Some(id) => id,
None => return,
};
let sender_id = self.get_user_id().await;
// Create and send call distribution message
let forward = CommunicationValue::new(CommunicationType::call_invite)
@ -344,10 +324,7 @@ impl ClientConnection {
/// Handle get call request
async fn handle_get_call(&self, cv: CommunicationValue) {
let user_id = match self.get_user_id().await {
Some(id) => id,
None => return,
};
let user_id = self.get_user_id().await;
let call_id = match cv.get_data(DataTypes::call_id) {
Some(id_str) => match Uuid::parse_str(&id_str.to_string()) {
@ -380,11 +357,10 @@ impl ClientConnection {
/// Forward message to Iota
async fn forward_to_iota(&self, cv: CommunicationValue) {
if let Some(user_id) = self.get_user_id().await {
if let Some(rho_conn) = self.get_rho_connection().await {
let updated_cv = cv.with_sender(user_id);
rho_conn.message_to_iota(updated_cv).await;
}
let user_id = self.get_user_id().await;
if let Some(rho_conn) = self.get_rho_connection().await {
let updated_cv = cv.with_sender(user_id);
rho_conn.message_to_iota(updated_cv).await;
}
}
@ -401,7 +377,7 @@ impl ClientConnection {
}
/// Set interested users list
pub async fn set_interested_users(&self, interested_ids: Vec<Uuid>) {
pub async fn set_interested_users(&self, interested_ids: Vec<i64>) {
let mut interested_guard = self.interested_users.write().await;
*interested_guard = interested_ids;
}
@ -424,12 +400,11 @@ impl ClientConnection {
/// Handle connection close
pub async fn handle_close(&self) {
if self.is_identified().await {
if let Some(user_id) = self.get_user_id().await {
if let Some(rho_conn) = rho_manager::get_rho_con_for_user(user_id).await {
rho_conn
.close_client_connection(Arc::new(self.clone()))
.await;
}
let user_id = self.get_user_id().await;
if let Some(rho_conn) = rho_manager::get_rho_con_for_user(user_id).await {
rho_conn
.close_client_connection(Arc::new(self.clone()))
.await;
}
}
}

102
src/rho/iota_connection.rs
View file

@ -7,6 +7,7 @@ use async_tungstenite::WebSocketReceiver;
use async_tungstenite::WebSocketSender;
use async_tungstenite::tungstenite::Message;
use json::JsonValue;
use json::number::Number;
use std::{
collections::HashMap,
sync::{Arc, Weak},
@ -27,8 +28,8 @@ use crate::{
pub struct IotaConnection {
pub sender: Arc<RwLock<WebSocketSender<Compat<tokio::net::TcpStream>>>>,
pub receiver: Arc<RwLock<WebSocketReceiver<Compat<tokio::net::TcpStream>>>>,
pub iota_id: Arc<RwLock<Uuid>>,
pub user_ids: Arc<RwLock<Vec<Uuid>>>,
pub iota_id: Arc<RwLock<i64>>,
pub user_ids: Arc<RwLock<Vec<i64>>>,
pub identified: Arc<RwLock<bool>>,
pub ping: Arc<RwLock<i64>>,
pub rho_connection: Arc<RwLock<Option<Weak<RhoConnection>>>>,
@ -43,7 +44,7 @@ impl IotaConnection {
Arc::new(Self {
sender: Arc::new(RwLock::new(sender)),
receiver: Arc::new(RwLock::new(receiver)),
iota_id: Arc::new(RwLock::new(Uuid::nil())),
iota_id: Arc::new(RwLock::new(0)),
user_ids: Arc::new(RwLock::new(Vec::new())),
identified: Arc::new(RwLock::new(false)),
ping: Arc::new(RwLock::new(0)),
@ -52,12 +53,12 @@ impl IotaConnection {
}
/// Get the Iota ID
pub async fn get_iota_id(&self) -> Uuid {
pub async fn get_iota_id(&self) -> i64 {
*self.iota_id.read().await
}
/// Get the user IDs
pub async fn get_user_ids(&self) -> Vec<Uuid> {
pub async fn get_user_ids(&self) -> Vec<i64> {
self.user_ids.read().await.clone()
}
@ -115,6 +116,7 @@ impl IotaConnection {
// Handle identification
if cv.is_type(CommunicationType::identification) && !self.is_identified().await {
line(PrintType::IotaIn, &cv.to_json().to_string());
self.handle_identification(cv).await;
return;
}
@ -151,35 +153,47 @@ impl IotaConnection {
/// Handle identification message
async fn handle_identification(self: Arc<Self>, cv: CommunicationValue) {
// Parse Iota ID
let iota_id = match cv.get_data(DataTypes::iota_id) {
Some(id_str) => match Uuid::parse_str(&id_str.to_string()) {
Ok(id) => id,
Err(_) => {
self.send_error_response(&cv.get_id()).await;
return;
}
},
None => {
self.send_error_response(&cv.get_id()).await;
return;
}
};
let iota_id: i64 = cv
.get_data(DataTypes::iota_id)
.unwrap_or(&JsonValue::Number(Number::from(0)))
.as_i64()
.unwrap_or(0);
if iota_id == 0 {
let error = CommunicationValue::new(CommunicationType::error).with_id(cv.get_id());
self.send_message(error).await;
return;
}
// Parse user IDs
let mut validated_user_ids: Vec<Uuid> = Vec::new();
let mut validated_user_ids: Vec<i64> = Vec::new();
if let Some(user_ids_str) = cv.get_data(DataTypes::user_ids) {
for id_str in user_ids_str.to_string().split(',') {
if id_str.is_empty() {
continue;
}
if let Ok(user_id) = Uuid::parse_str(id_str.trim()) {
if let Some(auth_iota_id) = auth_connector::get_iota_id(user_id).await {
if auth_iota_id == iota_id {
validated_user_ids.push(user_id);
match id_str.parse::<i64>() {
Ok(user_id) => {
if let Some(auth_iota_id) = auth_connector::get_iota_id(user_id).await {
line(
PrintType::IotaIn,
&format!(
"auth for {} should be {} is {}",
user_id, iota_id, auth_iota_id
),
);
if auth_iota_id == iota_id {
validated_user_ids.push(user_id);
}
} else {
line(
PrintType::IotaIn,
&format!("User ID {} not parsed", id_str.trim()),
);
}
} else {
line(PrintType::IotaIn, "User ID not found");
}
Err(e) => {
line(
PrintType::IotaIn,
&format!("Failed to parse '{}' as i64: {:?}", id_str, e),
);
}
}
}
@ -280,10 +294,10 @@ impl IotaConnection {
/// Handle GET_CHATS message
async fn handle_get_chats(&self, cv: CommunicationValue) {
let receiver_id = cv.get_receiver();
let mut interested_ids: Vec<Uuid> = Vec::new();
let mut interested_ids: Vec<i64> = Vec::new();
let calls: Vec<Arc<CallGroup>> = call_manager::get_call_groups(receiver_id).await;
let mut invites: HashMap<Uuid, Vec<JsonValue>> = HashMap::new();
let mut invites: HashMap<i64, Vec<JsonValue>> = HashMap::new();
let empty = &calls.is_empty();
for call in calls {
for inviter in call.members.read().await.iter() {
@ -309,22 +323,19 @@ impl IotaConnection {
JsonValue::new_array()
}
} else {
line(PrintType::CallIn, &format!("not empty: {:?}", invites));
let mut enrc_contacts = JsonValue::new_array();
if let Some(contacts_data) = cv.get_data(DataTypes::user_ids) {
if let JsonValue::Array(user_ids) = contacts_data {
for user_json in user_ids {
let user_id_str = user_json["user_id"].as_str().unwrap_or("");
if let Ok(user_id) = Uuid::parse_str(&user_id_str) {
interested_ids.push(user_id);
let mut enriched_contact = JsonValue::new_object();
let _ = enriched_contact.insert("user_id", user_id.to_string());
let _ = enriched_contact.insert(
"calls",
JsonValue::Array(invites.get(&user_id).unwrap_or(&vec![]).clone()),
);
let _ = enrc_contacts.push(enriched_contact);
}
let user_id = user_json["user_id"].as_i64().unwrap_or(0);
interested_ids.push(user_id);
let mut enriched_contact = JsonValue::new_object();
let _ = enriched_contact.insert("user_id", user_id.to_string());
let _ = enriched_contact.insert(
"calls",
JsonValue::Array(invites.get(&user_id).unwrap_or(&vec![]).clone()),
);
let _ = enrc_contacts.push(enriched_contact);
}
} else {
enrc_contacts = contacts_data.clone();
@ -355,11 +366,6 @@ impl IotaConnection {
}
}
async fn send_error_response(&self, message_id: &Uuid) {
let error = CommunicationValue::new(CommunicationType::error).with_id(*message_id);
self.send_message(error).await;
}
pub async fn handle_close(&self) {
if self.is_identified().await {
if let Some(rho_conn) = self.get_rho_connection().await {

71
src/rho/rho_connection.rs
View file

@ -4,20 +4,20 @@ use crate::data::{
user::UserStatus,
};
use crate::omega::omega_connection::OmegaConnection;
use json::{JsonValue, number::Number};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use uuid::Uuid;
pub struct RhoConnection {
iota_connection: Arc<IotaConnection>,
user_ids: Vec<Uuid>,
user_ids: Vec<i64>,
client_connections: Arc<RwLock<Vec<Arc<ClientConnection>>>>,
}
impl RhoConnection {
/// Create a new RhoConnection
pub async fn new(iota_connection: Arc<IotaConnection>, user_ids: Vec<Uuid>) -> Self {
pub async fn new(iota_connection: Arc<IotaConnection>, user_ids: Vec<i64>) -> Self {
let rho_connection = Self {
iota_connection,
user_ids: user_ids.clone(),
@ -30,11 +30,11 @@ impl RhoConnection {
rho_connection
}
pub async fn get_iota_id(&self) -> Uuid {
pub async fn get_iota_id(&self) -> i64 {
self.iota_connection.get_iota_id().await
}
pub fn get_user_ids(&self) -> &Vec<Uuid> {
pub fn get_user_ids(&self) -> &Vec<i64> {
&self.user_ids
}
@ -50,12 +50,12 @@ impl RhoConnection {
/// Get client connections for a specific user
pub async fn get_client_connections_for_user(
&self,
user_id: Uuid,
user_id: i64,
) -> Vec<Arc<ClientConnection>> {
let connections = self.client_connections.read().await;
let mut collections = Vec::new();
for con in connections.iter() {
if con.get_user_id().await.unwrap() == user_id {
if con.get_user_id().await == user_id {
collections.push(con.clone());
}
}
@ -64,15 +64,10 @@ impl RhoConnection {
/// Add a client connection
pub async fn add_client_connection(&self, connection: Arc<ClientConnection>) {
let notification = CommunicationValue::new(CommunicationType::client_connected)
.add_data_str(
DataTypes::user_id,
connection
.get_user_id()
.await
.unwrap_or(Uuid::nil())
.to_string(),
);
let notification = CommunicationValue::new(CommunicationType::client_connected).add_data(
DataTypes::user_id,
JsonValue::Number(Number::from(connection.get_user_id().await)),
);
self.iota_connection.send_message(notification).await;
@ -83,7 +78,7 @@ impl RhoConnection {
OmegaConnection::client_changed(
self.get_iota_id().await,
connection.get_user_id().await.unwrap_or(Uuid::nil()),
connection.get_user_id().await,
UserStatus::online,
)
.await;
@ -94,12 +89,10 @@ impl RhoConnection {
{
let mut connections = self.client_connections.write().await;
let target_user_id = connection.get_user_id().await.unwrap();
let target_user_id = connection.get_user_id().await;
connections.retain(|con| {
futures::executor::block_on(async {
con.get_user_id().await.unwrap() != target_user_id
})
futures::executor::block_on(async { con.get_user_id().await != target_user_id })
});
connections.push(Arc::clone(&connection));
@ -108,7 +101,7 @@ impl RhoConnection {
// Notify OmegaConnection
OmegaConnection::client_changed(
self.get_iota_id().await,
connection.get_user_id().await.unwrap_or(Uuid::nil()),
connection.get_user_id().await,
UserStatus::user_offline,
)
.await;
@ -131,15 +124,9 @@ impl RhoConnection {
/// Send message from Iota to specific client
pub async fn message_to_client(&self, cv: CommunicationValue) {
if let Some(receiver_id) = Some(cv.get_receiver()) {
let connections = self.client_connections.read().await;
for connection in connections.iter() {
if let Some(conn_user_id) = connection.get_user_id().await {
if conn_user_id == receiver_id {
connection.send_message(&cv).await;
}
}
}
let connections = self.client_connections.read().await;
for connection in connections.iter() {
connection.send_message(&cv).await;
}
}
@ -154,16 +141,15 @@ impl RhoConnection {
}
/// Set interested users for a specific client
pub async fn set_interested(&self, user_id: Uuid, interested_ids: Vec<Uuid>) {
pub async fn set_interested(&self, user_id: i64, interested_ids: Vec<i64>) {
let connections = self.client_connections.read().await;
for connection in connections.iter() {
if let Some(conn_user_id) = connection.get_user_id().await {
if conn_user_id == user_id {
connection
.set_interested_users(interested_ids.clone())
.await;
break;
}
let conn_user_id = connection.get_user_id().await;
if conn_user_id == user_id {
connection
.set_interested_users(interested_ids.clone())
.await;
break;
}
}
}
@ -182,16 +168,15 @@ impl RhoConnection {
let mut pings = HashMap::new();
for connection in connections.iter() {
if let Some(user_id) = connection.get_user_id().await {
pings.insert(user_id.to_string(), connection.get_ping().await);
}
let user_id = connection.get_user_id().await;
pings.insert(user_id.to_string(), connection.get_ping().await);
}
pings
}
/// Check if this RhoConnection contains a specific user ID
pub fn contains_user(&self, user_id: &Uuid) -> bool {
pub fn contains_user(&self, user_id: &i64) -> bool {
self.user_ids.contains(user_id)
}

11
src/rho/rho_manager.rs
View file

@ -6,12 +6,11 @@ use std::{
sync::{Arc, LazyLock},
};
use tokio::sync::RwLock;
use uuid::Uuid;
pub static RHO_CONNECTIONS: LazyLock<Arc<RwLock<HashMap<Uuid, Arc<RhoConnection>>>>> =
pub static RHO_CONNECTIONS: LazyLock<Arc<RwLock<HashMap<i64, Arc<RhoConnection>>>>> =
LazyLock::new(|| Arc::new(RwLock::new(HashMap::new())));
pub async fn get_rho_con_for_user(user_id: Uuid) -> Option<Arc<RhoConnection>> {
pub async fn get_rho_con_for_user(user_id: i64) -> Option<Arc<RhoConnection>> {
let connections = RHO_CONNECTIONS.read().await;
line(
PrintType::ClientIn,
@ -32,13 +31,13 @@ pub async fn get_rho_con_for_user(user_id: Uuid) -> Option<Arc<RhoConnection>> {
None
}
pub async fn contains_iota(iota_id: Uuid) -> bool {
pub async fn contains_iota(iota_id: i64) -> bool {
let connections = RHO_CONNECTIONS.read().await;
connections.contains_key(&iota_id)
}
/// Remove a RhoConnection by Iota ID
pub async fn remove_rho(iota_id: Uuid) -> Option<Arc<RhoConnection>> {
pub async fn remove_rho(iota_id: i64) -> Option<Arc<RhoConnection>> {
let mut connections = RHO_CONNECTIONS.write().await;
connections.remove(&iota_id)
}
@ -51,7 +50,7 @@ pub async fn add_rho(rho_connection: Arc<RhoConnection>) {
}
/// Get a RhoConnection by Iota ID directly
pub async fn get_rho_by_iota(iota_id: Uuid) -> Option<Arc<RhoConnection>> {
pub async fn get_rho_by_iota(iota_id: i64) -> Option<Arc<RhoConnection>> {
let connections = RHO_CONNECTIONS.read().await;
connections.get(&iota_id).map(Arc::clone)
}