Struct Hello 

pub struct Hello {
    pub client_version: String,
    pub protocol: u32,
    pub dog_name: Option<String>,
}

Client’s opening frame

Fields

client_version: String

Client crate version (semver string)

protocol: u32

crate::protocol::PROTOCOL_VERSION the client speaks

dog_name: Option<String>

The name this client was registered under as a dog, when it is one.

None is what every other client truthfully is, and what a dog built before this field existed sends. The CLI never sets it: a bare Client has no way to, by construction, so shep stop cannot impersonate a dog however its environment is set.

The daemon needs it on exactly one path, and it is the path where nothing else can supply it. A handshake refused for protocol skew never reaches a request, so Request::DogConfig’s name — the one place a dog otherwise identifies itself — is unreachable precisely when the daemon has to know WHICH dog it just refused in order to restart it (the handover design’s G8). A dog already knows its own name: the daemon put it in $SHEP_DOG_NAME when it spawned it.

Additive by construction: absent on the wire rather than null, and ignored by a daemon too old to know it, so crate::protocol::PROTOCOL_VERSION does not move for it. That argument deserves more care here than anywhere else, because Hello IS the version-negotiation frame: a daemon that rejected unknown fields would refuse a newer client BEFORE reading protocol, and that would be a hard break rather than an additive change. It does not — this type carries no #[serde(deny_unknown_fields)], and a_hello_without_a_dog_name_still_parses pins both directions.

Trait Implementations

impl Clone for Hello

fn clone(&self) -> Hello

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hello

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hello

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Hello

impl PartialEq for Hello

fn eq(&self, other: &Hello) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Hello

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Hello