Enum RefusalCode 

pub enum RefusalCode {
    Malformed,
    Oversized,
    ProtocolUnsupported,
    Signature,
    Stale,
    Replay,
    RepositoryMismatch,
    Untrusted,
    SelfLink,
    NotActive,
    UnknownLink,
    Capacity,
    FeatureUnsupported,
    Misaddressed,
}

Why a link message was turned down. Every refusal is typed, counted and shown: a mesh that refuses a peer says which rule did, instead of dropping a socket.

The codes are the diagnosis a person needs when two runtimes will not link, and they are deliberately distinct where the remedies differ: Untrusted is a key to add, RepositoryMismatch is two different repositories, SelfLink is a configuration that dials its own endpoint, and UnknownLink is not a failure at all but an instruction to say hello again.

use majordomus_cli::mesh::link::RefusalCode;

// the wire word is the code's identity across surfaces, and it is stable
assert_eq!(RefusalCode::RepositoryMismatch.as_str(), "repository_mismatch");
assert_eq!(
    serde_json::to_value(RefusalCode::Untrusted).unwrap(),
    serde_json::json!("untrusted"),
);
assert_ne!(RefusalCode::Untrusted, RefusalCode::RepositoryMismatch);

Variants

Malformed

Not the shape of the message.

Oversized

Over MAX_LINK_MESSAGE.

ProtocolUnsupported

The protocol ranges do not meet.

Signature

The signature does not verify.

Stale

The timestamp is outside the skew window.

Replay

A nonce or a counter already seen.

RepositoryMismatch

The peer serves another repository: the isolation rule.

Untrusted

The peer’s key is not trusted by this runtime’s policy: discovery is not trust.

SelfLink

The peer is this very runtime.

NotActive

This runtime’s cooperation is not active.

UnknownLink

The link id is unknown here: the answerer restarted or expired the link; say hello.

Capacity

A bound of this runtime is full.

FeatureUnsupported

The peer lacks a feature the operation needs.

Misaddressed

A hello addressed to another runtime: captured on its way there and replayed here.

Implementations

impl RefusalCode

pub fn as_str(self) -> &'static str

The code’s wire word: the snake-case spelling every surface uses, so a refusal reads the same in a log line, a JSON answer and a peer’s counters. It is written out here rather than derived from the variant name, because the word is protocol and renaming a variant must not silently change what another runtime reads.

use majordomus_cli::mesh::link::RefusalCode;

assert_eq!(RefusalCode::ProtocolUnsupported.as_str(), "protocol_unsupported");
assert_eq!(RefusalCode::SelfLink.as_str(), "self_link");
assert_eq!(
    serde_json::to_value(RefusalCode::SelfLink).unwrap(),
    serde_json::json!(RefusalCode::SelfLink.as_str()),
    "one spelling, whichever surface prints it",
);

Trait Implementations

impl Clone for RefusalCode

fn clone(&self) -> RefusalCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RefusalCode

impl Debug for RefusalCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RefusalCode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RefusalCode

impl JsonSchema for RefusalCode

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 Ord for RefusalCode

fn cmp(&self, other: &RefusalCode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for RefusalCode

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

fn partial_cmp(&self, other: &RefusalCode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for RefusalCode

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 RefusalCode