SAFE Network Node Dashboard

vdash is a terminal based dashboard for monitoring SAFE Network Nodes. It is written in Rust, using tui-rs to create the terminal UI and linemux to monitor node logfiles on the local machine.

Status: working on Windows, MacOS and Linux with local and public test networks.

vdash is already capable of monitoring multiple logfiles on the local machine so it wouldn't be hard to monitor multiple remote nodes by having a script pull logfiles from remote nodes to local copies monitored by vdash, but this is not on the roadmap. There may be existing tools that could do this so if anyone wants to look into that it would be great as I'm only making minor changes at the moment.

Here's an early vdash (v0.2.0) working with a local testnet node:

Features

vdash will load historic metrics from one or more Safe node logfiles and display these with live updates in the terminal (see above).

You can cycle through different Safe nodes using left/right arrow keys, and zoom the timeline scale in/out using 'i' and 'o' (or '+' and '-').

Press 'q' to quit.

Feature requests and discussion are currently summarised in the opening post of the Safe Network forum topic: Node Dashboard ideas please!.

For more details and progress see Roadmap (below).

Operating Systems

Linux: works on Linux (tested on Ubuntu).
Windows: works on Windows 10.
MacOS: works on MacOS.

Install from crates.io

1 Install Rust via https://doc.rust-lang.org/cargo/getting-started/installation.html

2a. Linux (Ubuntu)

sudo apt-get install build-essential

2b. Linux/MacOS install vdash:

cargo install vdash
vdash --help

2c. Windows install vdash-crossterm:

To install on Windows you must build manually and use the 'nightly' compiler until the 'itarget' feature becomes part of 'stable', so install Rust nightly using rustup:

rustup toolchain install nightly

To build vdash-crossterm on Windows, clone vdash, build with +nightly and use the binary it creates under ./taget/release:

git clone https://github.com/happybeing/vdash
cd vdash
cargo +nightly build -Z features=itarget --bin vdash-crossterm --release --no-default-features

./target/release/vdash-crossterm --help

Using vdash - SAFE Network Node Dashboard

vdash provides a terminal based graphical dashboard of SAFE Network Node activity on the local machine. It parses input from one or more node logfiles to gather live node metrics which are displayed using terminal graphics.

Status: useful work-in-progress, help welcome!

Get SAFE Network pre-requisites

Get Rust: see: https://doc.rust-lang.org/cargo/getting-started/installation.html
Get the SAFE CLI: either download using an install script or build the SAFE CLI locally. Instructions for both options are here.
Get the SAFE Node: when you have the SAFE CLI working you can install the node software with the command safe node install (details here).

You are now ready to install vdash and can test it by running a local test network.

Usage

In the terminal type the command and the paths of one or more node logfiles you want to monitor. For example:

vdash ~/.safe/node/local-node/sn_node.log

When the dashboard is active, pressing 's' or 'd' switches between summary and detail views. For more information:

vdash --help

Node Setup

IMPORTANT: You must ensure the node logfile includes the telemetry information used by vdash by setting the logging level to 'trace' when you start your node (as in the example below). You control the node logging level by setting the environment variable RUST_LOG.

safe node killall
rm -f ~/.safe/node/local-test-network/*/sn_node.log*
RUST_LOG=sn_node=trace safe node join

You can then run vdash, typically in a different terminal:

vdash ~/.safe/node/local-node/sn_node.log

Or Note:

safe node killall makes sure no existing nodes are still running, and deleting existing logfiles prevents you picking up statistics from previous activity. If you leave the logfile in place then vdash will waste time processing that, although you can skip that process using a command line option.
setting RUST_LOG ensures the logfiles contain the data which vdash needs, and excludes some that gets in the way.
On Windows to set RUST_LOG environment variable:

Using Windows Command Line:
```
 set RUST_LOG="sn_node=trace"
 safe node join
```
Using Windows PowerShell:
```
 $env:RUST_LOG="sn_node=trace"
 safe node join
```

Note: the examples use safe node join to start a node, but you will need to check you are using the correct parameters for your purpose. For example you might want to skip port forwarding etc.

Using vdash With a Local Test Network

Start a local test network: follow the instructions to Run a local network, but I suggest using the -t option to create an account and authorise the CLI with it altogether. As here:
```
safe node killall
rm -f ~/.safe/node/baby-fleming-nodes/*/sn_node.log
RUST_LOG=sn_node=trace safe node run-baby-fleming -t
```
Windows: see "Note" immediately above for how to set RUST_LOG on Windows.
Run vdash: in a different terminal window (so you can continue to use the safe-cli in the first terminal), start vdash with:
```
vdash ~/.safe/node/baby-fleming-nodes/*/sn_node.log
```
Or with a live network:
```
vdash ~/.safe/node/local-node/sn_node.log
```
Upload files using SAFE CLI: in the SAFE CLI window you can perform operations on the local test network that will affect the node and the effects will be shown in vdash. For example, to use the SAFE CLI to upload files:
```
safe files put ./<some-directory>/ --recursive
```

If you want to try vdash with a live network, check to see if one is running at the SAFE Network community forum: https://safenetforum.org

Build

See Get SAFE Network Pre-requisites.

Get code

git clone https://github.com/happybeing/vdash
cd vdash

Build - Linux / MacOS

Build vdash with the termion backend (see tui-rs). Note: MacOS is untested but may 'just work'.

cargo build --features="termion" --features="vdash" --release

If built for target 'musl' vdash uses considerably less memory:

rustup target add x86_64-unknown-linux-musl
cargo build --release --target x86_64-unknown-linux-musl

Comparing memory use (using htop on Linux):

VIRT   RES  SHR
803M  9372 4716 x13 threads (release)
32768 6848 2440 x13 threads (release/musl)

Build - Windows 10

Builds vdash the crossterm backend (see tui-rs), with the intention to support Windows.

NOT working on Windows yet, this is being worked on at the moment. Help with testing appreciated.

cargo build --bin vdash-crossterm --features="crossterm" --features="vdash" --release

Roadmap

Where vdash is headed:

LICENSE

Everything is GPL3.0 unless otherwise stated. Any contributions are accepted on the condition they conform to this license.

olegtaranenko/vdash