Enum RelayEffect 

pub enum RelayEffect<T> {
    Connect {
        key: SessionKey,
        target: T,
        kind: TransportKind,
    },
    Write {
        key: SessionKey,
        bytes: Bytes,
    },
    Shutdown {
        key: SessionKey,
    },
    Close {
        key: SessionKey,
    },
    SendClose {
        to: Did,
        session: SessionId,
        from_opener: bool,
    },
    OpenAccepted {
        token: u64,
        key: SessionKey,
        service: String,
    },
    RejectAccepted {
        token: u64,
    },
}

The relay’s own effect algebra (interpreted by NativeRelay / WtRelay).

Variants

Connect

Open a local backend session to target and relay it (peer opened a session).

Fields

key: SessionKey

Owner-scoped session key.

target: T

Local target to dial.

kind: TransportKind

Stream (TCP) or datagram (UDP).

Write

Write peer bytes to a session’s local stream.

Fields

key: SessionKey

Target session.

bytes: Bytes

Bytes.

Shutdown

Half-close a session’s local write side (peer FIN).

Fields

key: SessionKey

Target session.

Close

Close a session (full teardown).

Fields

key: SessionKey

Target session.

SendClose

Reply a Frame::Close to a peer that opened an unknown service. The reply goes out under the interpreter’s own namespace (its Scope), so the effect carries no namespace of its own.

Fields

to: Did

Peer to reply to.

session: SessionId

Session id to close.

from_opener: bool

Whether we opened the session (false: the peer did).

OpenAccepted

Bind a pending accepted connection/flow (engine-local token) to the session key the pure step just minted, then open it to the peer and start relaying. The reply to RelayCommand::Accepted — this is how a step-minted id reaches the engine.

Fields

token: u64

Engine-local handle for the pending connection/flow.

key: SessionKey

The session key minted by the pure step.

service: String

The remote service to open.

RejectAccepted

Drop an accepted local resource when the pure session-id space is exhausted.

Fields

token: u64

Engine-local handle whose resource must be released.

Trait Implementations

impl<T: Clone> Clone for RelayEffect<T>

fn clone(&self) -> RelayEffect<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for RelayEffect<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for RelayEffect<T>

impl<T: PartialEq> PartialEq for RelayEffect<T>

fn eq(&self, other: &RelayEffect<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for RelayEffect<T>