Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
75 changes: 44 additions & 31 deletions server/src/service/lifecycle.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}
}
}
Expand Down
84 changes: 84 additions & 0 deletions server/src/service/tests/session.rs
Original file line number Diff line number Diff line change
Expand Up @@ -42,3 +42,87 @@ async fn session_collection_only() -> Result<(), Box<dyn std::error::Error>> {
);
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<dyn std::error::Error>> {
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<dyn std::error::Error>> {
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<dyn std::error::Error>> {
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(())
}
14 changes: 14 additions & 0 deletions server/src/session.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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)]
Expand Down
Loading