Struct Pooled 

pub struct Pooled<M: Manage, X: Exchange<M>> { /* private fields */ }

A connection checked out of the pool.

Derefs to the underlying connection. Returns itself to the pool on drop — unless it has been poisoned, in which case it is closed instead.

Cancellation safety

This is the part that differs most from a readiness-based pool. With completion-based IO, dropping a future with an operation in flight does not unwind the operation: the kernel still owns the buffer and the peer’s response is still coming. compio keeps the buffer sound, but your protocol is now out of step — the next reader on this connection will see the tail of someone else’s response.

A connection cancelled mid-operation must therefore be destroyed, never reused. Wrap each operation in begin_op:

let op = conn.begin_op();
let n = conn.read(&mut buf).await?;   // if this await is cancelled…
op.complete_op();                     // …this never runs, and the conn is dropped

If you never cancel (no select!, no timeouts, no early return between submit and completion) you can skip it. Everyone believes that about their code right up until they add a timeout.

Implementations

impl<M: Manage, X: Exchange<M>> Pooled<M, X>

pub fn meta(&self) -> &SlotMeta

Lifecycle metadata: age, idle time, checkout count.

pub fn poison(&self)

Marks this connection unusable. It is closed on drop instead of pooled.

Call this whenever you learn the connection is in an unknown state: a protocol error, a partial write, a response you could not parse.

pub fn is_poisoned(&self) -> bool

True if poison has been called, directly or by a dropped OpGuard.

pub fn begin_op(&self) -> OpGuard

Arms cancellation protection for one operation.

The returned guard poisons this connection when dropped, unless [OpGuard::complete] runs first. It borrows nothing from self, so the connection stays fully usable while the guard is alive.

pub fn take(self) -> M::Connection

Removes the connection from the pool’s control and hands it to you.

The shard’s budget is freed immediately, so a replacement may be opened.

Trait Implementations

impl<M: Manage, X: Exchange<M>> Debug for Pooled<M, X>

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

Formats the value using the given formatter.

impl<M: Manage, X: Exchange<M>> Deref for Pooled<M, X>

type Target = <M as Manage>::Connection

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<M: Manage, X: Exchange<M>> DerefMut for Pooled<M, X>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<M: Manage, X: Exchange<M>> Drop for Pooled<M, X>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.