diff --git a/server/src/service/lifecycle.rs b/server/src/service/lifecycle.rs index a194470f..6b95d20d 100644 --- a/server/src/service/lifecycle.rs +++ b/server/src/service/lifecycle.rs @@ -324,46 +324,59 @@ impl Service { let old_owner = old_owner .as_ref() .expect("A disconnected client requires an old_owner"); - if name != old_owner.as_str() { - continue; // a well-known name was released, the client is still connected - } - if let Some(session) = self.session_from_sender(old_owner).await { - let client_name = match session.peer_info() { - Some(info) => format!("{old_owner} ({info})"), - None => old_owner.to_string(), - }; - session.mark_stale().await; - tracing::info!( - "Client {} disconnected. Session: {} marked for cleanup.", - client_name, - session.path() - ); - } + self.handle_owner_lost(name, old_owner).await; } Ok(()) } + /// A client's unique name disappeared from the bus, mark its session + /// for cleanup. A well-known name being released does not mean the + /// client disconnected. + pub(crate) async fn handle_owner_lost(&self, name: &str, old_owner: &UniqueName<'_>) { + if name != old_owner.as_str() { + return; + } + if let Some(session) = self.session_from_sender(old_owner).await { + let client_name = match session.peer_info() { + Some(info) => format!("{old_owner} ({info})"), + None => old_owner.to_string(), + }; + session.mark_stale().await; + tracing::info!( + "Client {} disconnected. Session: {} marked for cleanup.", + client_name, + session.path() + ); + } + } + pub(crate) async fn cleanup_stale_sessions(&self) { let mut interval = tokio::time::interval(std::time::Duration::from_secs(30)); loop { interval.tick().await; - let stale_paths: Vec<_> = { - let sessions = self.sessions.lock().await; - let mut paths = Vec::new(); - for (path, session) in sessions.iter() { - if session.is_stale().await { - paths.push(path.clone()); - } + self.cleanup_stale_sessions_tick().await; + } + } + + /// Close the sessions whose client has been gone for longer than the + /// stale timeout. + pub(crate) async fn cleanup_stale_sessions_tick(&self) { + let stale_paths: Vec<_> = { + let sessions = self.sessions.lock().await; + let mut paths = Vec::new(); + for (path, session) in sessions.iter() { + if session.is_stale().await { + paths.push(path.clone()); } - paths - }; - for path in stale_paths { - if let Some(session) = self.session(&path).await { - match session.close().await { - Ok(_) => tracing::info!("Stale session {} cleaned up.", path), - Err(err) => { - tracing::error!("Failed to clean up stale session {}: {}", path, err) - } + } + paths + }; + for path in stale_paths { + if let Some(session) = self.session(&path).await { + match session.close().await { + Ok(_) => tracing::info!("Stale session {} cleaned up.", path), + Err(err) => { + tracing::error!("Failed to clean up stale session {}: {}", path, err) } } } diff --git a/server/src/service/tests/session.rs b/server/src/service/tests/session.rs index dbc489c2..69b4bdcf 100644 --- a/server/src/service/tests/session.rs +++ b/server/src/service/tests/session.rs @@ -42,3 +42,87 @@ async fn session_collection_only() -> Result<(), Box> { ); Ok(()) } + +// The stale session machinery: a disconnected client's session is marked, +// ignored while in use, and closed once it outlives the timeout +#[tokio::test] +async fn stale_session_state() -> Result<(), Box> { + let setup = TestServiceSetup::plain_session(false).await?; + + let path = setup.session.inner().path().to_owned(); + let session = setup + .server + .session(&path) + .await + .expect("session should exist"); + + assert!(!session.is_stale().await, "A live session is not stale"); + + // The client disconnected, but not long enough ago + session.mark_stale().await; + assert!(session.is_marked_stale().await); + assert!(!session.is_stale().await, "The timeout did not pass yet"); + + // Using the session rescues it + setup.server.session(&path).await; + assert!(!session.is_marked_stale().await); + assert!(!session.is_stale().await); + + Ok(()) +} + +#[tokio::test] +async fn stale_session_cleaned_up() -> Result<(), Box> { + let setup = TestServiceSetup::plain_session(false).await?; + + let path = setup.session.inner().path().to_owned(); + let session = setup + .server + .session(&path) + .await + .expect("session should exist"); + session.force_stale().await; + assert!(session.is_stale().await); + + setup.server.cleanup_stale_sessions_tick().await; + + assert!( + setup.server.session(&path).await.is_none(), + "The stale session should be closed" + ); + + Ok(()) +} + +#[tokio::test] +async fn owner_lost_marks_session_stale() -> Result<(), Box> { + let setup = TestServiceSetup::plain_session(false).await?; + + let path = setup.session.inner().path().to_owned(); + let session = setup + .server + .session(&path) + .await + .expect("session should exist"); + let sender = session.sender().to_owned(); + + // A well-known name being released doesn't mean the client left + setup + .server + .handle_owner_lost("org.example.Client", &sender) + .await; + assert!(!session.is_marked_stale().await); + + // The client's unique name disappearing does + setup + .server + .handle_owner_lost(sender.as_str(), &sender) + .await; + assert!(session.is_marked_stale().await); + + // An unknown client is not an error + let stranger = zbus::names::UniqueName::from_str_unchecked(":1.42"); + setup.server.handle_owner_lost(":1.42", &stranger).await; + + Ok(()) +} diff --git a/server/src/session.rs b/server/src/session.rs index b9312a40..f7113e76 100644 --- a/server/src/session.rs +++ b/server/src/session.rs @@ -275,6 +275,20 @@ impl Session { .await .is_some_and(|t| t.elapsed() > SESSION_STALE_TIMEOUT) } + + /// Pretend the client disconnected before the stale timeout, to test + /// the cleanup without waiting for it. + #[cfg(test)] + pub(crate) async fn force_stale(&self) { + *self.disconnected_at.lock().await = + Some(Instant::now() - SESSION_STALE_TIMEOUT - Duration::from_secs(1)); + } + + /// Whether the client disconnected, regardless of the timeout. + #[cfg(test)] + pub(crate) async fn is_marked_stale(&self) -> bool { + self.disconnected_at.lock().await.is_some() + } } #[cfg(test)]