Enum Ask 

pub enum Ask {
    Hello {
        protocol: u16,
        who: Option<Identity>,
    },
    Reach {
        host: Host,
        needs: Needs,
    },
    Done {
        host: Host,
    },
}

What the client says.

Variants

Hello

Opens the session: which vocabulary I speak, and who I claim to be.

Fields

protocol: u16

Always PROTOCOL. First field of the first message on purpose — it is the one thing that must be readable by a binary that disagrees with this one about everything else.

who: Option<Identity>

Whatever the far side’s policy needs in order to know who is asking. Opaque here, and None everywhere there is no policy. Named who because as is a keyword.

Reach

Introduce me to this host.

The name is the graph’s — w1, gpu-a — and resolving it is the whole job of a broker. A Host and not a string, so that the thing the engine placed and the thing the broker resolves are the same type all the way down.

Fields

host: Host

The name the graph gave it.

needs: Needs

What this slice needs of whoever runs it.

Done

I am done with this host: let the rendezvous go.

Nothing is held by an embedded broker, so nothing is released. It is here because without it the platform cannot tell a session that ended from one that died, which is metering rather than politeness.

Fields

host: Host

Which one.

Implementations

impl Ask

pub fn hello() -> Self

A greeting from this binary, claiming nothing.

pub fn hello_as(who: Identity) -> Self

A greeting from this binary, claiming to be somebody.

pub fn to_bytes(&self) -> Result<Vec<u8>, Unreadable>

This message in bytes.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, Unreadable>

And back from them.

Trait Implementations

impl Clone for Ask

fn clone(&self) -> Ask

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ask

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ask

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Ask

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Ask

impl StructuralPartialEq for Ask