Struct LinkedPeer 

pub struct LinkedPeer {
    pub runtime: String,
    pub name: String,
    pub features: Vec<String>,
}

A linked mesh runtime, as the mesh reports it. Those carrying the feature the catalogue’s peers block names become advisors with the id peer:<runtime>.

use majordomus_cli::reasoning::availability::*;
use majordomus_cli::reasoning::catalogue::{AdvisorCatalogue, AdvisorTransport, References};

struct Nothing;
impl Presence for Nothing {
    fn executable(&self, _: &str) -> bool { false }
    fn variable(&self, _: &str) -> bool { false }
}
let c: AdvisorCatalogue = majordomus_cli::metadata::yaml::parse_into(
    "version: 1\ncapabilities:\n  - id: code_review\n    description: x\npeers:\n  feature: reviews\n  adapter: mesh-review\n  capabilities: [code_review]\n",
).unwrap();
let peers = [
    LinkedPeer { runtime: "n1-r1".into(), name: "one".into(), features: vec!["reviews".into()] },
    LinkedPeer { runtime: "n2-r1".into(), name: "two".into(), features: vec![] },
];
let refs = References::default();
let states = derive_availability(&c, &Inputs {
    refs: &refs, presence: &Nothing, mode: ReasoningMode::Standard, disabled: &[],
    history: &[], peers: &peers, now: 0, cooldown: None,
});
assert_eq!(states.len(), 1, "only the peer carrying the feature is an advisor");
assert_eq!(states[0].id, "peer:n1-r1");
assert_eq!(states[0].transport, AdvisorTransport::Peer);

Fields

runtime: String

<node>-<runtime>.

name: String

Its display name.

features: Vec<String>

The link features it carries; only those carrying the catalogue’s are advisors.

Trait Implementations

impl Clone for LinkedPeer

fn clone(&self) -> LinkedPeer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinkedPeer

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

Formats the value using the given formatter.

impl Eq for LinkedPeer

impl PartialEq for LinkedPeer

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