Struct Welcome 

pub struct Welcome {
    pub proto: u32,
    pub link: String,
    pub card: RuntimeCard,
    pub nonce: String,
    pub ts: u64,
    pub marks: Marks,
    pub heartbeat_seconds: u64,
    pub expiry_seconds: u64,
}

An answerer’s welcome: the mirror of the hello, plus the two things that make the link usable. The link id is what the dialer syncs under afterwards, and the marks let the very first sync carry exactly the events the answerer lacks instead of a round spent discovering that. The echoed nonce is what binds this welcome to that hello: without it, a welcome kept from an earlier exchange would answer a hello it never saw.

use std::collections::BTreeMap;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::link::{fresh_token, sign, verify_signed, Domain, RuntimeCard,
    Welcome, LINK_PROTOCOL_MAX};

let node = NodeIdentity::ephemeral().unwrap();
let nonce = fresh_token();
let welcome = Welcome {
    proto: LINK_PROTOCOL_MAX,
    link: fresh_token(),
    card: RuntimeCard {
        pk: node.public.public_key.clone(),
        runtime: "00000000000000aa".into(),
        instance: node.public.instance_id.as_str().into(),
        repo: "r".repeat(32),
        name: String::new(),
        version: String::new(),
        features: vec![],
        endpoints: vec![],
    },
    nonce: nonce.clone(),
    ts: 1_700_000_000,
    marks: BTreeMap::new(),
    heartbeat_seconds: 5,
    expiry_seconds: 30,
};
assert_eq!(welcome.nonce, nonce, "this welcome answers that hello and no other");
assert!(welcome.marks.is_empty(), "a runtime that has written nothing has nothing to mark");

let signed = sign(&node, Domain::Welcome, serde_json::to_value(&welcome).unwrap());
assert!(verify_signed(&node.public.public_key, Domain::Welcome, &signed));

Fields

proto: u32

The negotiated protocol version.

link: String

The link id the dialer syncs under.

card: RuntimeCard

The answerer.

nonce: String

The hello’s nonce, echoed: this welcome answers that hello and no other.

ts: u64

The answerer’s clock.

marks: Marks

The answerer’s marks, so the first sync carries exactly what it lacks.

heartbeat_seconds: u64

The answerer’s heartbeat, informational.

expiry_seconds: u64

The answerer’s expiry, informational.

Trait Implementations

impl Clone for Welcome

fn clone(&self) -> Welcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Welcome

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Welcome

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Welcome

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Welcome

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

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 Welcome