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

Initial migration to MTP [Broken]

Browse source
This commit is contained in:
Alex Emmet 2026-06-28 13:52:58 +02:00
commit 7ea84cc54b
15 changed files with 965 additions and 1190 deletions
Download patch file Download diff file Expand all files Collapse all files

214
src/anonymous_clients/anonymous_client_connection.rs
View file

@ -1,9 +1,9 @@
use mtp::codec::{CommunicationType, CommunicationValue, DataType, DataValue, TypeMap};
use mtp::transport::{Receiver, Sender};
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;
use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue};
use ttp_native::{Receiver, Sender};
use uuid::Uuid;
use crate::anonymous_clients::anonymous_manager::{self, generate_username};
@ -88,7 +88,7 @@ impl AnonymousClientConnection {
);
return;
}
if !cv.is_type(CommunicationType::pong) {
if !cv.is_type(CommunicationType::Pong) {
log_cv_out!(PrintType::Client, &cv);
}
if let Err(e) = self.sender.send(&cv).await {
@ -104,16 +104,15 @@ impl AnonymousClientConnection {
/// Handle incoming message from client
pub async fn handle_message(self: Arc<Self>, cv: CommunicationValue) {
tokio::spawn(async move {
if cv.is_type(CommunicationType::ping) {
if cv.is_type(CommunicationType::Ping) {
self.handle_ping(cv).await;
return;
}
log_cv_in!(PrintType::Client, &cv);
if cv.is_type(CommunicationType::identification) {
let call_id =
Uuid::parse_str(cv.get_data(DataTypes::call_id).as_str().unwrap_or(""))
.unwrap_or(Uuid::new_v4());
if cv.is_type(CommunicationType::Identification) {
let call_id = Uuid::parse_str(cv.get_data(DataType::CallId).as_str().unwrap_or(""))
.unwrap_or(Uuid::new_v4());
let call = if let Some(call) = call_manager::get_call(call_id).await {
if call.is_anonymous().await {
@ -121,7 +120,7 @@ impl AnonymousClientConnection {
} else {
self.send_error_response(
&cv.get_id(),
CommunicationType::error_not_authenticated,
CommunicationType::ErrorNotAuthenticated,
)
.await;
return;
@ -129,7 +128,7 @@ impl AnonymousClientConnection {
} else {
self.send_error_response(
&cv.get_id(),
CommunicationType::error_not_authenticated,
CommunicationType::ErrorNotAuthenticated,
)
.await;
return;
@ -139,9 +138,9 @@ impl AnonymousClientConnection {
for call_invitee in call.members.read().await.clone() {
let call_invitee_cv = get_omega_connection()
.await_response(
&CommunicationValue::new(CommunicationType::get_user_data).add_data(
DataTypes::user_id,
DataValue::Number(call_invitee.user_id as i64),
&CommunicationValue::new(CommunicationType::GetUserData).add_typed_default(
DataType::UserId,
DataValue::SignedNumber(call_invitee.user_id.into()),
),
Some(Duration::from_secs(2)),
)
@ -149,120 +148,122 @@ impl AnonymousClientConnection {
.unwrap();
let mut json_invitee = Vec::new();
let _ = json_invitee.push((
DataTypes::user_id,
call_invitee_cv.get_data(DataTypes::user_id).clone(),
DataType::UserId,
call_invitee_cv.get_data(DataType::UserId).clone(),
));
let _ = json_invitee.push((
DataTypes::username,
call_invitee_cv.get_data(DataTypes::username).clone(),
DataType::Username,
call_invitee_cv.get_data(DataType::Username).clone(),
));
let _ = json_invitee.push((
DataTypes::display,
call_invitee_cv.get_data(DataTypes::display).clone(),
DataType::Display,
call_invitee_cv.get_data(DataType::Display).clone(),
));
let _ = json_invitee.push((
DataTypes::avatar,
call_invitee_cv.get_data(DataTypes::avatar).clone(),
DataType::Avatar,
call_invitee_cv.get_data(DataType::Avatar).clone(),
));
let _ = invited.push(DataValue::Container(json_invitee));
let _ = invited.push(DataValue::Container(json_invitee.iter().map(|(k, v)| (k.to_id(&TypeMap::latest()), v.clone())).collect()));
}
let token = call.create_anonymous_token(self.get_user_id()).await;
let mut serialized = Vec::new();
let _ = serialized.push((DataTypes::call_id, DataValue::Str(call_id.to_string())));
let _ =
serialized.push((DataTypes::call_invited, DataValue::Array(invited.clone())));
let _ = serialized.push((DataTypes::call_members, DataValue::Array(invited)));
let _ = serialized.push((DataTypes::call_token, DataValue::Str(token.unwrap())));
let _ = serialized.push((DataType::CallId, DataValue::Str(call_id.to_string())));
let _ = serialized.push((DataType::CallInvited, DataValue::Array(invited.clone())));
let _ = serialized.push((DataType::CallMembers, DataValue::Array(invited)));
let _ = serialized.push((DataType::CallToken, DataValue::Str(token.unwrap())));
self.clone()
.send_message(
&&CommunicationValue::new(CommunicationType::identification_response)
&&CommunicationValue::new(CommunicationType::IdentificationResponse)
.with_id(cv.get_id())
.add_data(DataTypes::user_id, DataValue::Number(self.user_id as i64))
.add_data(
DataTypes::username,
.add_typed_default(
DataType::UserId,
DataValue::SignedNumber(self.user_id.into()),
)
.add_typed_default(
DataType::Username,
DataValue::Str(self.clone().get_user_name().await),
)
.add_data(
DataTypes::display,
.add_typed_default(
DataType::Display,
DataValue::Str(self.get_display_name().await),
)
.add_data(DataTypes::avatar, DataValue::Str(self.get_avatar().await))
.add_data(DataTypes::call_state, DataValue::Container(serialized)),
.add_typed_default(DataType::Avatar, DataValue::Str(self.get_avatar().await))
.add_typed_default(DataType::CallState, DataValue::Container(serialized.iter().map(|(k, v)| (k.to_id(&TypeMap::latest()), v.clone())).collect())),
)
.await;
}
// Handle ping
if cv.is_type(CommunicationType::ping) {
if cv.is_type(CommunicationType::Ping) {
self.handle_ping(cv).await;
return;
}
// Handle client status changes
if cv.is_type(CommunicationType::client_changed) {
if cv.is_type(CommunicationType::ClientChanged) {
self.handle_client_changed(cv).await;
return;
}
// Handle call invites
if cv.is_type(CommunicationType::call_invite) {
if cv.is_type(CommunicationType::CallInvite) {
self.handle_call_invite(cv).await;
return;
}
// Handle get call requests
if cv.is_type(CommunicationType::call_token) {
if cv.is_type(CommunicationType::CallToken) {
self.handle_get_call(cv).await;
return;
}
if cv.is_type(CommunicationType::call_disconnect_user) {
if cv.is_type(CommunicationType::CallDisconnectUser) {
self.handle_call_disconnect_user(cv).await;
return;
}
if cv.is_type(CommunicationType::call_timeout_user) {
if cv.is_type(CommunicationType::CallTimeoutUser) {
self.handle_call_timeout_user(cv).await;
return;
}
if cv.is_type(CommunicationType::change_user_data) {
if let Some(display_name) = cv.get_data(DataTypes::display).as_str() {
if cv.is_type(CommunicationType::ChangeUserData) {
if let Some(display_name) = cv.get_data(DataType::Display).as_str() {
let _ = self.set_display_name(display_name.to_string()).await;
}
return;
}
if cv.is_type(CommunicationType::get_user_data) {
if cv.is_type(CommunicationType::GetUserData) {
if let Some(anonymous) = {
if let Some(user_id) = cv.get_data(DataTypes::user_id).as_number() {
if let Some(user_id) = cv.get_data(DataType::UserId).as_signed_number() {
anonymous_manager::get_anonymous_user(user_id as u64).await
} else if let Some(username) = cv.get_data(DataTypes::username).as_str() {
} else if let Some(username) = cv.get_data(DataType::Username).as_str() {
anonymous_manager::get_anonymous_user_by_name(username.to_string()).await
} else {
None
}
} {
let response = CommunicationValue::new(CommunicationType::get_user_data)
let response = CommunicationValue::new(CommunicationType::GetUserData)
.with_id(cv.get_id())
.add_data(
DataTypes::username,
.add_typed_default(
DataType::Username,
DataValue::Str(anonymous.get_user_name().await),
)
.add_data(
DataTypes::user_id,
DataValue::Number(anonymous.user_id as i64),
.add_typed_default(
DataType::UserId,
DataValue::SignedNumber(anonymous.user_id.into()),
)
.add_data(
DataTypes::display,
.add_typed_default(
DataType::Display,
DataValue::Str(anonymous.get_display_name().await),
)
.add_data(DataTypes::user_state, DataValue::Str("online".to_string()))
.add_data(
DataTypes::avatar,
.add_typed_default(DataType::UserState, DataValue::Str("online".to_string()))
.add_typed_default(
DataType::Avatar,
DataValue::Str(anonymous.get_avatar().await),
);
@ -272,9 +273,9 @@ impl AnonymousClientConnection {
}
}
if cv.is_type(CommunicationType::get_user_data)
|| cv.is_type(CommunicationType::get_iota_data)
|| cv.is_type(CommunicationType::delete_user)
if cv.is_type(CommunicationType::GetUserData)
|| cv.is_type(CommunicationType::GetIotaData)
|| cv.is_type(CommunicationType::DeleteUser)
{
self.handle_omega_forward(cv).await;
return;
@ -296,7 +297,7 @@ impl AnonymousClientConnection {
/// Handle ping message
async fn handle_ping(self: Arc<Self>, cv: CommunicationValue) {
// Update our ping if provided
if let DataValue::Number(last_ping) = cv.get_data(DataTypes::last_ping) {
if let DataValue::SignedNumber(last_ping) = cv.get_data(DataType::LastPing) {
if let Ok(ping_val) = last_ping.to_string().parse::<i64>() {
let mut ping_guard = self.ping.write().await;
*ping_guard = ping_val;
@ -304,14 +305,14 @@ impl AnonymousClientConnection {
}
// Send pong response
let response = CommunicationValue::new(CommunicationType::pong).with_id(cv.get_id());
let response = CommunicationValue::new(CommunicationType::Pong).with_id(cv.get_id());
self.send_message(&response).await;
}
/// Handle client status change
async fn handle_client_changed(self: Arc<Self>, cv: CommunicationValue) {
if let DataValue::Str(status_str) = cv.get_data(DataTypes::user_state) {
if let DataValue::Str(status_str) = cv.get_data(DataType::UserState) {
let user_status = UserStatus::from_str(&status_str).unwrap_or(UserStatus::user_online);
OmegaConnection::client_changed(self.user_id as i64, self.user_id as i64, user_status)
.await;
@ -320,40 +321,37 @@ impl AnonymousClientConnection {
/// Handle call invite
async fn handle_call_invite(self: Arc<Self>, cv: CommunicationValue) {
let receiver_id: i64 = cv.get_data(DataTypes::receiver_id).as_number().unwrap_or(0);
let receiver_id: i64 = cv.get_data(DataType::ReceiverId).as_signed_number().unwrap_or(0) as i64;
if receiver_id == 0 {
self.send_error_response(&cv.get_id(), CommunicationType::error_no_user_id)
self.send_error_response(&cv.get_id(), CommunicationType::ErrorNoUserId)
.await;
return;
}
let call_id = match cv.get_data(DataTypes::call_id) {
let call_id = match cv.get_data(DataType::CallId) {
DataValue::Str(id_str) => match Uuid::parse_str(&id_str.to_string()) {
Ok(id) => id,
Err(_) => {
self.send_error_response(
&cv.get_id(),
CommunicationType::error_invalid_call_id,
)
.await;
self.send_error_response(&cv.get_id(), CommunicationType::ErrorInvalidCallId)
.await;
return;
}
},
_ => {
self.send_error_response(&cv.get_id(), CommunicationType::error_no_call_id)
self.send_error_response(&cv.get_id(), CommunicationType::ErrorNoCallId)
.await;
return;
}
};
let secret = cv
.get_data(DataTypes::call_secret)
.get_data(DataType::CallSecret)
.as_str()
.map(|s| s.to_string());
let invited =
call_manager::add_invite(call_id, self.user_id, receiver_id as u64, secret).await;
if !invited {
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_call_id)
self.send_error_response(&cv.get_id(), CommunicationType::ErrorInvalidCallId)
.await;
return;
}
@ -366,12 +364,15 @@ impl AnonymousClientConnection {
let sender_id = self.get_user_id();
// User is offline - send push notification for call invite
let push_cv = CommunicationValue::new(CommunicationType::push_notification)
let push_cv = CommunicationValue::new(CommunicationType::PushNotification)
.with_receiver(receiver_id as u64)
.add_data(DataTypes::sender_id, DataValue::Number(sender_id as i64))
.add_data(DataTypes::call_id, DataValue::Str(call_id.to_string()))
.add_data(
DataTypes::notifications,
.add_typed_default(
DataType::SenderId,
DataValue::SignedNumber(sender_id.into()),
)
.add_typed_default(DataType::CallId, DataValue::Str(call_id.to_string()))
.add_typed_default(
DataType::Notifications,
DataValue::Str("call_invite".to_string()),
);
@ -381,9 +382,9 @@ impl AnonymousClientConnection {
let _ = omega_conn.send_message(&push_cv).await;
});
let error_cv = CommunicationValue::new(CommunicationType::error_not_found)
let error_cv = CommunicationValue::new(CommunicationType::ErrorNotFound)
.with_id(cv.get_id())
.add_data(DataTypes::receiver_id, DataValue::Number(receiver_id));
.add_typed_default(DataType::ReceiverId, DataValue::SignedNumber(receiver_id.into()));
self.send_message(&error_cv).await;
return;
}
@ -393,19 +394,19 @@ impl AnonymousClientConnection {
let sender_id = self.get_user_id();
// Create and send call distribution message
let forward = CommunicationValue::new(CommunicationType::call_invite)
let forward = CommunicationValue::new(CommunicationType::CallInvite)
.with_receiver(receiver_id as u64)
.with_sender(sender_id)
.add_data(DataTypes::call_id, DataValue::Str(call_id.to_string()))
.add_data(
DataTypes::receiver_id,
.add_typed_default(DataType::CallId, DataValue::Str(call_id.to_string()))
.add_typed_default(
DataType::ReceiverId,
DataValue::Str(receiver_id.to_string()),
)
.add_data(DataTypes::sender_id, DataValue::Str(sender_id.to_string()));
.add_typed_default(DataType::SenderId, DataValue::Str(sender_id.to_string()));
target_rho.message_to_client(forward).await;
let response = CommunicationValue::new(CommunicationType::success).with_id(cv.get_id());
let response = CommunicationValue::new(CommunicationType::Success).with_id(cv.get_id());
self.send_message(&response).await;
}
@ -413,44 +414,40 @@ impl AnonymousClientConnection {
async fn handle_get_call(self: Arc<Self>, cv: CommunicationValue) {
let user_id = self.get_user_id();
let call_id = match cv.get_data(DataTypes::call_id) {
let call_id = match cv.get_data(DataType::CallId) {
DataValue::Str(id_str) => match Uuid::parse_str(&id_str.to_string()) {
Ok(id) => id,
Err(_) => {
self.send_error_response(
&cv.get_id(),
CommunicationType::error_invalid_call_id,
)
.await;
self.send_error_response(&cv.get_id(), CommunicationType::ErrorInvalidCallId)
.await;
return;
}
},
_ => {
self.send_error_response(&cv.get_id(), CommunicationType::error_no_call_id)
self.send_error_response(&cv.get_id(), CommunicationType::ErrorNoCallId)
.await;
return;
}
};
if let Some(token) = call_manager::get_call_token(user_id, call_id).await {
let response = CommunicationValue::new(CommunicationType::call_token)
let response = CommunicationValue::new(CommunicationType::CallToken)
.with_id(cv.get_id())
.with_receiver(user_id)
.add_data(DataTypes::call_token, DataValue::Str(token.to_string()));
.add_typed_default(DataType::CallToken, DataValue::Str(token.to_string()));
self.send_message(&response).await;
} else {
let error_cv = CommunicationValue::new(CommunicationType::error_no_call_id)
let error_cv = CommunicationValue::new(CommunicationType::ErrorNoCallId)
.with_id(cv.get_id())
.add_data(DataTypes::call_id, DataValue::Str(call_id.to_string()));
.add_typed_default(DataType::CallId, DataValue::Str(call_id.to_string()));
self.send_message(&error_cv).await;
return;
}
}
async fn handle_call_timeout_user(self: Arc<Self>, cv: CommunicationValue) {
let call_id =
Uuid::from_str(cv.get_data(DataTypes::call_id).as_str().unwrap_or("")).unwrap();
let user_id = cv.get_data(DataTypes::user_id).as_number().unwrap_or(0);
let untill = cv.get_data(DataTypes::untill).as_number().unwrap_or(0);
let call_id = Uuid::from_str(cv.get_data(DataType::CallId).as_str().unwrap_or("")).unwrap();
let user_id = cv.get_data(DataType::UserId).as_signed_number().unwrap_or(0);
let untill = cv.get_data(DataType::Untill).as_signed_number().unwrap_or(0);
let call = call_manager::get_call(call_id).await;
if let Some(call) = call {
@ -463,15 +460,14 @@ impl AnonymousClientConnection {
call.get_caller(user_id as u64)
.await
.unwrap()
.set_timeout(untill)
.set_timeout(untill.try_into().unwrap())
.await;
}
}
}
async fn handle_call_disconnect_user(self: Arc<Self>, cv: CommunicationValue) {
let call_id =
Uuid::from_str(cv.get_data(DataTypes::call_id).as_str().unwrap_or("")).unwrap();
let user_id = cv.get_data(DataTypes::user_id).as_number().unwrap_or(0);
let call_id = Uuid::from_str(cv.get_data(DataType::CallId).as_str().unwrap_or("")).unwrap();
let user_id = cv.get_data(DataType::UserId).as_signed_number().unwrap_or(0);
let call = call_manager::get_call(call_id).await;
if let Some(call) = call {
@ -525,9 +521,9 @@ impl AnonymousClientConnection {
} else {
user_status
};
let notification = CommunicationValue::new(CommunicationType::client_changed)
.add_data(DataTypes::user_id, DataValue::Str(user_id.to_string()))
.add_data(DataTypes::user_state, DataValue::Str(status.to_string()));
let notification = CommunicationValue::new(CommunicationType::ClientChanged)
.add_typed_default(DataType::UserId, DataValue::Str(user_id.to_string()))
.add_typed_default(DataType::UserState, DataValue::Str(status.to_string()));
self.send_message(&notification).await;
}