Struct SocketTransport 

pub struct SocketTransport {
    pub welcome: Welcome,
    /* private fields */
}

Fields

welcome: Welcome

Implementations

impl SocketTransport

pub async fn connect( path: &Path, hello: Hello, ) -> Result<Connected, TransportError>

Hello/Welcome only (50 ms connect + 2 s handshake budgets).

pub async fn attach( conn: Connected, attach: Attach, ) -> Result<(Self, AttachSnapshot), TransportError>

Attach (existing or create) on a handshaken connection. AttachRefused and DaemonFrame::Error alike → TransportError::Refused. Waits ATTACH_TIMEOUT_PARKED when the daemon lists the session as Parked.

pub fn last_error(&self) -> Option<&TransportError>

Why the last next_event returned None (if it was not a plain end).

pub fn is_reload_pending(&self) -> bool

true if the daemon announced a reload before EOF (graceful); false means a crash/SIGKILL (unexpected).

pub fn daemon_pid(&self) -> u32

The pid the daemon reported in Welcome.

pub fn reconnect_budget() -> Duration

The reconnect budget from SYNAPS_TUI_ATTACH_RECONNECT_SECS (default 60).

pub async fn reconnect_once( &mut self, mode: AttachMode, ) -> Result<AttachSnapshot, TransportError>

One attempt at reconnecting (Hello + Attach). On success replaces self and returns the snapshot. On Refused / Version the error is terminal (caller should stop retrying). Other errors are transient.

pub async fn ping(path: &Path) -> Result<Pong, TransportError>

pub async fn sessions(path: &Path) -> Result<Vec<SessionMeta>, TransportError>

pub async fn shutdown(path: &Path, force: bool) -> Result<(), TransportError>

pub async fn purge(path: &Path) -> Result<Pong, TransportError>

pub async fn reload( path: &Path, now: bool, drain_secs: Option<u64>, exe: Option<PathBuf>, ) -> Result<u64, TransportError>

Reload{..} on a control connection. Ok(generation) once the daemon answered Bye{Reloading{generation}} (it is about to exec); Refused{ReloadRefused} / Error → Err.

pub async fn detach(&self)

Detach cleanly: Detach + Bye. The turn keeps running in the daemon.

pub fn messages(&self) -> &[SharedMessage]

The client’s view of api_messages (kept current by the digest protocol in Full mode; always empty in Digest mode).

pub fn last_frame_bytes(&self) -> usize

Length in bytes of the last frame decoded on this connection (the Attached frame right after attach).

pub fn history_mode(&self) -> HistoryMode

Trait Implementations

impl ClientTransport for SocketTransport

fn send_from_self<'life0, 'async_trait>( &'life0 self, cmd: SessionCommand, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The daemon’s conn stamps from with this connection’s client id, so on the wire send and send_from_self are the same frame.

fn reconnect<'life0, 'async_trait>( &'life0 mut self, mode: AttachMode, ) -> Pin<Box<dyn Future<Output = Result<AttachSnapshot, TransportError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

C3: after Reloading/EOF — backoff 100 ms ×2 → cap 5 s, total ≤ SYNAPS_TUI_ATTACH_RECONNECT_SECS (60); Hello{reconnect_of} → Attach::Existing{alias-resolved id, mode} where mode = Takeover iff this client was the input owner (§2.7: two reconnecting mirrors cannot both take over). On success self IS the new connection; the returned snapshot is a full re-mirror.

fn session_id(&self) -> &SessionId

fn meta(&self) -> &SessionMeta

fn send<'life0, 'async_trait>( &'life0 self, cmd: SessionCommand, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Host-originated send (from: None; bypasses input ownership).

fn next_event<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Option<Envelope>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Next envelope, or None when the session ended / socket closed.

fn view(&self) -> Arc<RuntimeView>

Sync, cheap, never stale by more than one SettingChanged: what the TUI’s getters read on day 2.

fn client_id(&self) -> ClientId

Client id assigned at Attach (needed for Detach/Resync).

fn mode(&self) -> AttachMode

The mode this transport attached with.

fn input_owner(&self) -> Option<ClientId>

Current input owner — updated from Attached / InputOwnerChanged.

fn reconnect_once<'life0, 'async_trait>( &'life0 mut self, mode: AttachMode, ) -> Pin<Box<dyn Future<Output = Result<AttachSnapshot, TransportError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

F9: single reconnect attempt (no retry loop). Socket only.

fn is_reload_pending(&self) -> bool

true if the daemon announced a reload before EOF (graceful). Always false on LocalTransport.

fn daemon_pid(&self) -> u32

The daemon pid from Welcome. Returns 0 on LocalTransport.