Struct RuntimeState 

pub struct RuntimeState {
    pub nodes: BTreeMap<String, NodeState>,
}

What is true of a node in a running process, and of nothing on a published page.

A graph is definitions: they are the same in a static build and in a server, and they are what compose derives. This is the overlay a consumer with a process to ask lays over them, keyed by node id. It is deliberately not a field of Node: a node that could carry runtime state would carry it into the static projection, where it would be a value nobody can refresh and a reader cannot distinguish from a current one.

Fields

nodes: BTreeMap<String, NodeState>

Node id to what the process says about it now.

Implementations

impl RuntimeState

pub fn narrowed_to(&self, graph: &Graph) -> RuntimeState

The observations that name a node of this graph, and no others.

An observing process knows about subsystems, not about one graph’s vocabulary, so what it offers is wider than what any graph can show. Narrowing here rather than at each consumer is what keeps the overlay keyed by node id: an entry that survives names a node, and a renderer can look every key up.

use majordomus_cli::graph::{Builder, Node, NodeState, RuntimeState};
let mut b = Builder::new("g", "G", "one node", "the composed registry")
    .node_kind("module", "a subsystem");
b.node(Node {
    id: "module:mesh".into(), kind: "module".into(), label: "mesh".into(),
    summary: None, route: None, source: None, status: None, external: false,
    facts: Default::default(),
});
let graph = b.finish();

let mut observed = RuntimeState::default();
for id in ["module:mesh", "module:not-in-this-graph"] {
    observed.nodes.insert(id.into(), NodeState { status: "ok".into(), detail: None });
}

let overlay = observed.narrowed_to(&graph);
assert_eq!(overlay.nodes.keys().map(String::as_str).collect::<Vec<_>>(), ["module:mesh"]);

pub fn of(&self, node_id: &str) -> Option<&NodeState>

What the process says about one node now, if anything.

None is the ordinary answer, not a failure: a graph names more than any one process observes, so a renderer draws the declared status alone for those nodes.

use majordomus_cli::graph::{NodeState, RuntimeState};
let mut observed = RuntimeState::default();
observed.nodes.insert(
    "module:mesh".into(),
    NodeState { status: "ready".into(), detail: Some("2 peers".into()) },
);

assert_eq!(observed.of("module:mesh").map(|s| s.status.as_str()), Some("ready"));
assert!(observed.of("module:nothing-observed-it").is_none());

Trait Implementations

impl Clone for RuntimeState

fn clone(&self) -> RuntimeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimeState

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

Formats the value using the given formatter.

impl Default for RuntimeState

fn default() -> RuntimeState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RuntimeState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RuntimeState

impl JsonSchema for RuntimeState

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 RuntimeState

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

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 RuntimeState