chore(shell): migrate to using Error

Author: grampelberg

README.md

@@ -270,4 +270,3 @@ the design decisions section for an explanation of what's happening there.
 - Is there a way to do FPS on a per-session basis with prometheus? Naively the
   way to do it would be to have a per-session label value, but that would be
   crazy for cardinality.
-- Update shell to use the same error widget + handling that tabs are.

src/resources/pod.rs

@@ -1,7 +1,6 @@
 use std::{borrow::Borrow, cmp::Ordering, error::Error, fmt::Display, sync::Arc};
 
 use chrono::{TimeDelta, Utc};
-use itertools::Itertools;
 use k8s_openapi::{
     api::core::v1::{
         ContainerState, ContainerStateTerminated, ContainerStateWaiting, ContainerStatus, Pod,
@@ -28,28 +27,27 @@ use crate::widget::{
 // TODO: There's probably a better debug implementation than this.
 #[derive(Clone, Debug)]
 pub struct StatusError {
-    inner: v1::Status,
+    pub message: String,
 }
 
+// Because this is a golang error that's being returned, there's really no good
+// way to convert this into something that is moderately usable. The rest of the
+// `Status` struct is empty of anything useful. The decision is to be naive here
+// and let other display handlers figure out if they would like to deal with the
+// message.
 impl StatusError {
     pub fn new(inner: v1::Status) -> Self {
-        Self { inner }
+        Self {
+            message: inner.message.unwrap_or("unknown status".to_string()),
+        }
     }
 }
 
 impl Error for StatusError {}
 
 impl Display for StatusError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let lines = self
-            .inner
-            .message
-            .as_ref()
-            .map_or(format!("{:#?}", self.inner), |msg| {
-                msg.split(':').map(str::trim).join("\n")
-            });
-
-        write!(f, "{lines}")
+        write!(f, "{}", self.message)
     }
 }
 

src/widget.rs

@@ -1,5 +1,6 @@
 pub mod apex;
 pub mod debug;
+pub mod error;
 pub mod input;
 pub mod loading;
 pub mod log;

src/widget/error.rs

@@ -0,0 +1,81 @@
+use eyre::{Report, Result};
+use ratatui::{
+    layout::Rect,
+    prelude::*,
+    style::Style,
+    widgets::{Block, Borders, Paragraph},
+    Frame,
+};
+
+use super::Widget;
+use crate::events::{Broadcast, Event, Keypress};
+
+pub struct Error {
+    inner: Report,
+
+    position: (u16, u16),
+}
+
+impl Error {
+    pub fn new(inner: Report) -> Self {
+        Self {
+            inner,
+            position: (0, 0),
+        }
+    }
+}
+
+impl Widget for Error {
+    fn dispatch(&mut self, event: &Event) -> Result<Broadcast> {
+        match event.key() {
+            Some(Keypress::CursorLeft) => {
+                self.position.1 = self.position.1.saturating_sub(1);
+            }
+            Some(Keypress::CursorRight) => {
+                self.position.1 = self.position.1.saturating_add(1);
+            }
+            Some(Keypress::CursorUp) => {
+                self.position.0 = self.position.0.saturating_sub(1);
+            }
+            Some(Keypress::CursorDown) => {
+                self.position.0 = self.position.0.saturating_add(1);
+            }
+            _ => return Ok(Broadcast::Exited),
+        }
+
+        Ok(Broadcast::Consumed)
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
+        let block = Block::default()
+            .borders(Borders::ALL)
+            .border_style(Style::default().fg(Color::Red));
+
+        let pg = Paragraph::new(format!("Error:{:?}", self.inner))
+            .block(block)
+            .scroll(self.position);
+
+        let width = pg.line_width() as u16 + 2;
+
+        let [_, area, _] = Layout::horizontal([
+            Constraint::Fill(1),
+            Constraint::Max(width),
+            Constraint::Fill(1),
+        ])
+        .areas(area);
+
+        let height = pg.line_count(area.width) as u16 + 2;
+
+        let [_, vert, _] = Layout::vertical([
+            Constraint::Max(10),
+            Constraint::Max(height),
+            Constraint::Max(10),
+        ])
+        .areas(area);
+
+        frame.render_widget(pg, vert);
+
+        Ok(())
+    }
+}

src/widget/log.rs

@@ -1,9 +1,8 @@
 use std::sync::Arc;
 
 use color_eyre::{Section, SectionExt};
-use eyre::{eyre, Report, Result, WrapErr};
+use eyre::{eyre, Report, Result};
 use futures::{future::BoxFuture, AsyncBufReadExt, FutureExt, TryStreamExt};
-use itertools::Itertools;
 use k8s_openapi::api::core::v1::Pod;
 use kube::{api::LogParams, Api, ResourceExt};
 use ratatui::{layout::Rect, text::Line, widgets::Paragraph, Frame};
@@ -133,7 +132,7 @@ impl Widget for Log {
             let task = &mut self.task;
 
             match futures::executor::block_on(async move { task.await? }) {
-                Ok(_) => return Err(eyre!("Log task finished unexpectedly")),
+                Ok(()) => return Err(eyre!("Log task finished unexpectedly")),
                 Err(err) => {
                     let Some(kube::Error::Api(resp)) = err.downcast_ref::<kube::Error>() else {
                         return Err(err);

src/widget/pod/shell.rs

@@ -1,23 +1,19 @@
 use std::{pin::Pin, sync::Arc, vec};
 
 use chrono::{DateTime, Utc};
+use color_eyre::{Section, SectionExt};
 use derive_builder::Builder;
 use eyre::{eyre, Result};
 use futures::StreamExt;
+use itertools::Itertools;
 use k8s_openapi::api::core::v1::Pod;
 use kube::{
     api::{Api, AttachParams},
     ResourceExt,
 };
 use lazy_static::lazy_static;
 use prometheus::{histogram_opts, register_histogram, Histogram};
-use ratatui::{
-    layout::Rect,
-    prelude::*,
-    style::{palette::tailwind, Modifier, Style},
-    widgets,
-    widgets::{Block, Borders, Row},
-};
+use ratatui::{layout::Rect, prelude::*};
 use tokio::{
     io::{AsyncWrite, AsyncWriteExt},
     sync::mpsc::UnboundedReceiver,
@@ -81,14 +77,17 @@ impl Widget for Shell {
     }
 
     fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
-        self.table.draw(frame, area, &self.pod)
+        if let Err(err) = self.table.draw(frame, area, &self.pod) {
+            tracing::info!("failed to draw table: {}", err);
+        }
+
+        Ok(())
     }
 }
 
 enum CommandState {
     Input(Text),
     Attached,
-    Error(String),
 }
 
 static COMMAND: &str = "/bin/bash";
@@ -163,23 +162,6 @@ impl Command {
         }
     }
 
-    #[allow(clippy::unnecessary_wraps)]
-    fn dispatch_error(&mut self, event: &Event) -> Result<Broadcast> {
-        if !matches!(self.state, CommandState::Error(_)) {
-            return Ok(Broadcast::Ignored);
-        }
-
-        match event.key() {
-            // TODO: should handle scrolling inside the error message.
-            Some(_) => {
-                self.state = CommandState::Input(Command::input(&self.container));
-
-                Ok(Broadcast::Consumed)
-            }
-            _ => Ok(Broadcast::Ignored),
-        }
-    }
-
     fn draw_input(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
         let CommandState::Input(ref mut txt) = self.state else {
             return Ok(());
@@ -201,77 +183,40 @@ impl Command {
 
         txt.draw(frame, area)
     }
-
-    // TODO: this should be a separate widget of its own.
-    #[allow(clippy::cast_possible_truncation, clippy::unnecessary_wraps)]
-    fn draw_error(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
-        let CommandState::Error(ref err) = self.state else {
-            return Ok(());
-        };
-
-        let block = Block::default()
-            .title("Error")
-            .borders(Borders::ALL)
-            .border_style(Style::default().fg(Color::Red))
-            .title_style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD));
-
-        // TODO: get this into a variable so that it can be styled.
-        let rows: Vec<Row> = err
-            .split('\n')
-            .enumerate()
-            .map(|(i, line)| {
-                Row::new(vec![
-                    Span::from(format!("{i}: "))
-                        .style(style::Style::default().fg(tailwind::RED.c300)),
-                    Span::from(line),
-                ])
-            })
-            .collect();
-
-        let height = rows.len() as u16 + 2;
-
-        let content =
-            widgets::Table::new(rows, vec![Constraint::Max(3), Constraint::Fill(0)]).block(block);
-
-        let [_, area, _] = Layout::horizontal([
-            Constraint::Max(10),
-            Constraint::Fill(0),
-            Constraint::Max(10),
-        ])
-        .areas(area);
-
-        let [_, mut vert, _] = Layout::vertical([
-            Constraint::Max(10),
-            Constraint::Fill(0),
-            Constraint::Max(10),
-        ])
-        .areas(area);
-
-        if vert.height > height {
-            vert.height = height;
-        }
-
-        frame.render_widget(content, vert);
-
-        Ok(())
-    }
 }
 
 impl Widget for Command {
     fn dispatch(&mut self, event: &Event) -> Result<Broadcast> {
         propagate!(self.dispatch_input(event));
-        propagate!(self.dispatch_error(event));
 
         match event {
-            Event::Finished(result) => {
-                let Err(err) = result else {
-                    return Ok(Broadcast::Exited);
+            Event::Finished(result) => result.as_ref().map(|()| Broadcast::Exited).map_err(|err| {
+                let Some(err) = err.downcast_ref::<StatusError>() else {
+                    return eyre!(err.to_string());
                 };
 
-                self.state = CommandState::Error(err.to_string());
-
-                Ok(Broadcast::Consumed)
-            }
+                let separated = err.message.splitn(8, ':');
+
+                eyre!(
+                    "{}",
+                    separated.clone().last().unwrap_or("unknown error").trim()
+                )
+                .section(
+                    separated
+                        .with_position()
+                        .map(|(i, line)| {
+                            let l = line.trim().to_string();
+
+                            match i {
+                                itertools::Position::Middle => format!("├─ {l}"),
+                                itertools::Position::Last => format!("└─ {l}"),
+                                _ => l,
+                            }
+                        })
+                        .join("\n")
+                        .header("Raw:"),
+                )
+            }),
             _ => Ok(Broadcast::Ignored),
         }
     }
@@ -280,7 +225,6 @@ impl Widget for Command {
         match self.state {
             CommandState::Input(_) => self.draw_input(frame, area)?,
             CommandState::Attached => {}
-            CommandState::Error(_) => self.draw_error(frame, area)?,
         }
 
         Ok(())

src/widget/table.rs

@@ -12,7 +12,10 @@ use ratatui::{
 };
 
 use super::{input::Text, propagate, TableRow, Widget};
-use crate::events::{Broadcast, Event, Keypress};
+use crate::{
+    events::{Broadcast, Event, Keypress},
+    widget::error::Error,
+};
 
 lazy_static! {
     static ref TABLE_FILTER: IntCounter = register_int_counter!(
@@ -260,12 +263,20 @@ impl Table {
         filter.dispatch(event)
     }
 
+    #[allow(clippy::unnecessary_wraps)]
     fn dispatch_detail(&mut self, event: &Event) -> Result<Broadcast> {
         let State::Detail(ref mut widget) = self.state.borrow_mut() else {
             return Ok(Broadcast::Ignored);
         };
 
-        widget.dispatch(event)
+        match widget.dispatch(event) {
+            Ok(result) => Ok(result),
+            Err(err) => {
+                self.state.detail(Box::new(Error::new(err)));
+
+                Ok(Broadcast::Consumed)
+            }
+        }
     }
 
     fn handle_route(&mut self, route: &[String]) -> Result<()> {