Rerun custom (space) view (#437)

Author: Rickvanderveen

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "re_control"
-version = "0.3.0"
+version = "0.4.0"
 
 authors.workspace = true
 categories.workspace = true
@@ -9,6 +9,7 @@ rust-version.workspace = true
 
 [dependencies]
 heimdall = { workspace = true }
+sindri = { workspace = true }
 
 clap = { workspace = true, features = ["derive"] }
 miette = { workspace = true }

tools/re_control/Cargo.toml

@@ -20,6 +20,7 @@ use super::protocol::{HandlerFn, RobotMessage, ViewerMessage};
 
 const LINGER_DURATION: Duration = Duration::from_secs(2);
 const CONNECTION_ATTEMPT_DELAY: Duration = Duration::from_secs(5);
+const CONNECTION_ATTEMPTS: usize = 3;
 
 pub struct ControlViewer {
     address: SocketAddrV4,
@@ -61,7 +62,7 @@ impl ControlViewer {
         let handle = app.clone();
 
         tokio::spawn(async move {
-            loop {
+            for attempt in 1..=CONNECTION_ATTEMPTS {
                 let socket = Socket::new(
                     Domain::for_address(app.address.into()),
                     Type::STREAM,
@@ -80,7 +81,13 @@ impl ControlViewer {
                         app.handle_connection(stream).await;
                     }
                     Err(error) => {
-                        tracing::error!(?error, "failed to connect to {}", app.address);
+                        tracing::debug!(
+                            ?error,
+                            "failed to connect to {}, attempt [{}/{}]",
+                            app.address,
+                            attempt,
+                            CONNECTION_ATTEMPTS
+                        );
                     }
                 }
 
@@ -93,7 +100,6 @@ impl ControlViewer {
     }
 
     async fn handle_connection(&self, socket: TcpStream) {
-        tracing::info!("connected with app: {}", self.address);
         let (read_half, write_half) = socket.split();
 
         // Spawn tasks to handle read and write
@@ -116,7 +122,7 @@ impl ControlViewer {
         // is completed.
         writer_task.abort();
 
-        tracing::warn!("connection termintaed with app: {}", self.address);
+        tracing::warn!("connection terminated with app: {}", self.address);
     }
 
     async fn global_message_handler(
@@ -133,7 +139,7 @@ impl ControlViewer {
             }
             notify.notify_one();
         }
-        tracing::info!("Global message channel closed");
+        tracing::debug!("Global message channel closed");
     }
 
     async fn handle_read(
@@ -223,6 +229,11 @@ pub struct ControlViewerHandle {
 }
 
 impl ControlViewerHandle {
+    #[must_use]
+    pub fn addr(&self) -> SocketAddrV4 {
+        self.app.address
+    }
+
     pub fn send(&self, msg: ViewerMessage) -> Result<()> {
         self.app.tx.unbounded_send(msg).into_diagnostic()
     }

tools/re_control/re_control_comms/src/viewer.rs

@@ -1,26 +1,21 @@
 use std::net::Ipv4Addr;
 
 use miette::{IntoDiagnostic, Result};
-use re_control_comms::viewer::ControlViewer;
-use re_viewer::{external::eframe, StartupOptions};
+use re_viewer::StartupOptions;
 
-use crate::control::Control;
+use crate::re_control_view::ControlView;
 
 // Rerun can collect analytics if the `analytics` feature is enabled in
 // `Cargo.toml`. This variable is used for the rerun analytics
 const APP_ENV: &str = "Control Wrapper";
 
 pub struct App {
     startup_options: StartupOptions,
-    viewer: ControlViewer,
 }
 
 impl App {
-    pub fn new(startup_options: StartupOptions, viewer: ControlViewer) -> Self {
-        App {
-            startup_options,
-            viewer,
-        }
+    pub fn new(startup_options: StartupOptions) -> Self {
+        App { startup_options }
     }
 
     pub async fn run(self, main_thread_token: re_viewer::MainThreadToken) -> Result<()> {
@@ -35,20 +30,9 @@ impl App {
         )
         .into_diagnostic()?;
 
-        let rerun_native_options = re_viewer::native::eframe_options(None);
-        let native_options = eframe::NativeOptions {
-            viewport: rerun_native_options
-                .viewport
-                .with_app_id("yggdrasil_control"),
-            ..rerun_native_options
-        };
-
-        eframe::run_native(
-            "Rerun",
-            native_options,
+        re_viewer::run_native_app(
+            main_thread_token,
             Box::new(move |cc| {
-                re_viewer::customize_eframe_and_setup_renderer(cc)?;
-
                 let mut app = re_viewer::App::new(
                     main_thread_token,
                     re_viewer::build_info(),
@@ -58,8 +42,13 @@ impl App {
                     cc.storage,
                 );
                 app.add_receiver(rx);
-                Ok(Box::new(Control::new(app, self.viewer)))
+
+                // Register the custom view class
+                app.add_view_class::<ControlView>().unwrap();
+
+                Box::new(app)
             }),
+            None,
         )
         .into_diagnostic()?;
 

tools/re_control/src/app.rs

@@ -5,7 +5,7 @@ use clap::Parser;
 #[derive(Parser, Debug)]
 pub struct Cli {
     /// Robot ip address
-    pub robot_ip: Ipv4Addr,
+    pub robot_ip: Option<Ipv4Addr>,
 
     /// Max allowed memory usage for rerun, absolute (e.g. "16GB") or relative
     /// (e.g. "50%")

tools/re_control/src/cli.rs

@@ -0,0 +1,32 @@
+use re_control_comms::viewer::ControlViewerHandle;
+use sindri::config::{ConfigRobot, Robot};
+
+pub struct ConnectionState {
+    pub handle: ControlViewerHandle,
+    pub selected_robot_config: ConfigRobot,
+    pub team_number: u8,
+    pub wired_connection: bool,
+    pub possible_robot_connections: Vec<ConfigRobot>,
+}
+
+impl ConnectionState {
+    pub fn from_handle(handle: ControlViewerHandle) -> Self {
+        let sindri_config = sindri::config::load_config().unwrap();
+
+        let robots = sindri_config.robots;
+
+        ConnectionState {
+            handle,
+            selected_robot_config: robots[0].clone(),
+            team_number: sindri_config.team_number,
+            wired_connection: false,
+            possible_robot_connections: robots,
+        }
+    }
+
+    pub fn robot_from_state(&self) -> Robot {
+        self.selected_robot_config
+            .clone()
+            .to_robot(self.team_number, self.wired_connection)
+    }
+}