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

[Fix] Removed so much now useless logging ._.

Browse source
This commit is contained in:
Alex Emmet 2026-03-09 22:29:48 +01:00
commit 657cdf50b1
2 changed files with 8 additions and 368 deletions
Download patch file Download diff file Expand all files Collapse all files

212
src/rho/connection.rs
View file

@ -60,25 +60,8 @@ impl GeneralConnection {
loop {
let cv = match self.receiver.receive().await {
Ok(v) => {
log_in!(
0,
PrintType::General,
"General connection received message type={:?} id={} identified={} challenged={}",
v.get_type(),
v.get_id(),
*self.identified.read().await,
*self.challenged.read().await
);
v
}
Ok(v) => v,
Err(e) => {
log_err!(
0,
PrintType::General,
"General connection receive error before upgrade completion: {:?}",
e
);
break;
}
};
@ -91,30 +74,12 @@ impl GeneralConnection {
if !*self.challenged.read().await {
self.handle_challenge_response(cv).await;
if *self.challenged.read().await {
log_out!(
0,
PrintType::General,
"General connection challenge flow completed, handler will stop after immediate migration"
);
break;
}
continue;
}
log_in!(
0,
PrintType::General,
"General connection ready to migrate for id={} kind={:?}",
*self.id.read().await,
*self.connection_kind.read().await
);
if self.migrate().await {
log_out!(
0,
PrintType::General,
"General connection migration completed, handing over to specialized connection"
);
break;
}
}
@ -123,56 +88,23 @@ impl GeneralConnection {
}
async fn handle_identification(self: &Arc<Self>, cv: CommunicationValue) {
if !cv.is_type(CommunicationType::identification) {
log_in!(
0,
PrintType::General,
"Ignoring pre-identification message type={:?} id={}",
cv.get_type(),
cv.get_id()
);
return;
}
if let DataValue::Number(iota_id) = cv.get_data(DataTypes::iota_id) {
log_in!(
*iota_id,
PrintType::Iota,
"Received Iota identification request message_id={}",
cv.get_id()
);
*self.id.write().await = *iota_id as u64;
*self.connection_kind.write().await = Some(ConnectionKind::Iota);
let get_pub_key_msg = CommunicationValue::new(CommunicationType::get_iota_data)
.add_data(DataTypes::iota_id, DataValue::Number(*iota_id));
log_out!(
*iota_id,
PrintType::Iota,
"Requesting Iota public key from Omega"
);
let response_cv = get_omega_connection()
.await_response(&get_pub_key_msg, Some(Duration::from_secs(20)))
.await;
let response_cv = match response_cv {
Ok(r) => {
log_in!(
*iota_id,
PrintType::Iota,
"Received Iota public key response from Omega"
);
r
}
Ok(r) => r,
Err(e) => {
log_err!(
*iota_id,
PrintType::Iota,
"Failed to load Iota public key from Omega: {:?}",
e
);
return;
}
};
@ -185,11 +117,6 @@ impl GeneralConnection {
let pub_key = match load_public_key(base64_pub) {
Some(pk) => pk,
None => {
log_err!(
*iota_id,
PrintType::Iota,
"Failed to decode Iota public key from Omega response"
);
return;
}
};
@ -202,13 +129,6 @@ impl GeneralConnection {
.map(char::from)
.collect();
log_out!(
*iota_id,
PrintType::Iota,
"Generated challenge for Iota identification challenge_len={}",
challenge.len()
);
*self.challenge.write().await = challenge.clone();
*self.identified.write().await = true;
@ -226,101 +146,32 @@ impl GeneralConnection {
)
.add_data(DataTypes::challenge, DataValue::Str(encrypted_challenge));
log_out!(
*iota_id,
PrintType::Iota,
"Sending encrypted identification challenge to Iota"
);
if let Err(e) = self.sender.send(&response).await {
log_err!(
*iota_id,
PrintType::Iota,
"Failed to send challenge to Iota: {:?}",
e
);
}
} else {
log_err!(
0,
PrintType::General,
"Identification message missing iota_id payload"
);
let _ = self.sender.send(&response).await;
}
}
async fn handle_challenge_response(self: &Arc<Self>, cv: CommunicationValue) {
let id = *self.id.read().await as i64;
if !cv.is_type(CommunicationType::challenge_response) {
log_in!(
id,
PrintType::Iota,
"Ignoring pre-challenge-completion message type={:?} id={}",
cv.get_type(),
cv.get_id()
);
return;
}
if let DataValue::Str(response) = cv.get_data(DataTypes::challenge) {
let expected = self.challenge.read().await.clone();
log_in!(
id,
PrintType::Iota,
"Received challenge response message_id={} response_len={} expected_len={}",
cv.get_id(),
response.len(),
expected.len()
);
if *response == expected {
log_in!(
id,
PrintType::Iota,
"Challenge response validated successfully"
);
*self.challenged.write().await = true;
let response = CommunicationValue::new(CommunicationType::identification_response)
.with_id(cv.get_id())
.add_data(DataTypes::accepted, DataValue::Bool(true));
log_out!(
id,
PrintType::Iota,
"Sending identification_response accepted=true"
);
if let Err(e) = self.sender.send(&response).await {
log_err!(
id,
PrintType::Iota,
"Failed to send identification_response: {:?}",
e
);
if let Err(_) = self.sender.send(&response).await {
return;
}
log_in!(
id,
PrintType::Iota,
"Immediately migrating upgraded connection after successful challenge validation"
);
if self.migrate().await {
log_out!(
id,
PrintType::Iota,
"Immediate migration after challenge validation completed successfully"
);
} else {
log_err!(
id,
PrintType::Iota,
"Immediate migration after challenge validation failed"
);
log_out!(id, PrintType::Iota, "Immediate migration");
}
} else {
log_err!(
@ -344,87 +195,34 @@ impl GeneralConnection {
let kind = match *self.connection_kind.read().await {
Some(kind) => kind,
None => {
log_err!(
0,
PrintType::General,
"Migration requested without a resolved connection kind"
);
return false;
}
};
let id = *self.id.read().await;
log_in!(
id as i64,
PrintType::General,
"Starting migration for kind={:?} id={}",
kind,
id
);
match kind {
ConnectionKind::Client => {
let client = ClientConnection::from_general(self.clone(), id).await;
client.start();
log_out!(
id as i64,
PrintType::Client,
"Migrated general connection into ClientConnection"
);
}
ConnectionKind::Iota => {
let iota = IotaConnection::from_general(self.clone(), id).await;
log_in!(
id as i64,
PrintType::Iota,
"Created upgraded IotaConnection from GeneralConnection"
);
let rho = Arc::new(RhoConnection::new(iota.clone(), Vec::new()).await);
log_in!(
id as i64,
PrintType::Iota,
"Created RhoConnection for upgraded Iota connection"
);
iota.set_rho_connection(Arc::downgrade(&rho)).await;
log_in!(
id as i64,
PrintType::Iota,
"Attached weak RhoConnection reference to IotaConnection"
);
rho_manager::add_rho(rho).await;
log_out!(
id as i64,
PrintType::Iota,
"Registered upgraded Iota connection in rho_manager"
);
iota.start();
log_out!(
id as i64,
PrintType::Iota,
"Started upgraded IotaConnection read loop"
);
}
ConnectionKind::AnonymousClient => {
let client = AnonymousClientConnection::from_general(self.clone(), id).await;
client.start();
log_out!(
id as i64,
PrintType::Client,
"Migrated general connection into AnonymousClientConnection"
);
}
ConnectionKind::Phi => {
let iota = ClientConnection::from_general(self.clone(), id).await;
iota.start();
log_out!(
id as i64,
PrintType::General,
"Migrated general connection into Phi/Client handler"
);
}
}
true