Fix reconnect bug on bad connection, add bad conn popup[CPP-520] (#310)

Add a popup to connection dialog if unable to connect to deviceCPP-520, popup has a 7000ms delay to debounce.
Fix an issue where process messages loop would close normally without error and valid reconnect would not fire.
Made an attempt at syncing backend and frontend interpretation of connection state. 
Adds functionality to catch "Carriage Return" when viewing the connection dialog and trigger Connect/Disconnect.

Author: john-michaelburke

console_backend/src/common_constants.rs

@@ -287,6 +287,8 @@ pub enum Keys {
     RECORDING_FILENAME,
     #[strum(serialize = "CONSOLE_VERSION")]
     CONSOLE_VERSION,
+    #[strum(serialize = "CONNECTION_MESSAGE")]
+    CONNECTION_MESSAGE,
 }
 
 #[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
@@ -297,6 +299,8 @@ pub enum ConnectionState {
     CONNECTED,
     #[strum(serialize = "DISCONNECTED")]
     DISCONNECTED,
+    #[strum(serialize = "CONNECTING")]
+    CONNECTING,
 }
 
 #[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]

console_backend/src/connection.rs

@@ -19,7 +19,7 @@ use crate::process_messages::{process_messages, Messages};
 use crate::shared_state::{ConnectionState, SharedState};
 use crate::status_bar::StatusBar;
 use crate::types::*;
-use crate::utils::{refresh_connection_frontend, refresh_loggingbar};
+use crate::utils::{refresh_connection_frontend, refresh_loggingbar, send_conn_notification};
 use crate::watch::Watched;
 
 #[derive(Debug)]
@@ -115,13 +115,36 @@ fn conn_manager_thd(
         while let Ok(msg) = recv.wait() {
             match msg {
                 ConnectionManagerMsg::Connect(conn) => {
+                    shared_state.set_connection(ConnectionState::Connecting, &client_sender);
                     let (reader, writer) = match conn.try_connect(Some(&shared_state)) {
                         Ok(rw) => rw,
                         Err(e) => {
-                            error!("Unable to connect: {}", e);
+                            let (reconnect, message) = match e.kind() {
+                                ErrorKind::ConnectionRefused => {
+                                    (true, String::from("Connection refused. Reconnecting..."))
+                                }
+                                ErrorKind::ConnectionReset => {
+                                    (true, String::from("Connection reset. Reconnecting..."))
+                                }
+                                ErrorKind::TimedOut => {
+                                    (true, String::from("Connection timed out. Reconnecting..."))
+                                }
+                                ErrorKind::NotConnected => {
+                                    (true, String::from("Not connected. Reconnecting..."))
+                                }
+                                _ => (false, format!("Unable to connect: {}", e)),
+                            };
+                            error!("{}", message);
                             log::logger().flush();
-                            if conn.is_tcp() {
-                                manager_msg.send(ConnectionManagerMsg::Reconnect(conn))
+                            send_conn_notification(&client_sender, message.clone());
+                            if !conn.is_file() {
+                                if reconnect {
+                                    manager_msg.send(ConnectionManagerMsg::Reconnect(conn))
+                                } else {
+                                    manager_msg.send(ConnectionManagerMsg::Disconnect)
+                                }
+                            } else {
+                                manager_msg.send(ConnectionManagerMsg::Disconnect)
                             }
                             continue;
                         }
@@ -151,6 +174,7 @@ fn conn_manager_thd(
                 }
                 ConnectionManagerMsg::Reconnect(conn) => {
                     join(&mut reconnect_thd);
+                    shared_state.set_connection(ConnectionState::Connecting, &client_sender);
                     reconnect_thd = Some(start_reconnect_thd(conn, manager_msg.clone()));
                 }
                 ConnectionManagerMsg::Disconnect => {
@@ -161,6 +185,7 @@ fn conn_manager_thd(
                     }
                     refresh_loggingbar(&client_sender, &shared_state);
                     shared_state.set_connection(ConnectionState::Disconnected, &client_sender);
+                    refresh_connection_frontend(&client_sender, &shared_state);
                     join(&mut pm_thd);
                     info!("Disconnected successfully.");
                 }
@@ -203,16 +228,20 @@ fn process_messages_thd(
             messages,
             msg_sender,
             conn.clone(),
-            shared_state,
+            shared_state.clone(),
             client_sender,
         );
-        if conn.close_when_done() {
-            manager_msg.close();
-        }
-        if let Err(e) = res {
-            error!("Connection error: {}", e);
-            if conn.is_tcp() {
-                manager_msg.send(ConnectionManagerMsg::Reconnect(conn))
+        if conn.is_file() {
+            manager_msg.send(ConnectionManagerMsg::Disconnect);
+            if conn.close_when_done() {
+                manager_msg.close();
+            }
+        } else {
+            if let Err(e) = res {
+                error!("Connection error: {}", e);
+            }
+            if !matches!(shared_state.connection(), ConnectionState::Disconnected) {
+                manager_msg.send(ConnectionManagerMsg::Reconnect(conn));
             }
         }
     })
@@ -269,6 +298,10 @@ impl Connection {
         matches!(self, Connection::Tcp(_) | Connection::Serial(_))
     }
 
+    pub fn is_file(&self) -> bool {
+        matches!(self, Connection::File(_))
+    }
+
     pub fn is_serial(&self) -> bool {
         matches!(self, Connection::Serial(_))
     }

console_backend/src/shared_state.rs

@@ -844,6 +844,9 @@ pub enum ConnectionState {
         conn: Connection,
         stop_token: StopToken,
     },
+
+    /// Attempting to connect
+    Connecting,
 }
 
 impl ConnectionState {
@@ -859,10 +862,15 @@ impl ConnectionState {
         matches!(self, Self::Connected { .. })
     }
 
+    pub fn is_connecting(&self) -> bool {
+        matches!(self, Self::Connecting)
+    }
+
     pub fn name(&self) -> String {
         match self {
             ConnectionState::Closed => "closed".into(),
             ConnectionState::Disconnected => "disconnected".into(),
+            ConnectionState::Connecting => "connecting".into(),
             ConnectionState::Connected { conn, .. } => conn.name(),
         }
     }
@@ -873,6 +881,7 @@ impl std::fmt::Display for ConnectionState {
         match self {
             ConnectionState::Closed => write!(f, "{}", cc::ConnectionState::CLOSED),
             ConnectionState::Disconnected => write!(f, "{}", cc::ConnectionState::DISCONNECTED),
+            ConnectionState::Connecting => write!(f, "{}", cc::ConnectionState::CONNECTING),
             ConnectionState::Connected { .. } => {
                 write!(f, "{}", cc::ConnectionState::CONNECTED)
             }

console_backend/src/utils.rs

@@ -23,6 +23,15 @@ pub fn fixed_sbp_string<T, const L: usize>(data: &str) -> SbpString<[u8; L], T>
     SbpString::new(arr)
 }
 
+/// Notify the frontend of a Connection notification.
+pub fn send_conn_notification(client_sender: &BoxedClientSender, message: String) {
+    let mut builder = Builder::new_default();
+    let msg = builder.init_root::<crate::console_backend_capnp::message::Builder>();
+    let mut status = msg.init_connection_notification();
+    status.set_message(&message);
+    client_sender.send_data(serialize_capnproto_builder(builder));
+}
+
 /// Notify the frontend of an [ConnectionState] change.
 pub fn send_conn_state(app_state: ConnectionState, client_sender: &BoxedClientSender) {
     let mut builder = Builder::new_default();