Rework: Shard working, Telemetry Core needs logic filling in

backend/telemetry/src/aggregator.rs

@@ -0,0 +1,202 @@
+use common::{internal_messages::{self, LocalId}, node};
+use std::{str::FromStr, sync::Arc};
+use std::sync::atomic::AtomicU64;
+use futures::channel::{ mpsc, oneshot };
+use futures::{ Sink, SinkExt, StreamExt };
+use tokio::net::TcpStream;
+use tokio_util::compat::{ TokioAsyncReadCompatExt };
+use std::collections::{ HashMap, HashSet };
+
+/// A unique Id is assigned per websocket connection (or more accurately,
+/// per feed socket and per shard socket). This can be combined with the
+/// [`LocalId`] of messages to give us a global ID.
+type ConnId = u64;
+
+/// Incoming messages come via subscriptions, and end up looking like this.
+#[derive(Debug)]
+enum ToAggregator {
+    FromShardWebsocket(ConnId, FromShardWebsocket),
+    FromFeedWebsocket(ConnId, FromFeedWebsocket),
+}
+
+/// An incoming shard connection can send these messages to the aggregator.
+#[derive(Debug)]
+pub enum FromShardWebsocket {
+    /// When the socket is opened, it'll send this first
+    /// so that we have a way to communicate back to it.
+    Initialize {
+        channel: mpsc::Sender<ToShardWebsocket>,
+    },
+    /// Tell the aggregator about a new node.
+    Add {
+        local_id: LocalId,
+        ip: Option<std::net::IpAddr>,
+        node: common::types::NodeDetails,
+    },
+    /// Update/pass through details about a node.
+    Update {
+        local_id: LocalId,
+        payload: node::Payload
+    }
+}
+
+/// The aggregator can these messages back to a shard connection.
+#[derive(Debug)]
+pub enum ToShardWebsocket {
+    /// Mute messages to the core by passing the shard-local ID of them.
+    Mute {
+        local_id: LocalId
+    }
+}
+
+/// An incoming feed connection can send these messages to the aggregator.
+#[derive(Debug)]
+pub enum FromFeedWebsocket {
+    /// When the socket is opened, it'll send this first
+    /// so that we have a way to communicate back to it.
+    Initialize {
+        channel: mpsc::Sender<ToFeedWebsocket>,
+    },
+    /// The feed can subscribe to a chain to receive
+    /// messages relating to it.
+    Subscribe {
+        chain: Box<str>
+    },
+    /// The feed wants finality info for the chain, too.
+    SendFinality {
+        chain: Box<str>
+    },
+    /// The feed doesn't want any more finality info for the chain.
+    NoMoreFinality {
+        chain: Box<str>
+    },
+    /// An explicit ping message.
+    Ping {
+        chain: Box<str>
+    }
+}
+
+// The frontend sends text based commands; parse them into these messages:
+impl FromStr for FromFeedWebsocket {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (cmd, chain) = match s.find(':') {
+            Some(idx) => (&s[..idx], s[idx+1..].into()),
+            None => return Err(anyhow::anyhow!("Expecting format `CMD:CHAIN_NAME`"))
+        };
+        match cmd {
+            "ping" => Ok(FromFeedWebsocket::Ping { chain }),
+            "subscribe" => Ok(FromFeedWebsocket::Subscribe { chain }),
+            "send-finality" => Ok(FromFeedWebsocket::SendFinality { chain }),
+            "no-more-finality" => Ok(FromFeedWebsocket::NoMoreFinality { chain }),
+            _ => return Err(anyhow::anyhow!("Command {} not recognised", cmd))
+        }
+    }
+}
+
+/// The aggregator can these messages back to a feed connection.
+#[derive(Debug)]
+pub enum ToFeedWebsocket {
+
+}
+
+#[derive(Clone)]
+pub struct Aggregator(Arc<AggregatorInternal>);
+
+struct AggregatorInternal {
+    /// Shards that connect are each assigned a unique connection ID.
+    /// This helps us know who to send messages back to (especially in
+    /// conjunction with the [`LocalId`] that messages will come with).
+    shard_conn_id: AtomicU64,
+    /// Feeds that connect have their own unique connection ID, too.
+    feed_conn_id: AtomicU64,
+    /// Send messages in to the aggregator from the outside via this. This is
+    /// stored here so that anybody holding an `Aggregator` handle can
+    /// make use of it.
+    tx_to_aggregator: mpsc::Sender<ToAggregator>
+}
+
+impl Aggregator {
+    /// Spawn a new Aggregator. This connects to the telemetry backend
+    pub async fn spawn(denylist: Vec<String>) -> anyhow::Result<Aggregator> {
+        let (tx_to_aggregator, rx_from_external) = mpsc::channel(10);
+
+        // Handle any incoming messages in our handler loop:
+        tokio::spawn(Aggregator::handle_messages(rx_from_external, denylist));
+
+        // Return a handle to our aggregator:
+        Ok(Aggregator(Arc::new(AggregatorInternal {
+            shard_conn_id: AtomicU64::new(1),
+            feed_conn_id: AtomicU64::new(1),
+            tx_to_aggregator,
+        })))
+    }
+
+    // This is spawned into a separate task and handles any messages coming
+    // in to the aggregator. If nobody is tolding the tx side of the channel
+    // any more, this task will gracefully end.
+    async fn handle_messages(mut rx_from_external: mpsc::Receiver<ToAggregator>, denylist: Vec<String>) {
+
+        // Temporary: if we drop channels to shards, they will be booted:
+        let mut to_shards = vec![];
+
+        // Now, loop and receive messages to handle.
+        while let Some(msg) = rx_from_external.next().await {
+            match msg {
+                ToAggregator::FromFeedWebsocket(feed_conn_id, FromFeedWebsocket::Initialize { channel }) => {
+
+                },
+                ToAggregator::FromFeedWebsocket(feed_conn_id, FromFeedWebsocket::Ping { chain }) => {
+
+                },
+                ToAggregator::FromFeedWebsocket(feed_conn_id, FromFeedWebsocket::Subscribe { chain }) => {
+
+                },
+                ToAggregator::FromFeedWebsocket(feed_conn_id, FromFeedWebsocket::SendFinality { chain }) => {
+
+                },
+                ToAggregator::FromFeedWebsocket(feed_conn_id, FromFeedWebsocket::NoMoreFinality { chain }) => {
+
+                },
+                ToAggregator::FromShardWebsocket(shard_conn_id, FromShardWebsocket::Initialize { channel }) => {
+                    to_shards.push(channel);
+                },
+                ToAggregator::FromShardWebsocket(shard_conn_id, FromShardWebsocket::Add { local_id, ip, node }) => {
+
+                },
+                ToAggregator::FromShardWebsocket(shard_conn_id, FromShardWebsocket::Update { local_id, payload }) => {
+
+                },
+            }
+        }
+    }
+
+    /// Return a sink that a shard can send messages into to be handled by the aggregator.
+    pub fn subscribe_shard(&self) -> impl Sink<FromShardWebsocket, Error = anyhow::Error> + Unpin {
+        // Assign a unique aggregator-local ID to each connection that subscribes, and pass
+        // that along with every message to the aggregator loop:
+        let shard_conn_id: ConnId = self.0.shard_conn_id.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let tx_to_aggregator = self.0.tx_to_aggregator.clone();
+
+        // Calling `send` on this Sink requires Unpin. There may be a nicer way than this,
+        // but pinning by boxing is the easy solution for now:
+        Box::pin(tx_to_aggregator.with(move |msg| async move {
+            Ok(ToAggregator::FromShardWebsocket(shard_conn_id, msg))
+        }))
+    }
+
+    /// Return a sink that a feed can send messages into to be handled by the aggregator.
+    pub fn subscribe_feed(&self) -> impl Sink<FromFeedWebsocket, Error = anyhow::Error> + Unpin {
+        // Assign a unique aggregator-local ID to each connection that subscribes, and pass
+        // that along with every message to the aggregator loop:
+        let feed_conn_id: ConnId = self.0.feed_conn_id.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let tx_to_aggregator = self.0.tx_to_aggregator.clone();
+
+        // Calling `send` on this Sink requires Unpin. There may be a nicer way than this,
+        // but pinning by boxing is the easy solution for now:
+        Box::pin(tx_to_aggregator.with(move |msg| async move {
+            Ok(ToAggregator::FromFeedWebsocket(feed_conn_id, msg))
+        }))
+    }
+
+}

backend/telemetry/src/feed_message.rs

@@ -0,0 +1,221 @@
+//! This module provides the messages that will be
+//! sent to subscribing feeds.
+
+use serde::ser::{SerializeTuple, Serializer};
+use serde::Serialize;
+use std::mem;
+
+use crate::node::Node;
+use serde_json::to_writer;
+use common::types::{
+    Address, BlockDetails, BlockHash, BlockNumber, NodeHardware, NodeIO, NodeId, NodeStats,
+    Timestamp, NodeDetails,
+};
+
+pub trait FeedMessage {
+    const ACTION: u8;
+}
+
+pub trait FeedMessageWrite: FeedMessage {
+    fn write_to_feed(&self, ser: &mut FeedMessageSerializer);
+}
+
+impl<T> FeedMessageWrite for T
+where
+    T: FeedMessage + Serialize,
+{
+    fn write_to_feed(&self, ser: &mut FeedMessageSerializer) {
+        ser.write(self)
+    }
+}
+
+pub struct FeedMessageSerializer {
+    /// Current buffer,
+    buffer: Vec<u8>,
+}
+
+const BUFCAP: usize = 128;
+
+impl FeedMessageSerializer {
+    pub fn new() -> Self {
+        Self {
+            buffer: Vec::with_capacity(BUFCAP),
+        }
+    }
+
+    pub fn push<Message>(&mut self, msg: Message)
+    where
+        Message: FeedMessageWrite,
+    {
+        let glue = match self.buffer.len() {
+            0 => b'[',
+            _ => b',',
+        };
+
+        self.buffer.push(glue);
+        self.write(&Message::ACTION);
+        self.buffer.push(b',');
+        msg.write_to_feed(self);
+    }
+
+    fn write<S>(&mut self, value: &S)
+    where
+        S: Serialize,
+    {
+        let _ = to_writer(&mut self.buffer, value);
+    }
+
+    pub fn finalize(&mut self) -> Option<Vec<u8>> {
+        if self.buffer.is_empty() {
+            return None;
+        }
+
+        self.buffer.push(b']');
+
+        let bytes = mem::replace(&mut self.buffer, Vec::with_capacity(BUFCAP));
+
+        Some(bytes)
+    }
+}
+
+macro_rules! actions {
+    ($($action:literal: $t:ty,)*) => {
+        $(
+            impl FeedMessage for $t {
+                const ACTION: u8 = $action;
+            }
+        )*
+    }
+}
+
+actions! {
+     0: Version,
+     1: BestBlock,
+     2: BestFinalized,
+     3: AddedNode<'_>,
+     4: RemovedNode,
+     5: LocatedNode<'_>,
+     6: ImportedBlock<'_>,
+     7: FinalizedBlock,
+     8: NodeStatsUpdate<'_>,
+     9: Hardware<'_>,
+    10: TimeSync,
+    11: AddedChain<'_>,
+    12: RemovedChain<'_>,
+    13: SubscribedTo<'_>,
+    14: UnsubscribedFrom<'_>,
+    15: Pong<'_>,
+    16: AfgFinalized,
+    17: AfgReceivedPrevote,
+    18: AfgReceivedPrecommit,
+    19: AfgAuthoritySet,
+    20: StaleNode,
+    21: NodeIOUpdate<'_>,
+}
+
+#[derive(Serialize)]
+pub struct Version(pub usize);
+
+#[derive(Serialize)]
+pub struct BestBlock(pub BlockNumber, pub Timestamp, pub Option<u64>);
+
+#[derive(Serialize)]
+pub struct BestFinalized(pub BlockNumber, pub BlockHash);
+
+pub struct AddedNode<'a>(pub NodeId, pub &'a Node);
+
+#[derive(Serialize)]
+pub struct RemovedNode(pub NodeId);
+
+#[derive(Serialize)]
+pub struct LocatedNode<'a>(pub NodeId, pub f32, pub f32, pub &'a str);
+
+#[derive(Serialize)]
+pub struct ImportedBlock<'a>(pub NodeId, pub &'a BlockDetails);
+
+#[derive(Serialize)]
+pub struct FinalizedBlock(pub NodeId, pub BlockNumber, pub BlockHash);
+
+#[derive(Serialize)]
+pub struct NodeStatsUpdate<'a>(pub NodeId, pub &'a NodeStats);
+
+#[derive(Serialize)]
+pub struct NodeIOUpdate<'a>(pub NodeId, pub &'a NodeIO);
+
+#[derive(Serialize)]
+pub struct Hardware<'a>(pub NodeId, pub &'a NodeHardware);
+
+#[derive(Serialize)]
+pub struct TimeSync(pub u64);
+
+#[derive(Serialize)]
+pub struct AddedChain<'a>(pub &'a str, pub usize);
+
+#[derive(Serialize)]
+pub struct RemovedChain<'a>(pub &'a str);
+
+#[derive(Serialize)]
+pub struct SubscribedTo<'a>(pub &'a str);
+
+#[derive(Serialize)]
+pub struct UnsubscribedFrom<'a>(pub &'a str);
+
+#[derive(Serialize)]
+pub struct Pong<'a>(pub &'a str);
+
+#[derive(Serialize)]
+pub struct AfgFinalized(pub Address, pub BlockNumber, pub BlockHash);
+
+#[derive(Serialize)]
+pub struct AfgReceivedPrevote(
+    pub Address,
+    pub BlockNumber,
+    pub BlockHash,
+    pub Option<Address>,
+);
+
+#[derive(Serialize)]
+pub struct AfgReceivedPrecommit(
+    pub Address,
+    pub BlockNumber,
+    pub BlockHash,
+    pub Option<Address>,
+);
+
+#[derive(Serialize)]
+pub struct AfgAuthoritySet(
+    pub Address,
+    pub Address,
+    pub Address,
+    pub BlockNumber,
+    pub BlockHash,
+);
+
+#[derive(Serialize)]
+pub struct StaleNode(pub NodeId);
+
+impl FeedMessageWrite for AddedNode<'_> {
+    fn write_to_feed(&self, ser: &mut FeedMessageSerializer) {
+        let AddedNode(nid, node) = self;
+
+        let details = node.details();
+        let details = (
+            &details.name,
+            &details.implementation,
+            &details.version,
+            &details.validator,
+            &details.network_id,
+        );
+
+        ser.write(&(
+            nid,
+            details,
+            node.stats(),
+            node.io(),
+            node.hardware(),
+            node.block_details(),
+            &node.location(),
+            &node.startup_time(),
+        ));
+    }
+}

backend/telemetry/src/main.rs

@@ -0,0 +1,285 @@
+mod aggregator;
+mod feed_message;
+mod node;
+
+use std::net::SocketAddr;
+use std::str::FromStr;
+
+use bincode::Options;
+use common::internal_messages;
+use structopt::StructOpt;
+use simple_logger::SimpleLogger;
+use futures::{StreamExt, SinkExt, channel::mpsc};
+use warp::Filter;
+use warp::filters::ws;
+use common::{log_level::LogLevel};
+use aggregator::{ Aggregator, FromFeedWebsocket, ToFeedWebsocket, FromShardWebsocket, ToShardWebsocket };
+
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+const AUTHORS: &str = env!("CARGO_PKG_AUTHORS");
+const NAME: &str = "Substrate Telemetry Backend Core";
+const ABOUT: &str = "This is the Telemetry Backend Core that receives telemetry messages \
+                     from Substrate/Polkadot nodes and provides the data to a subsribed feed";
+
+#[derive(StructOpt, Debug)]
+#[structopt(name = NAME, version = VERSION, author = AUTHORS, about = ABOUT)]
+struct Opts {
+    /// This is the socket address that Telemetryis listening to. This is restricted to
+    /// localhost (127.0.0.1) by default and should be fine for most use cases. If
+    /// you are using Telemetry in a container, you likely want to set this to '0.0.0.0:8000'
+    #[structopt(
+        short = "l",
+        long = "listen",
+        default_value = "127.0.0.1:8000",
+    )]
+    socket: std::net::SocketAddr,
+    /// The desired log level; one of 'error', 'warn', 'info', 'debug' or 'trace', where
+    /// 'error' only logs errors and 'trace' logs everything.
+    #[structopt(
+        required = false,
+        long = "log",
+        default_value = "info",
+        about = "Log level."
+    )]
+    log_level: LogLevel,
+    /// Space delimited list of the names of chains that are not allowed to connect to
+    /// telemetry. Case sensitive.
+    #[structopt(
+        required = false,
+        long = "denylist",
+    )]
+    denylist: Vec<String>,
+}
+
+#[tokio::main]
+async fn main() {
+    let opts = Opts::from_args();
+    let log_level = &opts.log_level;
+
+    SimpleLogger::new()
+        .with_level(log_level.into())
+        .init()
+        .expect("Must be able to start a logger");
+
+    log::info!(
+        "Starting Telemetry Core version: {}",
+        VERSION
+    );
+
+    if let Err(e) = start_server(opts).await {
+        log::error!("Error starting server: {}", e);
+    }
+}
+
+/// Declare our routes and start the server.
+async fn start_server(opts: Opts) -> anyhow::Result<()> {
+
+    let shard_aggregator = Aggregator::spawn(opts.denylist).await?;
+    let feed_aggregator = shard_aggregator.clone();
+
+    // Handle requests to /health by returning OK.
+    let health_route =
+        warp::path("health")
+        .map(|| "OK");
+
+    // Handle websocket requests from shards.
+    let ws_shard_submit_route =
+        warp::path("shard_submit")
+        .and(warp::ws())
+        .and(warp::filters::addr::remote())
+        .map(move |ws: ws::Ws, addr: Option<SocketAddr>| {
+            let tx_to_aggregator = shard_aggregator.subscribe_shard();
+            log::info!("Opening /shard_submit connection from {:?}", addr);
+            ws.on_upgrade(move |websocket| async move {
+                let websocket = handle_shard_websocket_connection(websocket, tx_to_aggregator).await;
+                log::info!("Closing /shard_submit connection from {:?}", addr);
+                let _ = websocket.close().await;
+            })
+        });
+
+    // Handle websocket requests from frontends.
+    let ws_feed_route =
+        warp::path("feed")
+        .and(warp::ws())
+        .and(warp::filters::addr::remote())
+        .map(move |ws: ws::Ws, addr: Option<SocketAddr>| {
+            let tx_to_aggregator = feed_aggregator.subscribe_feed();
+            log::info!("Opening /feed connection from {:?}", addr);
+            ws.on_upgrade(move |websocket| async move {
+                let websocket = handle_feed_websocket_connection(websocket, tx_to_aggregator).await;
+                log::info!("Closing /feed connection from {:?}", addr);
+                let _ = websocket.close().await;
+            })
+        });
+
+    // Merge the routes and start our server:
+    let routes = ws_shard_submit_route
+        .or(ws_feed_route)
+        .or(health_route);
+    warp::serve(routes).run(opts.socket).await;
+    Ok(())
+}
+
+/// This handles messages coming to/from a shard connection
+async fn handle_shard_websocket_connection<S>(mut websocket: ws::WebSocket, mut tx_to_aggregator: S) -> ws::WebSocket
+    where S: futures::Sink<FromShardWebsocket, Error = anyhow::Error> + Unpin
+{
+    let (tx_to_shard_conn, mut rx_from_aggregator) = mpsc::channel(10);
+
+    // Tell the aggregator about this new connection, and give it a way to send messages to us:
+    let init_msg = FromShardWebsocket::Initialize {
+        channel: tx_to_shard_conn
+    };
+    if let Err(e) = tx_to_aggregator.send(init_msg).await {
+        log::error!("Error sending message to aggregator: {}", e);
+        return websocket;
+    }
+
+    // Loop, handling new messages from the shard or from the aggregator:
+    loop {
+        tokio::select! {
+            // AGGREGATOR -> SHARD
+            msg = rx_from_aggregator.next() => {
+                // End the loop when connection from aggregator ends:
+                let msg = match msg {
+                    Some(msg) => msg,
+                    None => break
+                };
+
+                let internal_msg = match msg {
+                    ToShardWebsocket::Mute { local_id } => {
+                        internal_messages::FromTelemetryCore::Mute { local_id }
+                    }
+                };
+
+                let bytes = bincode::options()
+                    .serialize(&internal_msg)
+                    .expect("message to shard should serialize");
+
+                if let Err(e) = websocket.send(ws::Message::binary(bytes)).await {
+                    log::error!("Error sending message to shard; booting it: {}", e);
+                    break
+                }
+            }
+            // SHARD -> AGGREGATOR
+            msg = websocket.next() => {
+                // End the loop when connection from shard ends:
+                let msg = match msg {
+                    Some(msg) => msg,
+                    None => break
+                };
+
+                let msg = match msg {
+                    Err(e) => {
+                        log::error!("Error receiving message from shard; booting it: {}", e);
+                        break;
+                    },
+                    Ok(msg) => msg
+                };
+
+                // If the message isn't something we want to handle, just ignore it.
+                // This includes system messages like "pings" and such, so don't log anything.
+                if !msg.is_binary() && !msg.is_text() {
+                    continue;
+                }
+
+                let bytes = msg.as_bytes();
+                let msg: internal_messages::FromShardAggregator = match bincode::options().deserialize(bytes) {
+                    Ok(msg) => msg,
+                    Err(e) => {
+                        log::error!("Failed to deserialize message from shard; booting it: {}", e);
+                        break;
+                    }
+                };
+
+                // Convert and send to the aggregator:
+                let aggregator_msg = match msg {
+                    internal_messages::FromShardAggregator::AddNode { ip, node, local_id } => {
+                        FromShardWebsocket::Add { ip, node, local_id }
+                    },
+                    internal_messages::FromShardAggregator::UpdateNode { payload, local_id } => {
+                        FromShardWebsocket::Update { local_id, payload }
+                    },
+                };
+                if let Err(e) = tx_to_aggregator.send(aggregator_msg).await {
+                    log::error!("Failed to send message to aggregator; closing shard: {}", e);
+                    break;
+                }
+            }
+        }
+    }
+
+    // loop ended; give socket back to parent:
+    websocket
+}
+
+/// This handles messages coming from a feed connection
+async fn handle_feed_websocket_connection<S>(mut websocket: ws::WebSocket, mut tx_to_aggregator: S) -> ws::WebSocket
+    where S: futures::Sink<FromFeedWebsocket, Error = anyhow::Error> + Unpin
+{
+    let (tx_to_feed_conn, mut rx_from_aggregator) = mpsc::channel(10);
+
+    // Tell the aggregator about this new connection, and give it a way to send messages to us:
+    let init_msg = FromFeedWebsocket::Initialize {
+        channel: tx_to_feed_conn
+    };
+    if let Err(e) = tx_to_aggregator.send(init_msg).await {
+        log::error!("Error sending message to aggregator: {}", e);
+        return websocket;
+    }
+
+    // Loop, handling new messages from the shard or from the aggregator:
+    loop {
+        tokio::select! {
+            // AGGREGATOR -> FRONTEND
+            msg = rx_from_aggregator.next() => {
+                // End the loop when connection from aggregator ends:
+                let msg = match msg {
+                    Some(msg) => msg,
+                    None => break
+                };
+
+                println!("TODO: encode message and send down feed websocket: {:?}", msg);
+            }
+            // FRONTEND -> AGGREGATOR
+            msg = websocket.next() => {
+                // End the loop when connection from feed ends:
+                let msg = match msg {
+                    Some(msg) => msg,
+                    None => break
+                };
+
+                // If we see any errors, log them and end our loop:
+                let msg = match msg {
+                    Err(e) => {
+                        log::error!("Error in node websocket connection: {}", e);
+                        break;
+                    },
+                    Ok(msg) => msg
+                };
+
+                // We ignore all but text messages from the frontend:
+                let text = match msg.to_str() {
+                    Ok(s) => s,
+                    Err(_) => continue
+                };
+
+                // Parse the message into a command we understand and send it to the aggregator:
+                let cmd = match FromFeedWebsocket::from_str(text) {
+                    Ok(cmd) => cmd,
+                    Err(e) => {
+                        log::warn!("Ignoring invalid command '{}' from the frontend: {}", text, e);
+                        continue
+                    }
+                };
+                if let Err(e) = tx_to_aggregator.send(cmd).await {
+                    log::error!("Failed to send message to aggregator; closing feed: {}", e);
+                    break;
+                }
+            }
+        }
+    }
+
+    // loop ended; give socket back to parent:
+    websocket
+}

backend/telemetry/src/node.rs

@@ -0,0 +1,209 @@
+use std::sync::Arc;
+
+use common::types::{
+    Block, BlockDetails, NodeDetails, NodeHardware, NodeIO, NodeId, NodeLocation, NodeStats,
+    Timestamp,
+};
+use common::util::now;
+use common::node::SystemInterval;
+
+/// Minimum time between block below broadcasting updates to the browser gets throttled, in ms.
+const THROTTLE_THRESHOLD: u64 = 100;
+/// Minimum time of intervals for block updates sent to the browser when throttled, in ms.
+const THROTTLE_INTERVAL: u64 = 1000;
+
+pub struct Node {
+    /// Static details
+    details: NodeDetails,
+    /// Basic stats
+    stats: NodeStats,
+    /// Node IO stats
+    io: NodeIO,
+    /// Best block
+    best: BlockDetails,
+    /// Finalized block
+    finalized: Block,
+    /// Timer for throttling block updates
+    throttle: u64,
+    /// Hardware stats over time
+    hardware: NodeHardware,
+    /// Physical location details
+    location: Option<Arc<NodeLocation>>,
+    /// Flag marking if the node is stale (not syncing or producing blocks)
+    stale: bool,
+    /// Unix timestamp for when node started up (falls back to connection time)
+    startup_time: Option<Timestamp>,
+}
+
+impl Node {
+    pub fn new(mut details: NodeDetails) -> Self {
+        let startup_time = details
+            .startup_time
+            .take()
+            .and_then(|time| time.parse().ok());
+
+        Node {
+            details,
+            stats: NodeStats::default(),
+            io: NodeIO::default(),
+            best: BlockDetails::default(),
+            finalized: Block::zero(),
+            throttle: 0,
+            hardware: NodeHardware::default(),
+            location: None,
+            stale: false,
+            startup_time,
+        }
+    }
+
+    pub fn details(&self) -> &NodeDetails {
+        &self.details
+    }
+
+    pub fn stats(&self) -> &NodeStats {
+        &self.stats
+    }
+
+    pub fn io(&self) -> &NodeIO {
+        &self.io
+    }
+
+    pub fn best(&self) -> &Block {
+        &self.best.block
+    }
+
+    pub fn best_timestamp(&self) -> u64 {
+        self.best.block_timestamp
+    }
+
+    pub fn finalized(&self) -> &Block {
+        &self.finalized
+    }
+
+    pub fn hardware(&self) -> &NodeHardware {
+        &self.hardware
+    }
+
+    pub fn location(&self) -> Option<&NodeLocation> {
+        self.location.as_deref()
+    }
+
+    pub fn update_location(&mut self, location: Arc<NodeLocation>) {
+        self.location = Some(location);
+    }
+
+    pub fn block_details(&self) -> &BlockDetails {
+        &self.best
+    }
+
+    pub fn update_block(&mut self, block: Block) -> bool {
+        if block.height > self.best.block.height {
+            self.stale = false;
+            self.best.block = block;
+
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn update_details(
+        &mut self,
+        timestamp: u64,
+        propagation_time: Option<u64>,
+    ) -> Option<&BlockDetails> {
+        self.best.block_time = timestamp - self.best.block_timestamp;
+        self.best.block_timestamp = timestamp;
+        self.best.propagation_time = propagation_time;
+
+        if self.throttle < timestamp {
+            if self.best.block_time <= THROTTLE_THRESHOLD {
+                self.throttle = timestamp + THROTTLE_INTERVAL;
+            }
+
+            Some(&self.best)
+        } else {
+            None
+        }
+    }
+
+    pub fn update_hardware(&mut self, interval: &SystemInterval) -> bool {
+        let mut changed = false;
+
+        if let Some(upload) = interval.bandwidth_upload {
+            changed |= self.hardware.upload.push(upload);
+        }
+        if let Some(download) = interval.bandwidth_download {
+            changed |= self.hardware.download.push(download);
+        }
+        self.hardware.chart_stamps.push(now() as f64);
+
+        changed
+    }
+
+    pub fn update_stats(&mut self, interval: &SystemInterval) -> Option<&NodeStats> {
+        let mut changed = false;
+
+        if let Some(peers) = interval.peers {
+            if peers != self.stats.peers {
+                self.stats.peers = peers;
+                changed = true;
+            }
+        }
+        if let Some(txcount) = interval.txcount {
+            if txcount != self.stats.txcount {
+                self.stats.txcount = txcount;
+                changed = true;
+            }
+        }
+
+        if changed {
+            Some(&self.stats)
+        } else {
+            None
+        }
+    }
+
+    pub fn update_io(&mut self, interval: &SystemInterval) -> Option<&NodeIO> {
+        let mut changed = false;
+
+        if let Some(size) = interval.used_state_cache_size {
+            changed |= self.io.used_state_cache_size.push(size);
+        }
+
+        if changed {
+            Some(&self.io)
+        } else {
+            None
+        }
+    }
+
+    pub fn update_finalized(&mut self, block: Block) -> Option<&Block> {
+        if block.height > self.finalized.height {
+            self.finalized = block;
+            Some(self.finalized())
+        } else {
+            None
+        }
+    }
+
+    pub fn update_stale(&mut self, threshold: u64) -> bool {
+        if self.best.block_timestamp < threshold {
+            self.stale = true;
+        }
+
+        self.stale
+    }
+
+    pub fn stale(&self) -> bool {
+        self.stale
+    }
+
+    pub fn set_validator_address(&mut self, addr: Box<str>) {
+        self.details.validator = Some(addr);
+    }
+
+    pub fn startup_time(&self) -> Option<Timestamp> {
+        self.startup_time
+    }
+}