Struct PoolRegistry 

pub struct PoolRegistry {
    pub sessions: Vec<PoolSessionEntry>,
}

In-memory view of registry.json.

This struct must always be loaded from and saved to disk within a single advisory-lock region (see with_registry_lock). Do not hold a PoolRegistry value across lock boundaries.

Crux: registry.json is the persistent source of truth

MCP processes must not rely on any in-memory state to discover live workers after a restart. Every mutation path must call save before dropping the lock.

Fields

sessions: Vec<PoolSessionEntry>

All currently-registered worker sessions.

Implementations

impl PoolRegistry

pub fn load_or_default(path: &Path) -> Result<Self, PoolError>

Load registry.json from disk, returning an empty registry if the file does not exist.

Arguments

• path — absolute path to registry.json.

Returns

Ok(PoolRegistry) — either the parsed on-disk state or an empty registry when the file is absent.

Errors

Returns PoolError::RegistryCorrupted(reason) if the file exists but cannot be parsed as valid JSON. Never falls back to an empty registry on parse failure — callers must handle the error explicitly and propagate it to the MCP wire layer.

Concurrency

This is a synchronous file read. The caller must hold the advisory fs4::fs_std::FileExt::lock_exclusive on registry.lock before calling this method to prevent concurrent read-modify-write races between multiple MCP processes.

pub fn save(&self, path: &Path) -> Result<(), PoolError>

Atomically persist the registry to registry.json via tempfile::NamedTempFile::persist (POSIX rename(2)).

Arguments

• path — absolute path to registry.json.

Returns

Ok(()) on success.

Errors

Returns PoolError::RegistryCorrupted if parent-directory creation, serialization, temp-file creation/write/fsync, or the atomic rename fails.

Atomicity

NamedTempFile::persist is atomic on modern Linux filesystems and macOS. It is not guaranteed atomic on all platforms.

Concurrency

Callers must hold the advisory fs4::fs_std::FileExt::lock_exclusive on registry.lock for the entire read-modify-write cycle (load → mutate → save) to prevent last-writer-wins data loss when multiple MCP processes write concurrently.

pub fn scan_and_gc(&mut self) -> Result<Vec<PoolSessionEntry>, PoolError>

Scan all registered sessions and remove entries whose worker process is no longer alive, returning the surviving (live) entries.

Liveness is tested with kill(pid, 0) (POSIX signal 0 — does not send a signal, only checks whether the process exists). An ESRCH return value means the process does not exist and the entry is pruned.

Arguments

None — operates on &mut self in place.

Returns

Ok(Vec<PoolSessionEntry>) — the subset of sessions that survived GC (i.e. whose worker process is still alive).

Errors

Currently infallible on POSIX; the Result wrapper is kept for future extension.

Platform support

On non-Unix targets the liveness check is omitted and all entries are assumed live (conservative).

pub fn add(&mut self, entry: PoolSessionEntry)

Add a session entry to the registry.

Arguments

• entry — the PoolSessionEntry to insert.

Notes

Does not persist to disk. Call save after mutating to ensure durability.

pub fn remove(&mut self, sid: &str) -> bool

Remove the entry with the given session ID.

Arguments

• sid — session ID to remove.

Returns

true if an entry was found and removed, false if no matching entry existed.

Notes

Does not persist to disk. Call save after mutating to ensure durability.

pub fn find(&self, sid: &str) -> Option<&PoolSessionEntry>

Look up a session entry by ID.

Arguments

• sid — session ID to search for.

Returns

Some(&PoolSessionEntry) if found, None otherwise.

Trait Implementations

impl Clone for PoolRegistry

fn clone(&self) -> PoolRegistry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PoolRegistry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PoolRegistry

fn default() -> PoolRegistry

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PoolRegistry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PoolRegistry

fn eq(&self, other: &PoolRegistry) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PoolRegistry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PoolRegistry