Fix lints

oxkitsune · oxkitsune · commit 44f40f2a9607 · 2024-12-02T18:52:47.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
@@ -1729,6 +1729,7 @@ dependencies = [
  "bincode",
  "mimalloc",
  "re_crash_handler",
+ "re_error",
  "re_log",
  "re_sdk_comms",
  "re_viewer",
diff --git a/examples/rust/custom_callback/Cargo.toml b/examples/rust/custom_callback/Cargo.toml
@@ -27,6 +27,7 @@ re_sdk_comms = { path = "../../../crates/store/re_sdk_comms", features = [
 ] }
 re_viewer = { path = "../../../crates/viewer/re_viewer", default-features = false }
 re_log = { path = "../../../crates/utils/re_log" }
+re_error = { path = "../../../crates/utils/re_error" }
 rerun = { path = "../../../crates/top/rerun" }
 
 bincode = "1.3.3"
diff --git a/examples/rust/custom_callback/src/app.rs b/examples/rust/custom_callback/src/app.rs
@@ -14,10 +14,11 @@ use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut app = ControlApp::bind("127.0.0.1:8888").await?.run();
-    let rec = rerun::RecordingStreamBuilder::new("rerun_control_panel_example").connect_tcp_opts(
-        "127.0.0.1:9877".to_socket_addrs().unwrap().next().unwrap(),
-        None,
-    )?;
+    let rec = rerun::RecordingStreamBuilder::new("rerun_example_custom_callback")
+        .connect_tcp_opts(
+            "127.0.0.1:9877".to_socket_addrs().unwrap().next().unwrap(),
+            None,
+        )?;
 
     // Add a handler for incoming messages
     let add_rec = rec.clone();
diff --git a/examples/rust/custom_callback/src/comms/app.rs b/examples/rust/custom_callback/src/comms/app.rs
@@ -70,8 +70,11 @@ impl ControlApp {
                             app.handle_connection(socket).await;
                         });
                     }
-                    Err(e) => {
-                        re_log::error!("Error accepting connection: {:?}", e);
+                    Err(err) => {
+                        re_log::error!(
+                            "Error accepting connection: {}",
+                            re_error::format_ref(&err)
+                        );
                     }
                 }
             }
@@ -120,12 +123,15 @@ impl ControlApp {
                             handler(&message);
                         }
                     }
-                    Err(e) => {
-                        re_log::error!("Failed to decode message: {:?}", e);
+                    Err(err) => {
+                        re_log::error!("Failed to decode message: {}", re_error::format_ref(&err));
                     }
                 },
-                Err(e) => {
-                    re_log::error!("Error reading from socket: {:?}", e);
+                Err(err) => {
+                    re_log::error!(
+                        "Error reading from socket: {:?}",
+                        re_error::format_ref(&err),
+                    );
                     break;
                 }
             }
diff --git a/examples/rust/custom_callback/src/comms/protocol.rs b/examples/rust/custom_callback/src/comms/protocol.rs
@@ -23,14 +23,15 @@ pub enum Message {
 
 impl Message {
     pub fn encode(&self) -> io::Result<Vec<u8>> {
-        bincode::serialize(self).map_err(|e| io::Error::new(ErrorKind::InvalidData, e))
+        bincode::serialize(self).map_err(|err| io::Error::new(ErrorKind::InvalidData, err))
     }
 
     pub fn encode_into(&self, buffer: &mut [u8]) -> io::Result<()> {
-        bincode::serialize_into(buffer, self).map_err(|e| io::Error::new(ErrorKind::InvalidData, e))
+        bincode::serialize_into(buffer, self)
+            .map_err(|err| io::Error::new(ErrorKind::InvalidData, err))
     }
 
     pub fn decode(data: &[u8]) -> io::Result<Self> {
-        bincode::deserialize(data).map_err(|e| io::Error::new(ErrorKind::InvalidData, e))
+        bincode::deserialize(data).map_err(|err| io::Error::new(ErrorKind::InvalidData, err))
     }
 }
diff --git a/examples/rust/custom_callback/src/comms/viewer.rs b/examples/rust/custom_callback/src/comms/viewer.rs
@@ -62,8 +62,11 @@ impl ControlViewer {
         loop {
             match TcpStream::connect(self.address.clone()).await {
                 Ok(socket) => {
-                    if let Err(e) = socket.set_linger(Some(Duration::from_secs(2))) {
-                        re_log::error!("Failed to set socket linger: {:?}", e);
+                    if let Err(err) = socket.set_linger(Some(Duration::from_secs(2))) {
+                        re_log::error!(
+                            "Failed to set socket linger: {}",
+                            re_error::format_ref(&err)
+                        );
                     }
 
                     re_log::info!("Connected to {}", self.address);
@@ -82,21 +85,25 @@ impl ControlViewer {
                     // Wait for tasks to complete
                     tokio::select! {
                         result = reader_task => {
-                            if let Err(e) = result {
-                                re_log::error!("Reader task ended with error: {:?}", e);
+                            if let Err(err) = result {
+                                re_log::error!("Reader task ended with error: {}", re_error::format_ref(&err));
                             }
                         }
                         result = writer_task => {
-                            if let Err(e) = result {
-                                re_log::error!("Writer task ended with error: {:?}", e);
+                            if let Err(err) = result {
+                                re_log::error!("Writer task ended with error: {}", re_error::format_ref(&err));
                             }
                         }
                     }
 
                     re_log::info!("Connection lost. Attempting to reconnect...");
                 }
-                Err(e) => {
-                    re_log::error!("Failed to connect to {}: {:?}", self.address, e);
+                Err(err) => {
+                    re_log::error!(
+                        "Failed to connect to {}: {}",
+                        self.address,
+                        re_error::format_ref(&err)
+                    );
                 }
             }
 
@@ -134,12 +141,18 @@ impl ControlViewer {
                         // we received a message from the server, we can process it here if needed
                         re_log::info!("Received message from server: {:?}", message);
                     }
-                    Err(e) => {
-                        re_log::error!("Failed to decode message: {:?}", e);
+                    Err(err) => {
+                        re_log::error!(
+                            "Failed to decode message: {:?}",
+                            re_error::format_ref(&err)
+                        );
                     }
                 },
-                Err(e) => {
-                    re_log::error!("Error reading from server: {:?}", e);
+                Err(err) => {
+                    re_log::error!(
+                        "Error reading from server: {:?}",
+                        re_error::format_ref(&err)
+                    );
                     break;
                 }
             }
@@ -166,11 +179,10 @@ impl ControlViewer {
                     }
                     _ => {
                         if let Ok(data) = message.encode() {
-                            if let Err(e) = write.write_all(&data).await {
-                                re_log::info!(
-                                    "Failed to send message: {:?}, error: {:?}",
-                                    message,
-                                    e
+                            if let Err(err) = write.write_all(&data).await {
+                                re_log::error!(
+                                    "Failed to send message error: {}",
+                                    re_error::format_ref(&err)
                                 );
                                 break;
                             }
diff --git a/examples/rust/custom_callback/src/panel.rs b/examples/rust/custom_callback/src/panel.rs
@@ -1,13 +1,13 @@
 use std::time::Instant;
 
+use crate::comms::{protocol::Message, viewer::ControlViewerHandle};
 use re_log::ResultExt;
 use re_viewer::external::{
     eframe,
     egui::{self, ScrollArea},
     re_ui::{list_item, UiExt},
 };
 
-use crate::comms::{protocol::Message, viewer::ControlViewerHandle};
 #[derive(Default)]
 pub struct ControlStates {
     pub last_resource_update: Option<Instant>,

Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,11 @@ impl ControlApp {`
`70`	`70`	`app.handle_connection(socket).await;`
`71`	`71`	`});`
`72`	`72`	`}`
`73`		`- Err(e) => {`
`74`		`- re_log::error!("Error accepting connection: {:?}", e);`
	`73`	`+ Err(err) => {`
	`74`	`+ re_log::error!(`
	`75`	`+ "Error accepting connection: {}",`
	`76`	`+ re_error::format_ref(&err)`
	`77`	`+ );`
`75`	`78`	`}`
`76`	`79`	`}`
`77`	`80`	`}`
`@@ -120,12 +123,15 @@ impl ControlApp {`
`120`	`123`	`handler(&message);`
`121`	`124`	`}`
`122`	`125`	`}`
`123`		`- Err(e) => {`
`124`		`- re_log::error!("Failed to decode message: {:?}", e);`
	`126`	`+ Err(err) => {`
	`127`	`+ re_log::error!("Failed to decode message: {}", re_error::format_ref(&err));`
`125`	`128`	`}`
`126`	`129`	`},`
`127`		`- Err(e) => {`
`128`		`- re_log::error!("Error reading from socket: {:?}", e);`
	`130`	`+ Err(err) => {`
	`131`	`+ re_log::error!(`
	`132`	`+ "Error reading from socket: {:?}",`
	`133`	`+ re_error::format_ref(&err),`
	`134`	`+ );`
`129`	`135`	`break;`
`130`	`136`	`}`
`131`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,14 +23,15 @@ pub enum Message {`
`23`	`23`
`24`	`24`	`impl Message {`
`25`	`25`	`pub fn encode(&self) -> io::Result<Vec<u8>> {`
`26`		`- bincode::serialize(self).map_err(\|e\| io::Error::new(ErrorKind::InvalidData, e))`
	`26`	`+ bincode::serialize(self).map_err(\|err\| io::Error::new(ErrorKind::InvalidData, err))`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`pub fn encode_into(&self, buffer: &mut [u8]) -> io::Result<()> {`
`30`		`- bincode::serialize_into(buffer, self).map_err(\|e\| io::Error::new(ErrorKind::InvalidData, e))`
	`30`	`+ bincode::serialize_into(buffer, self)`
	`31`	`+ .map_err(\|err\| io::Error::new(ErrorKind::InvalidData, err))`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`pub fn decode(data: &[u8]) -> io::Result<Self> {`
`34`		`- bincode::deserialize(data).map_err(\|e\| io::Error::new(ErrorKind::InvalidData, e))`
	`35`	`+ bincode::deserialize(data).map_err(\|err\| io::Error::new(ErrorKind::InvalidData, err))`
`35`	`36`	`}`
`36`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,11 @@ impl ControlViewer {`
`62`	`62`	`loop {`
`63`	`63`	`match TcpStream::connect(self.address.clone()).await {`
`64`	`64`	`Ok(socket) => {`
`65`		`- if let Err(e) = socket.set_linger(Some(Duration::from_secs(2))) {`
`66`		`- re_log::error!("Failed to set socket linger: {:?}", e);`
	`65`	`+ if let Err(err) = socket.set_linger(Some(Duration::from_secs(2))) {`
	`66`	`+ re_log::error!(`
	`67`	`+ "Failed to set socket linger: {}",`
	`68`	`+ re_error::format_ref(&err)`
	`69`	`+ );`
`67`	`70`	`}`
`68`	`71`
`69`	`72`	`re_log::info!("Connected to {}", self.address);`
`@@ -82,21 +85,25 @@ impl ControlViewer {`
`82`	`85`	`// Wait for tasks to complete`
`83`	`86`	`tokio::select! {`
`84`	`87`	`result = reader_task => {`
`85`		`- if let Err(e) = result {`
`86`		`- re_log::error!("Reader task ended with error: {:?}", e);`
	`88`	`+ if let Err(err) = result {`
	`89`	`+ re_log::error!("Reader task ended with error: {}", re_error::format_ref(&err));`
`87`	`90`	`}`
`88`	`91`	`}`
`89`	`92`	`result = writer_task => {`
`90`		`- if let Err(e) = result {`
`91`		`- re_log::error!("Writer task ended with error: {:?}", e);`
	`93`	`+ if let Err(err) = result {`
	`94`	`+ re_log::error!("Writer task ended with error: {}", re_error::format_ref(&err));`
`92`	`95`	`}`
`93`	`96`	`}`
`94`	`97`	`}`
`95`	`98`
`96`	`99`	`re_log::info!("Connection lost. Attempting to reconnect...");`
`97`	`100`	`}`
`98`		`- Err(e) => {`
`99`		`- re_log::error!("Failed to connect to {}: {:?}", self.address, e);`
	`101`	`+ Err(err) => {`
	`102`	`+ re_log::error!(`
	`103`	`+ "Failed to connect to {}: {}",`
	`104`	`+ self.address,`
	`105`	`+ re_error::format_ref(&err)`
	`106`	`+ );`
`100`	`107`	`}`
`101`	`108`	`}`
`102`	`109`
`@@ -134,12 +141,18 @@ impl ControlViewer {`
`134`	`141`	`// we received a message from the server, we can process it here if needed`
`135`	`142`	`re_log::info!("Received message from server: {:?}", message);`
`136`	`143`	`}`
`137`		`- Err(e) => {`
`138`		`- re_log::error!("Failed to decode message: {:?}", e);`
	`144`	`+ Err(err) => {`
	`145`	`+ re_log::error!(`
	`146`	`+ "Failed to decode message: {:?}",`
	`147`	`+ re_error::format_ref(&err)`
	`148`	`+ );`
`139`	`149`	`}`
`140`	`150`	`},`
`141`		`- Err(e) => {`
`142`		`- re_log::error!("Error reading from server: {:?}", e);`
	`151`	`+ Err(err) => {`
	`152`	`+ re_log::error!(`
	`153`	`+ "Error reading from server: {:?}",`
	`154`	`+ re_error::format_ref(&err)`
	`155`	`+ );`
`143`	`156`	`break;`
`144`	`157`	`}`
`145`	`158`	`}`
`@@ -166,11 +179,10 @@ impl ControlViewer {`
`166`	`179`	`}`
`167`	`180`	`_ => {`
`168`	`181`	`if let Ok(data) = message.encode() {`
`169`		`- if let Err(e) = write.write_all(&data).await {`
`170`		`- re_log::info!(`
`171`		`- "Failed to send message: {:?}, error: {:?}",`
`172`		`- message,`
`173`		`- e`
	`182`	`+ if let Err(err) = write.write_all(&data).await {`
	`183`	`+ re_log::error!(`
	`184`	`+ "Failed to send message error: {}",`
	`185`	`+ re_error::format_ref(&err)`
`174`	`186`	`);`
`175`	`187`	`break;`
`176`	`188`	`}`