Struct SyncRequest 

pub struct SyncRequest {
    pub link: String,
    pub counter: u64,
    pub instance: String,
    pub marks: Marks,
    pub events: Vec<MeshEvent>,
}

A dialer’s sync round: what this runtime holds, and what it believes the answerer lacks. Sending the events rather than asking for them is what makes one heartbeat a full replication step in both directions, so replication keeps working when only one side can open a connection. The counter refuses a replayed round and the instance refuses a stale one: a restarted dialer carries a new instance and must say hello again rather than resume a link the answerer no longer has.

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

let node = NodeIdentity::ephemeral().unwrap();
let link = fresh_token();
let round = SyncRequest {
    link: link.clone(),
    counter: 1,
    instance: node.public.instance_id.as_str().into(),
    marks: BTreeMap::new(),
    events: vec![],
};
let next = SyncRequest { counter: round.counter + 1, ..round.clone() };
assert!(next.counter > round.counter, "a round at or below the last accepted is a replay");
assert_eq!(next.link, link, "every round of one link travels under its id");

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

Fields

link: String

The link id the welcome gave.

counter: u64

Rising per link: a request at or below the last accepted counter is a replay.

instance: String

The dialer’s instance: a different one is a restarted runtime that must say hello.

marks: Marks

The dialer’s marks.

events: Vec<MeshEvent>

The events the answerer lacks, by the answerer’s last marks.

Trait Implementations

impl Clone for SyncRequest

fn clone(&self) -> SyncRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyncRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SyncRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for SyncRequest

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 SyncRequest

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

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 SyncRequest