Struct SessionLoopState 

pub struct SessionLoopState {
    pub client_to_backend: ClientToBackendBytes,
    pub backend_to_client: BackendToClientBytes,
    pub last_reported_c2b: ClientToBackendBytes,
    pub last_reported_b2c: BackendToClientBytes,
    pub auth_username: Option<String>,
    pub skip_auth_check: bool,
    /* private fields */
}

Session loop state for tracking bytes, auth, and metrics

This struct encapsulates all mutable state needed during a session loop, making it easy to pass around and test in isolation.

Example

let state = SessionLoopState::new(auth_enabled)
    .with_initial_bytes(1000, 500);

Fields

client_to_backend: ClientToBackendBytes

Bytes sent from client to backend

backend_to_client: BackendToClientBytes

Bytes sent from backend to client

last_reported_c2b: ClientToBackendBytes

Last reported client-to-backend bytes (for incremental metrics)

last_reported_b2c: BackendToClientBytes

Last reported backend-to-client bytes (for incremental metrics)

auth_username: Option<String>

Username from AUTHINFO USER command (if any)

skip_auth_check: bool

Whether to skip auth checking (optimization after first auth)

Implementations

impl SessionLoopState

pub fn new(auth_enabled: bool) -> Self

Create new session loop state

Arguments

• auth_enabled - If true, auth checking starts enabled; if false, it’s skipped

pub fn from_initial_bytes( client_to_backend: u64, backend_to_client: u64, auth_enabled: bool, ) -> Self

Create session loop state with initial byte counts

Used by hybrid mode when switching from per-command to stateful, to carry forward the bytes already transferred.

pub const fn with_initial_bytes(self, c2b: u64, b2c: u64) -> Self

Builder method: set initial byte counts

pub const fn check_and_maybe_flush_metrics(&mut self) -> bool

Check if metrics should be flushed and reset counter if so

Returns true every METRICS_FLUSH_INTERVAL iterations.

pub const fn add_client_to_backend(&mut self, bytes: usize)

Add bytes to client-to-backend counter

pub const fn add_backend_to_client(&mut self, bytes: u64)

Add bytes to backend-to-client counter

pub fn flush_byte_deltas( &mut self, metrics: &MetricsCollector, backend_id: BackendId, username: Option<&str>, )

Flush accumulated byte deltas to the metrics collector.

Reports the difference since the last flush and updates the last-reported watermarks. Used by both the periodic in-loop flush and the final flush on disconnect.

pub fn into_metrics(self) -> TransferMetrics

Convert to final transfer metrics

pub fn mark_authenticated(&mut self)

Mark authentication as complete (skip future checks)

pub fn apply_auth_result(&mut self, result: &AuthHandlerResult) -> u64

Update state based on auth handler result

Returns the bytes written for convenience in chaining.

pub fn mark_backend_request_sent(&mut self, kind: RequestKind)

Mark that a backend request was forwarded and its reply must be ordered first.

pub fn has_pending_backend_replies(&self) -> bool

Whether earlier forwarded backend replies are still ahead of any deferred local replies.

pub fn push_deferred_reply(&mut self, reply: &'static [u8])

Queue a local reply until earlier backend output has been sent.

pub fn has_deferred_replies(&self) -> bool

Whether deferred local replies remain queued.

pub fn read_mode(&self) -> StatefulReadMode

Reading mode for the stateful loop.

pub fn take_ready_deferred_replies(&mut self) -> SmallVec<[&'static [u8]; 2]>

Drain deferred local replies that are ready at the front of the ordered queue.

Trait Implementations

impl Default for SessionLoopState

fn default() -> Self

Returns the “default value” for a type.