Stop command execution and exit process in raw mode.

huangapple
go评论103阅读模式
英文:

Stop command execution and exit process in raw mode

问题

以下是翻译好的部分：

以下代码执行一个命令，然后允许您使用Ctrl + C退出进程：

  1. use std::process::Command;
  2. use termion::event::Key;
  3. use termion::input::TermRead;
  4. use termion::raw::IntoRawMode;
  5. use std::io::{stdin, stdout, Write};
  7. fn main() {
  8.     let stdin = stdin();
  9.     let mut stdout = stdout().into_raw_mode().unwrap();
  10.     let mut command = Command::new("script");
  12.     command
  13.         .arg("-qec")
  14.         .arg("sleep 5 && echo test")
  15.         .arg("/dev/null");
  17.     let output = command.output();
  19.     println!("output: {:?}", output);
  21.     for c in stdin.keys() {
  22.         match c.unwrap() {
  23.             Key::Char(c) => println!("{}\r\n", c),
  24.             Key::Ctrl('c') => {
  25.                 println!("Ctrl + C\r\n");
  26.                 write!(stdout, "{}", termion::cursor::Show).unwrap();
  27.                 std::process::exit(0);
  28.             }
  29.             _ => {}
  30.         }
  31.         stdout.flush().unwrap();
  32.     }
  33. }

您必须等待命令执行完成，然后才能按Ctrl + C退出程序。

如何在后台监听Ctrl + C，以便即使在命令运行时也能退出进程（类似于非原始模式中的中断命令）？

英文:

The following code executes a command, then enables you to exit the process with Ctrl + C:

  1. use std::process::Command;
  3. use termion::event::Key;
  4. use termion::input::TermRead;
  5. use termion::raw::IntoRawMode;
  7. use std::io::{stdin, stdout, Write};
  9. fn main() {
  10.     let stdin = stdin();
  11.     let mut stdout = stdout().into_raw_mode().unwrap();
  12.     let mut command = Command::new("script");
  14.     command
  15.         .arg("-qec")
  16.         .arg("sleep 5 && echo test")
  17.         .arg("/dev/null");
  19.     let output = command.output();
  21.     println!("output: {:?}", output);
  23.     for c in stdin.keys() {
  24.         match c.unwrap() {
  25.             Key::Char(c) => println!("{}\r\n", c),
  26.             Key::Ctrl('c') => {
  27.                 println!("Ctrl + C\r\n");
  28.                 write!(stdout, "{}", termion::cursor::Show).unwrap();
  29.                 std::process::exit(0);
  30.             }
  31.             _ => {}
  32.         }
  33.         stdout.flush().unwrap();
  34.     }
  35. }

Rust Playground

You have to wait for the command to be executed to be able to press Ctrl + C and exit the program.

How to listen to Ctrl + C in the background so that the process can exit even when the command is running (interrupting the command like in non-raw mode)?

答案1

得分: 0

以下是您提供的代码的翻译部分：

  1. 我不确定这是否是最佳方法，但它有效。我生成了三个并发线程：一个用于`stdout`，另一个用于`stderr`，第三个用于监听Ctrl + C。
  3. use std::{
  4.     io::{BufRead, BufReader},
  5.     process::{Command, Stdio},
  6. };
  8. use termion::event::Key;
  9. use termion::input::TermRead;
  10. use termion::raw::IntoRawMode;
  12. use std::io::{stdin, stdout, Write};
  14. fn main() {
  15.     let stdin = stdin();
  17.     std::thread::spawn(move || {
  18.         for c in stdin().keys() {
  19.             match c.unwrap() {
  20.                 Key::Ctrl('c') => {
  21.                     println!("Ctrl + C\r\n");
  22.                     std::process::exit(0);
  23.                 }
  24.                 _ => {}
  25.             }
  26.         }
  27.     });
  29.     let mut stdout = stdout().into_raw_mode().unwrap();
  31.     stdout.flush().unwrap();
  33.     let mut command = Command::new("script");
  35.     command
  36.         .arg("-qec")
  37.         .arg("sleep 5 && echo test")
  38.         .arg("/dev/null");
  40.     command.stdout(Stdio::piped());
  41.     command.stderr(Stdio::piped());
  43.     let mut child = command.spawn().expect("failed to spawn command");
  44.     let stdout_pipe = child.stdout.take().unwrap();
  45.     let stdout_reader = BufReader::new(stdout_pipe);
  46.     let stderr_pipe = child.stderr.take().unwrap();
  47.     let stderr_reader = BufReader::new(stderr_pipe);
  49.     let stdout_thread = std::thread::spawn(move || {
  50.         for line in stdout_reader.lines() {
  51.             if let Ok(line) = line {
  52.                 print!("{}\r\n", line);
  53.             }
  54.         }
  55.     });
  57.     let stderr_thread = std::thread::spawn(move || {
  58.         for line in stderr_reader.lines() {
  59.             if let Ok(line) = line {
  60.                 print!("{}\r\n", line);
  61.             }
  62.         }
  63.     });
  65.     let status = child.wait().expect("failed to wait for command");
  67.     stdout_thread.join().expect("failed to join stdout thread");
  68.     stderr_thread.join().expect("failed to join stderr thread");
  70.     println!("status: {}", status);
  71. }

请注意，我只提供了代码的翻译部分，没有包括问题或其他内容。如果您需要任何其他帮助，请随时告诉我。

英文:

I'm not sure if this is the best method, but it works. I spawned three concurrent threads: one for stdout, another for stderr, and a third one for listening to Ctrl + C.

  1. use std::{
  2.     io::{BufRead, BufReader},
  3.     process::{Command, Stdio},
  4. };
  6. use termion::event::Key;
  7. use termion::input::TermRead;
  8. use termion::raw::IntoRawMode;
  10. use std::io::{stdin, stdout, Write};
  12. fn main() {
  13.     let stdin = stdin();
  14.     
  15.     std::thread::spawn(move || {
  16.         for c in stdin().keys() {
  17.             match c.unwrap() {
  18.                 Key::Ctrl('c') => {
  19.                     println!("Ctrl + C\r\n");
  20.                     std::process::exit(0);
  21.                 }
  22.                 _ => {}
  23.             }
  24.         }
  25.     });
  26.     
  27.     let mut stdout = stdout().into_raw_mode().unwrap();
  28.     
  29.     stdout.flush().unwrap();
  31.     let mut command = Command::new("script");
  33.     command
  34.         .arg("-qec")
  35.         .arg("sleep 5 && echo test")
  36.         .arg("/dev/null");
  38.     command.stdout(Stdio::piped());
  39.     command.stderr(Stdio::piped());
  41.     let mut child = command.spawn().expect("failed to spawn command");
  42.     let stdout_pipe = child.stdout.take().unwrap();
  43.     let stdout_reader = BufReader::new(stdout_pipe);
  44.     let stderr_pipe = child.stderr.take().unwrap();
  45.     let stderr_reader = BufReader::new(stderr_pipe);
  47.     let stdout_thread = std::thread::spawn(move || {
  48.         for line in stdout_reader.lines() {
  49.             if let Ok(line) = line {
  50.                 print!("{}\r\n", line);
  51.             }
  52.         }
  53.     });
  55.     let stderr_thread = std::thread::spawn(move || {
  56.         for line in stderr_reader.lines() {
  57.             if let Ok(line) = line {
  58.                 print!("{}\r\n", line);
  59.             }
  60.         }
  61.     });
  63.     let status = child.wait().expect("failed to wait for command");
  65.     stdout_thread.join().expect("failed to join stdout thread");
  66.     stderr_thread.join().expect("failed to join stderr thread");
  68.     println!("status: {}", status);
  69. }

Note: ctrl doesn't seem to work with Termion's raw mode.

huangapple
  • 本文由 发表于 2023年5月14日 15:39:14
  • 转载请务必保留本文链接：https://go.coder-hub.com/76246357.html
  • rust
  • terminal
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定