Struct LinkReply 

pub struct LinkReply {
    pub signed: Option<Signed>,
    pub refusal: Option<LinkRefusal>,
}

What a hello or a sync answers over the wire: a signed message or a refusal. Both are successful replies — the transport carries them the same way and neither is an error — because a refusal is a decision this protocol wants recorded and shown, and an answer that arrived as an HTTP failure would be indistinguishable from a peer that is down.

use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::link::{sign, Domain, LinkReply, RefusalCode};

let node = NodeIdentity::ephemeral().unwrap();
let accepted = LinkReply::accepted(sign(&node, Domain::Welcome, serde_json::json!({})));
assert!(accepted.signed.is_some() && accepted.refusal.is_none());

let refused = LinkReply::refused(RefusalCode::SelfLink, "this runtime dialled itself");
assert!(refused.signed.is_none());
assert_eq!(refused.refusal.unwrap().code, RefusalCode::SelfLink);

Fields

signed: Option<Signed>

The signed welcome or sync answer, when accepted.

refusal: Option<LinkRefusal>

The refusal, when not.

Implementations

impl LinkReply

pub fn accepted(signed: Signed) -> Self

An accepted reply: the signed welcome or sync answer, and no refusal. The two halves are built through these constructors rather than by filling the struct in, so a reply can never be both at once or neither, which is the one shape a reader would have no sensible way to act on.

use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::link::{sign, Domain, LinkReply};

let node = NodeIdentity::ephemeral().unwrap();
let reply = LinkReply::accepted(sign(&node, Domain::SyncAnswer, serde_json::json!({})));
assert!(reply.refusal.is_none(), "an acceptance refuses nothing");
assert!(reply.signed.unwrap().sig.len() == 128);

pub fn refused(code: RefusalCode, detail: impl Into<String>) -> Self

A refused reply: the typed code that turned the message down, the reason in words, and nothing signed. The detail is for the person reading a log and the code is for the peer deciding what to do next — retry, say hello again, or stop dialling.

use majordomus_cli::mesh::link::{LinkReply, RefusalCode};

let reply = LinkReply::refused(RefusalCode::UnknownLink, "say hello again");
assert!(reply.signed.is_none(), "a refusal signs nothing");
let refusal = reply.refusal.unwrap();
assert_eq!(refusal.code, RefusalCode::UnknownLink);
assert_eq!(refusal.detail, "say hello again");

Trait Implementations

impl Clone for LinkReply

fn clone(&self) -> LinkReply

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinkReply

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LinkReply

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for LinkReply

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 LinkReply

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

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 LinkReply