feat: ability to disable dashboard

Author: lgalabru

Cargo.lock

@@ -65,6 +65,7 @@ base58 = "0.1.0"
 tracing = "0.1"
 tracing-subscriber = "0.2"
 tracing-appender = "0.1"
+ctrlc = "3.1.9"
 
 [dependencies.tui]
 version = "0.15.0"

Cargo.toml

@@ -116,6 +116,9 @@ struct Integrate {
     /// Path to Clarinet.toml
     #[clap(long = "manifest-path")]
     pub manifest_path: Option<String>,
+    /// Display streams of logs instead of terminal UI dashboard
+    #[clap(long = "no-dashboard")]
+    pub no_dashboard: bool,
 }
 
 #[derive(Clap)]
@@ -338,7 +341,7 @@ pub fn main() {
         Command::Integrate(cmd) => {
             let manifest_path = get_manifest_path_or_exit(cmd.manifest_path);
             let devnet = DevnetOrchestrator::new(manifest_path);
-            integrate::run_devnet(devnet);
+            integrate::run_devnet(devnet, None, !cmd.no_dashboard);
         }
     };
 }

src/frontend/cli.rs

@@ -1,5 +1,5 @@
 
-use super::DevnetEvent;
+use super::{DevnetEvent, NodeObserverEvent};
 use crate::integrate::{BlockData, MempoolAdmissionData, ServiceStatusData, Status, Transaction};
 use crate::poke::load_session;
 use crate::publish::{publish_contract, Network};
@@ -17,6 +17,7 @@ use rocket::config::{Config, Environment, LoggingLevel};
 use rocket::State;
 use rocket_contrib::json::Json;
 use serde_json::Value;
+use tracing::info;
 use std::collections::{BTreeMap, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::error::Error;
@@ -74,7 +75,7 @@ pub struct EventObserverConfig {
 
 impl EventObserverConfig {
     pub fn new(devnet_config: DevnetConfig, manifest_path: PathBuf, accounts: BTreeMap<String, AccountConfig>) -> Self {
-        println!("Checking contracts...");
+        info!("Checking contracts...");
         let session_settings = match load_session(manifest_path.clone(), false, Network::Devnet) {
             Ok(settings) => settings,
             Err(e) => {
@@ -130,13 +131,15 @@ pub async fn start_events_observer(
     events_config: EventObserverConfig,
     devnet_event_tx: Sender<DevnetEvent>,
     terminator_rx: Receiver<bool>,
+    event_tx: Option<Sender<NodeObserverEvent>>,
 ) -> Result<(), Box<dyn Error>> {
     let port = events_config.devnet_config.orchestrator_port;
     let manifest_path = events_config.manifest_path.clone();
     let rw_lock = Arc::new(RwLock::new(events_config));
 
     let moved_rw_lock = rw_lock.clone();
     let moved_tx = Arc::new(Mutex::new(devnet_event_tx.clone()));
+    let moved_node_tx = Arc::new(Mutex::new(event_tx.clone()));
     let config = Config::build(Environment::Production)
         .address("127.0.0.1")
         .port(port)
@@ -149,6 +152,7 @@ pub async fn start_events_observer(
         rocket::custom(config)
             .manage(moved_rw_lock)
             .manage(moved_tx)
+            .manage(moved_node_tx)
             .mount(
                 "/",
                 routes![
@@ -212,6 +216,7 @@ pub async fn start_events_observer(
 pub fn handle_new_burn_block(
     devnet_events_tx: State<Arc<Mutex<Sender<DevnetEvent>>>>,
     new_burn_block: Json<NewBurnBlock>,
+    node_event_tx: State<Arc<Mutex<Option<Sender<NodeObserverEvent>>>>>,
 ) -> Json<Value> {
     let devnet_events_tx = devnet_events_tx.inner();
 
@@ -246,6 +251,7 @@ pub fn handle_new_block(
     config: State<Arc<RwLock<EventObserverConfig>>>,
     devnet_events_tx: State<Arc<Mutex<Sender<DevnetEvent>>>>,
     new_block: Json<NewBlock>,
+    node_event_tx: State<Arc<Mutex<Option<Sender<NodeObserverEvent>>>>>,
 ) -> Json<Value> {
     let devnet_events_tx = devnet_events_tx.inner();
     let config = config.inner();
@@ -469,6 +475,7 @@ pub fn handle_new_microblocks(
     config: State<Arc<RwLock<EventObserverConfig>>>,
     devnet_events_tx: State<Arc<Mutex<Sender<DevnetEvent>>>>,
     new_microblock: Json<NewMicroBlock>,
+    node_event_tx: State<Arc<Mutex<Option<Sender<NodeObserverEvent>>>>>,
 ) -> Json<Value> {
 
     let devnet_events_tx = devnet_events_tx.inner();
@@ -506,6 +513,7 @@ pub fn handle_new_microblocks(
 pub fn handle_new_mempool_tx(
     devnet_events_tx: State<Arc<Mutex<Sender<DevnetEvent>>>>,
     raw_txs: Json<Vec<String>>,
+    node_event_tx: State<Arc<Mutex<Option<Sender<NodeObserverEvent>>>>>,
 ) -> Json<Value> {
     let decoded_transactions = raw_txs.iter().map(|t| get_tx_description(t)).collect::<Vec<String>>();
 

src/integrate/events_observer.rs

@@ -2,10 +2,10 @@ mod events_observer;
 mod orchestrator;
 mod ui;
 
-use std::sync::mpsc::channel;
+use std::sync::mpsc::{Sender, channel};
 
 use chrono::prelude::*;
-use tracing;
+use tracing::{self, debug, info, warn, error};
 use tracing_appender;
 
 use crate::utils;
@@ -14,8 +14,11 @@ pub use orchestrator::DevnetOrchestrator;
 
 use self::events_observer::{EventObserverConfig};
 
-pub fn run_devnet(devnet: DevnetOrchestrator) {
-    match block_on(do_run_devnet(devnet)) {
+pub enum NodeObserverEvent {
+}
+
+pub fn run_devnet(devnet: DevnetOrchestrator, event_tx: Option<Sender<NodeObserverEvent>>, display_dashboard: bool) {
+    match block_on(do_run_devnet(devnet, event_tx, display_dashboard)) {
         Err(_e) => std::process::exit(1),
         _ => {}
     };
@@ -29,7 +32,7 @@ where
     rt.block_on(future)
 }
 
-pub async fn do_run_devnet(mut devnet: DevnetOrchestrator) -> Result<bool, String> {
+pub async fn do_run_devnet(mut devnet: DevnetOrchestrator, event_tx: Option<Sender<NodeObserverEvent>>, display_dashboard: bool) -> Result<bool, String> {
     let (devnet_events_tx, devnet_events_rx) = channel();
     let (termination_success_tx, orchestrator_terminated_rx) = channel();
 
@@ -59,13 +62,12 @@ pub async fn do_run_devnet(mut devnet: DevnetOrchestrator) -> Result<bool, Strin
     let events_observer_tx = devnet_events_tx.clone();
     let (events_observer_terminator_tx, terminator_rx) = channel();
     let events_observer_handle = std::thread::spawn(move || {
-        let future = start_events_observer(config, events_observer_tx, terminator_rx);
+        let future = start_events_observer(config, events_observer_tx, terminator_rx, event_tx);
         let rt = utils::create_basic_runtime();
         let _ = rt.block_on(future);
     });
 
     // Let's start the orchestration
-    println!("Starting Devnet...");
 
     // The devnet orchestrator should be able to send some events to the UI thread,
     // and should be able to be restarted/terminated
@@ -77,14 +79,43 @@ pub async fn do_run_devnet(mut devnet: DevnetOrchestrator) -> Result<bool, Strin
         rt.block_on(future);
     });
 
-    let _ = ui::start_ui(
-        devnet_events_tx,
-        devnet_events_rx,
-        events_observer_terminator_tx,
-        orchestrator_terminator_tx,
-        orchestrator_terminated_rx,
-        &devnet_path,
-    );
+    if display_dashboard {
+        info!("Starting Devnet...");
+        let _ = ui::start_ui(
+            devnet_events_tx,
+            devnet_events_rx,
+            events_observer_terminator_tx,
+            orchestrator_terminator_tx,
+            orchestrator_terminated_rx,
+            &devnet_path,
+        );    
+    } else {
+        println!("Starting Devnet...");
+
+        ctrlc::set_handler(move || {
+            events_observer_terminator_tx
+                .send(true)
+                .expect("Unable to terminate devnet");
+            orchestrator_terminator_tx
+                .send(true)
+                .expect("Unable to terminate devnet");
+        }).expect("Error setting Ctrl-C handler");
+    
+        loop {
+            match devnet_events_rx.recv() {
+                Ok(DevnetEvent::Log(ref log)) => {
+                    println!("{}", log.message);
+                    match log.level {
+                        LogLevel::Debug => debug!("{}", log.message),
+                        LogLevel::Info | LogLevel::Success => info!("{}", log.message),
+                        LogLevel::Warning => warn!("{}", log.message),
+                        LogLevel::Error => error!("{}", log.message),
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
 
     events_observer_handle.join().unwrap();
     orchestrator_handle.join().unwrap();