show node error

Author: dzhou121

tiron-common/src/action.rs

@@ -18,6 +18,7 @@ impl ActionId {
 
 #[derive(Deserialize, Serialize)]
 pub enum ActionMessage {
+    NodeStartFailed { reason: String },
     ActionStarted { id: ActionId },
     ActionStdout { id: ActionId, content: String },
     ActionStderr { id: ActionId, content: String },

tiron-node/src/action/data.rs

@@ -1,10 +1,4 @@
-use std::{collections::HashMap, path::Path};
-
-use anyhow::{anyhow, Result};
-use rcl::runtime::Value;
-use tiron_common::action::{ActionData, ActionId};
-
-use crate::job::Job;
+use std::collections::HashMap;
 
 use super::{copy::CopyAction, package::PackageAction, Action};
 
@@ -19,63 +13,3 @@ pub fn all_actions() -> HashMap<String, Box<dyn Action>> {
     .into_iter()
     .collect()
 }
-
-pub fn parse_value(cwd: &Path, value: &Value) -> Result<Vec<ActionData>> {
-    let Value::List(action_values) = value else {
-        return Err(anyhow!("actions should be a list"));
-    };
-
-    let all_actions = all_actions();
-
-    let mut actions = Vec::new();
-    for action_value in action_values.iter() {
-        let Value::Dict(dict) = action_value else {
-            return Err(anyhow!("action should be a dict"));
-        };
-        let Some(action) = dict.get(&Value::String("action".into())) else {
-            return Err(anyhow!("missing action key in action"));
-        };
-        let Value::String(action_name) = action else {
-            return Err(anyhow!("action key should be string"));
-        };
-
-        let name = if let Some(name) = dict.get(&Value::String("name".into())) {
-            let Value::String(name) = name else {
-                return Err(anyhow!("name should be string"));
-            };
-            Some(name.to_string())
-        } else {
-            None
-        };
-
-        if action_name.as_ref() == "job" {
-            let Some(params) = dict.get(&Value::String("params".into())) else {
-                return Err(anyhow!("job needs params"));
-            };
-            let Value::Dict(params) = params else {
-                return Err(anyhow!("params should be a dict"));
-            };
-            let Some(job_name) = params.get(&Value::String("name".into())) else {
-                return Err(anyhow!("missing job name in action"));
-            };
-            let Value::String(job_name) = job_name else {
-                return Err(anyhow!("job name should be string"));
-            };
-            let mut job_actions = Job::load(cwd, job_name)?;
-            actions.append(&mut job_actions);
-        } else {
-            let Some(action) = all_actions.get(action_name.as_ref()) else {
-                return Err(anyhow!("action {action_name} can't be found"));
-            };
-            let params = dict.get(&Value::String("params".into()));
-            let input = action.input(cwd, params)?;
-            actions.push(ActionData {
-                id: ActionId::new(),
-                name: name.unwrap_or_else(|| action_name.to_string()),
-                action: action_name.to_string(),
-                input,
-            });
-        }
-    }
-    Ok(actions)
-}

tiron-node/src/lib.rs

@@ -1,4 +1,3 @@
 pub mod action;
-mod job;
 pub mod node;
 pub mod stdio;

tiron-tui/src/app.rs

@@ -156,6 +156,9 @@ impl App {
             ActionMessage::NodeShutdown { success } => {
                 host.success = Some(success);
             }
+            ActionMessage::NodeStartFailed { reason } => {
+                host.start_failed = Some(reason);
+            }
         }
         Ok(())
     }

tiron-tui/src/run.rs

@@ -19,6 +19,7 @@ pub struct HostSection {
     pub actions: Vec<ActionSection>,
     pub scroll: u16,
     pub success: Option<bool>,
+    pub start_failed: Option<String>,
 }
 
 impl HostSection {
@@ -42,6 +43,19 @@ impl HostSection {
 
         let mut y = 0;
 
+        if let Some(reason) = &self.start_failed {
+            render_line(
+                area,
+                buf,
+                &mut y,
+                self.scroll,
+                &format!("host start failed: {reason}"),
+                Some(Color::Red),
+                None,
+            );
+            y += 1;
+        }
+
         for action in &self.actions {
             action.render(area, buf, &mut y, self.scroll);
             y += 1;
@@ -106,8 +120,14 @@ impl RunPanel {
         }
     }
 
+    fn get_active_host(&self) -> Result<&HostSection> {
+        let active = self.active.min(self.hosts.len().saturating_sub(1));
+        let host = self.hosts.get(active).ok_or_else(|| anyhow!("no host"))?;
+        Ok(host)
+    }
+
     pub fn render(&self, area: Rect, buf: &mut Buffer) {
-        if let Some(host) = self.hosts.first() {
+        if let Ok(host) = self.get_active_host() {
             host.render(area, buf);
         }
     }
@@ -146,6 +166,7 @@ impl HostSection {
             actions,
             scroll: 0,
             success: None,
+            start_failed: None,
         }
     }
 }
@@ -172,7 +193,7 @@ impl ActionSection {
         } else {
             Color::Gray
         };
-        self.render_line(area, buf, y, scroll, &self.name, None, Some(bg));
+        render_line(area, buf, y, scroll, &self.name, None, Some(bg));
         *y += 1;
         if self.folded {
             return;
@@ -186,71 +207,70 @@ impl ActionSection {
                 ActionOutputLevel::Warn => Some(Color::Yellow),
                 ActionOutputLevel::Error => Some(Color::Red),
             };
-            self.render_line(area, buf, y, scroll, &line.content, fg, None);
+            render_line(area, buf, y, scroll, &line.content, fg, None);
             if *y >= area.height + scroll {
                 return;
             }
         }
     }
+}
 
-    #[allow(clippy::too_many_arguments)]
-    fn render_line(
-        &self,
-        area: Rect,
-        buf: &mut Buffer,
-        y: &mut u16,
-        scroll: u16,
-        line: &str,
-        fg: Option<Color>,
-        bg: Option<Color>,
-    ) {
-        let style = Style::default();
-        let style = if let Some(fg) = fg {
-            style.fg(fg)
-        } else {
-            style
-        };
-        let mut line_composer = WordWrapper::new(
-            vec![(
-                line.graphemes(true)
-                    .map(move |g| StyledGrapheme { symbol: g, style }),
-                Alignment::Left,
-            )]
-            .into_iter(),
-            area.width,
-            false,
-        );
+#[allow(clippy::too_many_arguments)]
+fn render_line(
+    area: Rect,
+    buf: &mut Buffer,
+    y: &mut u16,
+    scroll: u16,
+    line: &str,
+    fg: Option<Color>,
+    bg: Option<Color>,
+) {
+    let style = Style::default();
+    let style = if let Some(fg) = fg {
+        style.fg(fg)
+    } else {
+        style
+    };
+    let mut line_composer = WordWrapper::new(
+        vec![(
+            line.graphemes(true)
+                .map(move |g| StyledGrapheme { symbol: g, style }),
+            Alignment::Left,
+        )]
+        .into_iter(),
+        area.width,
+        false,
+    );
 
-        while let Some(WrappedLine {
-            line: current_line,
-            width: current_line_width,
-            alignment: current_line_alignment,
-        }) = line_composer.next_line()
-        {
-            if *y >= scroll {
-                if let Some(bg) = bg {
-                    let area = Rect::new(area.left(), area.top() + *y - scroll, area.width, 1);
-                    buf.set_style(area, Style::default().bg(bg));
-                }
-                let mut x = get_line_offset(current_line_width, area.width, current_line_alignment);
-                for StyledGrapheme { symbol, style } in current_line {
-                    let width = symbol.width();
-                    if width == 0 {
-                        continue;
-                    }
-                    // If the symbol is empty, the last char which rendered last time will
-                    // leave on the line. It's a quick fix.
-                    let symbol = if symbol.is_empty() { " " } else { symbol };
-                    buf.get_mut(area.left() + x, area.top() + *y - scroll)
-                        .set_symbol(symbol)
-                        .set_style(*style);
-                    x += width as u16;
-                }
+    while let Some(WrappedLine {
+        line: current_line,
+        width: current_line_width,
+        alignment: current_line_alignment,
+    }) = line_composer.next_line()
+    {
+        if *y >= scroll {
+            if let Some(bg) = bg {
+                let area = Rect::new(area.left(), area.top() + *y - scroll, area.width, 1);
+                buf.set_style(area, Style::default().bg(bg));
             }
-            *y += 1;
-            if *y >= area.height + scroll {
-                break;
+            let mut x = get_line_offset(current_line_width, area.width, current_line_alignment);
+            for StyledGrapheme { symbol, style } in current_line {
+                let width = symbol.width();
+                if width == 0 {
+                    continue;
+                }
+                // If the symbol is empty, the last char which rendered last time will
+                // leave on the line. It's a quick fix.
+                let symbol = if symbol.is_empty() { " " } else { symbol };
+                buf.get_mut(area.left() + x, area.top() + *y - scroll)
+                    .set_symbol(symbol)
+                    .set_style(*style);
+                x += width as u16;
             }
         }
+        *y += 1;
+        if *y >= area.height + scroll {
+            break;
+        }
     }
 }

tiron/src/action.rs

@@ -0,0 +1,72 @@
+use std::{collections::HashMap, path::Path};
+
+use anyhow::{anyhow, Result};
+use rcl::runtime::Value;
+use tiron_common::action::{ActionData, ActionId};
+use tiron_node::action::data::all_actions;
+
+use crate::job::Job;
+
+pub fn parse_actions(
+    cwd: &Path,
+    value: &Value,
+    vars: &HashMap<String, String>,
+) -> Result<Vec<ActionData>> {
+    let Value::List(action_values) = value else {
+        return Err(anyhow!("actions should be a list"));
+    };
+
+    let all_actions = all_actions();
+
+    let mut actions = Vec::new();
+    for action_value in action_values.iter() {
+        let Value::Dict(dict) = action_value else {
+            return Err(anyhow!("action should be a dict"));
+        };
+        let Some(action) = dict.get(&Value::String("action".into())) else {
+            return Err(anyhow!("missing action key in action"));
+        };
+        let Value::String(action_name) = action else {
+            return Err(anyhow!("action key should be string"));
+        };
+
+        let name = if let Some(name) = dict.get(&Value::String("name".into())) {
+            let Value::String(name) = name else {
+                return Err(anyhow!("name should be string"));
+            };
+            Some(name.to_string())
+        } else {
+            None
+        };
+
+        if action_name.as_ref() == "job" {
+            let Some(params) = dict.get(&Value::String("params".into())) else {
+                return Err(anyhow!("job needs params"));
+            };
+            let Value::Dict(params) = params else {
+                return Err(anyhow!("params should be a dict"));
+            };
+            let Some(job_name) = params.get(&Value::String("name".into())) else {
+                return Err(anyhow!("missing job name in action"));
+            };
+            let Value::String(job_name) = job_name else {
+                return Err(anyhow!("job name should be string"));
+            };
+            let mut job_actions = Job::load(cwd, job_name, vars)?;
+            actions.append(&mut job_actions);
+        } else {
+            let Some(action) = all_actions.get(action_name.as_ref()) else {
+                return Err(anyhow!("action {action_name} can't be found"));
+            };
+            let params = dict.get(&Value::String("params".into()));
+            let input = action.input(cwd, params)?;
+            actions.push(ActionData {
+                id: ActionId::new(),
+                name: name.unwrap_or_else(|| action_name.to_string()),
+                action: action_name.to_string(),
+                input,
+            });
+        }
+    }
+    Ok(actions)
+}