Headless runner for console[CPP-318][CPP-313].

Makefile.toml

@@ -152,6 +152,10 @@ dependencies = [
 ]
 run_task = "start-console"
 
+[tasks.headless-run]
+command = "cargo"
+args = ["run", "--bin", "headless", "--no-default-features", "${@}"]
+
 [tasks.store-version]
 script_runner = "@shell"
 script = '''

console_backend/Cargo.toml

@@ -80,6 +80,11 @@ path = "src/bin/fft_monitor.rs"
 bench = false
 required-features = ["fft"]
 
+[[bin]]
+name = "headless"
+path = "src/bin/headless.rs"
+bench = false
+
 [features]
 default = ["pyo3"]
 benches = []

console_backend/benches/cpu_benches.rs

@@ -14,7 +14,8 @@ extern crate console_backend;
 use console_backend::{
     connection::Connection,
     process_messages,
-    types::{ClientSender, RealtimeDelay, SharedState},
+    shared_state::SharedState,
+    types::{ClientSender, RealtimeDelay},
 };
 
 const BENCH_FILEPATH: &str = "./tests/data/piksi-relay.sbp";

console_backend/src/advanced_ins_tab.rs

@@ -6,7 +6,8 @@ use capnp::message::Builder;
 use crate::constants::*;
 use crate::errors::GET_MUT_OBJECT_FAILURE;
 use crate::fusion_status_flags::FusionStatusFlags;
-use crate::types::{CapnProtoSender, Deque, SharedState};
+use crate::shared_state::SharedState;
+use crate::types::{CapnProtoSender, Deque};
 use crate::utils::serialize_capnproto_builder;
 
 /// AdvancedInsTab struct.

console_backend/src/advanced_magnetometer_tab.rs

@@ -4,7 +4,8 @@ use capnp::message::Builder;
 
 use crate::constants::{MAGNETOMETER_Y_AXIS_PADDING_MULTIPLIER, NUM_POINTS};
 use crate::errors::GET_MUT_OBJECT_FAILURE;
-use crate::types::{CapnProtoSender, Deque, SharedState};
+use crate::shared_state::SharedState;
+use crate::types::{CapnProtoSender, Deque};
 use crate::utils::serialize_capnproto_builder;
 
 /// AdvancedMagnetometerTab struct.

console_backend/src/advanced_spectrum_analyzer_tab.rs

@@ -3,7 +3,8 @@ use log::error;
 use crate::constants::{AMPLITUDES, CHANNELS, FREQUENCIES};
 use crate::errors::SHARED_STATE_LOCK_MUTEX_FAILURE;
 use crate::fft_monitor::FftMonitor;
-use crate::types::{CapnProtoSender, SharedState, Specan};
+use crate::shared_state::SharedState;
+use crate::types::{CapnProtoSender, Specan};
 use crate::utils::serialize_capnproto_builder;
 use capnp::message::Builder;
 

console_backend/src/baseline_tab.rs

@@ -12,9 +12,9 @@ use crate::constants::*;
 use crate::date_conv::*;
 use crate::output::BaselineLog;
 use crate::piksi_tools_constants::EMPTY_STR;
+use crate::shared_state::SharedState;
 use crate::types::{
-    BaselineNED, CapnProtoSender, Deque, GnssModes, GpsTime, MsgSender, Result, SharedState,
-    UtcDateTime,
+    BaselineNED, CapnProtoSender, Deque, GnssModes, GpsTime, MsgSender, Result, UtcDateTime,
 };
 use crate::utils::*;
 

console_backend/src/bin/headless.rs

@@ -0,0 +1,41 @@
+use console_backend::{
+    cli_options::{handle_cli, CliOptions},
+    connection::ConnectionState,
+    log_panel::setup_logging,
+    shared_state::{backend_recv_thread, SharedState},
+    types::{ClientSender, Result},
+    utils::{refresh_loggingbar, refresh_navbar},
+};
+use crossbeam::{channel, scope};
+fn main() -> Result<()> {
+    scope(|s| {
+        let (client_send_, client_recv) = channel::unbounded::<Vec<u8>>();
+        let (_server_send, server_recv) = channel::unbounded::<Vec<u8>>();
+        let client_send = ClientSender::new(client_send_);
+        setup_logging(client_send.clone(), true);
+        let opt = CliOptions::from_filtered_cli();
+        let shared_state = SharedState::new();
+        let connection_state = ConnectionState::new(client_send.clone(), shared_state.clone());
+        if opt.input.is_none() {
+            eprintln!("\nRunning in headless mode only command line options work.");
+            eprintln!("Help:");
+            eprintln!("\tcargo make headless-run -- --help");
+            eprintln!("Usage:");
+            eprintln!("\tcargo make headless-run -- tcp piksi-relay-bb9f2b10e53143f4a816a11884e679cf.ce.swiftnav.com --port=55555\n");
+        } else {
+            handle_cli(opt, &connection_state, shared_state.clone());
+            refresh_navbar(&mut client_send.clone(), shared_state.clone());
+            refresh_loggingbar(&mut client_send.clone(), shared_state.clone());
+            backend_recv_thread(connection_state, client_send, server_recv, shared_state);
+            s.spawn(move |_| {
+                loop {
+                    if client_recv.recv().is_err() {
+                        break;
+                    }
+                }
+            })
+            .join().unwrap();
+        }
+    }).unwrap();
+    Ok(())
+}

console_backend/src/cli_options.rs

@@ -7,11 +7,14 @@ use std::{
 use strum::VariantNames;
 
 use crate::constants::{AVAILABLE_BAUDRATES, AVAILABLE_REFRESH_RATES};
+use crate::errors::{CONVERT_TO_STR_FAILURE, SHARED_STATE_LOCK_MUTEX_FAILURE};
 use crate::log_panel::LogLevel;
-use crate::types::FlowControl;
+use crate::output::CsvLogging;
+use crate::shared_state::SharedState;
+use crate::types::{FlowControl, RealtimeDelay};
 use crate::{
     common_constants::{SbpLogging, Tabs},
-    connection::Connection,
+    connection::{Connection, ConnectionState},
 };
 
 #[derive(Debug)]
@@ -233,3 +236,48 @@ fn is_baudrate(br: &str) -> Result<(), String> {
         AVAILABLE_BAUDRATES
     ))
 }
+
+/// Start connections based on CLI options.
+///
+/// # Parameters
+/// - `opt`: CLI Options to start specific connection type.
+/// - `connection_state`: The Server state to start a specific connection.
+/// - `client_send`: Client Sender channel for communication from backend to frontend.
+/// - `shared_state`: The shared state for validating another connection is not already running.
+pub fn handle_cli(opt: CliOptions, connection_state: &ConnectionState, shared_state: SharedState) {
+    if let Some(opt_input) = opt.input {
+        match opt_input {
+            Input::Tcp { host, port } => {
+                connection_state.connect_to_host(host, port);
+            }
+            Input::File { file_in } => {
+                let filename = file_in.display().to_string();
+                connection_state.connect_to_file(filename, RealtimeDelay::On, opt.exit_after);
+            }
+            Input::Serial {
+                serialport,
+                baudrate,
+                flow_control,
+            } => {
+                let serialport = serialport.display().to_string();
+                connection_state.connect_to_serial(serialport, baudrate, flow_control);
+            }
+        }
+    }
+    if let Some(folder) = opt.dirname {
+        shared_state.set_logging_directory(PathBuf::from(folder));
+    }
+    let log_level = if let Some(log_level_) = opt.log_level {
+        (*log_level_).clone()
+    } else {
+        LogLevel::INFO
+    };
+    shared_state.set_log_level(log_level);
+    let mut shared_data = shared_state.lock().expect(SHARED_STATE_LOCK_MUTEX_FAILURE);
+    (*shared_data).logging_bar.csv_logging = CsvLogging::from(opt.csv_log);
+    if let Some(sbp_log) = opt.sbp_log {
+        (*shared_data).logging_bar.sbp_logging =
+            SbpLogging::from_str(&sbp_log.to_string()).expect(CONVERT_TO_STR_FAILURE);
+    }
+    log::logger().flush();
+}

console_backend/src/connection.rs

@@ -1,6 +1,7 @@
 use crate::constants::*;
 use crate::errors::*;
 use crate::process_messages::process_messages;
+use crate::shared_state::SharedState;
 use crate::types::*;
 use anyhow::anyhow;
 use crossbeam::channel::{unbounded, Receiver, Sender};

console_backend/src/fusion_status_flags.rs

@@ -14,8 +14,8 @@ use crate::errors::{
     THREAD_JOIN_FAILURE, UNABLE_TO_SEND_INS_UPDATE_FAILURE, UNABLE_TO_STOP_TIMER_THREAD_FAILURE,
     UPDATE_STATUS_LOCK_MUTEX_FAILURE,
 };
-use crate::types::ArcBool;
-use crate::types::{CapnProtoSender, SharedState};
+use crate::shared_state::SharedState;
+use crate::types::{ArcBool, CapnProtoSender};
 use crate::utils::serialize_capnproto_builder;
 
 const STATUS_PERIOD: f64 = 1.0;

console_backend/src/lib.rs

@@ -26,6 +26,7 @@ pub mod process_messages;
 #[cfg(all(not(feature = "benches"), not(feature = "tests"), feature = "pyo3"))]
 pub mod server;
 pub mod settings_tab;
+pub mod shared_state;
 pub mod solution_tab;
 pub mod solution_velocity_tab;
 pub mod status_bar;
@@ -62,7 +63,7 @@ struct Tabs<'link, S: types::CapnProtoSender> {
 
 impl<'link, S: types::CapnProtoSender> Tabs<'link, S> {
     fn new(
-        shared_state: types::SharedState,
+        shared_state: shared_state::SharedState,
         client_sender: S,
         msg_sender: types::MsgSender,
         link: sbp::link::Link<'link, ()>,

console_backend/src/log_panel.rs

@@ -6,7 +6,7 @@ use capnp::message::Builder;
 use crate::common_constants as cc;
 use crate::constants::LOG_WRITER_BUFFER_MESSAGE_COUNT;
 use crate::errors::CONSOLE_LOG_JSON_TO_STRING_FAILURE;
-use crate::types::*;
+use crate::types::{CapnProtoSender, ClientSender};
 use crate::utils::serialize_capnproto_builder;
 
 use async_logger::Writer;
@@ -96,8 +96,8 @@ pub fn handle_log_msg(msg: MsgLog) {
     }
 }
 
-pub fn setup_logging(client_sender: ClientSender) {
-    let log_panel = LogPanelWriter::new(client_sender);
+pub fn setup_logging(client_sender: ClientSender, debug: bool) {
+    let log_panel = LogPanelWriter::new(client_sender, debug);
     let logger = Logger::builder()
         .buf_size(LOG_WRITER_BUFFER_MESSAGE_COUNT)
         .formatter(splitable_log_formatter)
@@ -111,11 +111,15 @@ pub fn setup_logging(client_sender: ClientSender) {
 #[derive(Debug)]
 pub struct LogPanelWriter<S: CapnProtoSender> {
     pub client_sender: S,
+    pub debug: bool,
 }
 
 impl<S: CapnProtoSender> LogPanelWriter<S> {
-    pub fn new(client_sender: S) -> LogPanelWriter<S> {
-        LogPanelWriter { client_sender }
+    pub fn new(client_sender: S, debug: bool) -> LogPanelWriter<S> {
+        LogPanelWriter {
+            client_sender,
+            debug,
+        }
     }
 }
 
@@ -132,6 +136,9 @@ impl<S: CapnProtoSender> Writer<Box<String>> for LogPanelWriter<S> {
         let mut entries = log_update.init_entries(slice.len() as u32);
 
         for (idx, item) in slice.iter().enumerate() {
+            if self.debug {
+                println!("{}", item);
+            }
             let mut entry = entries.reborrow().get(idx as u32);
 
             entry.set_line(&**item);

console_backend/src/main_tab.rs

@@ -5,9 +5,13 @@ use log::{debug, error};
 use sbp::{messages::SBP, time::GpsTime};
 
 use crate::common_constants::SbpLogging;
-use crate::constants::*;
-use crate::output::*;
-use crate::types::*;
+use crate::constants::{
+    BASELINE_TIME_STR_FILEPATH, POS_LLH_TIME_STR_FILEPATH, SBP_FILEPATH, SBP_JSON_FILEPATH,
+    VEL_TIME_STR_FILEPATH,
+};
+use crate::output::{CsvLogging, SbpLogger};
+use crate::shared_state::{create_directory, SharedState};
+use crate::types::CapnProtoSender;
 use crate::utils::refresh_loggingbar;
 
 pub struct MainTab<S: CapnProtoSender> {
@@ -191,7 +195,7 @@ mod tests {
     use super::*;
     use crate::baseline_tab::BaselineTab;
     use crate::solution_tab::SolutionTab;
-    use crate::types::{PosLLH, VelNED};
+    use crate::types::{BaselineNED, MsgSender, PosLLH, TestSender, VelNED};
     use crate::utils::{mm_to_m, ms_to_sec};
     use glob::glob;
     use sbp::messages::navigation::{MsgBaselineNED, MsgPosLLH, MsgVelNED};

console_backend/src/observation_tab.rs

@@ -3,7 +3,8 @@ use capnp::message::Builder;
 use log::warn;
 use std::collections::{BTreeMap, HashMap};
 
-use crate::types::*;
+use crate::shared_state::SharedState;
+use crate::types::{CapnProtoSender, ObservationMsg, SignalCodes};
 use crate::utils::{compute_doppler, sec_to_ns};
 
 use crate::utils::serialize_capnproto_builder;

console_backend/src/process_messages.rs

@@ -24,7 +24,11 @@ use crate::connection::Connection;
 use crate::constants::PAUSE_LOOP_SLEEP_DURATION_MS;
 use crate::errors::UNABLE_TO_CLONE_UPDATE_SHARED;
 use crate::log_panel::handle_log_msg;
-use crate::types::*;
+use crate::shared_state::SharedState;
+use crate::types::{
+    BaselineNED, CapnProtoSender, Dops, GpsTime, MsgSender, ObservationMsg, PosLLH, RealtimeDelay,
+    Result, Specan, VelNED,
+};
 use crate::update_tab;
 use crate::utils::{close_frontend, refresh_navbar};
 use crate::Tabs;