Trigger external command

Help
1

Hello everyone,
For learning purpose,I’m trying to build a TUI, which trigger a TMUX.
The ultimate goal is to then trigger ssh sessions base on the list of server in my config file.
I’m having trouble, to understand why my command is not being executed.

I have also looked at and tested to merge some example such as “spawn vim” but it went even worse with my keyboard keys not working anymore when mixed with my code…

Hopefully someone would have an idea what is wrong with my code to trigger effectively the command…

https://sr.ht/~vagrantin/essaysashTUI/

use std:: {
    fs::File,
    io::{self,BufRead,BufReader, stdout},
    path::Path,
    process::Command
};
use ratatui::{
    prelude::*,
    crossterm::{
        event::{self, KeyCode, KeyEventKind},
        terminal::{Clear,ClearType,disable_raw_mode, enable_raw_mode},
        ExecutableCommand,
    },
    widgets::*,
    DefaultTerminal,
};

struct App {
    items: Vec<Line<'static>>,
    selected: usize,
    server: Option<Line<'static>>,
    status_message: String
}

impl App {
    fn new() -> App {
            let filename = "servers.conf";
            let servers = servers_from_file(filename);
        App {
            items: servers,
            selected: 0,
            server: None, 
            status_message: "".to_owned()
        }
    }

    fn move_up(&mut self) {
        self.selected = self.selected.saturating_sub(1);
    }

    fn move_down(&mut self) {
        if self.selected < self.items.len() - 1 {
            self.selected += 1;
        }
    }
    fn exec_tmux(&mut self) {
        
        disable_raw_mode().unwrap();
        stdout().execute(Clear(ClearType::All)).unwrap();
        
        self.server = Some(self.items[self.selected].clone());
        let selected_server = match &self.server {
               Some(server_name) => format!("{}", server_name), //the issue is probably here
               None => "".to_string(),
           };
        let command = "tmux new -s";
        match Command::new("sh")
            .arg("-c")
            .arg(&command)
            .arg(&selected_server) //we are not getting this value.
            .output()
            { 
                Ok(_) => {
                    self.status_message = format!("Executed: {} {}", &command, &selected_server);
                }
                Err(e) => {
                    self.status_message = format!("Failed: {}", e);
                }
            }
        enable_raw_mode().unwrap();
    }
}

fn servers_from_file(filename: impl AsRef<Path>) -> Vec<Line<'static>> {
    let file = File::open(filename).expect("File not found");
    let buf = BufReader::new(file);
    let data: Vec<Line> = buf.lines()
        .map(|l| {Line::from(l.unwrap())})
        .collect::<Vec<_>>();
    data
}

fn run_render(mut terminal: DefaultTerminal) -> io::Result<()> {
    let mut app = App::new();
    loop {
        terminal.draw(|frame| {
            let chunks = Layout::vertical([
                Constraint::Min(1),
                Constraint::Length(5),
            ]);
            let [text, debug] = chunks.areas(frame.area());
            let items: Vec<ListItem> = app
                .items
                .iter()
                .enumerate()
                .map(|(i, item)| {
                    if i == app.selected {
                        ListItem::new::<Line<'_>>(item.clone()).style(Style::default().fg(Color::Yellow))
                    } else {
                        ListItem::new::<Line<'_>>(item.clone())
                    }
                })
                .collect();
            let list = List::new(items)
                .block(Block::default().title("List").borders(Borders::ALL));
            frame.render_widget(list, text);
           /* 
            let selected_server = match &app.server {
                Some(server_name) => format!("Selected!: {}", server_name),
                None => "".to_string(),
            };
            */
            let status = format!("{}", &app.status_message);

            let debug_message = Paragraph::new(status)
                .block(Block::bordered().title("debug"));
            frame.render_widget(debug_message, debug);

        })?;

        if let event::Event::Key(key) = event::read()? {
            if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('q') || key.code == KeyCode::Char('Q') {
                return Ok(());
            } else {
             match key.code {
                 KeyCode::Up => app.move_up(),
                 KeyCode::Char('t') => app.move_up(),
                 KeyCode::Down => app.move_down(),
                 KeyCode::Char('s') => app.move_down(),
                 KeyCode::Enter => {
                     app.exec_tmux();
                     terminal.clear()?;
                 },
                 _ => {}
             }
            }
        }
    }
}

//this is probably here that you have an issue to trigger Tmux
fn main() -> io::Result<()> {
    let mut terminal = ratatui::init();
    terminal.clear()?;
    let app_result = run_render(terminal);
    ratatui::restore();
    app_result
}

Thanks in advance for any hints
With kind regards

2

I have splited my code to help me troubleshoot this and avoid having everything inside main.
Also add some troubleshooting, at least i know that it is clearly failing to launch tmux but don’t know why

It is available on the dev branch

Module app.rs

use std:: {
    fs::File,
    io::{self,BufRead,BufReader, stdout,Result,Write},
    path::Path,
    process::Command
};
use ratatui::{
    prelude::*,
    crossterm::{
        terminal::{Clear,ClearType,disable_raw_mode, enable_raw_mode},
        ExecutableCommand,
    },
};

pub struct App {
   pub items: Vec<Line<'static>>,
   pub selected: usize,
   pub server: Option<Line<'static>>,
   pub status_message: String
}

impl App {
   pub fn new() -> App {
            let filename = "servers.conf";
            let servers = servers_from_file(filename);
        App {
            items: servers,
            selected: 0,
            server: None, 
            status_message: "".to_owned()
        }
    }

    pub fn move_up(&mut self) {
        self.selected = self.selected.saturating_sub(1);
    }

    pub fn move_down(&mut self) {
        if self.selected < self.items.len() - 1 {
            self.selected += 1;
        }
    }
    pub fn tmux_session(&mut self) -> Result<()>{
        disable_raw_mode()?;
        stdout().execute(Clear(ClearType::All))?;
        
        self.server = Some(self.items[self.selected].clone());
        let selected_server = match &self.server {
               Some(server_name) => format!("{}", server_name),
               None => "".to_string(),
           };
        let command = "new -s";
        match Command::new("tmux")
            .arg(&command)
            .arg(&selected_server)
            .output()
            { 
                Ok(output) => {
                    if output.status.success() {
                    self.status_message = format!("Executed: {} {}", &command, &selected_server);
                } else {
                    let stdout = io::stdout().write_all(&output.stdout).unwrap();
                    let stderr = io::stderr().write_all(&output.stderr).unwrap();
                    self.status_message = format!("didn't work: {}\n stdout {:?}\nstderr{:?}", output.status, stdout, stderr);
                    }
                }
                Err(e) => {
                    self.status_message = format!("Failed: {}", e);
                }
            }
        enable_raw_mode()?;
        Ok(())
    }
}

fn servers_from_file(filename: impl AsRef<Path>) -> Vec<Line<'static>> {
    let file = File::open(filename).expect("File not found");
    let buf = BufReader::new(file);
    let data: Vec<Line> = buf.lines()
        .map(|l| {Line::from(l.unwrap())})
        .collect::<Vec<_>>();
    data
}

![image|274x500](upload://3CNVkmJ3wp7D2hSy4aAutC7XmcQ.png)
3

I found the solution for may issue.
This was due to the way I was parsing the last parameter, it was not a proper String type.

This was the original way I was doing this, in this case my type was an &Line<'static> which couldn’t be correctly interpreted by Tmux as a parameter hence failing.

    fn tmux_session(&mut self) { 
  
        // Clears entire screen and moves cursor to (0,0)
        stdout().execute(Clear(ClearType::All)).unwrap();
        disable_raw_mode().unwrap();
  
        self.server = Some(self.items[self.selected].clone());
        let selected_server = match &self.server { 
               Some(server_name) => format!("{}", server_name),
               None => "".to_string(),
           };
        let command = "new -s";
        match Command::new("tmux")
            .arg(&command)
            .arg(&selected_server)
            .status()
            {
                Ok(_) => { 
                    self.status_message = format!("Executed: tmux {} {}", &command, &selected_server);
                }
                Err(e) => { 
                    self.status_message = format!("Failed: {}", e);
                }
            }
        enable_raw_mode().unwrap();
    }

This one way in my case to have the Tmux correctly executed, this time I’m getting a String type by correctly looking in the span type.

fn tmux_session(&mut self) -> Result<()>{
          disable_raw_mode()?;
          stdout().execute(Clear(ClearType::All))?;
          
          self.server = Some(self.items[self.selected].clone());
          let selected_server = match &self.server {
                 Some(server_name) => {
                     server_name.spans.iter()
                         .map(|span| span.content.clone())
                         .collect::<String>()
                         .trim()
                         .to_string()
                         },
                 None => "".to_string(),
             };
          match Command::new("tmux")
              .arg("new")
              .arg("-s")
              .arg(&selected_server)
              .status()
              { 
                  Ok(status) => {
                      if status.success() {
                      self.status_message = format!("Executed the tmux session : {}", &selected_server);
                  } else {
                      self.status_message = format!("Didn't work on server {}:\nIt's potentially a duplicate session ", &selected_server);
                      }
                  }
                  Err(e) => {
                      self.status_message = format!("Failed: {}", e);
                  }
              }
          enable_raw_mode()?;
          Ok(())
      }

Hope that helps

2 Likes