Enum Frame 

pub enum Frame {
    Data(Bytes),
    Resize {
        cols: u16,
        rows: u16,
    },
    Exit {
        code: i32,
    },
    Detached,
    Ping,
    Pong,
    Env {
        vars: Vec<(String, String)>,
    },
    AgentForward,
    AgentOpen {
        channel_id: u32,
    },
    AgentData {
        channel_id: u32,
        data: Bytes,
    },
    AgentClose {
        channel_id: u32,
    },
    OpenForward,
    OpenUrl {
        url: String,
    },
    NewSession {
        name: String,
    },
    Attach {
        session: String,
    },
    ListSessions,
    KillSession {
        session: String,
    },
    KillServer,
    SessionCreated {
        id: String,
    },
    SessionInfo {
        sessions: Vec<SessionEntry>,
    },
    Ok,
    Error {
        message: String,
    },
}

Variants

Data(Bytes)

Resize

Fields

cols: u16

rows: u16

Exit

Fields

code: i32

Detached

Sent to a client when another client takes over the session.

Ping

Heartbeat request (client → server).

Pong

Heartbeat reply (server → client).

Env

Environment variables (client → server, sent before first Resize on new session).

Fields

vars: Vec<(String, String)>

AgentForward

Client signals it can handle agent forwarding (client → server).

AgentOpen

New agent connection on the remote side (server → client).

Fields

channel_id: u32

AgentData

Agent protocol data (bidirectional).

Fields

channel_id: u32

data: Bytes

AgentClose

Close an agent channel (bidirectional).

Fields

channel_id: u32

OpenForward

Client signals it can handle URL open forwarding (client → server).

OpenUrl

URL to open on the client machine (server → client).

Fields

url: String

NewSession

Fields

name: String

Attach

Fields

session: String

ListSessions

KillSession

Fields

session: String

KillServer

SessionCreated

Fields

id: String

SessionInfo

Fields

sessions: Vec<SessionEntry>

Ok

Error

Fields

message: String

Implementations

impl Frame

pub fn expect_from(result: Option<Result<Frame, Error>>) -> Result<Frame>

Extract a Frame from a framed.next().await result, converting the common None / Some(Err) cases into descriptive errors.

Trait Implementations

impl Clone for Frame

fn clone(&self) -> Frame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Frame

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

Formats the value using the given formatter.

impl Encoder<Frame> for FrameCodec

type Error = Error

The type of encoding errors.

fn encode(&mut self, frame: Frame, dst: &mut BytesMut) -> Result<(), Error>

Encodes a frame into the buffer provided.

impl PartialEq for Frame

fn eq(&self, other: &Frame) -> 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 Eq for Frame

impl StructuralPartialEq for Frame