Struct ObservedGraph 

pub struct ObservedGraph {
    pub graph: Graph,
    pub runtime: RuntimeState,
}

The second projection of a graph: the definitions a static build publishes, and beside them what a process observes about them now.

The two are held apart on purpose. graph is byte-for-byte the value derive() produced, so a reader can compare a served graph against a published one and get equality; runtime is the overlay, which no published artifact carries and which nothing but a live process can fill. A consumer that merged them would produce a document that looks like the static projection, cannot be compared with it, and carries values that go stale the moment they are written.

use majordomus_cli::graph::{Builder, Node, NodeState, ObservedGraph, 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: Some("declared".into()),
    external: false, facts: Default::default(),
});
let graph = b.finish();

let mut observed = RuntimeState::default();
observed.nodes.insert("module:mesh".into(), NodeState { status: "ready".into(), detail: None });
let served = ObservedGraph::new(graph.clone(), &observed);

// the definitions are the published value, byte for byte; the observation sits beside them
assert_eq!(served.graph, graph);
assert_eq!(served.graph.nodes[0].status.as_deref(), Some("declared"));
assert_eq!(served.runtime.of("module:mesh").map(|s| s.status.as_str()), Some("ready"));

Fields

graph: Graph

The composed definitions, unchanged.

runtime: RuntimeState

What this process observes about them, keyed by node id, narrowed to nodes the graph holds.

Implementations

impl ObservedGraph

pub fn new(graph: Graph, observed: &RuntimeState) -> ObservedGraph

Lay an observation over a graph. The graph is not touched, and observations that name no node of it are dropped.

use majordomus_cli::graph::{Builder, Node, NodeState, ObservedGraph, 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 mut observed = RuntimeState::default();
for id in ["module:mesh", "module:a-subsystem-this-graph-does-not-name"] {
    observed.nodes.insert(id.into(), NodeState { status: "ok".into(), detail: None });
}

let served = ObservedGraph::new(b.finish(), &observed);
assert_eq!(served.runtime.nodes.len(), 1);
assert!(served.runtime.of("module:a-subsystem-this-graph-does-not-name").is_none());

Trait Implementations

impl Clone for ObservedGraph

fn clone(&self) -> ObservedGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ObservedGraph

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ObservedGraph

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ObservedGraph

impl JsonSchema for ObservedGraph

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 ObservedGraph

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

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 ObservedGraph