liminal-server 0.25.4

Standalone server for the liminal messaging bus
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! The whole topology document, including each live serving subject.

use super::{TopologyModel, WorkerStation};
use crate::console::error::ConsoleError;
use crate::console::records::{
    Connection, Device, DeviceBox, DeviceKind, Link, Station, StationKind, StationState,
    TopologyDocument,
};
use crate::console::wall::WallBase;
use std::collections::{BTreeMap, BTreeSet};

impl TopologyModel {
    /// The whole document as it stands, always. This device's start is wall
    /// time from `wall`, the same whenever the document is built, so a reader
    /// derives the uptime on its own clock and a document never goes stale.
    /// When the start falls outside u64 milliseconds since the epoch, the
    /// document names that fault where the start would be, and the fault
    /// comes back beside it for the caller to count: one bad reading never
    /// withholds the topology.
    #[must_use]
    pub fn document(&self, wall: &WallBase) -> (TopologyDocument, Option<ConsoleError>) {
        let this = &self.this.id;
        let (started, fault) = match wall.unix_ms_of(self.this.started) {
            Ok(started) => (Some(started), None),
            Err(error) => (None, Some(error)),
        };
        let mut devices = vec![Device {
            id: this.clone(),
            name: this.clone(),
            kind: DeviceKind::Device,
            liminal: Some(self.this.liminal.clone()),
            started,
            started_fault: fault.as_ref().map(ToString::to_string),
            parent: self.parent.clone(),
            zone: Some(DeviceBox::THIS),
        }];
        let peers: BTreeSet<_> = self
            .peers
            .iter()
            .chain(
                self.links
                    .values()
                    .flat_map(|link| std::iter::once(&link.name).chain(link.relayed.iter())),
            )
            .collect();
        devices.extend(peers.into_iter().map(|peer| Device {
            id: peer.clone(),
            name: peer.clone(),
            kind: DeviceKind::Device,
            liminal: None,
            started: None,
            started_fault: None,
            parent: None,
            zone: None,
        }));
        // A registered responder is a service; a registered worker that is
        // not also one is a worker. Neither takes this server's exchange or
        // depot id: one that would is kept off the map.
        let depot = self.this.depot.then(|| self.depot_id());
        let mut stations: BTreeMap<&String, (StationKind, Option<&WorkerStation>)> = self
            .workers
            .values()
            .filter(|worker| self.reserved(&worker.identity).is_none())
            .map(|worker| (&worker.identity, (StationKind::Worker, Some(worker))))
            .collect();
        stations.extend(
            self.stations
                .iter()
                .filter(|subject| self.reserved(subject).is_none())
                .map(|subject| (subject, (StationKind::Service, None))),
        );
        stations.extend(depot.iter().map(|id| (id, (StationKind::Depot, None))));
        stations.insert(this, (StationKind::Exchange, None));
        let document = TopologyDocument::new(
            self.rev,
            this.clone(),
            devices,
            stations
                .into_iter()
                .map(|(subject, (kind, worker))| Station {
                    id: subject.clone(),
                    name: subject.clone(),
                    device: this.clone(),
                    kind,
                    state: StationState::Live,
                    subjects: worker.map(|worker| worker.subjects.clone()),
                    activities: worker.map(|worker| worker.activities.clone()),
                })
                .collect(),
            self.all_lines(),
            self.peers
                .iter()
                .map(|peer| Link::to_peer(this, peer))
                .chain(self.links.values().cloned())
                .collect(),
            self.connections
                .iter()
                .map(|(id, (mount, participant))| Connection {
                    id: id.to_string(),
                    mount: *mount,
                    participant: participant.clone(),
                })
                .collect(),
        );
        (document, fault)
    }
}