diff --git a/server/src/db/machines.rs b/server/src/db/machines.rs index a51680f..205b762 100644 --- a/server/src/db/machines.rs +++ b/server/src/db/machines.rs @@ -399,7 +399,10 @@ mod tests { let m1 = upsert_machine(&pool, agent, "LEGACY-HOST", true, None) .await .expect("legacy upsert (no uid)"); - assert_eq!(m1.machine_uid, None, "legacy row must have NULL machine_uid"); + assert_eq!( + m1.machine_uid, None, + "legacy row must have NULL machine_uid" + ); let m2 = upsert_machine(&pool, agent, "LEGACY-HOST-RENAMED", true, None) .await diff --git a/server/src/main.rs b/server/src/main.rs index 672f3f3..5bd3c95 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -283,11 +283,7 @@ async fn main() -> Result<()> { machine.machine_uid.as_deref() }; sessions - .restore_offline_machine( - &machine.agent_id, - &machine.hostname, - restore_uid, - ) + .restore_offline_machine(&machine.agent_id, &machine.hostname, restore_uid) .await; } } diff --git a/server/src/session/mod.rs b/server/src/session/mod.rs index d5dacfb..e73de51 100644 --- a/server/src/session/mod.rs +++ b/server/src/session/mod.rs @@ -277,9 +277,9 @@ impl SessionManager { session_data.info.is_online = true; session_data.info.last_heartbeat = chrono::Utc::now(); session_data.info.agent_name = agent_name; // Update name in case it changed - // Record the reported uid on the session so the reaper can log it - // and supersede can match it later. Only set it from a reported - // uid; never clear an existing one on a None (legacy) reconnect. + // Record the reported uid on the session so the reaper can log it + // and supersede can match it later. Only set it from a reported + // uid; never clear an existing one on a None (legacy) reconnect. if let Some(uid) = machine_uid { session_data.info.machine_uid = Some(uid.to_string()); } @@ -1111,7 +1111,12 @@ mod tests { // Attended (support-code) session: is_persistent = false. let (session_id, _frame_tx, _input_rx) = mgr - .register_agent("agent-att".to_string(), "Attended PC".to_string(), false, None) + .register_agent( + "agent-att".to_string(), + "Attended PC".to_string(), + false, + None, + ) .await; // Starts Pending. @@ -1143,7 +1148,12 @@ mod tests { // Managed/persistent session: is_persistent = true. let (session_id, _frame_tx, _input_rx) = mgr - .register_agent("agent-mgd".to_string(), "Managed PC".to_string(), true, None) + .register_agent( + "agent-mgd".to_string(), + "Managed PC".to_string(), + true, + None, + ) .await; assert_eq!( @@ -1294,7 +1304,12 @@ mod tests { // First connect: agent_id #1, persistent (managed). let (sid1, _f1, _i1) = mgr - .register_agent("agent-uuid-1".to_string(), "HOST-A".to_string(), true, Some(uid)) + .register_agent( + "agent-uuid-1".to_string(), + "HOST-A".to_string(), + true, + Some(uid), + ) .await; // Agent disconnects; persistent session is preserved offline. @@ -1307,15 +1322,27 @@ mod tests { // Reconnect with a FRESH agent_id but the SAME machine_uid (config loss). let (sid2, _f2, _i2) = mgr - .register_agent("agent-uuid-2".to_string(), "HOST-A".to_string(), true, Some(uid)) + .register_agent( + "agent-uuid-2".to_string(), + "HOST-A".to_string(), + true, + Some(uid), + ) .await; // Reattached to the SAME session, now back online. - assert_eq!(sid2, sid1, "same machine_uid must reattach the existing session"); + assert_eq!( + sid2, sid1, + "same machine_uid must reattach the existing session" + ); assert_eq!(mgr.get_session(sid1).await.map(|s| s.is_online), Some(true)); // Exactly ONE session total — no duplicate was created. - assert_eq!(mgr.list_sessions().await.len(), 1, "must not duplicate the session"); + assert_eq!( + mgr.list_sessions().await.len(), + 1, + "must not duplicate the session" + ); // The session's agent_id was repointed to the current one, and the agent_id // index resolves the new id (and no longer the stale one). @@ -1368,7 +1395,12 @@ mod tests { // Keyed agent: relay passes None for machine_uid. let (sid1, _f1, _i1) = mgr - .register_agent("keyed-machine".to_string(), "HOST-K".to_string(), true, None) + .register_agent( + "keyed-machine".to_string(), + "HOST-K".to_string(), + true, + None, + ) .await; mgr.mark_agent_disconnected(sid1).await; @@ -1391,9 +1423,17 @@ mod tests { // The keyed agent reconnects (relay again passes None) and reattaches its OWN // session by agent_id. let (sid3, _f3, _i3) = mgr - .register_agent("keyed-machine".to_string(), "HOST-K".to_string(), true, None) + .register_agent( + "keyed-machine".to_string(), + "HOST-K".to_string(), + true, + None, + ) .await; - assert_eq!(sid3, sid1, "keyed agent reattaches on its authoritative agent_id"); + assert_eq!( + sid3, sid1, + "keyed agent reattaches on its authoritative agent_id" + ); } /// Removing a session purges its machine_uid index entry so a later reconnect @@ -1404,14 +1444,24 @@ mod tests { let uid = "muid-purge"; let (sid1, _f1, _i1) = mgr - .register_agent("purge-agent".to_string(), "HOST-P".to_string(), true, Some(uid)) + .register_agent( + "purge-agent".to_string(), + "HOST-P".to_string(), + true, + Some(uid), + ) .await; mgr.remove_session(sid1).await; assert!(mgr.get_session(sid1).await.is_none()); // Reconnect with the same uid -> a brand-new session (no stale reattach). let (sid2, _f2, _i2) = mgr - .register_agent("purge-agent-2".to_string(), "HOST-P".to_string(), true, Some(uid)) + .register_agent( + "purge-agent-2".to_string(), + "HOST-P".to_string(), + true, + Some(uid), + ) .await; assert_ne!(sid2, sid1, "removed session's uid must not reattach"); assert_eq!(mgr.list_sessions().await.len(), 1); @@ -1432,7 +1482,12 @@ mod tests { // Agent reconnects post-restart with a FRESH agent_id but the same uid. let (sid2, _f2, _i2) = mgr - .register_agent("fresh-agent".to_string(), "HOST-R".to_string(), true, Some(uid)) + .register_agent( + "fresh-agent".to_string(), + "HOST-R".to_string(), + true, + Some(uid), + ) .await; assert_eq!(sid2, sid, "restored machine must reattach by machine_uid"); assert_eq!(mgr.list_sessions().await.len(), 1); @@ -1448,15 +1503,23 @@ mod tests { let ttl = std::time::Duration::from_secs(600); let (sid, _f, _i) = mgr - .register_agent("reap-agent".to_string(), "HOST-REAP".to_string(), true, None) + .register_agent( + "reap-agent".to_string(), + "HOST-REAP".to_string(), + true, + None, + ) .await; mgr.mark_agent_disconnected(sid).await; // now offline - // Age it well past the TTL. + // Age it well past the TTL. mgr.set_last_heartbeat_age(sid, std::time::Duration::from_secs(1200)) .await; let reaped = mgr.reap_stale_persistent(ttl).await; - assert_eq!(reaped, 1, "a stale offline persistent session must be reaped"); + assert_eq!( + reaped, 1, + "a stale offline persistent session must be reaped" + ); assert!(mgr.get_session(sid).await.is_none()); assert_eq!(mgr.list_sessions().await.len(), 0); // Index purged too: the agent_id no longer resolves. @@ -1470,7 +1533,12 @@ mod tests { let ttl = std::time::Duration::from_secs(600); let (sid, _f, _i) = mgr - .register_agent("fresh-agent".to_string(), "HOST-FRESH".to_string(), true, None) + .register_agent( + "fresh-agent".to_string(), + "HOST-FRESH".to_string(), + true, + None, + ) .await; mgr.mark_agent_disconnected(sid).await; // Aged, but not past the TTL. @@ -1490,7 +1558,12 @@ mod tests { let ttl = std::time::Duration::from_secs(600); let (sid, _f, _i) = mgr - .register_agent("online-agent".to_string(), "HOST-ON".to_string(), true, None) + .register_agent( + "online-agent".to_string(), + "HOST-ON".to_string(), + true, + None, + ) .await; // Still online (no disconnect). Backdate anyway to prove online wins. mgr.set_last_heartbeat_age(sid, std::time::Duration::from_secs(99999)) @@ -1540,7 +1613,12 @@ mod tests { // Support (attended) session: is_persistent = false. let (sid, _f, _i) = mgr - .register_agent("support-agent".to_string(), "HOST-S".to_string(), false, None) + .register_agent( + "support-agent".to_string(), + "HOST-S".to_string(), + false, + None, + ) .await; // Force offline + stale (a support session that lingered, hypothetically). mgr.force_offline_for_test(sid).await; @@ -1548,7 +1626,10 @@ mod tests { .await; let reaped = mgr.reap_stale_persistent(ttl).await; - assert_eq!(reaped, 0, "the persistent reaper must never reap a support session"); + assert_eq!( + reaped, 0, + "the persistent reaper must never reap a support session" + ); assert!(mgr.get_session(sid).await.is_some()); } @@ -1577,10 +1658,18 @@ mod tests { // reattach lookups miss (uid was never indexed; agent_id differs), so a NEW // session is created — and supersede must remove the stranded old one. let (sid_new, _f2, _i2) = mgr - .register_agent("fresh-id".to_string(), "HOST-SUP".to_string(), true, Some(uid)) + .register_agent( + "fresh-id".to_string(), + "HOST-SUP".to_string(), + true, + Some(uid), + ) .await; - assert_ne!(sid_new, sid_old, "a fresh agent_id with an unindexed uid creates a new session"); + assert_ne!( + sid_new, sid_old, + "a fresh agent_id with an unindexed uid creates a new session" + ); // The stranded old session is gone; exactly one live session remains. assert!( mgr.get_session(sid_old).await.is_none(), @@ -1608,7 +1697,12 @@ mod tests { let ttl = std::time::Duration::from_secs(600); let (sid, _f, _i) = mgr - .register_agent("race-agent".to_string(), "HOST-RACE".to_string(), true, None) + .register_agent( + "race-agent".to_string(), + "HOST-RACE".to_string(), + true, + None, + ) .await; // Make it a valid reap candidate first: offline + stale. mgr.mark_agent_disconnected(sid).await; @@ -1618,7 +1712,12 @@ mod tests { // Simulate the agent reconnecting in the snapshot->remove window: it is now // ONLINE again (register_agent's reattach marks the session online). let (sid_re, _f2, _i2) = mgr - .register_agent("race-agent".to_string(), "HOST-RACE".to_string(), true, None) + .register_agent( + "race-agent".to_string(), + "HOST-RACE".to_string(), + true, + None, + ) .await; assert_eq!(sid_re, sid, "reconnect reattaches the same offline session"); assert_eq!(mgr.get_session(sid).await.map(|s| s.is_online), Some(true)); @@ -1633,7 +1732,10 @@ mod tests { && data.last_heartbeat_instant.elapsed() > ttl }) .await; - assert!(!removed, "a session that went online must not be removed by the guard"); + assert!( + !removed, + "a session that went online must not be removed by the guard" + ); assert!( mgr.get_session(sid).await.is_some(), "the now-online session must survive the guarded removal"