Struct SessionStore 

pub struct SessionStore { /* private fields */ }

Thread-safe storage for sessions.

Implementations

impl SessionStore

pub fn new() -> Self

Create a new empty session store.

pub fn create(&self) -> Result<SessionId>

Create a new session.

Returns the newly assigned session ID.

pub fn get(&self, id: &SessionId) -> Result<Option<Session>>

Get a clone of the session with the given ID.

pub fn contains(&self, id: &SessionId) -> Result<bool>

Check if a session exists.

pub fn update<F>(&self, id: &SessionId, f: F) -> Result<()>

where F: FnOnce(&mut Session),

Update a session using a closure.

The closure receives a mutable reference to the session and can modify it. Returns an error if the session doesn’t exist.

pub fn remove(&self, id: &SessionId) -> Result<Option<Session>>

Remove a session from the store.

Returns the removed session, or None if it didn’t exist.

pub fn count(&self) -> usize

Get the number of sessions in the store.

pub fn list_ids(&self) -> Result<Vec<SessionId>>

List all session IDs.

pub fn remove_matching<F>(&self, predicate: F) -> Result<usize>

where F: Fn(&Session) -> bool,

Remove all sessions matching a predicate.

Returns the number of sessions removed.

pub fn sweep_idle(&self, ttl: Duration) -> Result<Vec<SessionId>>

Drop sessions that have sat idle past ttl, returning their ids.

Nothing reclaimed a shell session before this: there was no TTL, no cap and no sweeper, and remove_matching had no caller outside tests. A client that creates sessions and never DELETEs them therefore accumulated them for as long as the process ran. Upload sessions have had exactly this — a periodic sweep against fs::SESSION_TTL — since they were introduced; shell sessions simply had no equivalent.

A session running a command is never swept, whatever its idle clock says. That clock is only advanced when a command starts and when it ends (BusySession), so during a long command it does not move at all — idle time alone cannot tell “abandoned” from “busy”, and a sweep keyed on it would reap a session with a command actively running in it. The state is what distinguishes them: the same guard that stops the clock also holds the session Active for the length of the command, and that guard closes every exit including a cancelled future. Active cannot hide an unbounded session either, since a command’s deadline is now bounded (execution::MAX_TIMEOUT).

Ids are returned rather than counted so the caller can record what went; a session vanishing with no trace is what makes an abandoned one indistinguishable from one the client deleted.

Trait Implementations

impl Default for SessionStore

fn default() -> Self

Returns the “default value” for a type.